axion-code 1.0.0__py3-none-any.whl

axion/runtime/git.py

@@ -0,0 +1,213 @@
+"""Git workflow operations.
+
+Maps to: rust/crates/runtime/src/git.rs
+
+Provides typed wrappers around common git commands using subprocess.run
+with proper error handling.
+"""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class GitError(Exception):
+    """Error from a git operation."""
+
+    def __init__(self, message: str, *, returncode: int = 1) -> None:
+        super().__init__(message)
+        self.returncode = returncode
+
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class GitStatus:
+    """Parsed output of ``git status``."""
+
+    branch: str
+    clean: bool
+    staged: int = 0
+    modified: int = 0
+    untracked: int = 0
+
+
+@dataclass
+class GitCommit:
+    """A single commit from ``git log``."""
+
+    hash: str
+    author: str
+    date: str
+    message: str
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _run(
+    args: list[str],
+    cwd: Path,
+    *,
+    check: bool = True,
+) -> subprocess.CompletedProcess[str]:
+    """Run a git command with standard options."""
+    try:
+        result = subprocess.run(
+            args,
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise GitError(f"Git command timed out: {' '.join(args)}") from exc
+    except FileNotFoundError as exc:
+        raise GitError("git executable not found") from exc
+
+    if check and result.returncode != 0:
+        stderr = result.stderr.strip()
+        raise GitError(
+            f"git {args[1] if len(args) > 1 else ''} failed: {stderr}",
+            returncode=result.returncode,
+        )
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def git_status(cwd: Path) -> GitStatus:
+    """Return parsed status (branch, clean/dirty, file counts)."""
+    # Branch name
+    branch_result = _run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd, check=False
+    )
+    branch = branch_result.stdout.strip() if branch_result.returncode == 0 else "unknown"
+
+    # Porcelain status for counts
+    result = _run(["git", "status", "--porcelain"], cwd)
+    lines = [line for line in result.stdout.splitlines() if line.strip()]
+
+    staged = 0
+    modified = 0
+    untracked = 0
+
+    for line in lines:
+        if len(line) < 2:
+            continue
+        x, y = line[0], line[1]
+        if x == "?":
+            untracked += 1
+        else:
+            if x in "ACDMR":
+                staged += 1
+            if y in "ACDMR":
+                modified += 1
+
+    return GitStatus(
+        branch=branch,
+        clean=len(lines) == 0,
+        staged=staged,
+        modified=modified,
+        untracked=untracked,
+    )
+
+
+def git_log(cwd: Path, n: int = 10) -> list[GitCommit]:
+    """Return recent commits."""
+    result = _run(
+        [
+            "git",
+            "log",
+            f"-{n}",
+            "--format=%H%n%an%n%ai%n%s%n---",
+        ],
+        cwd,
+    )
+
+    commits: list[GitCommit] = []
+    entries = result.stdout.strip().split("---\n")
+    for entry in entries:
+        entry = entry.strip()
+        if not entry:
+            continue
+        parts = entry.split("\n", 3)
+        if len(parts) >= 4:
+            commits.append(
+                GitCommit(
+                    hash=parts[0].strip(),
+                    author=parts[1].strip(),
+                    date=parts[2].strip(),
+                    message=parts[3].strip(),
+                )
+            )
+        elif len(parts) == 3:
+            commits.append(
+                GitCommit(
+                    hash=parts[0].strip(),
+                    author=parts[1].strip(),
+                    date=parts[2].strip(),
+                    message="",
+                )
+            )
+
+    return commits
+
+
+def git_diff(cwd: Path, staged: bool = False) -> str:
+    """Return diff output."""
+    args = ["git", "diff"]
+    if staged:
+        args.append("--staged")
+    result = _run(args, cwd)
+    return result.stdout
+
+
+def git_branch(cwd: Path) -> str:
+    """Return current branch name."""
+    result = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd)
+    return result.stdout.strip()
+
+
+def git_commit(cwd: Path, message: str, files: list[str]) -> str:
+    """Stage specific files and commit."""
+    if not files:
+        raise GitError("No files specified for commit")
+
+    # Stage files
+    _run(["git", "add", "--"] + files, cwd)
+
+    # Commit
+    result = _run(["git", "commit", "-m", message], cwd)
+    return result.stdout.strip()
+
+
+def git_create_branch(cwd: Path, name: str) -> str:
+    """Create and checkout a new branch."""
+    result = _run(["git", "checkout", "-b", name], cwd)
+    return result.stdout.strip() or result.stderr.strip()
+
+
+def git_stash(cwd: Path) -> str:
+    """Stash current changes."""
+    result = _run(["git", "stash"], cwd)
+    return result.stdout.strip()
+
+
+def git_stash_pop(cwd: Path) -> str:
+    """Pop the most recent stash."""
+    result = _run(["git", "stash", "pop"], cwd)
+    return result.stdout.strip()

