agent-notes 2.0.4__py3-none-any.whl

agent_notes/commands/build.py

@@ -0,0 +1,170 @@
+"""Build agent configuration files from source."""
+
+import yaml
+import shutil
+from pathlib import Path
+
+from ..config import (
+    AGENTS_YAML,
+    DIST_DIR,
+    info
+)
+from ..services.rendering import generate_agent_files, render_globals, load_agents_config
+
+
+# Re-export for backward compatibility
+def _load_frontmatter_template(template_name):
+    """DEPRECATED: Use services.rendering._load_frontmatter_template instead."""
+    from ..services.rendering import _load_frontmatter_template
+    return _load_frontmatter_template(template_name)
+def copy_global_files() -> list[Path]:
+    """Copy global files and rules to destination."""
+    from ..config import RULES_DIR, DIST_RULES_DIR
+    
+    copied_files = []
+    
+    # Use the rendering service for global files
+    copied_files.extend(render_globals())
+    
+    # Copy all rules files
+    if RULES_DIR.exists():
+        # Build rule files
+        DIST_RULES_DIR.mkdir(parents=True, exist_ok=True)
+        for rule_file in RULES_DIR.glob('*.md'):
+            dest_file = DIST_RULES_DIR / rule_file.name
+            shutil.copy2(rule_file, dest_file)
+            copied_files.append(dest_file)
+    
+    return copied_files
+
+
+def copy_skills() -> list[Path]:
+    """Copy skill directories to dist/skills/."""
+    from ..config import find_skill_dirs
+    
+    dist_skills = DIST_DIR / "skills"
+    # Clean and recreate
+    if dist_skills.exists():
+        shutil.rmtree(dist_skills)
+    dist_skills.mkdir(parents=True, exist_ok=True)
+    
+    copied = []
+    for skill_dir in find_skill_dirs():
+        dest = dist_skills / skill_dir.name
+        shutil.copytree(skill_dir, dest)
+        copied.append(dest)
+    return copied
+
+
+def copy_scripts() -> list[Path]:
+    """Copy script files to dist/scripts/, embedding pricing data from pricing.yaml."""
+    import json
+    from ..config import SCRIPTS_DIR, DIST_SCRIPTS_DIR, DATA_DIR
+
+    if not SCRIPTS_DIR.exists():
+        return []
+    if DIST_SCRIPTS_DIR.exists():
+        shutil.rmtree(DIST_SCRIPTS_DIR)
+    DIST_SCRIPTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    pricing_path = DATA_DIR / "pricing.yaml"
+    pricing_json = "null"
+    if pricing_path.exists():
+        pricing_json = json.dumps(yaml.safe_load(pricing_path.read_text()), indent=2)
+
+    copied = []
+    for script in SCRIPTS_DIR.iterdir():
+        if script.is_file():
+            content = script.read_text()
+            if "{{PRICING}}" in content:
+                content = content.replace("{{PRICING}}", pricing_json)
+            dest = DIST_SCRIPTS_DIR / script.name
+            dest.write_text(content)
+            dest.chmod(0o755)
+            copied.append(dest)
+    return copied
+
+
+def copy_commands() -> list[Path]:
+    """Copy command files from data/commands/ to dist/claude/commands/."""
+    from ..config import DATA_DIR, DIST_DIR
+    src = DATA_DIR / "commands"
+    if not src.exists():
+        return []
+    dest = DIST_DIR / "claude" / "commands"
+    if dest.exists():
+        shutil.rmtree(dest)
+    dest.mkdir(parents=True, exist_ok=True)
+    copied = []
+    for f in src.glob("*.md"):
+        out = dest / f.name
+        shutil.copy2(f, out)
+        copied.append(out)
+    return copied
+
+
+def count_lines(file_path: Path) -> int:
+    """Count lines in a file or all files within a directory."""
+    try:
+        if file_path.is_dir():
+            return sum(
+                len(f.read_text().splitlines())
+                for f in file_path.rglob("*")
+                if f.is_file()
+            )
+        return len(file_path.read_text().splitlines())
+    except Exception:
+        return 0
+
+
+def build() -> None:
+    """Build agent configuration files from source."""
+    from .. import state as state_module
+    from ..config import ROOT
+    
+    # Read configuration
+    try:
+        agents_config, tiers = load_agents_config()
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        return
+    
+    # Load state if present (no error if missing)
+    state = state_module.load()
+    
+    # Generate agent files (state=None is backward compatible)
+    print("Generating agent files...")
+    agent_files = generate_agent_files(agents_config, tiers, state=state)
+    
+    # Copy global files
+    print("Copying global files...")
+    global_files = copy_global_files()
+    
+    # Copy skills
+    print("Copying skills...")
+    skill_files = copy_skills()
+
+    # Copy scripts
+    print("Copying scripts...")
+    script_files = copy_scripts()
+
+    # Copy commands
+    print("Copying commands...")
+    command_files = copy_commands()
+
+    # Report results
+    all_files = agent_files + global_files + skill_files + script_files + command_files
+    print(f"\nGenerated {len(all_files)} files:")
+    
+    total_lines = 0
+    for file_path in sorted(all_files):
+        rel_path = file_path.relative_to(ROOT)
+        lines = count_lines(file_path)
+        total_lines += lines
+        print(f"  {rel_path} ({lines} lines)")
+    
+    print(f"\nTotal: {total_lines} lines across {len(all_files)} files")
+
+
+if __name__ == '__main__':
+    build()

