agent-notes 2.0.4__py3-none-any.whl

agent_notes/commands/set_role.py

@@ -0,0 +1,143 @@
+"""Set role to model mapping in state.json."""
+
+import sys
+from pathlib import Path
+from typing import Optional, List
+
+from ..config import Color
+
+
+def set_role(role_name: str, model_id: str, cli: Optional[str] = None, scope: Optional[str] = None, local: bool = False) -> None:
+    """Update role→model assignment in state.json and regenerate affected files.
+    
+    Args:
+        role_name: Role to update (orchestrator, reasoner, worker, scout)
+        model_id: New model ID (must be in model registry)
+        cli: Target CLI name (auto-detect if only one CLI has this role in scope) 
+        scope: 'global' or 'local' (auto: global if exists, else local)
+        local: Shortcut for scope='local'
+    """
+    from .. import state as state_mod
+    from ..state import get_scope, set_scope
+    from ..registries.role_registry import load_role_registry
+    from ..registries.model_registry import load_model_registry
+    from ..registries.cli_registry import load_registry
+    from .. import install_state
+    
+    # Load state.json
+    current_state = state_mod.load()
+    if current_state is None:
+        print("No installation found. Run `agent-notes install` first.")
+        sys.exit(1)
+    
+    # Determine scope
+    if local:
+        scope = 'local'
+    elif scope is None:
+        # Auto-detect: prefer global if exists
+        if current_state.global_install is not None:
+            scope = 'global'
+        elif current_state.local_installs:
+            scope = 'local'
+        else:
+            print("No installation found.")
+            sys.exit(1)
+    
+    project_path = Path.cwd() if scope == 'local' else None
+    scope_state = get_scope(current_state, scope, project_path)
+    
+    if scope_state is None:
+        print(f"No {scope} installation found.")
+        sys.exit(1)
+    
+    # Validate role exists
+    role_registry = load_role_registry()
+    try:
+        role = role_registry.get(role_name)
+    except KeyError:
+        print(f"Unknown role: {role_name}")
+        print(f"Available roles: {', '.join(role_registry.names())}")
+        sys.exit(1)
+    
+    # Validate model exists and get it
+    model_registry = load_model_registry()
+    try:
+        model = model_registry.get(model_id)
+    except KeyError:
+        print(f"Unknown model: {model_id}")
+        print(f"Available models: {', '.join(model_registry.ids())}")
+        sys.exit(1)
+    
+    # Determine target CLI(s)
+    registry = load_registry()
+    
+    if cli == "all":
+        # Apply to all CLIs where model is compatible
+        target_clis = []
+        for cli_name in scope_state.clis.keys():
+            backend = registry.get(cli_name)
+            if backend.first_alias_for(model.aliases) is not None:
+                target_clis.append(cli_name)
+            else:
+                print(f"Warning: Skipping {backend.label} - model {model_id} not compatible")
+        
+        if not target_clis:
+            print(f"Model {model_id} is not compatible with any installed CLI")
+            sys.exit(1)
+    
+    elif cli is None:
+        # Auto-detect: error if ambiguous
+        candidates = [name for name in scope_state.clis.keys() 
+                     if role_name in scope_state.clis[name].role_models]
+        if len(candidates) == 0:
+            # No CLI has this role yet, check all CLIs
+            all_candidates = list(scope_state.clis.keys())
+            if len(all_candidates) == 1:
+                target_clis = all_candidates
+            else:
+                print(f"Multiple CLIs found: {', '.join(all_candidates)}")
+                print("Specify --cli <name> or --cli all")
+                sys.exit(1)
+        elif len(candidates) == 1:
+            target_clis = candidates
+        else:
+            print(f"Multiple CLIs found with role '{role_name}': {', '.join(candidates)}")
+            print("Specify --cli <name> or --cli all")
+            sys.exit(1)
+    else:
+        # Explicit CLI specified
+        if cli not in scope_state.clis:
+            print(f"CLI '{cli}' not found in {scope} installation")
+            print(f"Installed CLIs: {', '.join(scope_state.clis.keys())}")
+            sys.exit(1)
+        
+        backend = registry.get(cli)
+        if backend.first_alias_for(model.aliases) is None:
+            print(f"Model {model_id} is not compatible with {backend.label}")
+            print(f"Compatible providers: {', '.join(backend.accepted_providers)}")
+            print(f"Model providers: {', '.join(model.aliases.keys())}")
+            sys.exit(1)
+        
+        target_clis = [cli]
+    
+    # Update state.json
+    for cli_name in target_clis:
+        backend_state = scope_state.clis[cli_name]
+        backend_state.role_models[role_name] = model_id
+        backend = registry.get(cli_name)
+        print(f"Updated {backend.label}: {role_name} → {model_id}")
+    
+    # Write back
+    install_state.record_install_state(current_state)
+    print(f"Wrote {state_mod.state_file()}")
+    
+    # Trigger regenerate
+    from ..regenerate import regenerate
+    
+    for cli_name in target_clis:
+        backend = registry.get(cli_name) 
+        print(f"\nRegenerating {backend.label}...")
+        regenerate(scope=scope, cli=cli_name, project_path=project_path)
+    
+    print(f"\n{Color.GREEN}Done.{Color.NC} Restart your AI CLI to pick up changes.")
+    print(f"Tip: Run `agent-notes regenerate` if you hand-edit state.json in the future.")

