If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/hanmin0822/MisakaTranslator shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 1y ago

• 13 active contributors
• Distributed ownership (top contributor 49% of recent commits)
• GPL-3.0 licensed
• CI configured
• ⚠ Stale — last commit 1y ago
• ⚠ GPL-3.0 is copyleft — check downstream compatibility
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live hanmin0822/MisakaTranslator repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/hanmin0822/MisakaTranslator.

What it runs against: a local clone of hanmin0822/MisakaTranslator — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in hanmin0822/MisakaTranslator | Confirms the artifact applies here, not a fork | | 2 | License is still GPL-3.0 | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | Last commit ≤ 489 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of hanmin0822/MisakaTranslator. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/hanmin0822/MisakaTranslator.git
#   cd MisakaTranslator
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of hanmin0822/MisakaTranslator and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "hanmin0822/MisakaTranslator(\\.git)?\\b" \\
  && ok "origin remote is hanmin0822/MisakaTranslator" \\
  || miss "origin remote is not hanmin0822/MisakaTranslator (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(GPL-3\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"GPL-3\\.0\"" package.json 2>/dev/null) \\
  && ok "license is GPL-3.0" \\
  || miss "license drift — was GPL-3.0 at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 489 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~459d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/hanmin0822/MisakaTranslator"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

MisakaTranslator is a real-time machine translation tool for Galgames, visual novels, and manga that uses either text-hooking or OCR to extract Japanese text and translate it on-the-fly into multiple languages. It combines C# UI (WPF in MisakaTranslator-WPF/) with multiple translation backends (Baidu, Google, custom APIs) and supports both online and offline translation modes, including Tesseract OCR preprocessing with image filters and Mecab-based morphological analysis for better context. Modular monorepo structure: MisakaTranslator-WPF/ is the main WPF desktop application (UI layer), while independent libraries provide pluggable functionality—ArtificialTransHelperLibrary for user-defined translations, DictionaryHelperLibrary (with XxgJpzhDict provider), KeyboardMouseHookLibrary for global text extraction, MecabHelperLibrary for Japanese morphology, and KeyboardMouseMonitor (VC++ service) for low-level input hooking. Central configuration via Directory.Build.props and Directory.Packages.props suggests shared NuGet dependencies across all projects.

Japanese game localization enthusiasts and translators (both professionals and hobbyists) who play untranslated Galgames or read manga and need real-time translation without waiting for official releases. Secondary audience: Chinese localization communities and developers building translation infrastructure (based on the bilibili tutorial links and QQ-based community coordination).

Moderately mature but in maintenance mode: the codebase is well-structured with organized modules (KeyboardMouseHookLibrary, MecabHelperLibrary, DictionaryHelperLibrary), has CI/CD via GitHub Actions (see .github/workflows/build.yml), and was actively developed for years. However, the README explicitly states 'This project is currently in maintenance status and will not add new features,' suggesting the author is no longer actively developing; commit recency and issue backlog are not visible in the provided data, but the presence of detailed documentation (CONTRIBUTING.md, CODE_OF_CONDUCT.md) and release artifacts indicates it reached production stability.

Moderate risk due to single-maintainer status (hanmin0822) with documented contact only via email/QQ (512240272@qq.com), no visible test suite in the file structure, and dependency on external binary libraries (Tesseract, Mecab, Textractor) that must be manually copied post-build—the README warns 'binary dependencies need manual copying from Release packages' and the project does not include these in the git repo. Maintenance-mode status means security patches or API updates from translation providers (Baidu, Google) may not be addressed promptly.

Project is in stable maintenance mode with no active feature development; GitHub Actions CI is configured (build.yml) but the README states it will not add new features. Community contributions are directed to the companion MisakaProject repos (MisakaPatcher for patched translations, MisakaHookFinder for custom hook discovery), suggesting the core project is feature-complete and new capabilities are being developed externally.

Clone the repository: git clone https://github.com/hanmin0822/MisakaTranslator.git. The project targets .NET Framework 4.7.2 and uses Visual Studio project format (.csproj files managed by Directory.Build.props). Open MisakaTranslator-WPF.csproj in Visual Studio 2019+. Build the solution (Ctrl+Shift+B or Build > Build Solution). Manually copy the lib folder from the latest Release artifacts (from GitHub Releases tab) into the bin directory post-build, and copy tessdata folder if using Tesseract. The KeyboardMouseMonitor VC++ project is optional; prebuilt binaries are available.

