monoco-toolkit 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

monoco/features/agent/resources/en/critique.prompty

@@ -0,0 +1,16 @@
+---
+name: critique
+description: Critique the code or design against requirements.
+provider: chat
+---
+You are a Principal Code Reviewer.
+Your task is to critique the following implementation/design:
+
+{{file}}
+
+# Instructions
+1. **Gap Analysis**: Check if all Acceptance Criteria are met.
+2. **Code Quality**: Identify potential bugs, security issues, or performance bottlenecks.
+3. **Design Patterns**: Suggest better patterns if applicable.
+
+Output a structured review.

monoco/features/agent/resources/en/develop.prompty

@@ -0,0 +1,16 @@
+---
+name: develop
+description: 执行核心开发任务：编码与单元测试。
+provider: chat
+---
+You are a Principal Software Engineer.
+Your task is to implement the feature described in this Issue:
+
+{{file}}
+
+# Instructions
+1.  **Implementation**: Write the code required to satisfy the Acceptance Criteria.
+2.  **Unit Tests**: Add or update unit tests to verify your changes.
+3.  **Linting**: Ensure code follows project style guidelines.
+
+Please provide the code changes.

monoco/features/agent/resources/en/investigate.prompty

@@ -0,0 +1,16 @@
+---
+name: investigate
+description: 扫描 Codebase，识别架构设计、业务约束，丰富 Issue 引用网络。
+provider: chat
+---
+You are a Senior Software Architect.
+Your task is to investigate the feasibility and impact of the following Issue:
+
+{{file}}
+
+# Instructions
+1.  **Architecture Scan**: Identify which modules/files need to be modified.
+2.  **Dependency Analysis**: Suggest `parent`, `dependencies`, and `related` issues.
+3.  **Constraint Check**: Identify any business rules or technical constraints (e.g., Billing module impact).
+
+Output your findings as a comment or update the Issue description directly.

monoco/features/agent/resources/en/refine.prompty

@@ -0,0 +1,14 @@
+---
+name: refine
+description: 细化需求，将 Draft 转化为可执行的 Plan。
+provider: chat
+---
+You are a Product Owner / Systems Analyst.
+Refine the following Draft Issue into a concrete Technical Plan:
+
+{{file}}
+
+# Instructions
+1.  **Clarify Objective**: Ensure the goal is specific and standard.
+2.  **Expand Criteria**: Add detailed Acceptance Criteria.
+3.  **Breakdown Tasks**: List concrete Technical Tasks.

monoco/features/agent/resources/en/verify.prompty

@@ -0,0 +1,16 @@
+---
+name: verify
+description: 代为检查工单完整性、代码质量与逻辑一致性。
+provider: chat
+---
+You are a QA Lead / Release Manager.
+Your task is to verify if the following Issue is ready for delivery:
+
+{{file}}
+
+# Instructions
+1.  **Definition of Done**: Check if all Technical Tasks are checked and Acceptance Criteria met.
+2.  **Quality Check**: Review the code changes (if provided in context) for bugs or antipatterns.
+3.  **Completeness**: Ensure documentation and tests are present.
+
+Output "PASS" if ready, or a list of "BLOCKERS" if not.

monoco/features/agent/resources/zh/critique.prompty

@@ -0,0 +1,18 @@
+---
+name: critique
+description: 对当前实现或设计进行批判性审查。
+provider: chat
+when:
+  stageMatch: "review"
+---
+你是一位首席代码审查员。
+你的任务是对以下实现/设计进行批判性审查：
+
+{{file}}
+
+# 指令
+1. **差距分析**: 检查是否满足所有验收标准。
+2. **代码质量**: 识别潜在的 Bug、安全问题或性能瓶颈。
+3. **设计模式**: 如果适用，建议更好的设计模式。
+
+输出结构化的审查意见。

monoco/features/agent/resources/zh/develop.prompty

@@ -0,0 +1,18 @@
+---
+name: develop
+description: 执行核心开发任务：编码与单元测试。
+provider: chat
+when:
+  stageMatch: "doing"
+---
+你是一位首席软件工程师。
+你的任务是实现此 Issue 中描述的功能：
+
+{{file}}
+
+# 指令
+1.  **代码实现**: 编写满足验收标准所需的代码。
+2.  **单元测试**: 添加或更新单元测试以验证你的更改。
+3.  **代码规范**: 确保代码遵循项目风格指南 (Linting)。
+
+请提供代码变更。

monoco/features/agent/resources/zh/investigate.prompty

