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

monoco/daemon/services.py

@@ -46,69 +46,25 @@ class Broadcaster:
         logger.debug(f"Broadcasted {event_type} to {len(self.subscribers)} clients.")
 
 
-class GitMonitor:
-    """
-    Polls the Git repository for HEAD changes and triggers updates.
-    """
-    def __init__(self, broadcaster: Broadcaster, poll_interval: float = 2.0):
-        self.broadcaster = broadcaster
-        self.poll_interval = poll_interval
-        self.last_head_hash: Optional[str] = None
-        self.is_running = False
-
-    async def get_head_hash(self) -> Optional[str]:
-        try:
-            # Run git rev-parse HEAD asynchronously
-            process = await asyncio.create_subprocess_exec(
-                "git", "rev-parse", "HEAD",
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            stdout, _ = await process.communicate()
-            if process.returncode == 0:
-                return stdout.decode().strip()
-            return None
-        except Exception as e:
-            logger.error(f"Git polling error: {e}")
-            return None
-
-    async def start(self):
-        self.is_running = True
-        logger.info("Git Monitor started.")
-        
-        # Initial check
-        self.last_head_hash = await self.get_head_hash()
-        
-        while self.is_running:
-            await asyncio.sleep(self.poll_interval)
-            current_hash = await self.get_head_hash()
-            
-            if current_hash and current_hash != self.last_head_hash:
-                logger.info(f"Git HEAD changed: {self.last_head_hash} -> {current_hash}")
-                self.last_head_hash = current_hash
-                await self.broadcaster.broadcast("HEAD_UPDATED", {
-                    "ref": "HEAD",
-                    "hash": current_hash
-                })
-
-    def stop(self):
-        self.is_running = False
-        logger.info("Git Monitor stopping...")
+# Monitors moved to monoco.core.git and monoco.features.issue.monitor
 
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 from monoco.core.config import MonocoConfig, get_config
 
+from monoco.core.workspace import MonocoProject, Workspace
+
 class ProjectContext:
     """
     Holds the runtime state for a single project.
+    Now wraps the core MonocoProject primitive.
     """
-    def __init__(self, path: Path, config: MonocoConfig, broadcaster: Broadcaster):
-        self.path = path
-        self.config = config
-        self.id = path.name  # Use directory name as ID for now
-        self.name = config.project.name
-        self.issues_root = path / config.paths.issues
+    def __init__(self, project: MonocoProject, broadcaster: Broadcaster):
+        self.project = project
+        self.id = project.id
+        self.name = project.name
+        self.path = project.path
+        self.issues_root = project.issues_root
         self.monitor = IssueMonitor(self.issues_root, broadcaster, project_id=self.id)
 
     async def start(self):
@@ -120,6 +76,7 @@ class ProjectContext:
 class ProjectManager:
     """
     Discovers and manages multiple Monoco projects within a workspace.
+    Uses core Workspace primitive for discovery.
     """
     def __init__(self, workspace_root: Path, broadcaster: Broadcaster):
         self.workspace_root = workspace_root
@@ -128,28 +85,16 @@ class ProjectManager:
 
     def scan(self):
         """
-        Scans workspace for potential Monoco projects.
-        A directory is a project if it has monoco.yaml or .monoco/config.yaml or an Issues directory.
+        Scans workspace for Monoco projects using core logic.
         """
         logger.info(f"Scanning workspace: {self.workspace_root}")
-        from monoco.core.workspace import find_projects
+        workspace = Workspace.discover(self.workspace_root)
         
-        projects = find_projects(self.workspace_root)
-        for p in projects:
-            self._register_project(p)
-
-    def _register_project(self, path: Path):
-        try:
-            config = get_config(str(path))
-            # If name is default, try to use directory name
-            if config.project.name == "Monoco Project":
-                config.project.name = path.name
-            
-            ctx = ProjectContext(path, config, self.broadcaster)
-            self.projects[ctx.id] = ctx
-            logger.info(f"Registered project: {ctx.id} ({ctx.path})")
-        except Exception as e:
-            logger.error(f"Failed to register project at {path}: {e}")
+        for project in workspace.projects:
+            if project.id not in self.projects:
+                ctx = ProjectContext(project, self.broadcaster)
+                self.projects[ctx.id] = ctx
+                logger.info(f"Registered project: {ctx.id} ({ctx.path})")
 
     async def start_all(self):
         self.scan()
@@ -174,92 +119,48 @@ class ProjectManager:
             for p in self.projects.values()
         ]
 
