monoco-toolkit 0.1.0__py3-none-any.whl

monoco/core/config.py

@@ -0,0 +1,113 @@
+import os
+import yaml
+from pathlib import Path
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+class PathsConfig(BaseModel):
+    """Configuration for directory paths."""
+    root: str = Field(default=".", description="Project root directory")
+    issues: str = Field(default="Issues", description="Directory for issues")
+    spikes: str = Field(default=".references", description="Directory for spikes/research")
+    specs: str = Field(default="SPECS", description="Directory for specifications")
+
+class CoreConfig(BaseModel):
+    """Core system configuration."""
+    editor: str = Field(default_factory=lambda: os.getenv("EDITOR", "vim"), description="Preferred text editor")
+    log_level: str = Field(default="INFO", description="Logging verbosity")
+    author: Optional[str] = Field(default=None, description="Default author for new artifacts")
+
+class ProjectConfig(BaseModel):
+    """Project identity configuration."""
+    name: str = Field(default="Monoco Project", description="Project name")
+    key: str = Field(default="MON", description="Project key/prefix for IDs")
+    spike_repos: Dict[str, str] = Field(default_factory=dict, description="Managed external research repositories (name -> url)")
+    members: Dict[str, str] = Field(default_factory=dict, description="Workspace member projects (name -> relative_path)")
+
+class I18nConfig(BaseModel):
+    """Configuration for internationalization."""
+    source_lang: str = Field(default="en", description="Source language code")
+    target_langs: list[str] = Field(default_factory=lambda: ["zh"], description="Target language codes")
+
+class UIConfig(BaseModel):
+    """Configuration for UI customizations."""
+    dictionary: Dict[str, str] = Field(default_factory=dict, description="Custom domain terminology mapping")
+
+class TelemetryConfig(BaseModel):
+    """Configuration for Telemetry."""
+    enabled: Optional[bool] = Field(default=None, description="Whether telemetry is enabled")
+
+class MonocoConfig(BaseModel):
+    """
+    Main Configuration Schema.
+    Hierarchy: Defaults < User Config (~/.monoco/config.yaml) < Project Config (./.monoco/config.yaml)
+    """
+    core: CoreConfig = Field(default_factory=CoreConfig)
+    paths: PathsConfig = Field(default_factory=PathsConfig)
+    project: ProjectConfig = Field(default_factory=ProjectConfig)
+    i18n: I18nConfig = Field(default_factory=I18nConfig)
+    ui: UIConfig = Field(default_factory=UIConfig)
+    telemetry: TelemetryConfig = Field(default_factory=TelemetryConfig)
+
+    @staticmethod
+    def _deep_merge(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
+        """Recursive dict merge."""
+        for k, v in update.items():
+            if isinstance(v, dict) and k in base and isinstance(base[k], dict):
+                MonocoConfig._deep_merge(base[k], v)
+            else:
+                base[k] = v
+        return base
+
+    @classmethod
+    def load(cls, project_root: Optional[str] = None) -> "MonocoConfig":
+        """
+        Load configuration from multiple sources.
+        """
+        # 1. Start with empty dict (will use defaults via Pydantic)
+        config_data = {}
+
+        # 2. Define config paths
+        home_path = Path.home() / ".monoco" / "config.yaml"
+        
+        # Determine project path
+        cwd = Path(project_root) if project_root else Path.cwd()
+        proj_path_hidden = cwd / ".monoco" / "config.yaml"
+        proj_path_root = cwd / "monoco.yaml"
+
+        # 3. Load User Config
+        if home_path.exists():
+            try:
+                with open(home_path, "r") as f:
+                    user_config = yaml.safe_load(f)
+                    if user_config:
+                        cls._deep_merge(config_data, user_config)
+            except Exception as e:
+                # We don't want to crash on config load fail, implementing simple warning equivalent
+                pass
+
+        # 4. Load Project Config (prefer .monoco/config.yaml, fallback to monoco.yaml)
+        target_proj_conf = proj_path_hidden if proj_path_hidden.exists() else (
+            proj_path_root if proj_path_root.exists() else None
+        )
+
+        if target_proj_conf:
+            try:
+                with open(target_proj_conf, "r") as f:
+                    proj_config = yaml.safe_load(f)
+                    if proj_config:
+                        cls._deep_merge(config_data, proj_config)
+            except Exception:
+                pass
+
+        # 5. Instantiate Model
+        return cls(**config_data)
+
+# Global singleton
+_settings = None
+
+def get_config(project_root: Optional[str] = None) -> MonocoConfig:
+    global _settings
+    if _settings is None or project_root is not None:
+        _settings = MonocoConfig.load(project_root)
+    return _settings

monoco/core/git.py

@@ -0,0 +1,184 @@
+import subprocess
+import shutil
+from pathlib import Path
+from typing import List, Tuple, Optional, Dict
+
+def _run_git(args: List[str], cwd: Path) -> Tuple[int, str, str]:
+    """Run a raw git command."""
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return 1, "", "Git executable not found"
+
+def is_git_repo(path: Path) -> bool:
+    code, _, _ = _run_git(["rev-parse", "--is-inside-work-tree"], path)
+    return code == 0
+
+def get_git_status(path: Path, subpath: Optional[str] = None) -> List[str]:
+    """
+    Get list of modified files.
+    If subpath is provided, only check that path.
+    """
+    cmd = ["status", "--porcelain"]
+    if subpath:
+        cmd.append(subpath)
+        
+    code, stdout, _ = _run_git(cmd, path)
+    if code != 0:
+        raise RuntimeError("Failed to check git status")
+        
+    lines = []
+    for line in stdout.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        # Porcelain format: XY PATH
+        if len(line) > 3:
+            path_str = line[3:]
+            if path_str.startswith('"') and path_str.endswith('"'):
+                path_str = path_str[1:-1]
+            lines.append(path_str)
+    return lines
+
+def git_add(path: Path, files: List[str]) -> None:
+    if not files:
+        return
+    code, _, stderr = _run_git(["add"] + files, path)
+    if code != 0:
+        raise RuntimeError(f"Git add failed: {stderr}")
+
+def git_commit(path: Path, message: str) -> str:
+    code, stdout, stderr = _run_git(["commit", "-m", message], path)
+    if code != 0:
+        raise RuntimeError(f"Git commit failed: {stderr}")
+    
+    code, hash_out, _ = _run_git(["rev-parse", "HEAD"], path)
+    return hash_out.strip()
+
+def search_commits_by_message(path: Path, grep_pattern: str) -> List[Dict[str, str]]:
+    cmd = ["log", f"--grep={grep_pattern}", "--name-only", "--format=COMMIT:%H|%s"]
+    code, stdout, stderr = _run_git(cmd, path)
+    if code != 0:
+        raise RuntimeError(f"Git log failed: {stderr}")
+        
+    commits = []
+    current_commit = None
+    
+    for line in stdout.splitlines():
+        if line.startswith("COMMIT:"):
+            if current_commit:
+                commits.append(current_commit)
+            
+            parts = line[7:].split("|", 1)
+            current_commit = {
+                "hash": parts[0],
+                "subject": parts[1] if len(parts) > 1 else "",
+                "files": []
+            }
+        elif line.strip():
+            if current_commit:
+                current_commit["files"].append(line.strip())
+                
+    if current_commit:
+        commits.append(current_commit)
+        
+    return commits
+
+def get_commit_stats(path: Path, commit_hash: str) -> Dict[str, int]:
+    cmd = ["show", "--shortstat", "--format=", commit_hash]
+    code, stdout, _ = _run_git(cmd, path)
+    stats = {"files": 0, "insertions": 0, "deletions": 0}
+    if code == 0 and stdout.strip():
+        parts = stdout.strip().split(",")
+        for p in parts:
+            p = p.strip()
+            if "file" in p:
+                stats["files"] = int(p.split()[0])
+            elif "insertion" in p:
+                stats["insertions"] = int(p.split()[0])
+            elif "deletion" in p:
+                stats["deletions"] = int(p.split()[0])
+    return stats
+
+# --- Branch & Worktree Extensions ---
+
+def get_current_branch(path: Path) -> str:
+    code, stdout, _ = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], path)
+    if code != 0:
+        return ""
+    return stdout.strip()
+
+def branch_exists(path: Path, branch_name: str) -> bool:
+    code, _, _ = _run_git(["rev-parse", "--verify", branch_name], path)
+    return code == 0
+
+def create_branch(path: Path, branch_name: str, checkout: bool = False):
+    cmd = ["checkout", "-b", branch_name] if checkout else ["branch", branch_name]
+    code, _, stderr = _run_git(cmd, path)
+    if code != 0:
+        raise RuntimeError(f"Failed to create branch {branch_name}: {stderr}")
+
+def checkout_branch(path: Path, branch_name: str):
+    code, _, stderr = _run_git(["checkout", branch_name], path)
+    if code != 0:
+        raise RuntimeError(f"Failed to checkout {branch_name}: {stderr}")
+
+def delete_branch(path: Path, branch_name: str, force: bool = False):
+    flag = "-D" if force else "-d"
+    code, _, stderr = _run_git(["branch", flag, branch_name], path)
+    if code != 0:
+        raise RuntimeError(f"Failed to delete branch {branch_name}: {stderr}")
+
+def get_worktrees(path: Path) -> List[Tuple[str, str, str]]:
+    """Returns list of (path, head, branch)"""
+    code, stdout, stderr = _run_git(["worktree", "list", "--porcelain"], path)
+    if code != 0:
+        raise RuntimeError(f"Failed to list worktrees: {stderr}")
+    
+    trees = []
+    current = {}
+    for line in stdout.splitlines():
+        if line.startswith("worktree "):
+            if current:
+                trees.append((current.get("worktree"), current.get("HEAD"), current.get("branch")))
+            current = {"worktree": line[9:].strip()}
+        elif line.startswith("HEAD "):
+            current["HEAD"] = line[5:].strip()
+        elif line.startswith("branch "):
+            current["branch"] = line[7:].strip()
+            
+    if current:
+        trees.append((current.get("worktree"), current.get("HEAD"), current.get("branch")))
+    return trees
+
+def worktree_add(path: Path, branch_name: str, worktree_path: Path):
+    # If branch doesn't exist, -b will create it. 
+    # Logic: git worktree add [-b <new_branch>] <path> <commit-ish>
+    
+    # We assume if branch_exists, use it. If not, create it.
+    cmd = ["worktree", "add"]
+    if not branch_exists(path, branch_name):
+        cmd.extend(["-b", branch_name])
+    
+    cmd.extend([str(worktree_path), branch_name])
+    
+    code, _, stderr = _run_git(cmd, path)
+    if code != 0:
+        raise RuntimeError(f"Failed to create worktree: {stderr}")
+
+def worktree_remove(path: Path, worktree_path: Path, force: bool = False):
+    cmd = ["worktree", "remove"]
+    if force:
+        cmd.append("--force")
+    cmd.append(str(worktree_path))
+    
+    code, _, stderr = _run_git(cmd, path)
+    if code != 0:
+        raise RuntimeError(f"Failed to remove worktree: {stderr}")

