axion-code 1.0.0__py3-none-any.whl

axion/commands/handlers/agents.py

@@ -0,0 +1,51 @@
+"""Agent slash command handler.
+
+Maps to: rust/crates/commands/src/lib.rs (handle_agents_slash_command)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class AgentSummary:
+    name: str
+    description: str
+    path: str
+
+
+def handle_agents_command(args: str, cwd: Path | None = None) -> str:
+    """Handle /agents [list] command."""
+    actual_cwd = cwd or Path.cwd()
+
+    agents = discover_agents(actual_cwd)
+    if not agents:
+        return "No agents found."
+
+    lines = ["Available agents:", ""]
+    for agent in agents:
+        lines.append(f"  {agent.name} — {agent.description}")
+        lines.append(f"    Path: {agent.path}")
+    return "\n".join(lines)
+
+
+def discover_agents(cwd: Path) -> list[AgentSummary]:
+    """Discover agent definitions in the project."""
+    agents: list[AgentSummary] = []
+
+    # Check .axion/agents/ first, .claude/agents/ for backwards compat
+    agents_dir = cwd / ".axion" / "agents"
+    if not agents_dir.exists():
+        agents_dir = cwd / ".claude" / "agents"
+    if agents_dir.exists():
+        for f in agents_dir.iterdir():
+            if f.suffix == ".md":
+                agents.append(AgentSummary(
+                    name=f.stem,
+                    description=f"Agent defined in {f.name}",
+                    path=str(f),
+                ))
+
+    return agents

axion/commands/handlers/builtin_commands.py

@@ -0,0 +1,367 @@
+"""Built-in slash command handlers: /commit, /undo, /review, /test, /init-project.
+
+These are high-value features that differentiate Axion from other tools.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# /commit — Auto-commit with AI-generated message
+# ---------------------------------------------------------------------------
+
+def handle_commit_command(args: str, cwd: Path | None = None) -> str:
+    """Stage changes and commit with an AI-generated message.
+
+    Usage:
+        /commit              — auto-generate commit message from diff
+        /commit fix auth bug — use provided message
+    """
+    actual_cwd = str(cwd or Path.cwd())
+
+    # Check for uncommitted changes
+    status = _run_git(["status", "--porcelain"], actual_cwd)
+    if not status.strip():
+        return "Nothing to commit — working tree is clean."
+
+    # Stage all changes
+    _run_git(["add", "-A"], actual_cwd)
+
+    # Get diff for message generation
+    diff = _run_git(["diff", "--cached", "--stat"], actual_cwd)
+
+    if args.strip():
+        # User provided a message
+        message = args.strip()
+    else:
+        # Generate message from the diff
+        diff_detail = _run_git(["diff", "--cached"], actual_cwd)
+        message = _generate_commit_message(diff_detail[:2000])
+
+    # Commit
+    result = _run_git(["commit", "-m", message], actual_cwd)
+    if "nothing to commit" in result.lower():
+        return "Nothing to commit."
+
+    return f"Committed:\n  {message}\n\n{diff.strip()}"
+
+
+def _generate_commit_message(diff: str) -> str:
+    """Generate a commit message from a diff (heuristic, no AI call)."""
+    lines = diff.strip().splitlines()
+
+    # Count additions/deletions
+    additions = sum(1 for ln in lines if ln.startswith("+") and not ln.startswith("+++"))
+    deletions = sum(1 for ln in lines if ln.startswith("-") and not ln.startswith("---"))
+
+    # Get changed files
+    files = set()
+    for line in lines:
+        if line.startswith("diff --git"):
+            parts = line.split()
+            if len(parts) >= 4:
+                files.add(parts[3].lstrip("b/"))
+        elif line.startswith("--- a/") or line.startswith("+++ b/"):
+            path = line[6:]
+            if path != "/dev/null":
+                files.add(path)
+
+    file_list = ", ".join(sorted(files)[:3])
+    if len(files) > 3:
+        file_list += f" (+{len(files) - 3} more)"
+
+    if additions > 0 and deletions == 0:
+        action = "Add"
+    elif deletions > 0 and additions == 0:
+        action = "Remove"
+    else:
+        action = "Update"
+
+    return f"{action} {file_list} ({additions}+ {deletions}-)"
+
+
+# ---------------------------------------------------------------------------
+# /undo — Revert last AI change via git
+# ---------------------------------------------------------------------------
+
+def handle_undo_command(args: str, cwd: Path | None = None) -> str:
+    """Undo the last change by reverting to previous git state.
+
+    Usage:
+        /undo         — undo last commit (soft reset)
+        /undo hard    — undo and discard all changes
+        /undo file.py — restore a specific file
+    """
+    actual_cwd = str(cwd or Path.cwd())
+    target = args.strip()
+
+    if not target or target == "last":
+        # Soft reset — undoes the commit but keeps changes staged
+        result = _run_git(["reset", "--soft", "HEAD~1"], actual_cwd)
+        if "fatal" in result.lower():
+            return f"Undo failed: {result}"
+        return "Undone — last commit reverted (changes kept staged). Use /undo hard to discard."
+
+    if target == "hard":
+        # Hard reset — discard everything
+        result = _run_git(["reset", "--hard", "HEAD~1"], actual_cwd)
+        if "fatal" in result.lower():
+            return f"Undo failed: {result}"
+        return "Undone — last commit and all changes discarded."
+
+    # Restore a specific file
+    file_path = target
+    result = _run_git(["checkout", "HEAD", "--", file_path], actual_cwd)
+    if "error" in result.lower() or "fatal" in result.lower():
+        # Try with restore instead
+        result = _run_git(["restore", file_path], actual_cwd)
+        if "error" in result.lower() or "fatal" in result.lower():
+            return f"Could not restore {file_path}: {result}"
+    return f"Restored {file_path} to last committed version."
+
+
+# ---------------------------------------------------------------------------
+# /review — Code review mode
+# ---------------------------------------------------------------------------
+
+def handle_review_command(args: str, cwd: Path | None = None) -> str:
+    """Analyze recent changes for bugs, issues, and improvements.
+
+    Returns a structured review prompt for the AI to process.
+
+    Usage:
+        /review           — review uncommitted changes
+        /review HEAD~3    — review last 3 commits
+        /review file.py   — review a specific file
+    """
+    actual_cwd = str(cwd or Path.cwd())
+    target = args.strip()
+
+    if not target:
+        # Review uncommitted changes
+        diff = _run_git(["diff"], actual_cwd)
+        staged = _run_git(["diff", "--cached"], actual_cwd)
+        combined = ""
+        if staged.strip():
+            combined += f"=== Staged Changes ===\n{staged}\n\n"
+        if diff.strip():
+            combined += f"=== Unstaged Changes ===\n{diff}\n\n"
+        if not combined.strip():
+            return "No changes to review. Make some changes first."
+
+        # Truncate if too long
+        if len(combined) > 5000:
+            combined = combined[:5000] + "\n... (truncated)"
+
+        return (
+            "REVIEW_MODE: Please review these code changes for:\n"
+            "1. Bugs or logic errors\n"
+            "2. Security vulnerabilities\n"
+            "3. Performance issues\n"
+            "4. Missing error handling\n"
+            "5. Code style improvements\n\n"
+            f"{combined}\n\n"
+            "Provide a structured review with severity ratings (critical/warning/info)."
+        )
+
+    if target.startswith("HEAD"):
+        # Review specific commits
+        diff = _run_git(["diff", f"{target}..HEAD"], actual_cwd)
+        if not diff.strip():
+            return f"No changes found in range {target}..HEAD"
+        if len(diff) > 5000:
+            diff = diff[:5000] + "\n... (truncated)"
+        return (
+            f"REVIEW_MODE: Review the changes from {target} to HEAD:\n\n"
+            f"{diff}\n\n"
+            "Check for bugs, security issues, and improvements."
+        )
+
+    # Review a specific file
+    file_path = Path(actual_cwd) / target
+    if not file_path.exists():
+        return f"File not found: {target}"
+
+    content = file_path.read_text(encoding="utf-8", errors="replace")
+    if len(content) > 5000:
+        content = content[:5000] + "\n... (truncated)"
+
+    return (
+        f"REVIEW_MODE: Review this file for bugs, security issues, and improvements:\n\n"
+        f"File: {target}\n"
+        f"```\n{content}\n```\n\n"
+        "Provide a structured review with line numbers and severity ratings."
+    )
+
+
+# ---------------------------------------------------------------------------
+# /test — Generate tests for a file
+# ---------------------------------------------------------------------------
+
+def handle_test_command(args: str, cwd: Path | None = None) -> str:
+    """Generate tests for a file or module.
+
+    Usage:
+        /test src/auth.py           — generate tests for auth.py
+        /test src/api/              — generate tests for all files in api/
+        /test src/auth.py --pytest  — use pytest framework
+    """
+    actual_cwd = cwd or Path.cwd()
+    target = args.strip()
+
+    if not target:
+        return (
+            "Usage: /test <file_or_dir>\n"
+            "  /test src/auth.py        — generate tests for a file\n"
+            "  /test src/api/           — generate tests for a directory\n"
+            "  /test src/auth.py pytest — use pytest framework"
+        )
+
+    # Parse framework preference
+    framework = "pytest"  # default
+    parts = target.split()
+    if len(parts) > 1 and parts[-1] in ("pytest", "unittest", "jest", "mocha", "vitest"):
+        framework = parts[-1]
+        target = " ".join(parts[:-1])
+
+    file_path = actual_cwd / target
+
+    if file_path.is_file():
+        content = file_path.read_text(encoding="utf-8", errors="replace")
+        if len(content) > 4000:
+            content = content[:4000] + "\n... (truncated)"
+
+        return (
+            f"TEST_MODE: Generate comprehensive {framework} tests for this file:\n\n"
+            f"File: {target}\n"
+            f"```\n{content}\n```\n\n"
+            f"Requirements:\n"
+            f"- Use {framework} framework\n"
+            f"- Test all public functions/methods\n"
+            f"- Include edge cases and error cases\n"
+            f"- Use descriptive test names\n"
+            f"- Write the test file to the appropriate tests/ directory"
+        )
+
+    if file_path.is_dir():
+        files = list(file_path.rglob("*.py"))[:10]
+        if not files:
+            files = list(file_path.rglob("*.ts"))[:10]
+        if not files:
+            files = list(file_path.rglob("*.js"))[:10]
+
+        file_list = "\n".join(f"  - {f.relative_to(actual_cwd)}" for f in files)
+        return (
+            f"TEST_MODE: Generate {framework} tests for these files:\n\n"
+            f"{file_list}\n\n"
+            f"Read each file, then generate comprehensive tests."
+        )
+
+    return f"Not found: {target}"
+
+
+# ---------------------------------------------------------------------------
+# /init-project — Project template scaffolding
+# ---------------------------------------------------------------------------
+
+TEMPLATES = {
+    "react": {
+        "name": "React + TypeScript",
+        "questions": "What features? (auth/database/tailwind/none)",
+        "description": "React app with TypeScript, Vite, and optional features",
+    },
+    "nextjs": {
+        "name": "Next.js Full-Stack",
+        "questions": "Database? (postgres/sqlite/none), Auth? (y/n)",
+        "description": "Next.js with App Router, TypeScript, Tailwind",
+    },
+    "django": {
+        "name": "Django REST API",
+        "questions": "Database? (postgres/sqlite), Auth type? (jwt/session/oauth)",
+        "description": "Django + DRF with PostgreSQL, JWT auth, Docker",
+    },
+    "fastapi": {
+        "name": "FastAPI Backend",
+        "questions": "Database? (postgres/sqlite), Add Docker? (y/n)",
+        "description": "FastAPI with Pydantic, SQLAlchemy, async",
+    },
+    "express": {
+        "name": "Express.js API",
+        "questions": "TypeScript? (y/n), Database? (postgres/mongodb/none)",
+        "description": "Node.js Express with optional TypeScript and database",
+    },
+    "cli": {
+        "name": "Python CLI Tool",
+        "questions": "Framework? (click/typer/argparse)",
+        "description": "Python CLI with Click, tests, and packaging",
+    },
+    "flask": {
+        "name": "Flask Web App",
+        "questions": "Database? (postgres/sqlite), Add auth? (y/n)",
+        "description": "Flask with Blueprints, SQLAlchemy, templates",
+    },
+    "chrome-ext": {
+        "name": "Chrome Extension",
+        "questions": "Manifest version? (v3), Need popup? (y/n)",
+        "description": "Chrome extension with manifest v3",
+    },
+}
+
+
+def handle_init_project_command(args: str, cwd: Path | None = None) -> str:
+    """Scaffold a new project from a template with AI guidance.
+
+    Usage:
+        /init-project              — show available templates
+        /init-project react        — create a React project
+        /init-project fastapi      — create a FastAPI backend
+    """
+    template = args.strip().lower()
+
+    if not template:
+        lines = ["Available project templates:", ""]
+        for key, info in TEMPLATES.items():
+            lines.append(f"  /init-project {key:12} — {info['name']}: {info['description']}")
+        lines.append("")
+        lines.append("Example: /init-project react")
+        return "\n".join(lines)
+
+    if template not in TEMPLATES:
+        available = ", ".join(TEMPLATES.keys())
+        return f"Unknown template: {template}\nAvailable: {available}"
+
+    info = TEMPLATES[template]
+    return (
+        f"INIT_PROJECT_MODE: Create a new {info['name']} project.\n\n"
+        f"Template: {template}\n"
+        f"Description: {info['description']}\n\n"
+        f"Ask the user these questions first:\n"
+        f"  - Project name?\n"
+        f"  - {info['questions']}\n\n"
+        f"Then create the complete project structure with working code:\n"
+        f"1. Create all necessary config files\n"
+        f"2. Create source files with real implementation (not just boilerplate)\n"
+        f"3. Create a README.md with setup instructions\n"
+        f"4. Create a .gitignore\n"
+        f"5. If database needed, create initial schema/migrations\n"
+        f"6. If auth needed, create working auth implementation\n"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Git helper
+# ---------------------------------------------------------------------------
+
+def _run_git(args: list[str], cwd: str) -> str:
+    """Run a git command and return output."""
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            capture_output=True, text=True, cwd=cwd, timeout=15,
+            encoding="utf-8", errors="replace",
+        )
+        return result.stdout + result.stderr
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return "git command failed"