-class IssueEventHandler(FileSystemEventHandler):
-    def __init__(self, loop, broadcaster: Broadcaster, project_id: str):
-        self.loop = loop
-        self.broadcaster = broadcaster
-        self.project_id = project_id
-
-    def _process_upsert(self, path_str: str):
-        if not path_str.endswith(".md"):
-            return
-        asyncio.run_coroutine_threadsafe(self._handle_upsert(path_str), self.loop)
-    
-    async def _handle_upsert(self, path_str: str):
-        try:
-            path = Path(path_str)
-            if not path.exists():
-                return
-            issue = parse_issue(path)
-            if issue:
-                await self.broadcaster.broadcast("issue_upserted", {
-                    "issue": issue.model_dump(mode='json'),
-                    "project_id": self.project_id
-                })
-        except Exception as e:
-            logger.error(f"Error handling upsert for {path_str}: {e}")
+from monoco.features.issue.monitor import IssueMonitor
 
-    def _process_delete(self, path_str: str):
-        if not path_str.endswith(".md"):
-            return
-        asyncio.run_coroutine_threadsafe(self._handle_delete(path_str), self.loop)
-
-    async def _handle_delete(self, path_str: str):
-        try:
-            filename = Path(path_str).name
-            match = re.match(r"([A-Z]+-\d{4})", filename)
-            if match:
-                issue_id = match.group(1)
-                await self.broadcaster.broadcast("issue_deleted", {
-                    "id": issue_id,
-                    "project_id": self.project_id
-                })
-        except Exception as e:
-            logger.error(f"Error handling delete for {path_str}: {e}")
-
-    def on_created(self, event):
-        if not event.is_directory:
-            self._process_upsert(event.src_path)
-
-    def on_modified(self, event):
-        if not event.is_directory:
-            self._process_upsert(event.src_path)
-            
-    def on_deleted(self, event):
-        if not event.is_directory:
-            self._process_delete(event.src_path)
-
-    def on_moved(self, event):
-        if not event.is_directory:
-            self._process_delete(event.src_path)
-            self._process_upsert(event.dest_path)
-
-class IssueMonitor:
+class ProjectContext:
     """
-    Monitor the Issues directory for changes using Watchdog and broadcast update events.
+    Holds the runtime state for a single project.
+    Now wraps the core MonocoProject primitive.
     """
-    def __init__(self, issues_root: Path, broadcaster: Broadcaster, project_id: str):
-        self.issues_root = issues_root
-        self.broadcaster = broadcaster
-        self.project_id = project_id
-        self.observer = Observer()
-        self.loop = None
-
-    async def start(self):
-        self.loop = asyncio.get_running_loop()
-        event_handler = IssueEventHandler(self.loop, self.broadcaster, self.project_id)
+    def __init__(self, project: MonocoProject, broadcaster: Broadcaster):
+        self.project = project
+        self.id = project.id
+        self.name = project.name
+        self.path = project.path
+        self.issues_root = project.issues_root
         
-        # Ensure directory exists
-        if not self.issues_root.exists():
-            logger.warning(f"Issues root {self.issues_root} does not exist. creating...")
-            self.issues_root.mkdir(parents=True, exist_ok=True)
+        async def on_upsert(issue_data: dict):
+            await broadcaster.broadcast("issue_upserted", {
+                "issue": issue_data,
+                "project_id": self.id
+            })
+
+        async def on_delete(issue_data: dict):
+            # We skip broadcast here if it's part of a move?
+            # Actually, standard upsert/delete is fine, but we need a specialized event for MOVE 
+            # to help VS Code redirect without closing/reopening.
+            await broadcaster.broadcast("issue_deleted", {
+                "id": issue_data["id"],
+                "project_id": self.id
+            })
+
+        self.monitor = IssueMonitor(self.issues_root, on_upsert, on_delete)
+
+    async def notify_move(self, old_path: str, new_path: str, issue_data: dict):
+        """Explicitly notify frontend about a logical move (Physical path changed)."""
+        await self.broadcaster.broadcast("issue_moved", {
+            "old_path": old_path,
+            "new_path": new_path,
+            "issue": issue_data,
+            "project_id": self.id
+        })
 
-        self.observer.schedule(event_handler, str(self.issues_root), recursive=True)
-        self.observer.start()
-        logger.info(f"Issue Monitor started (Watchdog). Watching {self.issues_root}")
+    async def start(self):
+        await self.monitor.start()
 
     def stop(self):
-        if self.observer.is_alive():
-            self.observer.stop()
-            self.observer.join()
-        logger.info("Issue Monitor stopped.")
+        self.monitor.stop()

monoco/features/config/commands.py

@@ -1,70 +1,151 @@
 import typer
 import yaml
+import json
 from pathlib import Path
-from typing import Optional
-from monoco.core.config import get_config, MonocoConfig
-from monoco.core.output import print_output
+from typing import Optional, Any, Annotated
 from rich.console import Console
+from rich.syntax import Syntax
+from pydantic import ValidationError
+
+from monoco.core.config import (
+    get_config,
+    MonocoConfig,
+    ConfigScope,
+    load_raw_config,
+    save_raw_config,
+    get_config_path
+)
+from monoco.core.output import AgentOutput, OutputManager
 
 app = typer.Typer(help="Manage Monoco configuration")
 console = Console()
 