agent_notes/commands/doctor.py

@@ -0,0 +1,112 @@
+"""Health check for agent-notes installation."""
+
+# Re-export for backward compatibility. New code should import from agent_notes.domain.
+from ..domain.diagnostics import Issue, FixAction  # noqa: F401
+
+# Re-export config constants that tests mock  
+from ..config import (
+    ROOT, DIST_CLAUDE_DIR, DIST_OPENCODE_DIR, DIST_GITHUB_DIR, DIST_RULES_DIR, 
+    DIST_SKILLS_DIR, DIST_SCRIPTS_DIR, SCRIPTS_DIR, BIN_HOME,
+    CLAUDE_HOME, OPENCODE_HOME, GITHUB_HOME, AGENTS_HOME,
+    Color, info, issue, ok, warn, fail
+)
+
+# Re-export all diagnostic functions from services
+from ..services.diagnostics import (
+    check_stale_files,
+    check_broken_symlinks, 
+    check_shadowed_files,
+    check_missing_files,
+    check_content_drift,
+    check_build_freshness,
+    count_stale,
+    print_summary,
+    print_issues,
+    do_fix,
+    _check_role_models,
+    _find_dist_source,
+    _count_agents,
+    _count_skills,
+    _count_scripts,
+    _count_rules,
+    _check_config,
+    _cli_base_dir,
+    _print_status
+)
+
+# Re-export filesystem utilities from services/fs for backward compatibility
+from ..services.fs import (
+    resolve_symlink, 
+    symlink_target_exists, 
+    files_differ
+)
+
+def _check_session_hook(scope: str, issues: list) -> None:
+    """Check that the Claude Code SessionStart hook is registered in settings.json."""
+    from ..services.settings_writer import has_hook
+    from ..services.installer import _session_hook_paths
+    from ..domain.diagnostics import Issue
+
+    try:
+        from ..registries.cli_registry import load_registry
+        registry = load_registry()
+        claude_backend = registry.get("claude")
+    except KeyError:
+        return
+
+    settings_path, _context_file, hook_command = _session_hook_paths(claude_backend, scope)
+    if not has_hook(settings_path, "SessionStart", hook_command):
+        issues.append(Issue(
+            "missing_hook",
+            str(settings_path),
+            "SessionStart hook not found — run: agent-notes install to re-add the hook",
+        ))
+
+
+def diagnose(scope: str, fix: bool = False) -> bool:
+    """Run all diagnostic checks and optionally apply fixes."""
+    from .. import install_state
+    
+    print_summary(scope)
+    
+    issues = []
+    fix_actions = []
+    
+    # Run checks
+    check_stale_files(scope, issues, fix_actions)
+    check_broken_symlinks(scope, issues, fix_actions) 
+    check_shadowed_files(scope, issues, fix_actions)
+    check_missing_files(scope, issues, fix_actions)
+    check_content_drift(scope, issues, fix_actions)
+    
+    # Build freshness check (scope-independent)
+    check_build_freshness(issues, fix_actions)
+
+    # SessionStart hook check (Claude Code only)
+    _check_session_hook(scope, issues)
+
+    # Print role→model assignments
+    state = install_state.load_current_state()
+    if state is not None:
+        _check_role_models(state)
+    
+    # Print issues and optionally fix
+    if print_issues(issues):
+        return True  # No issues
+    
+    if fix:
+        result = do_fix(issues, fix_actions)
+        # Services layer flagged that an install is needed — invoke it here
+        # (commands layer), avoiding a services→commands dependency.
+        if any(a.action == "_TRIGGER_INSTALL" for a in fix_actions):
+            from ..commands.install import install
+            install()
+        return result
+    else:
+        return False  # Issues found but not fixed
+
+# Alias for backward compatibility with CLI
+def doctor(local: bool = False, fix: bool = False):
+    """Main doctor function called by CLI."""
+    scope = "local" if local else "global"
+    return diagnose(scope, fix)