monoco/core/output.py

@@ -0,0 +1,97 @@
+import os
+import json
+import typer
+from typing import Any, List, Union, Annotated
+from pydantic import BaseModel
+from rich.console import Console
+from rich.table import Table
+from rich import print as rprint
+
+def _set_agent_mode(value: bool):
+    if value:
+        os.environ["AGENT_FLAG"] = "true"
+
+# Reusable dependency for commands
+AgentOutput = Annotated[bool, typer.Option("--json", help="Output in compact JSON for Agents", callback=_set_agent_mode)]
+
+class OutputManager:
+    """
+    Manages output rendering based on the environment (Human vs Agent).
+    """
+
+    @staticmethod
+    def is_agent_mode() -> bool:
+        """
+        Check if running in Agent Mode.
+        Triggers:
+        1. Environment variable AGENT_FLAG=true (or 1)
+        2. Environment variable MONOCO_AGENT=true (or 1)
+        """
+        return os.getenv("AGENT_FLAG", "").lower() in ("true", "1") or \
+               os.getenv("MONOCO_AGENT", "").lower() in ("true", "1")
+
+    @staticmethod
+    def print(data: Union[BaseModel, List[BaseModel], dict, list, str], title: str = ""):
+        """
+        Dual frontend dispatcher.
+        """
+        if OutputManager.is_agent_mode():
+            OutputManager._render_agent(data)
+        else:
+            OutputManager._render_human(data, title)
+
+    @staticmethod
+    def _render_agent(data: Any):
+        """
+        Agent channel: Zero decoration, Pure Data, Max Token Density.
+        Uses compact JSON.
+        """
+        if isinstance(data, BaseModel):
+            print(data.model_dump_json(exclude_none=True))
+        elif isinstance(data, list) and all(isinstance(item, BaseModel) for item in data):
+            # Pydantic v2 adapter for list of models
+            print(json.dumps([item.model_dump(mode='json', exclude_none=True) for item in data], separators=(',', ':')))
+        else:
+            # Fallback for dicts/lists/primitives
+            try:
+                print(json.dumps(data, separators=(',', ':'), default=str))
+            except TypeError:
+                print(str(data))
+
+    @staticmethod
+    def _render_human(data: Any, title: str):
+        """
+        Human channel: Visual priority.
+        """
+        console = Console()
+        
+        if title:
+            console.rule(f"[bold blue]{title}[/bold blue]")
+
+        if isinstance(data, str):
+            console.print(data)
+            return
+
+        # Special handling for Lists of Pydantic Models -> Table
+        if isinstance(data, list) and data and isinstance(data[0], BaseModel):
+            table = Table(show_header=True, header_style="bold magenta")
+            
+            # Introspect fields from the first item
+            model_type = type(data[0])
+            fields = model_type.model_fields.keys()
+            
+            for field in fields:
+                table.add_column(field.replace("_", " ").title())
+            
+            for item in data:
+                row = [str(getattr(item, field)) for field in fields]
+                table.add_row(*row)
+            
+            console.print(table)
+            return
+            
+        # Fallback to rich pretty print
+        rprint(data)
+
+# Global helper
+print_output = OutputManager.print