agent_notes/commands/uninstall.py

@@ -0,0 +1,26 @@
+"""Uninstall command."""
+
+from pathlib import Path
+
+from ..config import Color
+from .. import install_state
+
+
+def uninstall(local: bool = False) -> None:
+    """Remove installed components."""
+    print(f"Uninstalling ({'local' if local else 'global'}) ...")
+    print("")
+
+    from ..services import installer
+    scope = "local" if local else "global"
+    installer.uninstall_all(scope)
+
+    print("")
+    print(f"{Color.GREEN}Done.{Color.NC}")
+    
+    # Remove state for this scope only
+    try:
+        project_path = Path.cwd() if local else None
+        install_state.remove_install_state("local" if local else "global", project_path)
+    except Exception as e:
+        print(f"{Color.YELLOW}Warning: failed to update state.json: {e}{Color.NC}")

agent_notes/commands/update.py

@@ -0,0 +1,169 @@
+"""Pull latest changes, rebuild, show diff, and reinstall."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from ..config import ROOT, Color, get_version, PKG_DIR
+from .. import install_state
+from ..services import diff as update_diff
+
+
+def _run_git(args, cwd) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["git", *args], cwd=cwd,
+        capture_output=True, text=True, check=True,
+    )
+
+
+def _git_head(repo) -> str:
+    try:
+        return _run_git(["rev-parse", "HEAD"], repo).stdout.strip()
+    except Exception:
+        return ""
+
+
+def _git_pull(repo) -> None:
+    _run_git(["pull", "--ff-only"], repo)
+
+
+def _show_commits(repo, before: str, after: str, limit: int = 5) -> None:
+    if not before or not after or before == after:
+        return
+    try:
+        out = _run_git(["log", "--oneline", f"{before}..{after}"], repo).stdout.strip()
+    except Exception:
+        return
+    if not out:
+        return
+    lines = out.split("\n")
+    print(f"{Color.GREEN}Updated{Color.NC} {len(lines)} commits.")
+    for line in lines[:limit]:
+        print(f"  {line}")
+    if len(lines) > limit:
+        print(f"  ... and {len(lines) - limit} more")
+    print("")
+
+
+def update(
+    dry_run: bool = False,
+    yes: bool = False,
+    only: Optional[list[str]] = None,
+    since: Optional[str] = None,
+    skip_pull: bool = False,
+) -> None:
+    """Pull, rebuild, diff against state.json, prompt, reinstall.
+    
+    - dry_run: show the diff, do NOT reinstall
+    - yes: don't prompt, just reinstall if there are changes
+    - only: list of component types to include in the diff (agents, skills, rules, commands, config, settings)
+    - since: if set, compare against this git sha rather than current state.json (advanced)
+    - skip_pull: skip the git pull (useful when user already pulled)
+    """
+    repo = ROOT
+    print("Updating agent-notes...")
+    print("")
+
+    # Step 1: git pull
+    if not skip_pull:
+        git_dir = repo / ".git"
+        if not git_dir.exists():
+            print(f"{Color.RED}Error:{Color.NC} Not a git repository. Update requires a git-based install.")
+            return
+        before = _git_head(repo)
+        try:
+            _git_pull(repo)
+        except subprocess.CalledProcessError:
+            print(f"{Color.RED}Error:{Color.NC} Could not fast-forward. Resolve manually: cd {repo} && git status")
+            return
+        after = _git_head(repo)
+        _show_commits(repo, before, after)
+        if before == after and before:
+            print(f"{Color.GREEN}Already up to date (no new commits).{Color.NC}")
+
+    # Step 2: rebuild dist/
+    print("Rebuilding...")
+    try:
+        from ..commands.build import build as run_build
+        run_build()
+    except Exception as e:
+        print(f"{Color.RED}Build failed: {e}{Color.NC}")
+        return
+
+    # Step 3: determine which scope to update and compute "new" state
+    old_state = install_state.load_current_state()
+    
+    # Determine scope: if CWD has a local install, update that; otherwise update global
+    current_project = Path.cwd()
+    local_exists = old_state and str(current_project.resolve()) in old_state.local_installs if old_state else False
+    global_exists = old_state and old_state.global_install is not None if old_state else False
+    
+    # Default to global unless local exists and global doesn't, or if only local exists
+    if local_exists and not global_exists:
+        scope = "local"
+        project_path = current_project
+    elif local_exists and global_exists:
+        # Both exist - default to global (could add --local flag in future)
+        scope = "global"
+        project_path = None
+    else:
+        # Default to global
+        scope = "global"
+        project_path = None
+    
+    # Get the existing scope's mode, or default
+    if scope == "global" and old_state and old_state.global_install:
+        mode = old_state.global_install.mode
+    elif scope == "local" and old_state and str(current_project.resolve()) in old_state.local_installs:
+        mode = old_state.local_installs[str(current_project.resolve())].mode
+    else:
+        mode = "symlink"  # default
+    
+    new_state = install_state.build_install_state(
+        mode=mode,
+        scope=scope,
+        repo_root=PKG_DIR.parent,
+        project_path=project_path,
+    )
+
+    # If `since` is provided, we'd need to stash old state and rebuild from that commit.
+    # Keep it minimal for now: `since` only influences the commit label in the diff output.
+    if since:
+        if old_state is not None:
+            old_state.source_commit = since
+        else:
+            print(f"{Color.YELLOW}Warning: --since provided but no prior state.json; treating as initial install.{Color.NC}")
+
+    # Step 4: diff
+    diff = update_diff.diff_states(old_state, new_state)
+    if only:
+        diff = update_diff.filter_diff(diff, only=only)
+
+    # Step 5: render report
+    print("")
+    print(update_diff.render_diff_report(diff, use_color=Color.NC != ""))
+    print("")
+
+    # Step 6: decide
+    if not diff.has_changes():
+        print(f"{Color.GREEN}Nothing to apply.{Color.NC}")
+        return
+
+    if dry_run:
+        print(f"{Color.CYAN}Dry run — no changes applied.{Color.NC}")
+        return
+
+    if not yes:
+        resp = input("Apply these changes? [Y/n] ").strip().lower()
+        if resp not in ("", "y", "yes"):
+            print("Aborted.")
+            return
+
+    # Step 7: reinstall (use existing install flow — it also writes new state.json)
+    # Use the determined scope and mode from the analysis above
+    from ..commands.install import install
+    local = (scope == "local")
+    copy = (mode == "copy")
+    install(local=local, copy=copy)

agent_notes/commands/validate.py

@@ -0,0 +1,199 @@
+"""Validate command - lint all agent-notes configs."""
+
+import re
+from pathlib import Path
+from typing import List, Set
+
+# Re-export for backward compatibility. New code should import from agent_notes.domain.
+from ..domain.diagnostics import ValidationError, ValidationWarning  # noqa: F401
+
+from ..services.validation import (
+    has_field, get_field, line_count, has_frontmatter, check_unclosed_code_blocks
+)
+
+
+def validate() -> None:
+    """Lint all agent-notes configs."""
+    from ..config import (
+        Color, ROOT, DIST_CLAUDE_DIR, DIST_OPENCODE_DIR, DIST_GITHUB_DIR,
+        DIST_RULES_DIR, find_skill_dirs
+    )
+
+    errors: List[ValidationError] = []
+    warnings: List[ValidationWarning] = []
+    names: Set[str] = set()
+    skill_names: Set[str] = set()
+
+    # Validate Claude agents
+    print("Validating Claude Code agents (dist/claude/agents/*.md) ...")
+
+    claude_agents_dir = DIST_CLAUDE_DIR / "agents"
+    if claude_agents_dir.exists():
+        for f in claude_agents_dir.glob("*.md"):
+            local_name = f.stem
+            lines = line_count(f)
+            label = f"dist/claude/agents/{local_name}.md ({lines} lines)"
+
+            # Frontmatter exists
+            if not has_frontmatter(f):
+                errors.append(ValidationError(label, "missing frontmatter"))
+                continue
+
+            # Required fields
+            for field in ["name", "description", "model"]:
+                if not has_field(f, field):
+                    errors.append(ValidationError(label, f"missing required field: {field}"))
+
+            # Name matches filename
+            fm_name = get_field(f, "name")
+            if fm_name and fm_name != local_name:
+                errors.append(ValidationError(label, f"name '{fm_name}' does not match filename '{local_name}'"))
+
+            # Line count
+            if lines > 250:
+                errors.append(ValidationError(label, "exceeds 250 line limit"))
+            elif lines > 80:
+                warnings.append(ValidationWarning(label, "over 80 lines (consider trimming)"))
+            else:
+                print(f"  {Color.GREEN}OK{Color.NC}    {label}")
+
+            if fm_name:
+                names.add(f"agent:{fm_name}")
+
+    # Validate OpenCode agents
+    print("")
+    print("Validating OpenCode agents (dist/opencode/agents/*.md) ...")
+
+    opencode_agents_dir = DIST_OPENCODE_DIR / "agents"
+    if opencode_agents_dir.exists():
+        for f in opencode_agents_dir.glob("*.md"):
+            local_name = f.stem
+            lines = line_count(f)
+            label = f"dist/opencode/agents/{local_name}.md ({lines} lines)"
+
+            if not has_frontmatter(f):
+                errors.append(ValidationError(label, "missing frontmatter"))
+                continue
+
+            for field in ["description", "mode", "model"]:
+                if not has_field(f, field):
+                    errors.append(ValidationError(label, f"missing required field: {field}"))
+
+            if lines > 250:
+                errors.append(ValidationError(label, "exceeds 250 line limit"))
+            elif lines > 80:
+                warnings.append(ValidationWarning(label, "over 80 lines (consider trimming)"))
+            else:
+                print(f"  {Color.GREEN}OK{Color.NC}    {label}")
+
+    # Validate Skills
+    print("")
+    print("Validating skills (*/SKILL.md) ...")
+
+    skill_name_regex = re.compile(r'^[a-z0-9]+(-[a-z0-9]+)*$')
+
+    for skill_path in find_skill_dirs():
+        skill_name = skill_path.name
+        f = skill_path / "SKILL.md"
+        if not f.exists():
+            continue
+
+        lines = line_count(f)
+        label = f"{skill_name}/SKILL.md ({lines} lines)"
+
+        if not has_frontmatter(f):
+            errors.append(ValidationError(label, "missing frontmatter"))
+            continue
+
+        for field in ["name", "description"]:
+            if not has_field(f, field):
+                errors.append(ValidationError(label, f"missing required field: {field}"))
+
+        # Name matches directory
+        fm_name = get_field(f, "name")
+        if fm_name and fm_name != skill_name:
+            errors.append(ValidationError(label, f"name '{fm_name}' does not match directory '{skill_name}'"))
+
+        # Name format (OpenCode requirement)
+        if fm_name and not skill_name_regex.match(fm_name):
+            errors.append(ValidationError(label, f"name '{fm_name}' does not match required pattern (lowercase alphanumeric + hyphens)"))
+
+        print(f"  {Color.GREEN}OK{Color.NC}    {label}")
+
+        if fm_name:
+            skill_names.add(f"skill:{fm_name}")
+
+    # Check for duplicate names
+    print("")
+    print("Checking for duplicates ...")
+
+    all_names = names | skill_names
+    seen = set()
+    for name in all_names:
+        if name in seen:
+            errors.append(ValidationError("Duplicate name", name))
+        seen.add(name)
+
+    if all_names and not any("Duplicate name" in err.file_path for err in errors):
+        print(f"  {Color.GREEN}OK{Color.NC}    No duplicate names ({len(all_names)} total)")
+
+    # Global config files
+    print("")
+    print("Checking global config files ...")
+
+    required_global = [
+        DIST_CLAUDE_DIR / "CLAUDE.md",
+        DIST_OPENCODE_DIR / "AGENTS.md",
+        DIST_GITHUB_DIR / "copilot-instructions.md",
+        DIST_RULES_DIR / "code-quality.md",
+        DIST_RULES_DIR / "safety.md"
+    ]
+
+    for file_path in required_global:
+        rel_path = file_path.relative_to(ROOT)
+        if file_path.exists():
+            print(f"  {Color.GREEN}OK{Color.NC}    {rel_path}")
+        else:
+            errors.append(ValidationError(str(rel_path), "file not found"))
+
+    # Unclosed code blocks
+    print("")
+    print("Checking for unclosed code blocks ...")
+
+    codeblock_ok = True
+    for md_file in ROOT.rglob("*.md"):
+        # Skip .git and node_modules
+        if ".git" in str(md_file) or "node_modules" in str(md_file):
+            continue
+
+        if not check_unclosed_code_blocks(md_file):
+            rel_path = md_file.relative_to(ROOT)
+            try:
+                fence_count = md_file.read_text().count('```')
+                errors.append(ValidationError(str(rel_path), f"unclosed code block ({fence_count} fence markers)"))
+                codeblock_ok = False
+            except (FileNotFoundError, OSError):
+                pass
+
+    if codeblock_ok:
+        print(f"  {Color.GREEN}OK{Color.NC}    Code blocks valid")
+
+    # Print all errors and warnings
+    for error in errors:
+        print(f"  {Color.RED}FAIL{Color.NC}  {error.file_path} — {error.message}")
+
+    for warning in warnings:
+        print(f"  {Color.YELLOW}WARN{Color.NC}  {warning.file_path} — {warning.message}")
+
+    # Summary
+    print("")
+    print("===============================")
+    if errors:
+        print(f"{Color.RED}{len(errors)} error(s){Color.NC}, {len(warnings)} warning(s)")
+        exit(1)
+    elif warnings:
+        print(f"{Color.GREEN}0 errors{Color.NC}, {Color.YELLOW}{len(warnings)} warning(s){Color.NC}")
+        exit(0)
+    else:
+        print(f"{Color.GREEN}All checks passed.{Color.NC}")
+        exit(0)