agent_notes/commands/info.py

@@ -0,0 +1,95 @@
+"""Info command - show installation status and component counts."""
+
+from pathlib import Path
+
+from .. import install_state
+from ..config import get_version, CLAUDE_HOME, Color
+from ._install_helpers import count_scripts, count_skills, count_agents, count_global
+
+
+def show_info() -> None:
+    """Show installation status and component counts."""
+    from ..registries.cli_registry import load_registry
+
+    version = get_version()
+    print(f"agent-notes {version}")
+    print("")
+    print("Components:")
+    print(f"  Scripts:             {count_scripts()}")
+    print(f"  Skills:              {count_skills()}")
+
+    # Show agent counts per backend
+    registry = load_registry()
+    for backend in registry.all():
+        if backend.supports("agents"):
+            agent_count = count_agents(backend)
+            print(f"  Agents ({backend.label}):  {agent_count}")
+
+    print(f"  Global config:       {count_global()} files")
+    print("")
+    print("Install targets:")
+    print("  Scripts:       ~/.local/bin/")
+
+    # Show CLI install targets
+    for backend in registry.all():
+        print(f"  {backend.label}:  {backend.global_home}")
+
+    print("  Universal:     ~/.agents/")
+    print("")
+
+    # Check install status
+    global_ok = (CLAUDE_HOME / "agents").exists() and any((CLAUDE_HOME / "agents").iterdir())
+    local_ok = Path(".claude/agents").exists() and any(Path(".claude/agents").iterdir())
+
+    print("Status:")
+    if global_ok:
+        print(f"  Global:  {Color.GREEN}installed{Color.NC} (use doctor for details)")
+    else:
+        print(f"  Global:  {Color.YELLOW}not installed{Color.NC}")
+    if local_ok:
+        print(f"  Local:   {Color.GREEN}detected{Color.NC}")
+    else:
+        print(f"  Local:   {Color.CYAN}not detected{Color.NC}")
+    
+    # State info
+    st = install_state.load_current_state()
+    if st is not None:
+        print("")
+        print("Last install:")
+        
+        # Global install
+        if st.global_install:
+            gs = st.global_install
+            print(f"  Global:   installed {gs.installed_at}, {gs.mode}")
+            # Count backends and items
+            if gs.clis:
+                backend_summaries = []
+                for backend_name, bs in sorted(gs.clis.items()):
+                    counts = []
+                    for component_type, items in bs.installed.items():
+                        if items:
+                            counts.append(f"{len(items)} {component_type}")
+                    if counts:
+                        backend_summaries.append(f"{backend_name} ({', '.join(counts)})")
+                if backend_summaries:
+                    print(f"            Backends: {', '.join(backend_summaries)}")
+        else:
+            print("  Global:   none")
+        
+        # Local installs
+        if st.local_installs:
+            for project_path, ls in sorted(st.local_installs.items()):
+                print(f"  Local:    {project_path}  (installed {ls.installed_at}, {ls.mode})")
+                if ls.clis:
+                    backend_summaries = []
+                    for backend_name, bs in sorted(ls.clis.items()):
+                        counts = []
+                        for component_type, items in bs.installed.items():
+                            if items:
+                                counts.append(f"{len(items)} {component_type}")
+                        if counts:
+                            backend_summaries.append(f"{backend_name} ({', '.join(counts)})")
+                    if backend_summaries:
+                        print(f"            Backends: {', '.join(backend_summaries)}")
+        else:
+            print("  Local:    none")

agent_notes/commands/install.py