axion/commands/handlers/mcp.py

@@ -0,0 +1,59 @@
+"""MCP slash command handler.
+
+Maps to: rust/crates/commands/src/lib.rs (handle_mcp_slash_command)
+"""
+
+from __future__ import annotations
+
+from axion.runtime.mcp.tool_bridge import McpToolRegistry
+
+
+def handle_mcp_command(args: str, registry: McpToolRegistry | None = None) -> str:
+    """Handle /mcp [list|show <server>|help] commands."""
+    parts = args.strip().split(maxsplit=1)
+    action = parts[0].lower() if parts else "list"
+    target = parts[1].strip() if len(parts) > 1 else ""
+
+    reg = registry or McpToolRegistry()
+
+    if action in ("list", ""):
+        servers = reg.all_servers()
+        if not servers:
+            return "No MCP servers connected."
+        lines = ["Connected MCP servers:", ""]
+        for server in servers:
+            tool_count = len(server.tools)
+            lines.append(
+                f"  {server.server_name} [{server.status.value}] "
+                f"— {tool_count} tool(s)"
+            )
+            if server.error_message:
+                lines.append(f"    Error: {server.error_message}")
+        return "\n".join(lines)
+
+    if action == "show":
+        if not target:
+            return "Usage: /mcp show <server_name>"
+        server = reg.get_server(target)
+        if server is None:
+            return f"Server not found: {target}"
+        lines = [f"MCP Server: {server.server_name}", f"Status: {server.status.value}"]
+        if server.tools:
+            lines.append(f"\nTools ({len(server.tools)}):")
+            for tool in server.tools:
+                lines.append(f"  {tool.name} — {tool.description}")
+        if server.resources:
+            lines.append(f"\nResources ({len(server.resources)}):")
+            for res in server.resources:
+                lines.append(f"  {res.name} ({res.uri})")
+        return "\n".join(lines)
+
+    if action == "help":
+        return (
+            "MCP (Model Context Protocol) commands:\n"
+            "  /mcp list          — List connected servers\n"
+            "  /mcp show <name>   — Show server details and tools\n"
+            "  /mcp help          — Show this help"
+        )
+
+    return f"Unknown MCP action: {action}. Use: list, show, help"

