mita-code 0.1.0__py3-none-any.whl

mita/tools/builtins/file_read.py

@@ -0,0 +1,74 @@
+"""Built-in tool: read file contents."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from mita.tools.schema import ToolDefinition, ToolParameter, ToolResult
+
+TOOL_DEF = ToolDefinition(
+    name="file_read",
+    description="Read the contents of a file. Returns the file content with line numbers.",
+    parameters=[
+        ToolParameter(name="path", type="string", description="Path to the file to read."),
+        ToolParameter(
+            name="offset",
+            type="integer",
+            description="Line number to start reading from (1-based). Default: 1.",
+            required=False,
+            default=1,
+        ),
+        ToolParameter(
+            name="limit",
+            type="integer",
+            description="Maximum number of lines to read. Default: 2000.",
+            required=False,
+            default=2000,
+        ),
+    ],
+    destructive=False,
+)
+
+
+async def execute(args: dict[str, Any]) -> ToolResult:
+    """Read file contents with optional offset and limit."""
+    path_str = str(args.get("path", ""))
+    offset = int(args.get("offset", 1) or 1)
+    limit = int(args.get("limit", 2000) or 2000)
+
+    if not path_str:
+        return ToolResult(tool_call_id="", success=False, error="Missing required parameter: path")
+
+    path = Path(path_str).expanduser().resolve()
+
+    if not path.exists():
+        return ToolResult(tool_call_id="", success=False, error=f"File not found: {path}")
+
+    if not path.is_file():
+        return ToolResult(tool_call_id="", success=False, error=f"Not a file: {path}")
+
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError as e:
+        return ToolResult(tool_call_id="", success=False, error=f"Cannot read file: {e}")
+
+    lines = text.splitlines()
+    total_lines = len(lines)
+
+    # Apply offset (1-based) and limit
+    start = max(0, offset - 1)
+    end = start + limit
+    selected = lines[start:end]
+
+    # Format with line numbers
+    numbered = []
+    for i, line in enumerate(selected, start=start + 1):
+        numbered.append(f"{i:>6}\t{line}")
+
+    output = "\n".join(numbered)
+
+    if end < total_lines:
+        output += f"\n\n... [{total_lines - end} more lines, {total_lines} total]"
+
+    return ToolResult(tool_call_id="", success=True, output=output)

mita/tools/builtins/file_write.py

@@ -0,0 +1,42 @@
+"""Built-in tool: write file contents."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from mita.tools.schema import ToolDefinition, ToolParameter, ToolResult
+
+TOOL_DEF = ToolDefinition(
+    name="file_write",
+    description="Write content to a file. Creates the file and any parent directories if needed.",
+    parameters=[
+        ToolParameter(name="path", type="string", description="Path to the file to write."),
+        ToolParameter(name="content", type="string", description="Content to write to the file."),
+    ],
+    destructive=True,  # Overwrites existing files
+)
+
+
+async def execute(args: dict[str, Any]) -> ToolResult:
+    """Write content to a file."""
+    path_str = str(args.get("path", ""))
+    content = str(args.get("content", ""))
+
+    if not path_str:
+        return ToolResult(tool_call_id="", success=False, error="Missing required parameter: path")
+
+    path = Path(path_str).expanduser().resolve()
+
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        existed = path.exists()
+        path.write_text(content, encoding="utf-8")
+        action = "Updated" if existed else "Created"
+        return ToolResult(
+            tool_call_id="",
+            success=True,
+            output=f"{action} {path} ({len(content)} chars, {content.count(chr(10)) + 1} lines)",
+        )
+    except OSError as e:
+        return ToolResult(tool_call_id="", success=False, error=f"Cannot write file: {e}")

mita/tools/builtins/git.py