@@ -0,0 +1,99 @@
+"""Install command."""
+
+from pathlib import Path
+
+from ..config import Color, PKG_DIR
+from .. import install_state
+from ._install_helpers import _verify_install
+
+
+def install(local: bool = False, copy: bool = False, reconfigure: bool = False) -> None:
+    """Build from source and install to targets."""
+    from ..state import get_scope, state_file
+    from pathlib import Path
+    
+    scope = "local" if local else "global"
+    project_path = Path.cwd().resolve() if local else None
+
+    state = install_state.load_current_state()
+    existing = get_scope(state, scope, project_path) if state else None
+
+    if existing and not reconfigure:
+        # Print existing-install summary
+        print(f"Found existing {scope} installation at {state_file()}")
+        print(f"  Installed: {existing.installed_at}")
+        cli_labels = []
+        from ..registries.cli_registry import load_registry
+        registry = load_registry()
+        for cli_name in existing.clis.keys():
+            try:
+                cli_labels.append(registry.get(cli_name).label)
+            except KeyError:
+                cli_labels.append(cli_name)
+        print(f"  CLIs:      {', '.join(cli_labels)}")
+        print(f"  Mode:      {existing.mode}")
+        print()
+        print("Verifying ...")
+        # Run verification. Use doctor_checks or a new helper.
+        issues = _verify_install(existing, scope, project_path, registry)
+        if not issues:
+            print()
+            print("Installation is healthy.")
+            print()
+            print("Tip: To reinstall with different choices, run:")
+            print("       agent-notes uninstall")
+            print("       agent-notes install")
+            print()
+            print("     Or to re-run the wizard and overwrite in place:")
+            print("       agent-notes install --reconfigure")
+        else:
+            print()
+            print(f"Installation has {len(issues)} issue(s).")
+            print()
+            print("Tip: Run `agent-notes doctor --fix` to repair, or `agent-notes install --reconfigure` to rewizard.")
+        return
+
+    if existing and reconfigure:
+        print(f"Clearing existing {scope} state (--reconfigure) ...")
+        install_state.remove_install_state(scope, project_path)
+        # Fall through to normal install flow
+    
+    # Validate args
+    if copy and not local:
+        print("Error: --copy is only valid with --local installs.")
+        print("Global installs always use symlinks.")
+        return
+
+    # Build first
+    print("Building from source...")
+    try:
+        from ..commands.build import build
+        build()
+    except Exception as e:
+        print(f"{Color.RED}Build failed: {e}{Color.NC}")
+        return
+
+    # Execute
+    print(f"Installing ({'local' if local else 'global'}, {'copy' if copy else 'symlink'}) ...")
+    print("")
+
+    from ..services import installer
+    scope = "local" if local else "global"
+    copy_mode = copy
+    installer.install_all(scope, copy_mode)
+
+    print("")
+    print(f"{Color.GREEN}Done.{Color.NC} Restart Claude Code / OpenCode to pick up changes.")
+    
+    # Record state
+    try:
+        project_path = Path.cwd() if local else None
+        st = install_state.build_install_state(
+            mode="copy" if copy else "symlink",
+            scope="local" if local else "global",
+            repo_root=PKG_DIR.parent,  # repo root (parent of agent_notes pkg)
+            project_path=project_path,
+        )
+        install_state.record_install_state(st)
+    except Exception as e:
+        print(f"{Color.YELLOW}Warning: failed to write state.json: {e}{Color.NC}")

agent_notes/commands/list.py