axion/commands/handlers/models.py

@@ -0,0 +1,75 @@
+"""Handler for the /models slash command.
+
+Lists locally available Ollama models when an Ollama server is running.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from axion.api.ollama import OllamaClient
+
+
+def handle_models_command(args: str = "") -> str:
+    """Handle /models -- list available Ollama models.
+
+    Runs the async listing synchronously so the command handler can be
+    invoked from a synchronous slash-command dispatch path.
+    """
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+
+    if loop and loop.is_running():
+        # Already inside an async context; create a task via a new thread
+        import concurrent.futures
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            result = pool.submit(_list_models_sync).result(timeout=10)
+        return result
+
+    return asyncio.run(_list_models_async())
+
+
+def _list_models_sync() -> str:
+    return asyncio.run(_list_models_async())
+
+
+async def _list_models_async() -> str:
+    client = OllamaClient.from_env()
+
+    if not await client.is_available():
+        await client.close()
+        return (
+            "Ollama is not running.\n"
+            "Start it with: ollama serve\n"
+            f"Expected at: {client.base_url}"
+        )
+
+    try:
+        models = await client.list_models()
+    finally:
+        await client.close()
+
+    if not models:
+        return "Ollama is running but no models are installed.\nPull one with: ollama pull llama3.1"
+
+    lines = [f"Available Ollama models ({len(models)}):", ""]
+    for m in models:
+        size_mb = m.size / (1024 * 1024) if m.size else 0
+        family = m.details.get("family", "")
+        params = m.details.get("parameter_size", "")
+        detail_parts: list[str] = []
+        if params:
+            detail_parts.append(params)
+        if family:
+            detail_parts.append(family)
+        if size_mb > 0:
+            detail_parts.append(f"{size_mb:.0f} MB")
+        detail = f" ({', '.join(detail_parts)})" if detail_parts else ""
+        lines.append(f"  {m.name}{detail}")
+
+    lines.append("")
+    lines.append('Use a model with: /model <name>  or  --model "<name>"')
+    return "\n".join(lines)

axion/commands/handlers/plugins.py

@@ -0,0 +1,55 @@
+"""Plugin slash command handler.
+
+Maps to: rust/crates/commands/src/lib.rs (handle_plugins_slash_command)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from axion.plugins.manager import PluginManager
+
+
+def handle_plugins_command(args: str, manager: PluginManager) -> str:
+    """Handle /plugins [list|install|enable|disable|uninstall] commands."""
+    parts = args.strip().split(maxsplit=1)
+    action = parts[0].lower() if parts else "list"
+    target = parts[1].strip() if len(parts) > 1 else ""
+
+    if action == "list":
+        summaries = manager.registry.summaries()
+        if not summaries:
+            return "No plugins installed."
+        lines = ["Installed plugins:", ""]
+        for s in summaries:
+            status = "enabled" if s.enabled else "disabled"
+            lines.append(
+                f"  {s.name} v{s.version} [{status}] "
+                f"— {s.description} ({s.tool_count} tools, {s.command_count} commands)"
+            )
+        return "\n".join(lines)
+
+    if action == "install":
+        if not target:
+            return "Usage: /plugins install <path>"
+        summary = manager.install(Path(target))
+        if summary:
+            return f"Installed plugin: {summary.name} v{summary.version}"
+        return f"Failed to install plugin from: {target}"
+
+    if action == "enable":
+        if manager.enable(target):
+            return f"Enabled plugin: {target}"
+        return f"Plugin not found: {target}"
+
+    if action == "disable":
+        if manager.disable(target):
+            return f"Disabled plugin: {target}"
+        return f"Plugin not found: {target}"
+
+    if action == "uninstall":
+        if manager.uninstall(target):
+            return f"Uninstalled plugin: {target}"
+        return f"Plugin not found: {target}"
+
+    return f"Unknown plugin action: {action}. Use: list, install, enable, disable, uninstall"

