ata-coder 2.4.2__py3-none-any.whl

ata_coder/commands/_core.py

@@ -0,0 +1,184 @@
+"""Command handlers — auto-split from commands.py."""
+
+from __future__ import annotations
+from typing import Any
+
+
+def register_commands(r: Any) -> None:
+    """Register this group's commands on the registry."""
+    # ── Basic ────────────────────────────────────────────────────────────
+# ── Basic ──────────────────────────────────────────────────────────
+
+    @r.register("/help", "Show help", "basic")
+    def cmd_help(arg: str, ctx: dict) -> bool:
+        ctx["ui"].show_help()
+        return True
+
+    @r.register("/quit", "Exit", "basic")
+    @r.register("/exit", "Exit", "basic")
+    @r.register("/q", "Exit", "basic")
+    def cmd_quit(arg: str, ctx: dict) -> bool:
+        agent = ctx.get("agent")
+        sid = getattr(agent, "_current_session_id", "") if agent else ""
+        if sid and "-" in sid:
+            parts = sid.split("-")
+            if len(parts) >= 2:
+                print(f"\nResume this session with:\n  ata --resume {parts[-1]}")
+                return False
+        print("Goodbye!")
+        return False
+
+    @r.register("/clear", "Clear conversation", "basic")
+    def cmd_clear(arg: str, ctx: dict) -> bool:
+        ctx["agent"].reset()
+        print("Conversation cleared.")
+        return True
+
+    @r.register("/context", "Show conversation window", "basic")
+    def cmd_context(arg: str, ctx: dict) -> bool:
+        agent = ctx["agent"]
+        ctx["ui"].show_context(
+            total_messages=len(agent._state.messages),
+            tool_calls=agent._state.tool_call_count,
+            skill=agent.skills.active_skill.name if agent.skills and agent.skills.active_skill else "default",
+            model=ctx["config"].llm.model,
+            estimated_tokens=agent.get_token_estimate(),
+            max_tokens=ctx["config"].agent.max_context_tokens,
+        )
+        return True
+
+    @r.register("/compact", "Compact conversation", "basic")
+    def cmd_compact(arg: str, ctx: dict) -> bool:
+        print(ctx["agent"].compact())
+        return True
+
+    @r.register("/cost", "Estimate cost", "basic")
+    def cmd_cost(arg: str, ctx: dict) -> bool:
+        from .model_registry import estimate_cost
+        agent = ctx["agent"]
+        tokens = agent.get_token_estimate()
+        model = ctx["config"].llm.model
+        cost = estimate_cost(tokens, model)
+        print(f"Estimated: ~${cost:.4f} (~{tokens:,} tokens, {model})")
+        return True
+
+    @r.register("/summary", "Conversation summary", "basic")
+    def cmd_summary(arg: str, ctx: dict) -> bool:
+        print(ctx["agent"].get_conversation_summary())
+        return True
+
+
+    # ── Skills ────────────────────────────────────────────────────────────
+# ── Skills ─────────────────────────────────────────────────────────
+
+    @r.register("/skills", "List skills", "skill")
+    def cmd_skills(arg: str, ctx: dict) -> bool:
+        sm = ctx.get("skill_mgr")
+        if not sm:
+            print("Skills not loaded.")
+            return True
+        for s in sm.list_skills():
+            marker = " [active]" if sm.active_skill and sm.active_skill.name == s.name else ""
+            print(f"  {s.name}{marker}: {s.description[:80]}")
+        return True
+
+    @r.register("/skill", "Switch skill", "skill")
+    def cmd_skill(arg: str, ctx: dict) -> bool:
+        sm = ctx.get("skill_mgr")
+        if not sm:
+            print("Skills not loaded.")
+            return True
+        if arg:
+            s = sm.activate(arg)
+            print(f"Skill: {s.name}" if s else f"Not found: {arg}")
+        else:
+            a = sm.active_skill
+            print(f"Active: {a.name} - {a.description}" if a else "No active skill.")
+        return True
+
+    @r.register("/skill-auto", "Toggle skill auto-detect", "skill")
+    def cmd_skill_auto(arg: str, ctx: dict) -> bool:
+        if arg.lower() in ("off", "false", "0"):
+            ctx["auto_skill_state"]["value"] = False
+            print("Auto-skill: off")
+        else:
+            ctx["auto_skill_state"]["value"] = True
+            print("Auto-skill: on")
+        return True
+
+
+    # ── Memory ────────────────────────────────────────────────────────────
+# ── Memory ─────────────────────────────────────────────────────────
+
+    @r.register("/remember", "Save a memory", "memory")
+    def cmd_remember(arg: str, ctx: dict) -> bool:
+        store = ctx.get("memory_store")
+        if not store:
+            print("Memory not loaded.")
+            return True
+        parts = arg.split("|", 1)
+        if len(parts) < 2:
+            print("Usage: /remember type/name description | content")
+            return True
+        header = parts[0].strip()
+        content = parts[1].strip()
+        header_parts = header.split(maxsplit=1)
+        type_name = header_parts[0]
+        description = header_parts[1] if len(header_parts) > 1 else ""
+
+        if "/" in type_name:
+            mem_type, name = type_name.split("/", 1)
+        else:
+            mem_type, name = "reference", type_name
+
+        from .memory import Memory
+        store.add(Memory(name=name, description=description, content=content, metadata={"type": mem_type}))
+        print(f"Saved: [{mem_type}] {name}")
+        return True
+
+    @r.register("/recall", "Search memories", "memory")
+    def cmd_recall(arg: str, ctx: dict) -> bool:
+        store = ctx.get("memory_store")
+        if not store:
+            print("Memory not loaded.")
+            return True
+        if not arg:
+            print("Usage: /recall <query>")
+            return True
+        results = store.search(arg)
+        if not results:
+            print("No matches.")
+            return True
+        for m in results[:5]:
+            print(f"\n[{m.memory_type}] {m.description}\n{m.content[:300]}")
+        return True
+
+    @r.register("/memories", "List memories", "memory")
+    def cmd_memories(arg: str, ctx: dict) -> bool:
+        store = ctx.get("memory_store")
+        if not store:
+            print("Memory not loaded.")
+            return True
+        memories = store.list_all(arg if arg else None)
+        if not memories:
+            print("No memories.")
+            return True
+        for m in memories:
+            print(f"  [{m.memory_type}] {m.name} - {m.description} ({str(m.updated)[:10]})")
+        return True
+
+    @r.register("/forget", "Delete a memory", "memory")
+    def cmd_forget(arg: str, ctx: dict) -> bool:
+        store = ctx.get("memory_store")
+        if not store:
+            print("Memory not loaded.")
+            return True
+        if not arg:
+            print("Usage: /forget <name>")
+            return True
+        ok = store.delete(arg)
+        print(f"Deleted: {arg}" if ok else f"Not found: {arg}")
+        return True
+
+
+