@@ -0,0 +1,18 @@
+---
+name: investigate
+description: 扫描代码库，识别架构设计、业务约束，丰富 Issue 引用网络。
+provider: chat
+when:
+  statusMatch: "open"
+---
+你是一位资深软件架构师。
+你的任务是调查以下 Issue 的可行性和影响：
+
+{{file}}
+
+# 指令
+1.  **架构扫描**: 识别哪些模块/文件需要修改。
+2.  **依赖分析**: 建议 `parent` (父级), `dependencies` (依赖), 和 `related` (相关) 议题。
+3.  **约束检查**: 识别任何业务规则或技术约束（例如，即使很小的改动也可能影响计费模块）。
+
+请以评论形式输出你的发现，或直接更新 Issue 描述。

monoco/features/agent/resources/zh/refine.prompty

@@ -0,0 +1,16 @@
+---
+name: refine
+description: 细化需求，将 Draft 转化为可执行的 Plan。
+provider: chat
+when:
+  stageMatch: "draft"
+---
+你是一位产品负责人 (PO) / 系统分析师。
+将以下草案 (Draft) Issue 细化为具体的技术计划：
+
+{{file}}
+
+# 指令
+1.  **阐明目标**: 确保目标具体且标准。
+2.  **扩展标准**: 添加详细的验收标准 (Acceptance Criteria)。
+3.  **任务分解**: 列出具体的技术任务 (Technical Tasks)。

monoco/features/agent/resources/zh/verify.prompty

@@ -0,0 +1,18 @@
+---
+name: verify
+description: 代为检查工单完整性、代码质量与逻辑一致性。
+provider: chat
+when:
+  stageMatch: "review|done"
+---
+你是一位 QA 负责人 / 发布经理。
+你的任务是验证以下 Issue 是否已准备好交付：
+
+{{file}}
+
+# 指令
+1.  **完成定义 (DoD)**: 检查是否所有技术任务 (Technical Tasks) 都已勾选，且满足验收标准。
+2.  **质量检查**: 审查代码变更（如果在上下文中提供了），查找 Bug 或反模式。
+3.  **完整性**: 确保文档和测试都已存在。
+
+如果准备好了，输出 "PASS"；否则列出 "BLOCKERS" (阻碍项)。

monoco/features/config/commands.py

@@ -2,7 +2,7 @@ import typer
 import yaml
 import json
 from pathlib import Path
-from typing import Optional, Any
+from typing import Optional, Any, Annotated
 from rich.console import Console
 from rich.syntax import Syntax
 from pydantic import ValidationError
@@ -15,6 +15,7 @@ from monoco.core.config import (
     save_raw_config,
     get_config_path
 )
+from monoco.core.output import AgentOutput, OutputManager
 
 app = typer.Typer(help="Manage Monoco configuration")
 console = Console()
@@ -38,12 +39,17 @@ def _parse_value(value: str) -> Any:
 @app.command()
 def show(
     output: str = typer.Option("yaml", "--output", "-o", help="Output format: yaml or json"),
+    json_output: AgentOutput = False,
 ):
     """Show the currently active (merged) configuration."""
     config = get_config()
     # Pydantic v1/v2 compat: use dict() or model_dump()
     data = config.dict()
     
+    if OutputManager.is_agent_mode():
+        OutputManager.print(data)
+        return
+
     if output == "json":
         print(json.dumps(data, indent=2))
     else:
@@ -52,7 +58,10 @@ def show(
         console.print(syntax)
 
 @app.command()
-def get(key: str = typer.Argument(..., help="Configuration key (e.g. project.name)")):
+def get(
+    key: str = typer.Argument(..., help="Configuration key (e.g. project.name)"),
+    json_output: AgentOutput = False,
+):
     """Get a specific configuration value."""
     config = get_config()
     data = config.dict()
@@ -64,22 +73,26 @@ def get(key: str = typer.Argument(..., help="Configuration key (e.g. project.nam
         if isinstance(current, dict) and part in current:
             current = current[part]
         else:
-            console.print(f"[red]Key '{key}' not found.[/red]")
+            OutputManager.error(f"Key '{key}' not found.")
             raise typer.Exit(code=1)
             
-    if isinstance(current, (dict, list)):
-        if isinstance(current, dict):
-            print(yaml.dump(current, default_flow_style=False))
-        else:
-            print(json.dumps(current))
+    if OutputManager.is_agent_mode():
+        OutputManager.print({"key": key, "value": current})
     else:
-        print(current)
+        if isinstance(current, (dict, list)):
+            if isinstance(current, dict):
+                print(yaml.dump(current, default_flow_style=False))
+            else:
+                print(json.dumps(current))
+        else:
+            print(current)
 
 @app.command(name="set")
 def set_val(
     key: str = typer.Argument(..., help="Config key (e.g. telemetry.enabled)"),
     value: str = typer.Argument(..., help="Value to set"),
     global_scope: bool = typer.Option(False, "--global", "-g", help="Update global configuration"),
+    json_output: AgentOutput = False,
 ):
     """Set a configuration value in specific scope (project by default)."""
     scope = ConfigScope.GLOBAL if global_scope else ConfigScope.PROJECT
@@ -98,7 +111,7 @@ def set_val(
         target = target[part]
         if not isinstance(target, dict):
             parent_key = ".".join(parts[:i+1])
-            console.print(f"[red]Cannot set '{key}': '{parent_key}' is not a dictionary ({type(target)}).[/red]")
+            OutputManager.error(f"Cannot set '{key}': '{parent_key}' is not a dictionary ({type(target)}).")
             raise typer.Exit(code=1)
             
     parsed_val = _parse_value(value)
@@ -113,18 +126,26 @@ def set_val(
         # But simpler is to check if MonocoConfig accepts this structure.
         MonocoConfig(**raw_data)
     except ValidationError as e:
-        console.print(f"[red]Validation failed for key '{key}':[/red]")
-        console.print(e)
+        OutputManager.error(f"Validation failed for key '{key}':\n{e}")
         raise typer.Exit(code=1)
     except Exception as e:
-        console.print(f"[red]Unexpected validation error: {e}[/red]")
+        OutputManager.error(f"Unexpected validation error: {e}")
         raise typer.Exit(code=1)
 
     # 4. Save
     save_raw_config(scope, raw_data)
     
     scope_display = "Global" if global_scope else "Project"
-    console.print(f"[green]✓ Set {key} = {parsed_val} in {scope_display} config.[/green]")
+    
+    if OutputManager.is_agent_mode():
+        OutputManager.print({
+            "status": "updated",
+            "scope": scope_display.lower(),
+            "key": key,
+            "value": parsed_val
+        })
+    else:
+        console.print(f"[green]✓ Set {key} = {parsed_val} in {scope_display} config.[/green]")
 
 if __name__ == "__main__":
     app()

monoco/features/i18n/commands.py

@@ -4,7 +4,9 @@ from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
 
-from monoco.core.config import get_config
+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).")
@@ -14,6 +16,9 @@ console = Console()
 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)."),
+    json: AgentOutput = False,
 ):
     """
     Scan the project for internationalization (i18n) status.
@@ -25,36 +30,92 @@ def scan(
 
     Returns a report of files missing translations in the checking target languages.
     """
-    config = get_config()
-    target_root = Path(root).resolve() if root else Path(config.paths.root)
+    if root:
+        target_root = Path(root).resolve()
+    else:
+        target_root = find_monoco_root(Path.cwd())
+
+    # Load config with correct root
+    config = get_config(project_root=str(target_root))
     target_langs = config.i18n.target_langs
+    source_lang = config.i18n.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: {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})")
     
-    all_files = core.discover_markdown_files(target_root)
+    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)]
     
     # Store missing results: { file_path: [missing_langs] }
     missing_map = {}
+    # Store lang mismatch results: [file_path]
+    lang_mismatch_files = []
+
     total_checks = len(source_files) * len(target_langs)
     found_count = 0
     
     for f in source_files:
-        missing_langs = core.check_translation_exists(f, target_root, target_langs)
+        # Check translation existence
+        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))
         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):