@@ -0,0 +1,169 @@
+"""List installed components."""
+
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from ..registries import default_skill_registry, default_rule_registry
+from ..config import Color, DATA_DIR, find_skill_dirs
+
+
+def list_clis() -> None:
+    """Print all registered CLIs."""
+    from ..registries.cli_registry import load_registry
+    registry = load_registry()
+    backends = sorted(registry.all(), key=lambda b: b.name)
+    print(f"CLIs ({len(backends)}):")
+    for b in backends:
+        # Pad name to ~10 chars, label to ~20 chars
+        print(f"  {b.name:<10} {b.label:<25} → {b.global_home}")
+
+
+def list_models() -> None:
+    """Print all available models with CLI compatibility."""
+    from ..registries.model_registry import load_model_registry
+    from ..registries.cli_registry import load_registry
+    models = load_model_registry().all()
+    registry = load_registry()
+    print(f"Models ({len(models)}):")
+    for m in sorted(models, key=lambda m: m.id):
+        compat = [b.name for b in registry.all() if b.first_alias_for(m.aliases) is not None]
+        label = f" {m.label}" if hasattr(m, 'label') and m.label else ""
+        model_class = f" [{m.model_class}]" if hasattr(m, 'model_class') and m.model_class else ""
+        if compat:
+            compat_str = ", ".join(compat)
+            print(f"  {m.id:<22}{label:<22}{model_class:<10} compatible: {compat_str}")
+        else:
+            print(f"  {m.id:<22}{label:<22}{model_class:<10} compatible: (none)")
+
+
+def list_roles() -> None:
+    """Print all roles."""
+    from ..registries.role_registry import load_role_registry
+    roles = load_role_registry().all()
+    print(f"Roles ({len(roles)}):")
+    for r in sorted(roles, key=lambda r: r.name):
+        typical = f" (typical: {r.typical_class})" if hasattr(r, 'typical_class') and r.typical_class else ""
+        print(f"  {r.name:<15} {r.description}{typical}")
+
+
+def list_agents() -> None:
+    """List all agents with metadata from YAML."""
+    print(f"{Color.CYAN}Agents:{Color.NC}")
+    source_agents_dir = DATA_DIR / "agents"
+    agents_yaml = DATA_DIR / "agents" / "agents.yaml"
+
+    # Load agents metadata from YAML if available
+    agents_metadata: Dict[str, Dict[str, Any]] = {}
+    if agents_yaml.exists():
+        try:
+            with open(agents_yaml, 'r') as f:
+                yaml_data = yaml.safe_load(f)
+                if yaml_data and 'agents' in yaml_data:
+                    agents_metadata = yaml_data['agents']
+        except (yaml.YAMLError, FileNotFoundError):
+            pass
+
+    if source_agents_dir.exists():
+        for f in sorted(source_agents_dir.glob("*.md")):
+            name = f.stem
+
+            if name in agents_metadata:
+                role = agents_metadata[name].get('role', agents_metadata[name].get('tier', ''))  # role or fallback to tier
+                description = agents_metadata[name].get('description', '')
+                print(f"  {name:<22} {Color.DIM}({role:<8}){Color.NC} {description}")
+            else:
+                print(f"  {name}")
+
+    print("")
+
+def list_skills() -> None:
+    """List all skills."""
+    print(f"{Color.CYAN}Skills:{Color.NC}")
+
+    skill_dirs = find_skill_dirs()
+    if skill_dirs:
+        for skill_path in sorted(skill_dirs):
+            print(f"  {skill_path.name}")
+    else:
+        # If no skills found via find_skill_dirs, try the registry
+        try:
+            registry = default_skill_registry()
+            skills = registry.all()
+            if skills:
+                for skill in sorted(skills, key=lambda s: s.name):
+                    print(f"  {skill.name}")
+        except Exception:
+            pass  # Ignore registry errors
+
+    print("")
+
+
+def list_rules() -> None:
+    """List all rules and global configs."""
+    print(f"{Color.CYAN}Rules:{Color.NC}")
+
+    # Try registry first, but fall back to filesystem if needed for testing
+    try:
+        registry = default_rule_registry()
+        rules = registry.all()
+
+        # If we get an empty registry but there are files in DATA_DIR/rules, use fallback
+        if not rules:
+            source_rules_dir = DATA_DIR / "rules"
+            if source_rules_dir.exists() and list(source_rules_dir.glob("*.md")):
+                # Use fallback
+                for f in sorted(source_rules_dir.glob("*.md")):
+                    print(f"  {f.stem}")
+            # else: truly no rules
+        else:
+            for rule in sorted(rules, key=lambda r: r.name):
+                print(f"  {rule.name}")
+    except Exception:
+        # Fallback to old behavior if registry fails
+        source_rules_dir = DATA_DIR / "rules"
+        if source_rules_dir.exists():
+            for f in sorted(source_rules_dir.glob("*.md")):
+                print(f"  {f.stem}")
+
+    print("")
+
+    print(f"{Color.CYAN}Global configs:{Color.NC}")
+    from ..registries.cli_registry import load_registry
+    registry = load_registry()
+    for backend in registry.all():
+        if backend.global_template:
+            print(f"  {backend.global_template}")
+    print("")
+
+def list_all() -> None:
+    """Show grouped summary of everything."""
+    list_clis()
+    print()
+    list_models()
+    print()
+    list_roles()
+    print()
+    list_agents()
+    list_skills()
+    list_rules()
+
+
+def list_components(filter_type: str = "all") -> None:
+    """List installed components."""
+    dispatch = {
+        "agents": list_agents,
+        "skills": list_skills,
+        "rules": list_rules,
+        "clis": list_clis,
+        "models": list_models,
+        "roles": list_roles,
+        "all": list_all,
+    }
+
+    if filter_type in dispatch:
+        dispatch[filter_type]()
+    else:
+        print(f"Unknown filter: {filter_type}")
+        print("Usage: agent-notes list [agents|skills|rules|clis|models|roles|all]")
+        exit(1)