monoco-toolkit 0.2.8__py3-none-any.whl → 0.3.1__py3-none-any.whl

monoco/features/i18n/commands.py

@@ -4,20 +4,36 @@ from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
 
-from typing import Optional, Annotated
 from monoco.core.config import get_config, find_monoco_root
 from monoco.core.output import AgentOutput, OutputManager
 from . import core
 
-app = typer.Typer(help="Management tools for Documentation Internationalization (i18n).")
+app = typer.Typer(
+    help="Management tools for Documentation Internationalization (i18n)."
+)
 console = Console()
 
+
 @app.command("scan")
 def scan(
-    root: str = typer.Option(None, "--root", help="Target root directory to scan. Defaults to the project root."),
-    limit: int = typer.Option(10, "--limit", help="Maximum number of missing files to display. Use 0 for unlimited."),
-    check_issues: bool = typer.Option(False, "--check-issues", help="Include Issues directory in the scan."),
-    check_source_lang: bool = typer.Option(False, "--check-source-lang", help="Verify if source files content matches source language (heuristic)."),
+    root: str = typer.Option(
+        None,
+        "--root",
+        help="Target root directory to scan. Defaults to the project root.",
+    ),
+    limit: int = typer.Option(
+        10,
+        "--limit",
+        help="Maximum number of missing files to display. Use 0 for unlimited.",
+    ),
+    check_issues: bool = typer.Option(
+        False, "--check-issues", help="Include Issues directory in the scan."
+    ),
+    check_source_lang: bool = typer.Option(
+        False,
+        "--check-source-lang",
+        help="Verify if source files content matches source language (heuristic).",
+    ),
     json: AgentOutput = False,
 ):
     """
@@ -39,15 +55,21 @@ def scan(
     config = get_config(project_root=str(target_root))
     target_langs = config.i18n.target_langs
     source_lang = config.i18n.source_lang
-    
+
     if not OutputManager.is_agent_mode():
-        console.print(f"Scanning i18n coverage in [bold cyan]{target_root}[/bold cyan]...")
-        console.print(f"Target Languages: [bold yellow]{', '.join(target_langs)}[/bold yellow] (Source: {source_lang})")
-    
+        console.print(
+            f"Scanning i18n coverage in [bold cyan]{target_root}[/bold cyan]..."
+        )
+        console.print(
+            f"Target Languages: [bold yellow]{', '.join(target_langs)}[/bold yellow] (Source: {source_lang})"
+        )
+
     all_files = core.discover_markdown_files(target_root, include_issues=check_issues)
-    
-    source_files = [f for f in all_files if not core.is_translation_file(f, target_langs)]
-    
+
+    source_files = [
+        f for f in all_files if not core.is_translation_file(f, target_langs)
+    ]
+
     # Store missing results: { file_path: [missing_langs] }
     missing_map = {}
     # Store lang mismatch results: [file_path]
@@ -55,16 +77,18 @@ def scan(
 
     total_checks = len(source_files) * len(target_langs)
     found_count = 0
-    
+
     for f in source_files:
         # Check translation existence
-        missing_langs = core.check_translation_exists(f, target_root, target_langs, source_lang)
+        missing_langs = core.check_translation_exists(
+            f, target_root, target_langs, source_lang
+        )
         if missing_langs:
             missing_map[f] = missing_langs
-            found_count += (len(target_langs) - len(missing_langs))
+            found_count += len(target_langs) - len(missing_langs)
         else:
             found_count += len(target_langs)
-            
+
         # Check source content language if enabled
         if check_source_lang:
             if not core.is_content_source_language(f, source_lang):
@@ -75,10 +99,10 @@ def scan(
                 except:
                     detected = "unknown"
                 lang_mismatch_files.append((f, detected))
-            
+
     # Reporting
     coverage = (found_count / total_checks * 100) if total_checks > 0 else 100
-    
+
     # Sort missing_map by file path for stable output
     sorted_missing = sorted(missing_map.items(), key=lambda x: str(x[0]))
 
@@ -94,23 +118,27 @@ def scan(
                 "found_translations": found_count,
                 "coverage_percent": round(coverage, 2),
                 "missing_files_count": len(sorted_missing),
-                "mismatch_files_count": len(lang_mismatch_files)
+                "mismatch_files_count": len(lang_mismatch_files),
             },
             "missing_files": [
                 {
                     "file": str(f.relative_to(target_root)),
                     "missing_langs": langs,
                     "expected_paths": [
-                        str(core.get_target_translation_path(f, target_root, l, source_lang).relative_to(target_root))
+                        str(
+                            core.get_target_translation_path(
+                                f, target_root, l, source_lang
+                            ).relative_to(target_root)
+                        )
                         for l in langs
-                    ]
+                    ],
                 }
                 for f, langs in sorted_missing
             ],
             "language_mismatches": [
                 {"file": str(f.relative_to(target_root)), "detected": detected}
                 for f, detected in lang_mismatch_files
-            ]
+            ],
         }
         OutputManager.print(report)
         return
@@ -120,62 +148,68 @@ def scan(
     total_missing_files = len(sorted_missing)
     display_limit = limit if limit > 0 else total_missing_files
     displayed_missing = sorted_missing[:display_limit]
-    
+
     # Build table title with count info
     table_title = "i18n Availability Report"
     if total_missing_files > 0:
         if display_limit < total_missing_files:
             table_title = f"i18n Availability Report (Showing {display_limit} / {total_missing_files} missing files)"
         else:
-            table_title = f"i18n Availability Report ({total_missing_files} missing files)"
-    
+            table_title = (
+                f"i18n Availability Report ({total_missing_files} missing files)"
+            )
+
     table = Table(title=table_title, box=None)
     table.add_column("Source File", style="cyan", no_wrap=True, overflow="fold")
     table.add_column("Missing Languages", style="red")
     table.add_column("Expected Paths", style="dim", no_wrap=True, overflow="fold")
-    
+
     for f, langs in displayed_missing:
         rel_path = f.relative_to(target_root)
         expected_paths = []
         for lang in langs:
             target = core.get_target_translation_path(f, target_root, lang, source_lang)
             expected_paths.append(str(target.relative_to(target_root)))
-            
-        table.add_row(
-            str(rel_path), 
-            ", ".join(langs),
-            "\n".join(expected_paths)
-        )
-        
+
+        table.add_row(str(rel_path), ", ".join(langs), "\n".join(expected_paths))
+
     console.print(table)
-    
+
     # Show Language Mismatch Warnings
     if lang_mismatch_files:
         console.print("\n")
-        mismatch_table = Table(title=f"Source Language Mismatch (Expected: {source_lang})", box=None)
+        mismatch_table = Table(
+            title=f"Source Language Mismatch (Expected: {source_lang})", box=None
+        )
         mismatch_table.add_column("File", style="yellow")
         mismatch_table.add_column("Detected", style="red")
-        
+
         limit_mismatch = 10
         for f, detected in lang_mismatch_files[:limit_mismatch]:
-             mismatch_table.add_row(str(f.relative_to(target_root)), detected)
-             
+            mismatch_table.add_row(str(f.relative_to(target_root)), detected)
+
         console.print(mismatch_table)
         if len(lang_mismatch_files) > limit_mismatch:
-             console.print(f"[dim]... and {len(lang_mismatch_files) - limit_mismatch} more.[/dim]")
+            console.print(
+                f"[dim]... and {len(lang_mismatch_files) - limit_mismatch} more.[/dim]"
+            )
 
     # Show hint if output was truncated
     if display_limit < total_missing_files:
-        console.print(f"\n[dim]💡 Tip: Use [bold]--limit 0[/bold] to show all {total_missing_files} missing files.[/dim]\n")
-    
+        console.print(
+            f"\n[dim]💡 Tip: Use [bold]--limit 0[/bold] to show all {total_missing_files} missing files.[/dim]\n"
+        )
+
     # Calculate partial vs complete missing
-    partial_missing = sum(1 for _, langs in sorted_missing if len(langs) < len(target_langs))
+    partial_missing = sum(
+        1 for _, langs in sorted_missing if len(langs) < len(target_langs)
+    )
     complete_missing = total_missing_files - partial_missing
-    
+
     status_color = "green" if coverage == 100 else "yellow"
     if coverage < 50:
         status_color = "red"
-    
+
     summary_lines = [
         f"Total Source Files: {len(source_files)}",
         f"Target Languages: {len(target_langs)}",
@@ -183,16 +217,16 @@ def scan(
         f"Found Translations: {found_count}",
         f"Missing Files: {total_missing_files}",
     ]
-    
+
     if total_missing_files > 0:
         summary_lines.append(f"  - Partial Missing: {partial_missing}")
         summary_lines.append(f"  - Complete Missing: {complete_missing}")
-        
+
     if lang_mismatch_files:
         summary_lines.append(f"Language Mismatches: {len(lang_mismatch_files)}")
-    
+
     summary_lines.append(f"Coverage: [{status_color}]{coverage:.1f}%[/{status_color}]")
-    
+
     summary = "\n".join(summary_lines)
     console.print(Panel(summary, title="I18N STATUS", expand=False))
 

monoco/features/i18n/core.py

@@ -1,24 +1,44 @@
-import os
 import fnmatch
 from pathlib import Path
-from typing import List, Set, Dict, Any, Optional
+from typing import List, Optional
 import re
 
 DEFAULT_EXCLUDES = [
-    ".git", ".reference", "dist", "build", "node_modules", "__pycache__", 
-    ".agent", ".mono", ".venv", "venv", "ENV",
+    ".git",
+    ".reference",
+    "dist",
+    "build",
+    "node_modules",
+    "__pycache__",
+    ".agent",
+    ".mono",
+    ".venv",
+    "venv",
+    "ENV",
     # Agent Integration Directories
-    ".claude", ".gemini", ".qwen", ".openai", ".cursor", ".vscode", ".idea", ".fleet",
+    ".claude",
+    ".gemini",
+    ".qwen",
+    ".openai",
+    ".cursor",
+    ".vscode",
+    ".idea",
+    ".fleet",
     # System Prompts & Agent Configs
-    "AGENTS.md", "CLAUDE.md", "GEMINI.md", "QWEN.md", "SKILL.md"
+    "AGENTS.md",
+    "CLAUDE.md",
+    "GEMINI.md",
+    "QWEN.md",
+    "SKILL.md",
 ]
 
+
 def load_gitignore_patterns(root: Path) -> List[str]:
     """Load patterns from .gitignore file."""
     gitignore_path = root / ".gitignore"
     if not gitignore_path.exists():
         return []
-    
+
     patterns = []
     try:
         with open(gitignore_path, "r", encoding="utf-8") as f:
@@ -33,17 +53,20 @@ def load_gitignore_patterns(root: Path) -> List[str]:
         pass
     return patterns
 
-def is_excluded(path: Path, root: Path, patterns: List[str], excludes: Optional[List[str]] = None) -> bool:
+
+def is_excluded(
+    path: Path, root: Path, patterns: List[str], excludes: Optional[List[str]] = None
+) -> bool:
     """Check if a path should be excluded based on patterns and defaults."""
     rel_path = str(path.relative_to(root))
-    
+
     final_excludes = excludes if excludes is not None else DEFAULT_EXCLUDES
 
     # 1. Check default excludes (exact match for any path component, case-insensitive)
     for part in path.parts:
         if part.lower() in [e.lower() for e in final_excludes]:
             return True
-            
+
     # 2. Check gitignore patterns
     for pattern in patterns:
         # Check against relative path
@@ -65,27 +88,29 @@ def is_excluded(path: Path, root: Path, patterns: List[str], excludes: Optional[
 
     return False
 
+
 def discover_markdown_files(root: Path, include_issues: bool = False) -> List[Path]:
     """Recursively find markdown files while respecting exclusion rules."""
     patterns = load_gitignore_patterns(root)
     all_md_files = []
-    
+
     excludes = list(DEFAULT_EXCLUDES)
     if not include_issues:
         excludes.append("Issues")
 
-    # We walk to ensure we can skip directories early if needed, 
+    # We walk to ensure we can skip directories early if needed,
     # but for now rglob + filter is simpler.
     for p in root.rglob("*.md"):
         if p.is_file() and not is_excluded(p, root, patterns, excludes=excludes):
             all_md_files.append(p)
-            
+
     return sorted(all_md_files)
 
+
 def is_translation_file(path: Path, target_langs: List[str]) -> bool:
     """Check if the given path is a translation file (target)."""
     normalized_langs = [lang.lower() for lang in target_langs]
-    
+
     # Suffix check (case-insensitive)
     stem_upper = path.stem.upper()
     for lang in normalized_langs:
@@ -95,21 +120,24 @@ def is_translation_file(path: Path, target_langs: List[str]) -> bool:
     # Generic Suffix Check: Detect any _XX suffix where XX is 2-3 letters
     # This prevents files like README_ZH.md from being treated as source files
     # even if 'zh' is not in target_langs (e.g. when scanning for 'en' gaps).
-    if re.search(r'_[A-Z]{2,3}$', stem_upper):
+    if re.search(r"_[A-Z]{2,3}$", stem_upper):
         return True
-            
+
     # Subdir check (case-insensitive)
     path_parts_lower = [p.lower() for p in path.parts]
     for lang in normalized_langs:
         if lang in path_parts_lower:
             return True
-            
+
     return False
 
-def get_target_translation_path(path: Path, root: Path, lang: str, source_lang: str = "en") -> Path:
+
+def get_target_translation_path(
+    path: Path, root: Path, lang: str, source_lang: str = "en"
+) -> Path:
     """Calculate the expected translation path for a specific language."""
     lang = lang.lower()
-    
+
     # Parallel Directory Mode: docs/en/... -> docs/zh/...
     path_parts = list(path.parts)
     # Search for source_lang component to replace
@@ -123,27 +151,37 @@ def get_target_translation_path(path: Path, root: Path, lang: str, source_lang:
     stem = path.stem
     source_suffix = f"_{source_lang.upper()}"
     if stem.upper().endswith(source_suffix):
-         stem = stem[:-len(source_suffix)]
-         
+        stem = stem[: -len(source_suffix)]
+
     if path.parent == root:
         return path.with_name(f"{stem}_{lang.upper()}{path.suffix}")
-    
+
     # Subdir Mode: for documentation directories (fallback)
     return path.parent / lang / path.name
 
-def check_translation_exists(path: Path, root: Path, target_langs: List[str], source_lang: str = "en") -> List[str]:
+
+def check_translation_exists(
+    path: Path, root: Path, target_langs: List[str], source_lang: str = "en"
+) -> List[str]:
     """
     Verify which target languages have translations.
     Returns a list of missing language codes.
     """
     if is_translation_file(path, target_langs):
-        return [] # Already a translation, skip
-    
+        return []  # Already a translation, skip
+
     # Special handling for standard files: always treat as EN source
     effective_source_lang = source_lang
-    if path.name.upper() in ["README.MD", "CHANGELOG.MD", "CODE_OF_CONDUCT.MD", "CONTRIBUTING.MD", "LICENSE.MD", "SECURITY.MD"]:
+    if path.name.upper() in [
+        "README.MD",
+        "CHANGELOG.MD",
+        "CODE_OF_CONDUCT.MD",
+        "CONTRIBUTING.MD",
+        "LICENSE.MD",
+        "SECURITY.MD",
+    ]:
         effective_source_lang = "en"
-    
+
     missing = []
     for lang in target_langs:
         # Skip if target language matches the effective source language
@@ -155,41 +193,43 @@ def check_translation_exists(path: Path, root: Path, target_langs: List[str], so
             missing.append(lang)
     return missing
 
+
 def detect_language(content: str) -> str:
     """
     Detect the language of the content using simple heuristics.
     Returns: 'zh', 'en', or 'unknown'
     """
     if not content:
-        return 'unknown'
-        
+        return "unknown"
+
     # Strip YAML Frontmatter if present
     # Matches --- at start, followed by anything, followed by ---
-    frontmatter_pattern = re.compile(r'^---\n.*?\n---\n', re.DOTALL)
-    content = frontmatter_pattern.sub('', content)
-    
+    frontmatter_pattern = re.compile(r"^---\n.*?\n---\n", re.DOTALL)
+    content = frontmatter_pattern.sub("", content)
+
     if not content.strip():
-        return 'unknown'
+        return "unknown"
 
     # 1. Check for CJK characters (Chinese/Japanese/Korean)
     # Range: \u4e00-\u9fff (Common CJK Unified Ideographs)
     # Heuristic: If CJK count > threshold, it's likely Asian (we assume ZH for now in this context)
     total_chars = len(content)
-    cjk_count = sum(1 for c in content if '\u4e00' <= c <= '\u9fff')
-    
+    cjk_count = sum(1 for c in content if "\u4e00" <= c <= "\u9fff")
+
     # If > 5% chars are CJK, highly likely to be Chinese document
     if total_chars > 0 and cjk_count / total_chars > 0.05:
-        return 'zh'
-        
+        return "zh"
+
     # 2. Check for English
     # Heuristic: High ASCII ratio and low CJK
     non_ascii = sum(1 for c in content if ord(c) > 127)
-    
+
     # If < 10% non-ASCII, likely English (or code)
     if total_chars > 0 and non_ascii / total_chars < 0.1:
-        return 'en'
-        
-    return 'unknown'
+        return "en"
+
+    return "unknown"
+
 
 def is_content_source_language(path: Path, source_lang: str = "en") -> bool:
     """