monoco/core/setup.py

@@ -0,0 +1,285 @@
+import os
+import subprocess
+import yaml
+from pathlib import Path
+import typer
+from rich.console import Console
+from monoco.core.output import print_output
+
+console = Console()
+
+def get_git_user() -> str:
+    try:
+        result = subprocess.run(
+            ["git", "config", "user.name"], 
+            capture_output=True, 
+            text=True, 
+            timeout=1
+        )
+        return result.stdout.strip()
+    except Exception:
+        return ""
+
+def generate_key(name: str) -> str:
+    """Generate a 3-4 letter uppercase key from name."""
+    # Strategy 1: Upper case of first letters of words
+    parts = name.split()
+    if len(parts) >= 2:
+        candidate = "".join(p[0] for p in parts[:4]).upper()
+        if len(candidate) >= 2:
+            return candidate
+    
+    # Strategy 2: First 3 letters
+    return name[:3].upper()
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.layout.containers import Window, HSplit
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.styles import Style
+import sys
+
+def ask_with_selection(message: str, default: str) -> str:
+    """Provides a selection-based prompt for stable rendering."""
+    options = [f"{default} (Default)", "Custom Input..."]
+    selected_index = 0
+    
+    kb = KeyBindings()
+    
+    @kb.add('up')
+    @kb.add('k')
+    def _(event):
+        nonlocal selected_index
+        selected_index = (selected_index - 1) % len(options)
+
+    @kb.add('down')
+    @kb.add('j')
+    def _(event):
+        nonlocal selected_index
+        selected_index = (selected_index + 1) % len(options)
+
+    @kb.add('enter')
+    def _(event):
+        event.app.exit(result=selected_index)
+
+    @kb.add('c-c')
+    def _(event):
+        console.print("\n[red]Aborted by user.[/red]")
+        sys.exit(0)
+
+    def get_text():
+        # Render the menu with explicit highlighting
+        res = [('class:message', f"{message}:\n")]
+        for i, opt in enumerate(options):
+            if i == selected_index:
+                res.append(('class:selected', f" ➔ {opt}\n"))
+            else:
+                res.append(('class:unselected', f"   {opt}\n"))
+        return res
+
+    style = Style.from_dict({
+        'message': 'bold #ffffff',
+        'selected': 'bold #00ff00', # High contrast green
+        'unselected': '#888888',
+    })
+
+    # Run a mini application to handle the selection
+    app = Application(
+        layout=Layout(HSplit([Window(content=FormattedTextControl(get_text), height=len(options)+1)])),
+        key_bindings=kb,
+        style=style,
+        full_screen=False,
+    )
+    
+    # Flush stdout to ensure previous output is visible
+    sys.stdout.flush()
+    
+    choice = app.run()
+    
+    if choice == 0:
+        return default
+    else:
+        # Prompt for custom input
+        from prompt_toolkit import prompt
+        return prompt(f"Enter custom {message.lower()}: ").strip() or default
+
+def init_cli(
+    ctx: typer.Context, 
+    global_only: bool = typer.Option(False, "--global", help="Only configure global user settings"),
+    project_only: bool = typer.Option(False, "--project", help="Only configure current project")
+):
+    """
+    Initialize Monoco configuration (Global and/or Project).
+    """
+    from rich.prompt import Confirm
+    
+    home_dir = Path.home() / ".monoco"
+    global_config_path = home_dir / "config.yaml"
+    
+    # --- 1. Global Configuration ---
+    if not project_only:
+        if not global_config_path.exists() or global_only:
+            console.rule("[bold blue]Global Setup[/bold blue]")
+            
+            # Ensure ~/.monoco exists
+            home_dir.mkdir(parents=True, exist_ok=True)
+            
+            default_author = get_git_user() or os.getenv("USER", "developer")
+            author = ask_with_selection("Your Name (for issue tracking)", default_author)
+            
+            telemetry_enabled = Confirm.ask("Enable anonymous telemetry to help improve Monoco?", default=True)
+
+            user_config = {
+                "core": {
+                    "author": author,
+                    # Editor is handled by env/config defaults, no need to prompt
+                },
+                "telemetry": {
+                    "enabled": telemetry_enabled
+                }
+            }
+            
+            with open(global_config_path, "w") as f:
+                yaml.dump(user_config, f, default_flow_style=False)
+                
+            console.print(f"[green]✓ Global config saved to {global_config_path}[/green]\n")
+
+    if global_only:
+        return
+
+    # --- 2. Project Configuration ---
+    cwd = Path.cwd()
+    project_config_dir = cwd / ".monoco"
+    project_config_path = project_config_dir / "config.yaml"
+    
+    # Check if we should init project
+    if project_config_path.exists():
+        if not Confirm.ask(f"Project config already exists at [dim]{project_config_path}[/dim]. Overwrite?"):
+            console.print("[yellow]Skipping project initialization.[/yellow]")
+            return
+
+    console.rule("[bold blue]Project Setup[/bold blue]")
+    
+    default_name = cwd.name
+    project_name = ask_with_selection("Project Name", default_name)
+    
+    default_key = generate_key(project_name)
+    project_key = ask_with_selection("Project Key (prefix for issues)", default_key)
+
+    
+    project_config_dir.mkdir(exist_ok=True)
+    
+    project_config = {
+        "project": {
+            "name": project_name,
+            "key": project_key
+        },
+        "paths": {
+            "issues": "Issues",
+            "spikes": ".references",
+            "specs": "SPECS"
+        }
+    }
+    
+    with open(project_config_path, "w") as f:
+        yaml.dump(project_config, f, default_flow_style=False)
+
+    # 2b. Generate Config Template
+    template_path = project_config_dir / "config_template.yaml"
+    template_content = """# Monoco Configuration Template
+# This file serves as a reference for all available configuration options.
+# Rename this file to config.yaml to use it.
+
+core:
+  # Default author for new artifacts (e.g. issues)
+  # author: "Developer Name"
+  
+  # Logging verbosity (DEBUG, INFO, WARNING, ERROR)
+  # log_level: "INFO"
+  
+  # Preferred text editor
+  # editor: "vim"
+
+project:
+  # The display name of the project
+  name: "My Project"
+  
+  # The prefix used for issue IDs (e.g. MON-001)
+  key: "MON"
+  
+  # Managed external research repositories (name -> url)
+  # spike_repos:
+  #   react: "https://github.com/facebook/react"
+
+paths:
+  # Directory for tracking issues
+  issues: "Issues"
+  
+  # Directory for specifications/documents
+  specs: "SPECS"
+  
+  # Directory for research references (spikes)
+  spikes: ".references"
+
+i18n:
+  # Source language code
+  source_lang: "en"
+  
+  # Target language codes for translation
+  target_langs: 
+    - "zh"
+
+ui:
+  # Custom Domain Terminology Mapping
+  # Use this to rename core concepts in the UI without changing internal logic.
+  dictionary:
+    # Entities
+    epic: "Saga"
+    feature: "Story"
+    chore: "Task"
+    fix: "Bug"
+    
+    # Statuses
+    todo: "Pending"
+    doing: "In Progress"
+    review: "QA"
+    done: "Released"
+"""
+    with open(template_path, "w") as f:
+        f.write(template_content)
+
+    # 3. Scaffold Directories & Modules
+    
+    # Import Feature Cores locally to avoid circular deps if any (though setup is core)
+    from monoco.features.issue import core as issue_core
+    from monoco.features.spike import core as spike_core
+    from monoco.features.i18n import core as i18n_core
+    from monoco.features import skills
+
+    # Initialize Issues
+    issues_path = cwd / project_config["paths"]["issues"]
+    issue_core.init(issues_path)
+
+    # Initialize Spikes
+    spikes_name = project_config["paths"]["spikes"]
+    spike_core.init(cwd, spikes_name)
+
+    # Initialize I18n
+    i18n_core.init(cwd)
+
+    # Initialize Skills & Agent Docs
+    resources = [
+        issue_core.get_resources(),
+        spike_core.get_resources(),
+        i18n_core.get_resources()
+    ]
+    skills.init(cwd, resources)
+
+    console.print(f"[green]✓ Project config initialized at {project_config_path}[/green]")
+    console.print(f"[green]✓ Config template generated at {template_path}[/green]")
+
+
+
+    console.print(f"[green]Access configured! issues will be created as {project_key}-XXX[/green]")
+