Daily commands: After build and dependency setup (see howDoIStart), run the executable at MisakaTranslator-WPF/bin/Release/MisakaTranslator.exe or Debug/MisakaTranslator.exe depending on configuration. Launch configuration is defined in KeyboardMouseMonitor/Properties/LaunchSettings.json for the monitor service. The bilibili tutorial (BV1Qt4y11713) and internal guides (GuidePages/ XAML files) walk users through initial configuration of hook method selection, API keys, and dictionary setup.

• MisakaTranslator-WPF/MisakaTranslator-WPF.csproj: Primary application project file; defines all dependencies, target framework (4.7.2), and compilation settings for the main WPF UI.
• KeyboardMouseHookLibrary/GlobalHook.cs: Core text extraction engine using global keyboard/mouse hooking; implements the low-level API calls to intercept game text before display.
• DictionaryHelperLibrary/IDict.cs: Plugin interface for dictionary providers; any new dictionary backend (XxgJpzhDict, user custom) must implement this contract.
• MecabHelperLibrary/MecabHelper.cs: Japanese morphological analysis wrapper; critical for word segmentation and context-aware translation quality.
• ArtificialTransHelperLibrary/ArtificialTransHelper.cs: User-defined translation system allowing players to define custom sentence mappings and export translation memories for sharing.
• KeyboardMouseMonitor/KeyboardMouseMonitor.cs: Native VC++ interop layer (managed C# wrapper) providing low-level text extraction when hooking fails; bridges managed code to unmanaged Win32 APIs.
• Directory.Build.props: Centralized NuGet package version and shared build settings for all projects in the solution; modifying dependencies here affects the entire codebase.

Translation backends: Examine implementations in MisakaTranslator-WPF/ main window logic and API handler patterns for Baidu/Google (add new provider following existing interface). Text extraction: KeyboardMouseHookLibrary/GlobalHook.cs handles the hooking logic; KeyboardMouseMonitor/KeyboardMouseMonitor.cs is the VC++ bridge. Dictionary/morphology: DictionaryHelperLibrary/IDict.cs and MecabHelperLibrary/MecabHelper.cs define the interface—implement IDict for new dictionary sources. UI/UX: XAML files in MisakaTranslator-WPF/ (e.g., AddOptWindow.xaml, ArtificialTransAddWindow.xaml for adding new translation rules). Image preprocessing: Common.cs likely contains utility methods for OCR image filtering.

Binary dependencies not in repo: Tesseract OCR, Mecab dictionary data, and Textractor hook libraries must be manually placed in a lib/ folder post-build (README warns this explicitly). API key management: Translation services (Baidu, Google) require API credentials; the application likely stores these in encrypted config files or registry, but exact mechanism not visible in file list—review Common.cs and App.xaml.cs for startup logic. VC++ project requirement: KeyboardMouseMonitor is a Visual C++ project; Windows SDK and C++ build tools must be installed separately; the codebase suggests it can be skipped if prebuilt binaries are available, but omitting it disables low-level hooking features. Tesseract language packs: tessdata/ folder must include Japanese language training data (jpn.traineddata) for OCR to work; missing this is a common silent failure. P/Invoke stability: Global keyboard/mouse hooking via NativeMethods can cause system-wide hangs or crashes on certain Windows versions; test thoroughly on target OS versions.

• Global keyboard/mouse hooking via P/Invoke — MisakaTranslator's core extraction mechanism relies on intercepting Windows messages at the OS level (SetWindowsHookEx API) before games can filter them; without understanding WH_KEYBOARD_LL and WH_MOUSE_LL hook types, you cannot debug or extend KeyboardMouseHookLibrary.
• Optical Character Recognition (OCR) preprocessing pipeline — Tesseract OCR accuracy depends heavily on input image quality; MisakaTranslator's binarization, grayscaling, and contrast adjustment (mentioned in CONTRIBUTING) are critical for recognizing small game text, especially in low-resolution screens or antialiased fonts.
• Japanese morphological analysis (Mecab) — Mecab breaks Japanese sentences into morphemes (words + particles) without spaces; this is essential for accurate translation because a single kanji can have multiple readings depending on context. MisakaTranslator uses this for dictionary lookups and word-level translations.
• Plugin architecture via interface contracts (IDict) — DictionaryHelperLibrary defines IDict as a contract allowing third-party dictionary implementations (XxgJpzhDict, custom user dictionaries) to be swapped at runtime; this extensibility pattern is central to why MisakaTranslator can support multiple dictionary sources without recompilation.
• Text deduplication and normalization — Game text extracted via hooking often contains duplicates (same sentence repeated in memory) and garbage characters; the README mentions 'multiple deduplication methods' which are critical for preventing the same translation from appearing multiple times or nonsense text from overwhelming the UI.
• P/Invoke marshaling for unmanaged code interop — MisakaTranslator bridges C# managed code with native VC++ libraries (Tesseract, Mecab, Textractor DLLs) via DllImport and struct marshaling; incorrect marshaling causes crashes or silent data corruption, making NativeMethods.txt files critical for debugging.

• Artikash/Textractor — Direct upstream dependency cited in the README; MisakaTranslator builds on Textractor's text extraction engine for game hooking, making this essential context for understanding the hook mechanism.
• lgztx96/texthost — Earlier VNR predecessor mentioned in the README; understanding its architecture and design decisions informs why MisakaTranslator chose C# over Python for performance.
• jsc723/MisakaPatcher — Official companion repo in MisakaProject ecosystem; integrates MisakaTranslator with external translation patch support, extending functionality for localization teams.
• hanmin0822/MisakaHookFinder — Official companion repo; solves the problem of finding custom hook addresses for games MisakaTranslator cannot auto-detect, bridging the gap between extraction and translation.
• UnicodeC/VNR — Historical predecessor to VNR (the Python tool mentioned in README as slower alternative); understanding VNR's design clarifies MisakaTranslator's architectural motivations.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add unit tests for DictionaryHelperLibrary (IDict.cs, XxgJpzhDict.cs)

The DictionaryHelperLibrary is a core component for word lookup and translation optimization, but there are no visible test files in the repo structure. This library handles critical functionality for the dictionary and Mecab integration features mentioned in the README. Adding unit tests would ensure reliability across dictionary operations and catch regressions when adding new dictionary providers.

• [ ] Create a new test project: DictionaryHelperLibrary.Tests/DictionaryHelperLibrary.Tests.csproj
• [ ] Add test cases for IDict interface implementations (XxgJpzhDict.cs) covering lookup, parsing, and edge cases
• [ ] Add integration tests verifying dictionary operations with sample Japanese-Chinese word pairs
• [ ] Update Directory.Build.props or Directory.Build.targets to include test project in build pipeline
• [ ] Ensure tests can run in the existing build.yml workflow

Add GitHub Actions workflow for automated NuGet dependency scanning and updates

The repo uses centralized package management (Directory.Packages.props) across 8+ projects (ArtificialTransHelperLibrary, KeyboardMouseHookLibrary, MecabHelperLibrary, etc.). Currently build.yml only handles CI/CD compilation. Adding a dedicated workflow for dependency vulnerability scanning and automated updates would improve security and maintenance, especially critical for translation API integrations that may have security-sensitive dependencies.

• [ ] Create .github/workflows/dependabot.yml to enable GitHub Dependabot for automated dependency updates
• [ ] Add .github/workflows/security-scan.yml with steps for NuGet audit to detect vulnerable packages in Directory.Packages.props
• [ ] Configure Dependabot to group updates by project (separate groups for each helper library) to reduce noise
• [ ] Document the dependency update process in CONTRIBUTING.md with specific instructions for this multi-project setup

Add comprehensive documentation for Hook and OCR configuration in GuidePages with code examples

The GuidePages folder contains multiple XAML UI pages (ChooseHookFuncPage, ChooseHandleFuncPage, ChooseOCRAreaPage) that guide users through complex Hook/OCR setup, but there's no corresponding markdown documentation or API reference for developers wanting to extend these features. Add a developer guide that explains the Hook function selection, OCR preprocessing options, and text repair modes with concrete examples.

• [ ] Create docs/HOOK_CONFIGURATION.md documenting the Hook function workflow (reference GuidePages/Hook/*.xaml.cs files)
• [ ] Create docs/OCR_CONFIGURATION.md explaining OCR preprocessing methods and area selection (reference ImageProcWindow.xaml.cs and ChooseHandleFuncPage.xaml.cs)
• [ ] Create docs/TEXT_REPAIR_GUIDE.md explaining the multiple deduplication methods for Hook-extracted text (reference ChooseTextRepairFuncPage.xaml.cs)
• [ ] Add code examples showing how to programmatically configure hooks and OCR using the helper libraries
• [ ] Link these new docs from README.md and CONTRIBUTING.md for better discoverability

• Add test coverage for DictionaryHelperLibrary: The dictionary plugin system (IDict.cs and XxgJpzhDict.cs) has no visible unit tests. Create xUnit or MSTest tests in a new DictionaryHelperLibrary.Tests project covering dictionary lookup, caching, and error handling for missing entries—this would catch regressions when adding new dictionary providers.
• Document the text preprocessing pipeline: Common.cs likely contains image filters (grayscale, binarization mentioned in CONTRIBUTING) used by Tesseract OCR, but no inline comments or separate utility class explains the parameters. Extract these into a clearly-named ImagePreprocessor class with XML documentation and add examples to the GuidePages/ folder showing before/after OCR results.
• Add MecabHelper unit tests: MecabHelperLibrary/MecabHelper.cs wraps a native Mecab binary; add tests verifying morphological analysis (verb conjugation detection, particle handling) works correctly for common Galgame text patterns (e.g., 'は', 'を', 'に' particles). This prevents silent failures when Mecab dictionary is misconfigured.

• High · Keyboard/Mouse Hook Implementation — KeyboardMouseHookLibrary/, KeyboardMouseMonitor/. The KeyboardMouseHookLibrary and KeyboardMouseMonitor components implement global keyboard and mouse hooks which interact directly with Windows APIs (indicated by NativeMethods.txt files). Global hooks can be security-sensitive as they capture all keyboard/mouse input system-wide. Without proper input validation and filtering, this could lead to unintended data capture or manipulation. Fix: Implement strict input validation and filtering on captured inputs. Ensure hooks are only active when necessary. Add user consent mechanisms. Consider sandboxing or privilege separation. Audit NativeMethods implementations for unsafe P/Invoke declarations.
• High · OCR Integration - Potential API Key/Credential Exposure — MisakaTranslator-WPF/Properties/App.config, IAppSettings.cs. The codebase integrates with multiple online APIs (Baidu OCR, various translation APIs) for OCR and translation functionality. Configuration files and API credentials management are not visible in the provided structure, creating risk of hardcoded secrets or insecure storage in application settings or config files. Fix: Use secure credential storage mechanisms (Windows Data Protection API, Azure Key Vault, or similar). Never hardcode API keys. Implement environment variable-based configuration for sensitive data. Use configuration files with restricted file permissions.
• High · Missing Dependency and Security Update Information — Directory.Packages.props, Directory.Build.props, *.csproj files. The Directory.Packages.props and dependency management files are referenced but their content is not provided. Without visibility into dependency versions and package sources, there is risk of using vulnerable or outdated library versions, particularly concerning given the C# ecosystem and NuGet package sources. Fix: Audit all NuGet package dependencies for known vulnerabilities using tools like OWASP Dependency-Check or NuGet Package Analyzer. Pin dependency versions and regularly update. Implement automated security scanning in CI/CD pipeline (.github/workflows/build.yml).
• Medium · No Visible Input Validation in Text Processing Modules — ArtificialTransHelperLibrary/, MecabHelperLibrary/, ComicTranslator/. The codebase processes game text, OCR output, and user input through multiple translation and text repair modules. Without visible input validation logic in the file structure, there is risk of injection attacks through malformed text input. Fix: Implement comprehensive input validation for all user-provided and extracted text. Use whitelisting approaches. Sanitize output before display. Implement rate limiting for API calls to prevent abuse.
• Medium · WPF Application Security - Potential Code Injection — MisakaTranslator-WPF/*.xaml, MisakaTranslator-WPF/GuidePages/. WPF applications can be vulnerable to XAML injection if user-controlled data is used to dynamically load XAML or bind to untrusted sources. The multiple .xaml files suggest dynamic UI construction that could be exploited. Fix: Avoid dynamic XAML loading from untrusted sources. Use strict data binding validation. Implement code-behind logic for dynamic UI generation rather than XAML interpretation. Use XamlReader restrictions if dynamic loading is necessary.
• Medium · Inadequate CI/CD Security Configuration — .github/workflows/build.yml. The GitHub Actions workflow file (build.yml) is present but its content is not provided. Without visibility, potential issues could include: missing secret rotation, inadequate artifact signing, exposure of build artifacts, or insufficient permission scoping for workflow triggers. Fix: Review GitHub Actions workflow for: (1) Least privilege permissions, (2) Secret management and rotation, (3) Artifact signing and verification, (4) Protected branch requirements, (5) Dependency verification, (6) Audit logging.
• Medium · Dictionary and Translation Data Source Validation — DictionaryHelperLibrary/XxgJpzhDict.cs. The DictionaryHelperLibrary (XxgJpzhDict.cs) loads external dictionary data. Without visible validation of data sources and formats, there is risk of malformed or malicious dictionary data being loaded. Fix: Validate all dictionary data source integrity (checksums, signatures). Implement strict parsing with bounds checking. Sanitize loaded dictionary data. Consider using signed/encrypted dictionary packages.
• undefined · undefined — undefined. undefined Fix: undefined

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.