axion-code 1.0.0__py3-none-any.whl

axion/commands/parsing.py

@@ -0,0 +1,317 @@
+"""Slash command parsing with full variant matching and typo-tolerant suggestions.
+
+Maps to: rust/crates/commands/src/lib.rs (parsing, SlashCommand enum)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from axion.commands.registry import CommandRegistry, SlashCommandSpec, get_command_registry
+
+# ---------------------------------------------------------------------------
+# Parsed command variants
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ParsedCommand:
+    """Result of parsing a slash command input."""
+
+    name: str
+    args: str = ""
+    spec: SlashCommandSpec | None = None
+    # Structured arguments for commands with specific parsing
+    parsed_args: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class CommandParseError:
+    """Error when a slash command cannot be parsed."""
+
+    input_text: str
+    message: str
+    suggestions: list[str] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Argument parsers for specific commands
+# ---------------------------------------------------------------------------
+
+VALID_PERMISSION_MODES = {"read-only", "workspace-write", "danger-full-access", "prompt", "allow"}
+
+
+def _parse_model_args(args: str) -> dict[str, Any]:
+    """Parse /model [name] arguments."""
+    if not args.strip():
+        return {"action": "show"}
+    return {"action": "set", "model": args.strip()}
+
+
+def _parse_permissions_args(args: str) -> dict[str, Any]:
+    """Parse /permissions [mode] arguments."""
+    mode = args.strip().lower()
+    if not mode:
+        return {"action": "show"}
+    if mode not in VALID_PERMISSION_MODES:
+        return {"action": "invalid", "mode": mode, "valid": sorted(VALID_PERMISSION_MODES)}
+    return {"action": "set", "mode": mode}
+
+
+def _parse_session_args(args: str) -> dict[str, Any]:
+    """Parse /session [action] [target] arguments."""
+    parts = args.strip().split(maxsplit=1)
+    action = parts[0].lower() if parts else "show"
+    target = parts[1].strip() if len(parts) > 1 else ""
+
+    if action in ("list", "ls"):
+        return {"action": "list"}
+    if action in ("show", "info"):
+        return {"action": "show", "target": target}
+    if action == "fork":
+        return {"action": "fork", "branch_name": target or None}
+    if action == "switch":
+        return {"action": "switch", "target": target}
+    if action in ("delete", "rm"):
+        return {"action": "delete", "target": target}
+    # Default: show current
+    return {"action": "show"}
+
+
+def _parse_mcp_args(args: str) -> dict[str, Any]:
+    """Parse /mcp [action] [target] arguments."""
+    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 in ("list", "ls", ""):
+        return {"action": "list"}
+    if action == "show":
+        return {"action": "show", "server": target}
+    if action == "help":
+        return {"action": "help"}
+    return {"action": action, "target": target}
+
+
+def _parse_plugins_args(args: str) -> dict[str, Any]:
+    """Parse /plugins [action] [target] arguments."""
+    parts = args.strip().split(maxsplit=1)
+    action = parts[0].lower() if parts else "list"
+    target = parts[1].strip() if len(parts) > 1 else ""
+
+    return {"action": action, "target": target}
+
+
+def _parse_effort_args(args: str) -> dict[str, Any]:
+    """Parse /effort [level] arguments."""
+    level = args.strip().lower()
+    if not level:
+        return {"action": "show"}
+    if level in ("low", "medium", "high"):
+        return {"action": "set", "level": level}
+    return {"action": "invalid", "level": level}
+
+
+def _parse_output_style_args(args: str) -> dict[str, Any]:
+    """Parse /output-style [style] arguments."""
+    style = args.strip().lower()
+    if not style:
+        return {"action": "show"}
+    if style in ("brief", "verbose", "default"):
+        return {"action": "set", "style": style}
+    return {"action": "invalid", "style": style}
+
+
+# Command-specific parsers
+_ARGUMENT_PARSERS: dict[str, Any] = {
+    "model": _parse_model_args,
+    "permissions": _parse_permissions_args,
+    "session": _parse_session_args,
+    "mcp": _parse_mcp_args,
+    "plugins": _parse_plugins_args,
+    "effort": _parse_effort_args,
+    "output-style": _parse_output_style_args,
+}
+
+
+# ---------------------------------------------------------------------------
+# Main parsing function
+# ---------------------------------------------------------------------------
+
+def parse_slash_command(
+    input_text: str,
+    registry: CommandRegistry | None = None,
+) -> ParsedCommand | CommandParseError:
+    """Parse a slash command from user input.
+
+    Returns ParsedCommand on success, CommandParseError on failure.
+    Handles alias resolution, argument parsing, and fuzzy suggestions.
+    """
+    reg = registry or get_command_registry()
+
+    stripped = input_text.strip()
+    if not stripped.startswith("/"):
+        return CommandParseError(
+            input_text=stripped,
+            message="Not a slash command",
+            suggestions=[],
+        )
+
+    # Split command name and args
+    parts = stripped[1:].split(maxsplit=1)
+    cmd_name = parts[0].lower() if parts else ""
+    cmd_args = parts[1] if len(parts) > 1 else ""
+
+    if not cmd_name:
+        return CommandParseError(
+            input_text=stripped,
+            message="Empty command",
+            suggestions=["/help"],
+        )
+
+    # Look up in registry
+    spec = reg.get(cmd_name)
+    if spec is not None:
+        # Parse arguments if there's a specific parser
+        parsed_args: dict[str, Any] = {}
+        parser = _ARGUMENT_PARSERS.get(spec.name)
+        if parser:
+            parsed_args = parser(cmd_args)
+
+        return ParsedCommand(
+            name=spec.name,
+            args=cmd_args,
+            spec=spec,
+            parsed_args=parsed_args,
+        )
+
+    # Not found — suggest similar commands
+    suggestions = suggest_commands(cmd_name, reg, limit=3)
+    return CommandParseError(
+        input_text=stripped,
+        message=f"Unknown command: /{cmd_name}",
+        suggestions=suggestions,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Fuzzy suggestions (Levenshtein distance)
+# ---------------------------------------------------------------------------
+
+def suggest_commands(
+    input_name: str,
+    registry: CommandRegistry | None = None,
+    limit: int = 3,
+) -> list[str]:
+    """Suggest similar commands using Levenshtein distance."""
+    reg = registry or get_command_registry()
+    all_names = [s.name for s in reg.all_specs()]
+
+    try:
+        from rapidfuzz import fuzz
+
+        scored = [(name, fuzz.ratio(input_name, name)) for name in all_names]
+        scored.sort(key=lambda x: x[1], reverse=True)
+        return [f"/{name}" for name, score in scored[:limit] if score > 40]
+    except ImportError:
+        # Fallback: simple prefix + substring matching
+        results: list[str] = []
+        for name in all_names:
+            if name.startswith(input_name[:2]) or input_name in name:
+                results.append(f"/{name}")
+                if len(results) >= limit:
+                    break
+        return results
+
+
+# ---------------------------------------------------------------------------
+# Help rendering
+# ---------------------------------------------------------------------------
+
+_CATEGORY_LABELS: dict[str, str] = {
+    "core": "Core Commands",
+    "model": "Model & Permissions",
+    "session": "Session Management",
+    "config": "Configuration",
+    "tools": "Tool Management",
+    "info": "Info & Diagnostics",
+    "auth": "Authentication",
+    "workflow": "Task & Workflow",
+    "advanced": "Advanced",
+    "misc": "Miscellaneous",
+    "plugin": "Plugin Commands",
+    "skill": "Skills",
+}
+
+_CATEGORY_ORDER = [
+    "core", "model", "session", "config", "tools",
+    "info", "auth", "workflow", "utility",
+]
+
+
+def render_help(
+    registry: CommandRegistry | None = None,
+) -> str:
+    """Render categorized help text for all available slash commands."""
+    reg = registry or get_command_registry()
+    lines: list[str] = ["Available commands:", ""]
+
+    rendered_categories: set[str] = set()
+    for cat in _CATEGORY_ORDER:
+        specs = reg.by_category(cat)
+        if not specs:
+            continue
+
+        rendered_categories.add(cat)
+        label = _CATEGORY_LABELS.get(cat, cat.title())
+        lines.append(f"  {label}:")
+
+        for spec in sorted(specs, key=lambda s: s.name):
+            hint = f" {spec.argument_hint}" if spec.argument_hint else ""
+            aliases = ""
+            if spec.aliases:
+                aliases = f" (aliases: {', '.join('/' + a for a in spec.aliases)})"
+            lines.append(f"    /{spec.name}{hint} — {spec.summary}{aliases}")
+
+        lines.append("")
+
+    # Remaining categories
+    for cat in sorted(reg.categories()):
+        if cat in rendered_categories:
+            continue
+        specs = reg.by_category(cat)
+        if not specs:
+            continue
+        label = _CATEGORY_LABELS.get(cat, cat.title())
+        lines.append(f"  {label}:")
+        for spec in sorted(specs, key=lambda s: s.name):
+            hint = f" {spec.argument_hint}" if spec.argument_hint else ""
+            lines.append(f"    /{spec.name}{hint} — {spec.summary}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def render_help_detail(
+    command_name: str,
+    registry: CommandRegistry | None = None,
+) -> str | None:
+    """Render detailed help for a specific command."""
+    reg = registry or get_command_registry()
+    spec = reg.get(command_name)
+    if spec is None:
+        return None
+
+    lines = [
+        f"/{spec.name}",
+        f"  {spec.summary}",
+    ]
+    if spec.argument_hint:
+        lines.append(f"  Usage: /{spec.name} {spec.argument_hint}")
+    if spec.aliases:
+        lines.append(f"  Aliases: {', '.join('/' + a for a in spec.aliases)}")
+    if spec.resume_supported:
+        lines.append("  Supports --resume mode")
+    lines.append(f"  Category: {spec.category}")
+
+    return "\n".join(lines)

axion/commands/registry.py

@@ -0,0 +1,166 @@
+"""Slash command registry — ONLY commands that actually have handlers.
+
+No fake commands. If it shows in /help, it works.
+"""
+
+from __future__ import annotations
+
+import enum
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SlashCommandSpec:
+    """Metadata for a slash command."""
+
+    name: str
+    aliases: list[str] = field(default_factory=list)
+    summary: str = ""
+    argument_hint: str | None = None
+    resume_supported: bool = False
+    source: str = "builtin"
+    category: str = "general"
+
+
+class CommandSource(enum.Enum):
+    BUILTIN = "builtin"
+    PLUGIN = "plugin"
+    SKILL = "skill"
+
+
+@dataclass
+class CommandManifestEntry:
+    name: str
+    source: CommandSource = CommandSource.BUILTIN
+
+
+# ---------------------------------------------------------------------------
+# ONLY commands that have working handlers
+# ---------------------------------------------------------------------------
+
+SLASH_COMMAND_SPECS: list[SlashCommandSpec] = [
+    # -- Core --
+    SlashCommandSpec(name="help", summary="Show available commands", argument_hint="[command]", category="core"),
+    SlashCommandSpec(name="quit", aliases=["exit", "q"], summary="Exit the REPL", category="core"),
+    SlashCommandSpec(name="clear", summary="Clear conversation history", category="core"),
+    SlashCommandSpec(name="compact", summary="Compact session history to reduce tokens", category="core"),
+    SlashCommandSpec(name="cost", summary="Show token usage and costs", category="core"),
+    SlashCommandSpec(name="status", summary="Show session status", category="core"),
+
+    # -- Model --
+    SlashCommandSpec(name="model", summary="Show or switch AI model", argument_hint="[opus|sonnet|haiku|gpt-4o|grok-2|llama3.1]", category="model"),
+    SlashCommandSpec(name="models", summary="List available Ollama models", category="model"),
+    SlashCommandSpec(name="permissions", summary="Show or change permission mode", argument_hint="[allow|prompt|read-only]", category="model"),
+
+    # -- Session --
+    SlashCommandSpec(name="session", summary="Manage sessions (list/switch/new/fork/delete)", argument_hint="[list|switch|new|fork|delete]", category="session"),
+    SlashCommandSpec(name="resume", summary="Resume a previous session", argument_hint="[session_id|latest]", category="session"),
+    SlashCommandSpec(name="export", summary="Export transcript to markdown", argument_hint="[filename]", category="session"),
+    SlashCommandSpec(name="share", summary="Share session with teammates", argument_hint="[file|import <path>]", category="session"),
+
+    # -- Config & Setup --
+    SlashCommandSpec(name="config", summary="Show loaded configuration", category="config"),
+    SlashCommandSpec(name="init", summary="Create AXION.md for your project", category="config"),
+    SlashCommandSpec(name="sandbox", summary="Show sandbox status", category="config"),
+
+    # -- Tools & Plugins --
+    SlashCommandSpec(name="mcp", summary="Manage MCP servers", argument_hint="[list|show|help]", category="tools"),
+    SlashCommandSpec(name="plugins", summary="Manage plugins", argument_hint="[list|install|enable|disable]", category="tools"),
+    SlashCommandSpec(name="agents", summary="List available agents", category="tools"),
+    SlashCommandSpec(name="skills", summary="List available skills", category="tools"),
+
+    # -- Info --
+    SlashCommandSpec(name="version", summary="Show version", category="info"),
+    SlashCommandSpec(name="doctor", summary="Run health checks", category="info"),
+    SlashCommandSpec(name="memory", summary="Show project memory", category="info"),
+    SlashCommandSpec(name="diff", summary="Show git changes with syntax highlighting", category="info"),
+
+    # -- Auth --
+    SlashCommandSpec(name="login", summary="Save API key (axion login --provider openai)", category="auth"),
+    SlashCommandSpec(name="logout", summary="Remove saved credentials", category="auth"),
+    SlashCommandSpec(name="auth-mode", aliases=["auth"], summary="Show or switch auth (subscription/api)", argument_hint="[subscription|api|status]", category="auth"),
+
+    # -- Workflow --
+    SlashCommandSpec(name="plan", summary="Plan before coding (read-only exploration)", argument_hint="<task>", category="workflow"),
+    SlashCommandSpec(name="commit", summary="Auto-commit with AI message", argument_hint="[message]", category="workflow"),
+    SlashCommandSpec(name="undo", summary="Revert last change (git reset)", argument_hint="[hard|file.py]", category="workflow"),
+    SlashCommandSpec(name="review", summary="AI code review of recent changes", argument_hint="[file|HEAD~N]", category="workflow"),
+    SlashCommandSpec(name="test", summary="Generate tests for a file", argument_hint="<file> [pytest|jest]", category="workflow"),
+    SlashCommandSpec(name="init-project", aliases=["scaffold"], summary="Scaffold project from template", argument_hint="[react|django|fastapi|express|cli]", category="workflow"),
+    SlashCommandSpec(name="security-review", summary="AI security audit of code", argument_hint="[file]", category="workflow"),
+
+    # -- Media --
+    SlashCommandSpec(name="image", summary="Paste image from clipboard or file path", argument_hint="[path]", category="media"),
+
+    # -- Utility --
+    SlashCommandSpec(name="context", summary="Show context window usage (tokens/capacity)", category="utility"),
+    SlashCommandSpec(name="branch", summary="Show or switch git branch", argument_hint="[branch_name]", category="utility"),
+    SlashCommandSpec(name="hooks", summary="Show configured hooks", category="utility"),
+    SlashCommandSpec(name="copy", summary="Copy last response to clipboard", category="utility"),
+    SlashCommandSpec(name="rename", summary="Rename current session", argument_hint="<new_name>", category="utility"),
+    SlashCommandSpec(name="files", summary="List files referenced in this session", category="utility"),
+    SlashCommandSpec(name="summary", summary="AI summarizes the conversation so far", category="utility"),
+    SlashCommandSpec(name="stats", summary="Show detailed usage statistics", category="utility"),
+]
+
+
+# ---------------------------------------------------------------------------
+# Command registry
+# ---------------------------------------------------------------------------
+
+class CommandRegistry:
+    """Registry of slash commands — only commands with working handlers."""
+
+    def __init__(self) -> None:
+        self._commands: dict[str, SlashCommandSpec] = {}
+        self._by_category: dict[str, list[SlashCommandSpec]] = {}
+        self._register_builtins()
+
+    def _register_builtins(self) -> None:
+        for spec in SLASH_COMMAND_SPECS:
+            self._commands[spec.name] = spec
+            for alias in spec.aliases:
+                self._commands[alias] = spec
+            cat = spec.category
+            if cat not in self._by_category:
+                self._by_category[cat] = []
+            self._by_category[cat].append(spec)
+
+    def get(self, name: str) -> SlashCommandSpec | None:
+        return self._commands.get(name.lstrip("/").lower())
+
+    def all_specs(self) -> list[SlashCommandSpec]:
+        seen: set[str] = set()
+        specs: list[SlashCommandSpec] = []
+        for spec in self._commands.values():
+            if spec.name not in seen:
+                seen.add(spec.name)
+                specs.append(spec)
+        return specs
+
+    def command_names(self) -> list[str]:
+        return list(self._commands.keys())
+
+    def by_category(self, category: str) -> list[SlashCommandSpec]:
+        return self._by_category.get(category, [])
+
+    def categories(self) -> list[str]:
+        return sorted(self._by_category.keys())
+
+    def register_plugin_command(self, name: str, summary: str = "") -> None:
+        spec = SlashCommandSpec(name=name, summary=summary, source="plugin", category="plugin")
+        self._commands[name] = spec
+
+    def register_skill_command(self, name: str, summary: str = "") -> None:
+        spec = SlashCommandSpec(name=name, summary=summary, source="skill", category="skill")
+        self._commands[name] = spec
+
+
+_registry: CommandRegistry | None = None
+
+
+def get_command_registry() -> CommandRegistry:
+    global _registry
+    if _registry is None:
+        _registry = CommandRegistry()
+    return _registry

axion/compat_harness/extractor.py

@@ -0,0 +1,145 @@
+"""Extract TypeScript manifests from upstream repo.
+
+Maps to: rust/crates/compat-harness/src/lib.rs
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class UpstreamPaths:
+    """Resolver for upstream repo file paths."""
+
+    repo_root: Path
+
+    def commands_path(self) -> Path:
+        return self.repo_root / "src" / "commands.ts"
+
+    def tools_path(self) -> Path:
+        return self.repo_root / "src" / "tools.ts"
+
+    def cli_path(self) -> Path:
+        return self.repo_root / "src" / "entrypoints" / "cli.tsx"
+
+    @classmethod
+    def from_repo_root(cls, root: Path) -> UpstreamPaths:
+        return cls(repo_root=root)
+
+    @classmethod
+    def from_workspace_dir(cls, directory: Path) -> UpstreamPaths | None:
+        """Auto-discover upstream repo from workspace directory."""
+        candidates = _upstream_repo_candidates(directory)
+        for candidate in candidates:
+            if (candidate / "src" / "commands.ts").exists():
+                return cls(repo_root=candidate)
+        return None
+
+
+@dataclass
+class ExtractedManifest:
+    """Parsed manifests from upstream TypeScript."""
+
+    commands: list[str] = field(default_factory=list)
+    tools: list[str] = field(default_factory=list)
+    bootstrap_phases: list[str] = field(default_factory=list)
+
+
+def extract_manifest(paths: UpstreamPaths) -> ExtractedManifest:
+    """Read and parse all upstream manifest files."""
+    manifest = ExtractedManifest()
+
+    # Extract commands
+    commands_path = paths.commands_path()
+    if commands_path.exists():
+        source = commands_path.read_text(encoding="utf-8")
+        manifest.commands = extract_commands(source)
+
+    # Extract tools
+    tools_path = paths.tools_path()
+    if tools_path.exists():
+        source = tools_path.read_text(encoding="utf-8")
+        manifest.tools = extract_tools(source)
+
+    # Extract bootstrap phases
+    cli_path = paths.cli_path()
+    if cli_path.exists():
+        source = cli_path.read_text(encoding="utf-8")
+        manifest.bootstrap_phases = extract_bootstrap_plan(source)
+
+    return manifest
+
+
+def extract_commands(source: str) -> list[str]:
+    """Parse command names from TypeScript imports and feature gates."""
+    commands: list[str] = []
+    for line in source.splitlines():
+        # Match import { X } from './commands/X'
+        match = re.search(r"import\s*\{([^}]+)\}", line)
+        if match:
+            symbols = [s.strip() for s in match.group(1).split(",")]
+            commands.extend(s for s in symbols if s)
+
+        # Match feature('name', ...)
+        match = re.search(r"feature\(['\"]([^'\"]+)['\"]", line)
+        if match:
+            commands.append(match.group(1))
+
+    return sorted(set(commands))
+
+
+def extract_tools(source: str) -> list[str]:
+    """Parse tool names from TypeScript imports."""
+    tools: list[str] = []
+    for line in source.splitlines():
+        match = re.search(r"import\s*\{([^}]+)\}", line)
+        if match:
+            symbols = [s.strip() for s in match.group(1).split(",")]
+            for s in symbols:
+                if s.endswith("Tool"):
+                    tools.append(s)
+    return sorted(set(tools))
+
+
+def extract_bootstrap_plan(source: str) -> list[str]:
+    """Detect bootstrap phases from CLI entry point."""
+    phases: list[str] = []
+    markers = {
+        "--version": "version_check",
+        "profiler": "profiler",
+        "system-prompt": "system_prompt",
+        "daemon": "daemon",
+    }
+    for line in source.splitlines():
+        for marker, phase in markers.items():
+            if marker in line:
+                phases.append(phase)
+    return list(dict.fromkeys(phases))  # Dedupe preserving order
+
+
+def _upstream_repo_candidates(primary: Path) -> list[Path]:
+    """Find candidate upstream repo locations."""
+    candidates: list[Path] = []
+
+    # Check environment variable
+    env_root = os.environ.get("CLAUDE_CODE_UPSTREAM")
+    if env_root:
+        candidates.append(Path(env_root))
+
+    # Check parent directories
+    current = primary
+    for _ in range(5):
+        candidates.append(current)
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+    # Check vendor directories
+    candidates.append(primary / "vendor" / "claude-code")
+
+    return candidates

axion/plugins/hooks.py

@@ -0,0 +1,22 @@
+"""Plugin-level hook execution.
+
+Maps to: rust/crates/plugins/src/hooks.rs
+"""
+
+from __future__ import annotations
+
+from axion.plugins.manager import PluginRegistry
+from axion.runtime.hooks import HookConfig, HookRunner
+
+
+def hook_runner_from_registry(registry: PluginRegistry) -> HookRunner:
+    """Create a HookRunner from aggregated plugin hooks."""
+    hooks = registry.aggregated_hooks()
+
+    return HookRunner(
+        pre_tool_use=[HookConfig(command=cmd) for cmd in hooks["pre_tool_use"]],
+        post_tool_use=[HookConfig(command=cmd) for cmd in hooks["post_tool_use"]],
+        post_tool_use_failure=[
+            HookConfig(command=cmd) for cmd in hooks["post_tool_use_failure"]
+        ],
+    )