axion/runtime/hooks.py

@@ -0,0 +1,235 @@
+"""Hook system for pre/post tool execution.
+
+Maps to: rust/crates/runtime/src/hooks.rs
+"""
+
+from __future__ import annotations
+
+import asyncio
+import enum
+import json
+import logging
+import os
+from dataclasses import dataclass, field
+from typing import Any, Protocol, runtime_checkable
+
+logger = logging.getLogger(__name__)
+
+
+class HookEvent(enum.Enum):
+    PRE_TOOL_USE = "pre_tool_use"
+    POST_TOOL_USE = "post_tool_use"
+    POST_TOOL_USE_FAILURE = "post_tool_use_failure"
+
+
+@dataclass
+class HookRunResult:
+    """Result of running hooks for a single event."""
+
+    denied: bool = False
+    failed: bool = False
+    cancelled: bool = False
+    messages: list[str] = field(default_factory=list)
+    permission_override: str | None = None
+    permission_reason: str | None = None
+    updated_input: str | None = None
+
+
+@dataclass
+class HookConfig:
+    """Configuration for a single hook."""
+
+    command: str
+    timeout_ms: int = 10_000
+
+
+@runtime_checkable
+class HookProgressReporter(Protocol):
+    """Protocol for hook progress reporting."""
+
+    def on_hook_started(self, event: HookEvent, tool_name: str, command: str) -> None: ...
+    def on_hook_completed(self, event: HookEvent, tool_name: str, command: str) -> None: ...
+
+
+class HookRunner:
+    """Executes hooks as subprocesses.
+
+    Maps to: rust/crates/runtime/src/hooks.rs::HookRunner
+    """
+
+    def __init__(
+        self,
+        pre_tool_use: list[HookConfig] | None = None,
+        post_tool_use: list[HookConfig] | None = None,
+        post_tool_use_failure: list[HookConfig] | None = None,
+        progress_reporter: HookProgressReporter | None = None,
+    ) -> None:
+        self.pre_tool_use = pre_tool_use or []
+        self.post_tool_use = post_tool_use or []
+        self.post_tool_use_failure = post_tool_use_failure or []
+        self.progress_reporter = progress_reporter
+
+    @classmethod
+    def from_config(cls, hooks_data: dict[str, Any]) -> HookRunner:
+        """Create HookRunner from configuration dict."""
+        def parse_hooks(data: list[Any]) -> list[HookConfig]:
+            configs = []
+            for item in data:
+                if isinstance(item, str):
+                    configs.append(HookConfig(command=item))
+                elif isinstance(item, dict):
+                    configs.append(HookConfig(
+                        command=item.get("command", ""),
+                        timeout_ms=item.get("timeout_ms", 10_000),
+                    ))
+            return configs
+
+        return cls(
+            pre_tool_use=parse_hooks(hooks_data.get("preToolUse", [])),
+            post_tool_use=parse_hooks(hooks_data.get("postToolUse", [])),
+            post_tool_use_failure=parse_hooks(hooks_data.get("postToolUseFailure", [])),
+        )
+
+    async def run_pre_tool_use(
+        self, tool_name: str, tool_input: str
+    ) -> HookRunResult:
+        """Run pre-tool-use hooks. Returns deny if any hook exits with code 2."""
+        return await self._run_hooks(
+            HookEvent.PRE_TOOL_USE,
+            self.pre_tool_use,
+            tool_name,
+            tool_input,
+        )
+
+    async def run_post_tool_use(
+        self, tool_name: str, tool_input: str, tool_output: str, is_error: bool
+    ) -> HookRunResult:
+        """Run post-tool-use hooks."""
+        return await self._run_hooks(
+            HookEvent.POST_TOOL_USE,
+            self.post_tool_use,
+            tool_name,
+            tool_input,
+            tool_output=tool_output,
+            is_error=is_error,
+        )
+
+    async def run_post_tool_use_failure(
+        self, tool_name: str, tool_input: str, error: str
+    ) -> HookRunResult:
+        """Run post-tool-use-failure hooks."""
+        return await self._run_hooks(
+            HookEvent.POST_TOOL_USE_FAILURE,
+            self.post_tool_use_failure,
+            tool_name,
+            tool_input,
+            tool_output=error,
+            is_error=True,
+        )
+
+    async def _run_hooks(
+        self,
+        event: HookEvent,
+        hooks: list[HookConfig],
+        tool_name: str,
+        tool_input: str,
+        tool_output: str = "",
+        is_error: bool = False,
+    ) -> HookRunResult:
+        """Run a list of hooks sequentially."""
+        result = HookRunResult()
+
+        for hook in hooks:
+            if self.progress_reporter:
+                self.progress_reporter.on_hook_started(event, tool_name, hook.command)
+
+            try:
+                hook_result = await self._execute_hook(
+                    hook, event, tool_name, tool_input, tool_output, is_error
+                )
+            except Exception as exc:
+                logger.error("Hook '%s' failed: %s", hook.command, exc)
+                result.failed = True
+                result.messages.append(f"Hook error: {exc}")
+                continue
+
+            if self.progress_reporter:
+                self.progress_reporter.on_hook_completed(event, tool_name, hook.command)
+
+            if hook_result.denied:
+                return hook_result
+            if hook_result.messages:
+                result.messages.extend(hook_result.messages)
+            if hook_result.updated_input:
+                result.updated_input = hook_result.updated_input
+
+        return result
+
+    async def _execute_hook(
+        self,
+        hook: HookConfig,
+        event: HookEvent,
+        tool_name: str,
+        tool_input: str,
+        tool_output: str,
+        is_error: bool,
+    ) -> HookRunResult:
+        """Execute a single hook as a subprocess."""
+        # Build environment
+        env = {
+            **os.environ,
+            "HOOK_EVENT": event.value,
+            "HOOK_TOOL_NAME": tool_name,
+            "HOOK_TOOL_INPUT": tool_input,
+            "HOOK_TOOL_OUTPUT": tool_output,
+            "HOOK_TOOL_IS_ERROR": str(is_error).lower(),
+        }
+
+        # Build payload
+        payload = json.dumps({
+            "event": event.value,
+            "tool_name": tool_name,
+            "tool_input": tool_input,
+            "tool_output": tool_output,
+            "is_error": is_error,
+        })
+
+        timeout_secs = hook.timeout_ms / 1000.0
+
+        process = await asyncio.create_subprocess_shell(
+            hook.command,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+        )
+
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(input=payload.encode()),
+                timeout=timeout_secs,
+            )
+        except asyncio.TimeoutError:
+            process.kill()
+            await process.wait()
+            return HookRunResult(failed=True, messages=["Hook timed out"])
+
+        exit_code = process.returncode
+        result = HookRunResult()
+
+        if stdout:
+            result.messages.append(stdout.decode("utf-8", errors="replace").strip())
+
+        # Exit code 0 = allow, 2 = deny, anything else = error
+        if exit_code == 0:
+            pass
+        elif exit_code == 2:
+            result.denied = True
+            reason = stderr.decode("utf-8", errors="replace").strip() if stderr else "Hook denied"
+            result.messages.append(reason)
+        else:
+            result.failed = True
+            if stderr:
+                result.messages.append(stderr.decode("utf-8", errors="replace").strip())
+
+        return result