ata_coder/commands/_safety.py

@@ -0,0 +1,95 @@
+"""Command handlers — auto-split from commands.py."""
+
+from __future__ import annotations
+from typing import Any
+
+
+def register_commands(r: Any) -> None:
+    """Register this group's commands on the registry."""
+    # ── Safety ────────────────────────────────────────────────────────────
+# ── Safety ─────────────────────────────────────────────────────────
+
+    @r.register("/undo", "Undo changes", "safety")
+    def cmd_undo(arg: str, ctx: dict) -> bool:
+        agent = ctx["agent"]
+        if arg.lower() == "all":
+            print(agent.undo_all())
+        else:
+            try:
+                n = int(arg) if arg else 1
+            except ValueError:
+                n = 1
+            print(agent.undo(n))
+        return True
+
+    @r.register("/redo", "Re-apply reverted change", "safety")
+    def cmd_redo(arg: str, ctx: dict) -> bool:
+        try:
+            n = int(arg) if arg else 1
+        except ValueError:
+            print("Usage: /redo <change-id>")
+            return True
+        print(ctx["agent"].restore_change(n))
+        return True
+
+    @r.register("/changes", "List file changes", "safety")
+    def cmd_changes(arg: str, ctx: dict) -> bool:
+        print(ctx["agent"].list_changes())
+        return True
+
+    @r.register("/diff-changes", "Show change diffs", "safety")
+    def cmd_diff_changes(arg: str, ctx: dict) -> bool:
+        try:
+            n = int(arg) if arg else 3
+        except ValueError:
+            n = 3
+        print(ctx["agent"].show_change_diff(n))
+        return True
+
+    @r.register("/dry-run", "Toggle dry-run mode", "safety")
+    def cmd_dry_run(arg: str, ctx: dict) -> bool:
+        enable = None if not arg else arg.lower() in ("on", "true", "1", "yes")
+        print(ctx["agent"].toggle_dry_run(enable))
+        return True
+
+    @r.register("/stats", "Safety stats", "safety")
+    def cmd_stats(arg: str, ctx: dict) -> bool:
+        a = ctx["agent"]
+        if a.fool_proof:
+            s = a.fool_proof.stats
+            print(f"Blocks: {s['blocks']}  Confirmations: {s['confirmations']}  "
+                  f"Changes: {s['tracker_changes']} active  "
+                  f"Dry-run: {'ON' if a.change_tracker and a.change_tracker.dry_run else 'OFF'}")
+        return True
+
+
+    # ── Dangerous mode ────────────────────────────────────────────────────────────
+# ── Dangerous mode ─────────────────────────────────────────────────
+
+    @r.register("/dangerous", "Dangerous mode", "danger")
+    def cmd_dangerous(arg: str, ctx: dict) -> bool:
+        pm = ctx["agent"].privilege_mgr
+        if not pm:
+            print("Not available.")
+            return True
+        al = arg.lower()
+        if al in ("on", "enable", "1", "yes"):
+            print(pm.enable_dangerous_mode("user-command", timeout_minutes=15))
+        elif al in ("off", "disable", "0", "no"):
+            print(pm.disable_dangerous_mode())
+        elif al == "audit":
+            print(pm.get_audit_log())
+        elif al == "elevate":
+            print(pm.get_elevation_instructions())
+        else:
+            print(pm.status())
+        return True
+
+    @r.register("/elevate", "Elevation guide", "danger")
+    def cmd_elevate(arg: str, ctx: dict) -> bool:
+        pm = ctx["agent"].privilege_mgr
+        print(pm.get_elevation_instructions() if pm else "Not available.")
+        return True
+
+
+