@@ -0,0 +1,112 @@
+"""Built-in tool: git operations (status, diff, commit, log)."""
+
+from __future__ import annotations
+
+import asyncio
+import shlex
+from typing import Any
+
+from mita.tools.schema import ToolDefinition, ToolParameter, ToolResult
+
+TOOL_DEF = ToolDefinition(
+    name="git",
+    description=(
+        "Run git commands. Supports: status, diff, log, add, commit, branch, checkout. "
+        "Destructive operations (push, reset, clean) require confirmation."
+    ),
+    parameters=[
+        ToolParameter(
+            name="subcommand",
+            type="string",
+            description=(
+                "The git subcommand to run "
+                '(e.g. "status", "diff", "log --oneline -10", "add .", "commit -m msg").'
+            ),
+        ),
+    ],
+    destructive=False,  # Per-command destructiveness handled by is_safe_git_command
+)
+
+# Git subcommands that are always safe (read-only)
+SAFE_SUBCOMMANDS = frozenset(
+    {
+        "status",
+        "diff",
+        "log",
+        "show",
+        "branch",
+        "remote",
+        "tag",
+        "stash",
+        "ls-files",
+        "rev-parse",
+        "describe",
+    }
+)
+
+
+def is_safe_git_command(subcommand: str) -> bool:
+    """Check if a git subcommand is read-only."""
+    first_word = subcommand.strip().split()[0] if subcommand.strip() else ""
+    return first_word in SAFE_SUBCOMMANDS
+
+
+async def execute(args: dict[str, Any]) -> ToolResult:
+    """Execute a git subcommand using subprocess_exec (no shell injection)."""
+    subcommand = str(args.get("subcommand", ""))
+
+    if not subcommand:
+        return ToolResult(
+            tool_call_id="",
+            success=False,
+            error="Missing required parameter: subcommand",
+        )
+
+    # Use shlex.split to safely tokenize, then prepend "git"
+    try:
+        cmd_parts = ["git", *shlex.split(subcommand)]
+    except ValueError as e:
+        return ToolResult(
+            tool_call_id="",
+            success=False,
+            error=f"Invalid subcommand syntax: {e}",
+        )
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *cmd_parts,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout_bytes, stderr_bytes = await asyncio.wait_for(proc.communicate(), timeout=30)
+    except TimeoutError:
+        proc.kill()
+        return ToolResult(
+            tool_call_id="",
+            success=False,
+            error=f"Git command timed out: git {subcommand}",
+        )
+    except OSError as e:
+        return ToolResult(tool_call_id="", success=False, error=f"Failed to run git: {e}")
+
+    stdout = stdout_bytes.decode("utf-8", errors="replace") if stdout_bytes else ""
+    stderr = stderr_bytes.decode("utf-8", errors="replace") if stderr_bytes else ""
+
+    output_parts: list[str] = []
+    if stdout:
+        output_parts.append(stdout)
+    if stderr:
+        output_parts.append(f"STDERR:\n{stderr}")
+
+    output = "\n".join(output_parts) if output_parts else "(no output)"
+    exit_code = proc.returncode or 0
+
+    if exit_code != 0:
+        output = f"[exit code {exit_code}]\n{output}"
+
+    return ToolResult(
+        tool_call_id="",
+        success=exit_code == 0,
+        output=output,
+        error=f"Git command failed with exit code {exit_code}" if exit_code != 0 else None,
+    )

mita/tools/builtins/glob_tool.py