axion/runtime/image.py

@@ -0,0 +1,212 @@
+"""Image utilities — clipboard capture, file loading, base64 encoding.
+
+Supports:
+- Grabbing screenshots/images from clipboard (Win32, macOS, Linux)
+- Loading image files from disk (png, jpg, gif, webp)
+- Converting to base64 for API submission
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Supported image extensions
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
+
+MIME_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+}
+
+# Max image size: 5MB (Anthropic limit is ~20MB but we cap lower for speed)
+MAX_IMAGE_BYTES = 5 * 1024 * 1024
+
+
+def is_image_path(text: str) -> bool:
+    """Check if text looks like an image file path."""
+    text = text.strip().strip('"').strip("'")
+    try:
+        p = Path(text)
+        return p.suffix.lower() in IMAGE_EXTENSIONS and p.exists()
+    except (OSError, ValueError):
+        return False
+
+
+def load_image_file(path: str) -> tuple[str, str] | None:
+    """Load an image file and return (media_type, base64_data) or None."""
+    p = Path(path.strip().strip('"').strip("'"))
+    if not p.exists():
+        return None
+
+    suffix = p.suffix.lower()
+    media_type = MIME_TYPES.get(suffix)
+    if not media_type:
+        return None
+
+    try:
+        data = p.read_bytes()
+        if len(data) > MAX_IMAGE_BYTES:
+            logger.warning("Image too large: %d bytes (max %d)", len(data), MAX_IMAGE_BYTES)
+            return None
+        b64 = base64.b64encode(data).decode("ascii")
+        return media_type, b64
+    except (OSError, IOError) as exc:
+        logger.warning("Failed to read image %s: %s", path, exc)
+        return None
+
+
+def grab_clipboard_image() -> tuple[str, str] | None:
+    """Grab an image from the system clipboard.
+
+    Returns (media_type, base64_data) or None if no image on clipboard.
+    Works on Windows, macOS, and Linux (with xclip).
+    """
+    import sys
+
+    if sys.platform == "win32":
+        return _clipboard_win32()
+    elif sys.platform == "darwin":
+        return _clipboard_macos()
+    else:
+        return _clipboard_linux()
+
+
+def _clipboard_win32() -> tuple[str, str] | None:
+    """Grab clipboard image on Windows using win32clipboard or Pillow."""
+    try:
+        # Try Pillow's ImageGrab (most reliable on Windows)
+        import io
+
+        from PIL import ImageGrab
+
+        img = ImageGrab.grabclipboard()
+        if img is None:
+            return None
+
+        # Convert to PNG bytes
+        buf = io.BytesIO()
+        img.save(buf, format="PNG")
+        data = buf.getvalue()
+
+        if len(data) > MAX_IMAGE_BYTES:
+            return None
+
+        b64 = base64.b64encode(data).decode("ascii")
+        return "image/png", b64
+    except ImportError:
+        pass
+    except Exception as exc:
+        logger.debug("Pillow clipboard grab failed: %s", exc)
+
+    # Fallback: try PowerShell
+    try:
+        import subprocess
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+            tmp_path = tmp.name
+
+        # PowerShell one-liner to save clipboard image
+        ps_cmd = (
+            f'Add-Type -AssemblyName System.Windows.Forms; '
+            f'$img = [System.Windows.Forms.Clipboard]::GetImage(); '
+            f'if ($img) {{ $img.Save("{tmp_path}") }} '
+            f'else {{ exit 1 }}'
+        )
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", ps_cmd],
+            capture_output=True, timeout=5,
+        )
+
+        if result.returncode == 0:
+            p = Path(tmp_path)
+            if p.exists() and p.stat().st_size > 0:
+                data = p.read_bytes()
+                p.unlink(missing_ok=True)
+                if len(data) <= MAX_IMAGE_BYTES:
+                    b64 = base64.b64encode(data).decode("ascii")
+                    return "image/png", b64
+            p.unlink(missing_ok=True)
+    except Exception as exc:
+        logger.debug("PowerShell clipboard grab failed: %s", exc)
+
+    return None
+
+
+def _clipboard_macos() -> tuple[str, str] | None:
+    """Grab clipboard image on macOS using pbpaste/osascript."""
+    try:
+        import subprocess
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+            tmp_path = tmp.name
+
+        subprocess.run(
+            ["osascript", "-e",
+             f'set fp to POSIX file "{tmp_path}"\n'
+             f'try\n'
+             f'  set img to the clipboard as «class PNGf»\n'
+             f'  set fh to open for access fp with write permission\n'
+             f'  write img to fh\n'
+             f'  close access fh\n'
+             f'on error\n'
+             f'  return "no image"\n'
+             f'end try'],
+            capture_output=True, timeout=5,
+        )
+
+        p = Path(tmp_path)
+        if p.exists() and p.stat().st_size > 0:
+            data = p.read_bytes()
+            p.unlink(missing_ok=True)
+            if len(data) <= MAX_IMAGE_BYTES:
+                b64 = base64.b64encode(data).decode("ascii")
+                return "image/png", b64
+        p.unlink(missing_ok=True)
+    except Exception as exc:
+        logger.debug("macOS clipboard grab failed: %s", exc)
+
+    return None
+
+
+def _clipboard_linux() -> tuple[str, str] | None:
+    """Grab clipboard image on Linux using xclip."""
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"],
+            capture_output=True, timeout=5,
+        )
+
+        if result.returncode == 0 and result.stdout:
+            data = result.stdout
+            if len(data) <= MAX_IMAGE_BYTES:
+                b64 = base64.b64encode(data).decode("ascii")
+                return "image/png", b64
+    except FileNotFoundError:
+        logger.debug("xclip not found — install xclip for clipboard image support")
+    except Exception as exc:
+        logger.debug("Linux clipboard grab failed: %s", exc)
+
+    return None
+
+
+def image_size_description(b64_data: str) -> str:
+    """Human-readable size of a base64-encoded image."""
+    raw_bytes = len(b64_data) * 3 // 4  # approximate
+    if raw_bytes < 1024:
+        return f"{raw_bytes} bytes"
+    elif raw_bytes < 1024 * 1024:
+        return f"{raw_bytes / 1024:.1f} KB"
+    else:
+        return f"{raw_bytes / (1024 * 1024):.1f} MB"