ata_coder/commands/_settings.py

@@ -0,0 +1,241 @@
+"""Command handlers — auto-split from commands.py."""
+
+from __future__ import annotations
+from typing import Any
+
+
+def register_commands(r: Any) -> None:
+    """Register this group's commands on the registry."""
+    # ── Think ────────────────────────────────────────────────────────────
+# ── Think ──────────────────────────────────────────────────────────
+
+    @r.register("/think", "Thinking mode", "settings")
+    def cmd_think(arg: str, ctx: dict) -> bool:
+        cfg = ctx["config"]
+        strengths = ["off", "low", "medium", "high", "xhigh", "max"]
+        if not arg:
+            current = cfg.llm.thinking_strength or "off"
+            print(f"Thinking: {current}  ({' | '.join(strengths)})")
+        elif arg.lower() == "off":
+            cfg.llm.thinking_strength = ""
+            print("Thinking: OFF")
+        elif arg.lower() in strengths:
+            cfg.llm.thinking_strength = arg.lower()
+            print(f"Thinking: {arg.upper()}")
+        else:
+            print(f"Invalid. Choose: {' | '.join(strengths)}")
+        return True
+
+
+    # ── Settings ────────────────────────────────────────────────────────────
+# ── Settings ───────────────────────────────────────────────────────
+
+    @r.register("/model", "Change model", "settings")
+    def cmd_model(arg: str, ctx: dict) -> bool:
+        agent = ctx["agent"]
+        if not arg:
+            print(f"Model: {agent.llm.config.model}")
+            return True
+        agent.llm.set_model(arg)
+        agent.llm.register_tools(agent._all_tools)
+        print(f"Model: {arg}")
+        return True
+
+    @r.register("/effort", "Set effort: low/medium/high/xhigh/max", "settings")
+    def cmd_effort(arg: str, ctx: dict) -> bool:
+        valid = {"low", "medium", "high", "xhigh", "max"}
+        if not arg or arg.lower() not in valid:
+            current = getattr(ctx.get("config", None), "effort", "medium")
+            print(f"Effort: {current}  (low / medium / high / xhigh / max)")
+            print("  low    = haiku, 4K tokens, thinking disabled")
+            print("  medium = default, 16K tokens, no thinking")
+            print("  high   = default, 32K tokens, reasoning_effort=high")
+            print("  xhigh  = opus, 48K tokens, reasoning_effort=xhigh")
+            print("  max    = opus, 64K tokens, reasoning_effort=max")
+            return True
+        level = arg.lower()
+        ctx["config"].effort = level
+        agent = ctx["agent"]
+        if level == "low":
+            agent.llm.config.max_tokens = 4096
+            agent.llm.config.thinking_strength = "off"
+        elif level == "medium":
+            agent.llm.config.max_tokens = 16384
+            agent.llm.config.thinking_strength = ""
+        elif level == "high":
+            agent.llm.config.max_tokens = 32768
+            agent.llm.config.thinking_strength = "high"
+        elif level == "xhigh":
+            agent.llm.config.max_tokens = 49152
+            agent.llm.config.thinking_strength = "xhigh"
+        elif level == "max":
+            agent.llm.config.max_tokens = 65536
+            agent.llm.config.thinking_strength = "max"
+        print(f"Effort: {level}")
+        return True
+
+    @r.register("/models", "List models from API", "settings")
+    def cmd_models(arg: str, ctx: dict) -> bool:
+        from .model_registry import fetch_available_models
+        cfg = ctx["config"]
+        models = fetch_available_models(cfg.llm.base_url, cfg.llm.api_key)
+        if not models:
+            print("Failed to fetch models.")
+            return True
+        current = cfg.llm.model
+        print(f"\n{len(models)} model(s) (current: {current}):")
+        for mid in sorted(models):
+            print(f"  {mid}{'  << current' if mid == current else ''}")
+        return True
+
+    @r.register("/workspace", "Change workspace", "settings")
+    def cmd_workspace(arg: str, ctx: dict) -> bool:
+        from pathlib import Path
+        import os
+
+        cfg = ctx["config"]
+        agent = ctx["agent"]
+
+        if not arg:
+            print(f"Workspace: {cfg.agent.workspace_dir}")
+            return True
+
+        new_path = os.path.abspath(os.path.expanduser(arg))
+        if not os.path.isdir(new_path):
+            print(f"Not found: {arg}")
+            return True
+
+        cfg.agent.workspace_dir = new_path
+        agent.tools.workspace = Path(new_path)
+        agent.tools.config.workspace_dir = new_path
+        print(f"Workspace: {new_path}")
+        return True
+
+    @r.register("/permissions", "Permission rules", "settings")
+    def cmd_permissions(arg: str, ctx: dict) -> bool:
+        ps = ctx.get("permission_store")
+        print(ps.describe() if ps else "Not loaded.")
+        return True
+
+    @r.register("/mcp", "MCP status", "settings")
+    def cmd_mcp(arg: str, ctx: dict) -> bool:
+        mcp = ctx.get("mcp_client")
+        if not mcp:
+            print("MCP not configured.")
+            return True
+        for name in mcp.connected_servers:
+            count = sum(
+                1 for t in mcp.get_tools()
+                if t["function"]["name"].startswith(f"mcp__{name}__")
+            )
+            print(f"  {name}: {count} tools")
+        return True
+
+    @r.register("/mcp-tools", "List MCP tools", "settings")
+    def cmd_mcp_tools(arg: str, ctx: dict) -> bool:
+        mcp = ctx.get("mcp_client")
+        if not mcp:
+            print("MCP not configured.")
+            return True
+        for t in mcp.get_tools():
+            fn = t["function"]
+            print(f"  {fn['name']}: {fn['description'][:100]}")
+        return True
+
+    @r.register("/mcp search", "Search MCP tools/resources", "settings")
+    def cmd_mcp_search(arg: str, ctx: dict) -> bool:
+        """Search MCP tools and resources by keyword.  Usage: /mcp search <keyword>"""
+        mcp = ctx.get("mcp_client")
+        if not mcp:
+            print("MCP not configured.")
+            return True
+        if not arg:
+            print("Usage: /mcp search <keyword>")
+            print("  Searches tool names, descriptions, and resource URIs.")
+            return True
+
+        # Search tools
+        tools = mcp.search_tools(arg, limit=15)
+        if tools:
+            print(f"\n  Tools matching '{arg}' ({len(tools)}):")
+            for t in tools:
+                name = t.get("name", "?")
+                desc = (t.get("description") or "")[:80]
+                server = t.get("_mcp_server", "?")
+                print(f"    \033[1m{name}\033[0m @{server}")
+                if desc:
+                    print(f"      {desc}")
+
+        # Search resources
+        resources = mcp.search_resources(arg, limit=15)
+        if resources:
+            print(f"\n  Resources matching '{arg}' ({len(resources)}):")
+            for r in resources:
+                uri = r.get("uri", "?")
+                name = r.get("name", "")
+                server = r.get("_mcp_server", "?")
+                label = f"{name} ({uri})" if name else uri
+                print(f"    \033[1m{label}\033[0m @{server}")
+
+        if not tools and not resources:
+            print(f"  No tools or resources found matching '{arg}'.")
+        return True
+
+    @r.register("/mcp resources", "List/search MCP resources", "settings")
+    def cmd_mcp_resources(arg: str, ctx: dict) -> bool:
+        """List or search MCP resources.  Usage: /mcp resources [keyword]"""
+        mcp = ctx.get("mcp_client")
+        if not mcp:
+            print("MCP not configured.")
+            return True
+
+        if arg:
+            resources = mcp.search_resources(arg)
+            label = f"matching '{arg}'"
+        else:
+            resources = mcp.get_all_resources()
+            label = "available"
+
+        if not resources:
+            print(f"  No resources {label}.")
+            return True
+
+        print(f"\n  MCP resources {label} ({len(resources)}):")
+        for r in resources:
+            uri = r.get("uri", "?")
+            name = r.get("name", "")
+            desc = (r.get("description") or "")[:80]
+            server = r.get("_mcp_server", "?")
+            display = name or uri
+            print(f"    \033[1m{display}\033[0m @{server}")
+            if desc:
+                print(f"      {desc}")
+            if name:
+                print(f"      uri: {uri}")
+        return True
+
+    @r.register("/templates", "List templates", "settings")
+    def cmd_templates(arg: str, ctx: dict) -> bool:
+        tm = ctx.get("template_mgr")
+        if not tm:
+            print("Not loaded.")
+            return True
+        for t in tm.list_templates():
+            print(f"  {t}")
+        return True
+
+    @r.register("/template", "Render template", "settings")
+    def cmd_template(arg: str, ctx: dict) -> bool:
+        tm = ctx.get("template_mgr")
+        if not tm:
+            print("Not loaded.")
+            return True
+        if not arg:
+            print("Usage: /template <name>")
+            return True
+        r = tm.render(arg)
+        print(r if r else f"Not found: {arg}")
+        return True
+
+
+