+def _parse_value(value: str) -> Any:
+    """Parse string value into appropriate type (bool, int, float, str)."""
+    if value.lower() in ("true", "yes", "on"):
+        return True
+    if value.lower() in ("false", "no", "off"):
+        return False
+    if value.lower() == "null":
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        try:
+            return float(value)
+        except ValueError:
+            return value
+
+@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:
+        yaml_str = yaml.dump(data, default_flow_style=False)
+        syntax = Syntax(yaml_str, "yaml")
+        console.print(syntax)
+
 @app.command()
-def show():
-    """Show current configuration."""
-    settings = get_config()
-    print_output(settings, title="Current Configuration")
+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()
+    
+    parts = key.split(".")
+    current = data
+    
+    for part in parts:
+        if isinstance(current, dict) and part in current:
+            current = current[part]
+        else:
+            OutputManager.error(f"Key '{key}' not found.")
+            raise typer.Exit(code=1)
+            
+    if OutputManager.is_agent_mode():
+        OutputManager.print({"key": key, "value": current})
+    else:
+        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"),
-    scope: str = typer.Option("global", "--scope", "-s", help="Configuration scope: global or project")
+    global_scope: bool = typer.Option(False, "--global", "-g", help="Update global configuration"),
+    json_output: AgentOutput = False,
 ):
-    """Set a configuration value."""
-    # This is a simplified implementation of config setting
-    # In a real system, we'd want to validate the key against the schema
+    """Set a configuration value in specific scope (project by default)."""
+    scope = ConfigScope.GLOBAL if global_scope else ConfigScope.PROJECT
     
-    if scope == "global":
-        config_path = Path.home() / ".monoco" / "config.yaml"
-    else:
-        # Check project root
-        cwd = Path.cwd()
-        config_path = cwd / ".monoco" / "config.yaml"
-        if not (cwd / ".monoco").exists():
-             config_path = cwd / "monoco.yaml"
-
-    config_data = {}
-    if config_path.exists():
-        with open(config_path, "r") as f:
-            config_data = yaml.safe_load(f) or {}
-
-    # Simple nested key support (e.g. telemetry.enabled)
+    # 1. Load Raw Config for the target scope
+    raw_data = load_raw_config(scope)
+    
+    # 2. Parse Key & Update Data
     parts = key.split(".")
-    target = config_data
-    for part in parts[:-1]:
+    target = raw_data
+    
+    # Context management for nested updates
+    for i, part in enumerate(parts[:-1]):
         if part not in target:
             target[part] = {}
         target = target[part]
+        if not isinstance(target, dict):
+            parent_key = ".".join(parts[:i+1])
+            OutputManager.error(f"Cannot set '{key}': '{parent_key}' is not a dictionary ({type(target)}).")
+            raise typer.Exit(code=1)
+            
+    parsed_val = _parse_value(value)
+    target[parts[-1]] = parsed_val
     
-    # Type conversion
-    if value.lower() in ("true", "yes", "on"):
-        val = True
-    elif value.lower() in ("false", "no", "off"):
-        val = False
-    else:
-        try:
-            val = int(value)
-        except ValueError:
-            val = value
+    # 3. Validate against Schema
+    # We simulate a full load by creating a temporary MonocoConfig with these overrides.
+    # Note: This validation is "active" - we want to ensure the resulting config WOULD be valid.
+    # However, raw_data is partial. Pydantic models with defaults will accept partials.
+    try:
+        # We can try to validate just the relevant model part if we knew which one it was.
+        # But simpler is to check if MonocoConfig accepts this structure.
+        MonocoConfig(**raw_data)
+    except ValidationError as e:
+        OutputManager.error(f"Validation failed for key '{key}':\n{e}")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        OutputManager.error(f"Unexpected validation error: {e}")
+        raise typer.Exit(code=1)
 
-    target[parts[-1]] = val
-
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    with open(config_path, "w") as f:
-        yaml.dump(config_data, f, default_flow_style=False)
+    # 4. Save
+    save_raw_config(scope, raw_data)
+    
+    scope_display = "Global" if global_scope else "Project"
     
-    console.print(f"[green]✓ Set {key} = {val} in {scope} 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/adapter.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from typing import Dict
+from monoco.core.feature import MonocoFeature, IntegrationData
+from monoco.features.i18n import core
+
+class I18nFeature(MonocoFeature):
+    @property
+    def name(self) -> str:
+        return "i18n"
+
+    def initialize(self, root: Path, config: Dict) -> None:
+        core.init(root)
+
+    def integrate(self, root: Path, config: Dict) -> IntegrationData:
+        # Determine language from config, default to 'en'
+        lang = config.get("i18n", {}).get("source_lang", "en")
+        base_dir = Path(__file__).parent / "resources"
+        
+        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={"Documentation I18n": content}
+        )

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)