@@ -202,22 +242,24 @@ def is_content_source_language(path: Path, source_lang: str = "en") -> bool:
 
         content = path.read_text(encoding="utf-8")
         detected = detect_language(content)
-        
+
         # 'unknown' is leniently accepted as valid to avoid false positives on code-heavy files
-        if detected == 'unknown':
+        if detected == "unknown":
             return True
-            
+
         # Normalize source_lang
         expected = source_lang.lower()
-        if expected == 'zh' or expected == 'cn':
-            return detected == 'zh'
-        elif expected == 'en':
-            return detected == 'en'
-            
+        if expected == "zh" or expected == "cn":
+            return detected == "zh"
+        elif expected == "en":
+            return detected == "en"
+
         # For other languages, we don't have detectors yet
         return True
     except Exception:
-        return True # Assume valid on error
+        return True  # Assume valid on error
+
+
 # ... (Existing code) ...
 
 SKILL_CONTENT = """---
@@ -257,8 +299,6 @@ def init(root: Path):
     pass
 
     return {
-        "skills": {
-            "i18n": SKILL_CONTENT
-        },
-        "prompts": {} # Handled by adapter via resource files
+        "skills": {"i18n": SKILL_CONTENT},
+        "prompts": {},  # Handled by adapter via resource files
     }

monoco/features/issue/adapter.py

@@ -3,6 +3,7 @@ from typing import Dict
 from monoco.core.feature import MonocoFeature, IntegrationData
 from monoco.features.issue import core
 
+
 class IssueFeature(MonocoFeature):
     @property
     def name(self) -> str:
@@ -15,20 +16,18 @@ class IssueFeature(MonocoFeature):
     def integrate(self, root: Path, config: Dict) -> IntegrationData:
         # Determine language from config, default to 'en'
         lang = config.get("i18n", {}).get("source_lang", "en")
-        
+
         # Current file is in monoco/features/issue/adapter.py
         # Resource path: monoco/features/issue/resources/{lang}/AGENTS.md
         base_dir = Path(__file__).parent / "resources"
-        
+
         # Try specific language, fallback to 'en'
         prompt_file = base_dir / lang / "AGENTS.md"
         if not prompt_file.exists():
             prompt_file = base_dir / "en" / "AGENTS.md"
-            
+
         content = ""
         if prompt_file.exists():
             content = prompt_file.read_text(encoding="utf-8").strip()
-            
-        return IntegrationData(
-            system_prompts={"Issue Management": content}
-        )
+
+        return IntegrationData(system_prompts={"Issue Management": content})