@@ -0,0 +1,67 @@
+"""Built-in tool: glob-based file search."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from mita.tools.schema import ToolDefinition, ToolParameter, ToolResult
+
+TOOL_DEF = ToolDefinition(
+    name="glob",
+    description="Search for files matching a glob pattern. Returns matching file paths.",
+    parameters=[
+        ToolParameter(
+            name="pattern",
+            type="string",
+            description='Glob pattern (e.g. "**/*.py", "src/**/*.ts").',
+        ),
+        ToolParameter(
+            name="path",
+            type="string",
+            description="Directory to search in. Defaults to current directory.",
+            required=False,
+            default=".",
+        ),
+    ],
+    destructive=False,
+)
+
+MAX_RESULTS = 500
+
+
+async def execute(args: dict[str, Any]) -> ToolResult:
+    """Search for files matching a glob pattern."""
+    pattern = str(args.get("pattern", ""))
+    base_path = str(args.get("path", ".") or ".")
+
+    if not pattern:
+        return ToolResult(
+            tool_call_id="", success=False, error="Missing required parameter: pattern"
+        )
+
+    base = Path(base_path).expanduser().resolve()
+    if not base.is_dir():
+        return ToolResult(tool_call_id="", success=False, error=f"Not a directory: {base}")
+
+    try:
+        matches = sorted(base.glob(pattern))
+    except ValueError as e:
+        return ToolResult(tool_call_id="", success=False, error=f"Invalid glob pattern: {e}")
+
+    # Filter out directories, keep only files
+    files = [str(m) for m in matches if m.is_file()]
+
+    if not files:
+        return ToolResult(tool_call_id="", success=True, output="No files matched.")
+
+    truncated = len(files) > MAX_RESULTS
+    output_files = files[:MAX_RESULTS]
+    output = "\n".join(output_files)
+
+    if truncated:
+        output += f"\n\n... [{len(files)} total matches, showing first {MAX_RESULTS}]"
+    else:
+        output += f"\n\n[{len(files)} file(s) matched]"
+
+    return ToolResult(tool_call_id="", success=True, output=output, truncated=truncated)

mita/tools/builtins/grep_tool.py

@@ -0,0 +1,93 @@
+"""Built-in tool: content search (ripgrep-style)."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from mita.tools.schema import ToolDefinition, ToolParameter, ToolResult
+
+TOOL_DEF = ToolDefinition(
+    name="grep",
+    description="Search file contents for a regex pattern. Returns matching lines with context.",
+    parameters=[
+        ToolParameter(
+            name="pattern",
+            type="string",
+            description="Regex pattern to search for.",
+        ),
+        ToolParameter(
+            name="path",
+            type="string",
+            description="File or directory to search in. Defaults to current directory.",
+            required=False,
+            default=".",
+        ),
+        ToolParameter(
+            name="include",
+            type="string",
+            description='Glob pattern to filter files (e.g. "*.py"). Only used for directories.',
+            required=False,
+        ),
+    ],
+    destructive=False,
+)
+
+MAX_MATCHES = 200
+
+
+async def execute(args: dict[str, Any]) -> ToolResult:
+    """Search file contents for a regex pattern."""
+    pattern_str = str(args.get("pattern", ""))
+    path_str = str(args.get("path", ".") or ".")
+    include = args.get("include")
+
+    if not pattern_str:
+        return ToolResult(
+            tool_call_id="", success=False, error="Missing required parameter: pattern"
+        )
+
+    try:
+        regex = re.compile(pattern_str)
+    except re.error as e:
+        return ToolResult(tool_call_id="", success=False, error=f"Invalid regex: {e}")
+
+    target = Path(path_str).expanduser().resolve()
+
+    if target.is_file():
+        files = [target]
+    elif target.is_dir():
+        glob_pattern = str(include) if include else "**/*"
+        files = sorted(f for f in target.glob(glob_pattern) if f.is_file())
+    else:
+        return ToolResult(tool_call_id="", success=False, error=f"Path not found: {target}")
+
+    matches: list[str] = []
+    match_count = 0
+
+    for file_path in files:
+        try:
+            text = file_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+
+        for line_num, line in enumerate(text.splitlines(), 1):
+            if regex.search(line):
+                matches.append(f"{file_path}:{line_num}: {line.rstrip()}")
+                match_count += 1
+                if match_count >= MAX_MATCHES:
+                    break
+        if match_count >= MAX_MATCHES:
+            break
+
+    if not matches:
+        return ToolResult(tool_call_id="", success=True, output="No matches found.")
+
+    output = "\n".join(matches)
+    if match_count >= MAX_MATCHES:
+        output += f"\n\n... [showing first {MAX_MATCHES} matches]"
+    else:
+        output += f"\n\n[{match_count} match(es)]"
+
+    return ToolResult(tool_call_id="", success=True, output=output)