axion/commands/handlers/skills.py

@@ -0,0 +1,61 @@
+"""Skill slash command handler.
+
+Maps to: rust/crates/commands/src/lib.rs (handle_skills_slash_command)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class SkillSummary:
+    name: str
+    description: str
+    path: str
+
+
+def handle_skills_command(args: str, cwd: Path | None = None) -> str:
+    """Handle /skills [list] command."""
+    actual_cwd = cwd or Path.cwd()
+
+    skills = discover_skills(actual_cwd)
+    if not skills:
+        return "No skills found."
+
+    lines = ["Available skills:", ""]
+    for skill in skills:
+        lines.append(f"  /{skill.name} — {skill.description}")
+    return "\n".join(lines)
+
+
+def discover_skills(cwd: Path) -> list[SkillSummary]:
+    """Discover skill definitions in the project."""
+    skills: list[SkillSummary] = []
+
+    # Check .axion/skills/ first, .claude/skills/ for backwards compat
+    skills_dir = cwd / ".axion" / "skills"
+    if not skills_dir.exists():
+        skills_dir = cwd / ".claude" / "skills"
+    if skills_dir.exists():
+        for f in skills_dir.iterdir():
+            if f.suffix == ".md":
+                skills.append(SkillSummary(
+                    name=f.stem,
+                    description=f"Skill defined in {f.name}",
+                    path=str(f),
+                ))
+
+    # Check .claude/commands/ (legacy)
+    commands_dir = cwd / ".claude" / "commands"
+    if commands_dir.exists():
+        for f in commands_dir.iterdir():
+            if f.suffix == ".md":
+                skills.append(SkillSummary(
+                    name=f.stem,
+                    description=f"Skill from commands/{f.name}",
+                    path=str(f),
+                ))
+
+    return skills