+                # Try to detect actual language for better error message
+                try:
+                    content = f.read_text(encoding="utf-8")
+                    detected = core.detect_language(content)
+                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]))
-    
+
+    if OutputManager.is_agent_mode():
+        # JSON Output
+        report = {
+            "root": str(target_root),
+            "source_lang": source_lang,
+            "target_langs": target_langs,
+            "stats": {
+                "total_source_files": len(source_files),
+                "total_checks": total_checks,
+                "found_translations": found_count,
+                "coverage_percent": round(coverage, 2),
+                "missing_files_count": len(sorted_missing),
+                "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))
+                        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
+
+    # Human Output
     # Apply limit
     total_missing_files = len(sorted_missing)
     display_limit = limit if limit > 0 else total_missing_files
@@ -77,7 +138,7 @@ def scan(
         rel_path = f.relative_to(target_root)
         expected_paths = []
         for lang in langs:
-            target = core.get_target_translation_path(f, target_root, lang)
+            target = core.get_target_translation_path(f, target_root, lang, source_lang)
             expected_paths.append(str(target.relative_to(target_root)))
             
         table.add_row(
@@ -88,6 +149,21 @@ def scan(
         
     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.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)
+             
+        console.print(mismatch_table)
+        if len(lang_mismatch_files) > limit_mismatch:
+             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")
@@ -111,11 +187,14 @@ def scan(
     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))
 
-    if missing_map:
+    if missing_map or lang_mismatch_files:
         raise typer.Exit(code=1)

monoco/features/i18n/core.py

@@ -1,9 +1,17 @@
 import os
 import fnmatch
 from pathlib import Path
-from typing import List, Set, Dict, Any
+from typing import List, Set, Dict, Any, Optional
+import re
 
-DEFAULT_EXCLUDES = [".git", ".reference", "dist", "build", "node_modules", "__pycache__", ".agent", ".mono", ".venv", "venv", "ENV", "Issues"]
+DEFAULT_EXCLUDES = [
+    ".git", ".reference", "dist", "build", "node_modules", "__pycache__", 
+    ".agent", ".mono", ".venv", "venv", "ENV",
+    # Agent Integration Directories
+    ".claude", ".gemini", ".qwen", ".openai", ".cursor", ".vscode", ".idea", ".fleet",
+    # System Prompts & Agent Configs
+    "AGENTS.md", "CLAUDE.md", "GEMINI.md", "QWEN.md", "SKILL.md"
+]
 
 def load_gitignore_patterns(root: Path) -> List[str]:
     """Load patterns from .gitignore file."""
@@ -25,13 +33,15 @@ def load_gitignore_patterns(root: Path) -> List[str]:
         pass
     return patterns
 
-def is_excluded(path: Path, root: Path, patterns: List[str]) -> 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 DEFAULT_EXCLUDES]:
+        if part.lower() in [e.lower() for e in final_excludes]:
             return True
             
     # 2. Check gitignore patterns
@@ -55,15 +65,19 @@ def is_excluded(path: Path, root: Path, patterns: List[str]) -> bool:
 
     return False
 
-def discover_markdown_files(root: Path) -> List[Path]:
+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, 
     # but for now rglob + filter is simpler.
     for p in root.rglob("*.md"):
-        if p.is_file() and not is_excluded(p, root, patterns):
+        if p.is_file() and not is_excluded(p, root, patterns, excludes=excludes):
             all_md_files.append(p)
             
     return sorted(all_md_files)
@@ -77,6 +91,12 @@ def is_translation_file(path: Path, target_langs: List[str]) -> bool:
     for lang in normalized_langs:
         if stem_upper.endswith(f"_{lang.upper()}"):
             return True
+
+    # 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):
+        return True
             
     # Subdir check (case-insensitive)
     path_parts_lower = [p.lower() for p in path.parts]
@@ -86,29 +106,32 @@ def is_translation_file(path: Path, target_langs: List[str]) -> bool:
             
     return False
 
-def get_target_translation_path(path: Path, root: Path, lang: str) -> 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/...
-    # We assume 'en' is the source language for now.
     path_parts = list(path.parts)
-    # Search for 'en' component to replace
-    # We iterate from root relative parts to be safe, but simple replacement of the first 'en' 
-    # component (if not part of filename) is a good heuristic for docs structure.
+    # Search for source_lang component to replace
     for i, part in enumerate(path_parts):
-        if part.lower() == 'en':
+        if part.lower() == source_lang.lower():
             path_parts[i] = lang
             return Path(*path_parts)
 
-    # Suffix Mode: for root files
+    # Suffix Mode:
+    # If stem ends with _{SOURCE_LANG}, strip it.
+    stem = path.stem
+    source_suffix = f"_{source_lang.upper()}"
+    if stem.upper().endswith(source_suffix):
+         stem = stem[:-len(source_suffix)]
+         
     if path.parent == root:
-        return path.with_name(f"{path.stem}_{lang.upper()}{path.suffix}")
+        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]) -> 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.
@@ -116,12 +139,85 @@ def check_translation_exists(path: Path, root: Path, target_langs: List[str]) ->
     if is_translation_file(path, target_langs):
         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"]:
+        effective_source_lang = "en"
+    
     missing = []
     for lang in target_langs:
-        target = get_target_translation_path(path, root, lang)
+        # Skip if target language matches the effective source language
+        if lang.lower() == effective_source_lang.lower():
+            continue
+
+        target = get_target_translation_path(path, root, lang, effective_source_lang)
         if not target.exists():
             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'
+        
+    # 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)
+    
+    if not content.strip():
+        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')
+    
+    # If > 5% chars are CJK, highly likely to be Chinese document
+    if total_chars > 0 and cjk_count / total_chars > 0.05:
+        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'
+
+def is_content_source_language(path: Path, source_lang: str = "en") -> bool:
+    """
+    Check if file content appears to be in the source language.
+    """
+    try:
+        # Special handling for README/CHANGELOG
+        if path.name.upper() in ["README.MD", "CHANGELOG.MD"]:
+            source_lang = "en"
+
+        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':
+            return True
+            
+        # Normalize source_lang
+        expected = source_lang.lower()
+        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
 # ... (Existing code) ...
 
 SKILL_CONTENT = """---