mita/tools/builtins/shell.py

@@ -0,0 +1,83 @@
+"""Built-in tool: shell command execution with timeout."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from mita.tools.schema import ToolDefinition, ToolParameter, ToolResult
+
+TOOL_DEF = ToolDefinition(
+    name="shell",
+    description=(
+        "Execute a shell command. Commands run in a bash subprocess with a timeout. "
+        "Use for system commands, builds, tests, etc."
+    ),
+    parameters=[
+        ToolParameter(
+            name="command",
+            type="string",
+            description="The shell command to execute.",
+        ),
+        ToolParameter(
+            name="timeout",
+            type="integer",
+            description="Timeout in seconds. Default: 120.",
+            required=False,
+            default=120,
+        ),
+    ],
+    destructive=True,  # Shell commands can be destructive
+)
+
+
+async def execute(args: dict[str, Any]) -> ToolResult:
+    """Execute a shell command."""
+    command = str(args.get("command", ""))
+    timeout = int(args.get("timeout", 120) or 120)
+
+    if not command:
+        return ToolResult(
+            tool_call_id="", success=False, error="Missing required parameter: command"
+        )
+
+    try:
+        proc = await asyncio.create_subprocess_shell(
+            command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout_bytes, stderr_bytes = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except TimeoutError:
+        proc.kill()
+        return ToolResult(
+            tool_call_id="",
+            success=False,
+            error=f"Command timed out after {timeout}s: {command}",
+        )
+    except OSError as e:
+        return ToolResult(tool_call_id="", success=False, error=f"Failed to run command: {e}")
+
+    stdout = stdout_bytes.decode("utf-8", errors="replace") if stdout_bytes else ""
+    stderr = stderr_bytes.decode("utf-8", errors="replace") if stderr_bytes else ""
+
+    output_parts: list[str] = []
+    if stdout:
+        output_parts.append(stdout)
+    if stderr:
+        output_parts.append(f"STDERR:\n{stderr}")
+
+    output = (
+        "\n".join(output_parts) if output_parts else "Command completed successfully (no output)."
+    )
+    exit_code = proc.returncode or 0
+
+    if exit_code != 0:
+        output = f"[exit code {exit_code}]\n{output}"
+
+    return ToolResult(
+        tool_call_id="",
+        success=exit_code == 0,
+        output=output,
+        error=f"Command exited with code {exit_code}" if exit_code != 0 else None,
+    )

mita/tools/executor.py

@@ -0,0 +1,80 @@
+"""Tool dispatch: confirmation flow and execution."""
+
+from __future__ import annotations
+
+from mita.config.schema import ToolSettings
+from mita.tools.registry import ToolRegistry
+from mita.tools.safety import is_command_banned, needs_confirmation
+from mita.tools.schema import ToolCall, ToolResult
+
+
+async def execute_tool(
+    tool_call: ToolCall,
+    registry: ToolRegistry,
+    settings: ToolSettings,
+    confirm_fn: object | None = None,
+) -> ToolResult:
+    """Execute a tool call with safety checks and optional confirmation.
+
+    Args:
+        tool_call: The parsed tool call from LLM output.
+        registry: The tool registry to look up handlers.
+        settings: Tool settings (auto_approve, banned_commands, etc.).
+        confirm_fn: Optional async callable(str) -> bool for user confirmation.
+                     If None, destructive tools are denied automatically.
+    """
+    tool_def = registry.get_definition(tool_call.name)
+    if tool_def is None:
+        return ToolResult(
+            tool_call_id=tool_call.id,
+            success=False,
+            error=f"Unknown tool: {tool_call.name}",
+        )
+
+    # Check for banned commands (shell and git tools)
+    if tool_call.name == "shell":
+        command = tool_call.arguments.get("command", "")
+        if is_command_banned(command, settings.banned_commands):
+            return ToolResult(
+                tool_call_id=tool_call.id,
+                success=False,
+                error=f"Command is banned by configuration: {command}",
+            )
+    if tool_call.name == "git":
+        subcommand = tool_call.arguments.get("subcommand", "")
+        if is_command_banned(f"git {subcommand}", settings.banned_commands):
+            return ToolResult(
+                tool_call_id=tool_call.id,
+                success=False,
+                error=f"Git command is banned by configuration: git {subcommand}",
+            )
+
+    # Confirmation flow
+    if needs_confirmation(tool_call, tool_def, settings):
+        if confirm_fn is None:
+            return ToolResult(
+                tool_call_id=tool_call.id,
+                success=False,
+                error="Destructive action requires confirmation, but no confirmation handler.",
+            )
+
+        prompt = f"Allow {tool_call.name}({_summarize_args(tool_call)})?"
+        approved = await confirm_fn(prompt)  # type: ignore[operator]
+        if not approved:
+            return ToolResult(
+                tool_call_id=tool_call.id,
+                success=False,
+                error="User denied this action.",
+            )
+
+    return await registry.execute(tool_call)
+
+
+def _summarize_args(tool_call: ToolCall) -> str:
+    """Create a short summary of tool call arguments for the confirmation prompt."""
+    parts: list[str] = []
+    for key, value in tool_call.arguments.items():
+        if isinstance(value, str) and len(value) > 50:
+            value = value[:50] + "..."
+        parts.append(f"{key}={value!r}")
+    return ", ".join(parts)

mita/tools/registry.py

@@ -0,0 +1,69 @@
+"""Tool registry: name → (definition, handler) mapping."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from mita.tools.schema import ToolCall, ToolDefinition, ToolResult
+
+# Type for async tool handler functions
+ToolHandler = Callable[[dict[str, Any]], Awaitable[ToolResult]]
+
+
+class ToolRegistry:
+    """Central registry for all available tools (built-in + plugins)."""
+
+    def __init__(self) -> None:
+        self._tools: dict[str, ToolDefinition] = {}
+        self._handlers: dict[str, ToolHandler] = {}
+
+    def register(self, definition: ToolDefinition, handler: ToolHandler) -> None:
+        """Register a tool with its definition and handler."""
+        self._tools[definition.name] = definition
+        self._handlers[definition.name] = handler
+
+    def get_definition(self, name: str) -> ToolDefinition | None:
+        """Get a tool definition by name."""
+        return self._tools.get(name)
+
+    def get_definitions(self) -> list[ToolDefinition]:
+        """Get all registered tool definitions."""
+        return list(self._tools.values())
+
+    def get_openai_schemas(self) -> list[dict[str, Any]]:
+        """Get all tool definitions as OpenAI-compatible schemas."""
+        return [t.to_openai_schema() for t in self._tools.values()]
+
+    def has_tool(self, name: str) -> bool:
+        """Check if a tool is registered."""
+        return name in self._tools
+
+    async def execute(self, tool_call: ToolCall) -> ToolResult:
+        """Execute a tool call and return the result."""
+        handler = self._handlers.get(tool_call.name)
+        if handler is None:
+            return ToolResult(
+                tool_call_id=tool_call.id,
+                success=False,
+                error=f"Unknown tool: {tool_call.name}",
+            )
+        result = await handler(tool_call.arguments)
+        # Attach the tool_call_id
+        result = result.model_copy(update={"tool_call_id": tool_call.id})
+        return result.truncate_output()
+
+    @property
+    def tool_names(self) -> list[str]:
+        """List all registered tool names."""
+        return list(self._tools.keys())
+
+
+def create_default_registry() -> ToolRegistry:
+    """Create a registry with all built-in tools registered."""
+    from mita.tools.builtins import BUILTIN_TOOLS
+
+    registry = ToolRegistry()
+    for _name, (definition, handler) in BUILTIN_TOOLS.items():
+        registry.register(definition, handler)  # type: ignore[arg-type]
+    return registry