mita-code 0.1.0__py3-none-any.whl

mita/plugins/manager.py

@@ -0,0 +1,210 @@
+"""Plugin manager — manages all MCP plugin connections and tool registration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console
+
+from mita.config.schema import PluginDefinition
+from mita.plugins.client import MCPPluginClient
+from mita.tools.registry import ToolHandler, ToolRegistry
+from mita.tools.schema import ToolDefinition, ToolParameter, ToolResult
+
+
+def _schema_to_parameters(input_schema: dict[str, Any]) -> list[ToolParameter]:
+    """Convert a JSON Schema inputSchema to a list of ToolParameter."""
+    properties = input_schema.get("properties", {})
+    required = set(input_schema.get("required", []))
+    params: list[ToolParameter] = []
+
+    for name, prop in properties.items():
+        params.append(
+            ToolParameter(
+                name=name,
+                type=prop.get("type", "string"),
+                description=prop.get("description", ""),
+                required=name in required,
+                default=prop.get("default"),
+            )
+        )
+    return params
+
+
+class PluginManager:
+    """Manages MCP plugin connections and exposes their tools."""
+
+    def __init__(self, plugins: list[PluginDefinition]) -> None:
+        self._plugins = plugins
+        self._clients: dict[str, MCPPluginClient] = {}
+
+    @property
+    def plugin_names(self) -> list[str]:
+        return [p.name for p in self._plugins]
+
+    def get_client(self, name: str) -> MCPPluginClient | None:
+        return self._clients.get(name)
+
+    async def start_all(self, console: Console | None = None) -> list[str]:
+        """Start all configured plugins. Returns list of successfully started plugin names."""
+        started: list[str] = []
+        for plugin in self._plugins:
+            try:
+                client = MCPPluginClient(plugin)
+                await client.connect()
+                self._clients[plugin.name] = client
+                started.append(plugin.name)
+            except (ConnectionError, OSError, TimeoutError, ValueError, RuntimeError) as e:
+                if console:
+                    console.print(f"[yellow]Plugin '{plugin.name}' failed to start: {e}[/yellow]")
+        return started
+
+    async def stop_all(self) -> None:
+        """Disconnect all running plugins."""
+        for client in self._clients.values():
+            try:
+                await client.disconnect()
+            except (ConnectionError, OSError):
+                pass
+        self._clients.clear()
+
+    async def start_plugin(self, name: str, console: Console | None = None) -> bool:
+        """Start a single plugin by name."""
+        plugin = next((p for p in self._plugins if p.name == name), None)
+        if plugin is None:
+            if console:
+                console.print(f"[red]Plugin '{name}' not found in configuration.[/red]")
+            return False
+
+        try:
+            client = MCPPluginClient(plugin)
+            await client.connect()
+            self._clients[name] = client
+            return True
+        except (ConnectionError, OSError, TimeoutError, ValueError, RuntimeError) as e:
+            if console:
+                console.print(f"[red]Plugin '{name}' failed to start: {e}[/red]")
+            return False
+
+    async def stop_plugin(self, name: str) -> None:
+        """Stop a single plugin by name."""
+        client = self._clients.pop(name, None)
+        if client is not None:
+            await client.disconnect()
+
+    async def list_tools(self, name: str | None = None) -> dict[str, list[dict[str, Any]]]:
+        """List tools from connected plugins.
+
+        Args:
+            name: If provided, list tools from this plugin only.
+
+        Returns:
+            Dict mapping plugin name to list of tool dicts.
+        """
+        result: dict[str, list[dict[str, Any]]] = {}
+        clients = {name: self._clients[name]} if name and name in self._clients else self._clients
+        for pname, client in clients.items():
+            try:
+                result[pname] = await client.list_tools()
+            except (ConnectionError, OSError, RuntimeError):
+                result[pname] = []
+        return result
+
+    def register_tools(self, registry: ToolRegistry) -> int:
+        """Register all MCP plugin tools into a ToolRegistry.
+
+        Must be called after start_all(). Returns the number of tools registered.
+        """
+        import asyncio
+
+        loop = asyncio.get_event_loop()
+        count = 0
+
+        for pname, client in self._clients.items():
+            try:
+                tools = loop.run_until_complete(client.list_tools())
+            except (ConnectionError, OSError, RuntimeError):
+                continue
+
+            for tool in tools:
+                tool_name = f"mcp:{pname}/{tool['name']}"
+                definition = ToolDefinition(
+                    name=tool_name,
+                    description=tool["description"],
+                    parameters=_schema_to_parameters(tool.get("inputSchema", {})),
+                    source=f"mcp:{pname}",
+                )
+                handler = _make_mcp_handler(client, tool["name"])
+                registry.register(definition, handler)
+                count += 1
+
+        return count
+
+    async def register_tools_async(self, registry: ToolRegistry) -> int:
+        """Async version of register_tools. Returns the number of tools registered."""
+        count = 0
+
+        for pname, client in self._clients.items():
+            try:
+                tools = await client.list_tools()
+            except (ConnectionError, OSError, RuntimeError):
+                continue
+
+            for tool in tools:
+                tool_name = f"mcp:{pname}/{tool['name']}"
+                definition = ToolDefinition(
+                    name=tool_name,
+                    description=tool["description"],
+                    parameters=_schema_to_parameters(tool.get("inputSchema", {})),
+                    source=f"mcp:{pname}",
+                )
+                handler = _make_mcp_handler(client, tool["name"])
+                registry.register(definition, handler)
+                count += 1
+
+        return count
+
+    async def test_plugin(self, name: str) -> dict[str, Any]:
+        """Test plugin connectivity. Returns status dict."""
+        client = self._clients.get(name)
+        if client is None:
+            return {"name": name, "connected": False, "error": "Not started"}
+
+        alive = await client.ping()
+        if not alive:
+            return {"name": name, "connected": True, "ping": False, "error": "Ping failed"}
+
+        try:
+            tools = await client.list_tools()
+            return {
+                "name": name,
+                "connected": True,
+                "ping": True,
+                "tools": len(tools),
+                "tool_names": [t["name"] for t in tools],
+            }
+        except (ConnectionError, OSError, RuntimeError) as e:
+            return {"name": name, "connected": True, "ping": True, "error": str(e)}
+
+
+def _make_mcp_handler(client: MCPPluginClient, remote_tool_name: str) -> ToolHandler:
+    """Create a tool handler that dispatches to an MCP plugin."""
+
+    async def handler(args: dict[str, Any]) -> ToolResult:
+        try:
+            output = await client.call_tool(remote_tool_name, args)
+            return ToolResult(tool_call_id="", success=True, output=output)
+        except TimeoutError:
+            return ToolResult(
+                tool_call_id="",
+                success=False,
+                error=f"MCP tool '{remote_tool_name}' timed out",
+            )
+        except (ConnectionError, OSError, RuntimeError) as e:
+            return ToolResult(
+                tool_call_id="",
+                success=False,
+                error=f"MCP tool '{remote_tool_name}' failed: {e}",
+            )
+
+    return handler

mita/skills/__init__.py

@@ -0,0 +1 @@
+"""Skills system: reusable parameterized prompt templates."""

mita/skills/executor.py

@@ -0,0 +1,84 @@
+"""Render skill templates with argument substitution."""
+
+from __future__ import annotations
+
+import re
+
+from mita.skills.loader import Skill
+
+
+def render_skill(skill: Skill, user_input: str) -> str:
+    """Render a skill template, substituting arguments from user input.
+
+    Args:
+        skill: The skill to render.
+        user_input: The raw user input (e.g., "/commit -m 'fix bug'").
+
+    Returns:
+        The rendered prompt string.
+    """
+    args = _parse_args(user_input, skill)
+    return _substitute(skill.template, args)
+
+
+def _parse_args(user_input: str, skill: Skill) -> dict[str, str]:
+    """Parse arguments from user input into a dict."""
+    args: dict[str, str] = {}
+
+    # Remove the skill name prefix (e.g., "/commit" -> rest of input)
+    parts = user_input.strip().split(None, 1)
+    remainder = parts[1] if len(parts) > 1 else ""
+
+    # Map positional and named args
+    skill_args = skill.frontmatter.args
+    if not skill_args:
+        # No declared args — pass entire remainder as {{input}}
+        args["input"] = remainder
+        return args
+
+    # Simple approach: split remainder by spaces, assign positionally
+    # Also support --name=value and --name value
+    tokens = _tokenize(remainder)
+    positional_idx = 0
+
+    i = 0
+    while i < len(tokens):
+        token = tokens[i]
+        if token.startswith("--"):
+            # Named argument
+            key = token.lstrip("-")
+            if "=" in key:
+                k, v = key.split("=", 1)
+                args[k] = v
+            elif i + 1 < len(tokens):
+                args[key] = tokens[i + 1]
+                i += 1
+        elif positional_idx < len(skill_args):
+            args[skill_args[positional_idx].name] = token
+            positional_idx += 1
+        i += 1
+
+    # Fill defaults for missing args
+    for arg in skill_args:
+        if arg.name not in args and arg.default is not None:
+            args[arg.name] = str(arg.default)
+
+    return args
+
+
+def _tokenize(text: str) -> list[str]:
+    """Tokenize input, respecting quoted strings."""
+    tokens: list[str] = []
+    for match in re.finditer(r'"([^"]*)"' r"|'([^']*)'" r"|(\S+)", text):
+        tokens.append(match.group(1) or match.group(2) or match.group(3) or "")
+    return tokens
+
+
+def _substitute(template: str, args: dict[str, str]) -> str:
+    """Replace {{arg}} placeholders in the template."""
+
+    def replacer(match: re.Match[str]) -> str:
+        key = match.group(1).strip()
+        return args.get(key, match.group(0))
+
+    return re.sub(r"\{\{(\w+)\}\}", replacer, template)

mita/skills/loader.py

@@ -0,0 +1,117 @@
+"""Discover and parse skill Markdown files from configured paths."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class SkillFrontmatter(BaseModel):
+    """YAML frontmatter for a skill file."""
+
+    name: str
+    description: str = ""
+    args: list[SkillArg] = Field(default_factory=list)
+    trigger: str | None = None
+
+
+class SkillArg(BaseModel):
+    """A parameter accepted by a skill."""
+
+    name: str
+    type: str = "string"
+    description: str = ""
+    required: bool = True
+    default: Any | None = None
+
+
+# Rebuild SkillFrontmatter to pick up SkillArg
+SkillFrontmatter.model_rebuild()
+
+
+class Skill(BaseModel):
+    """A parsed skill: frontmatter + Markdown template."""
+
+    frontmatter: SkillFrontmatter
+    template: str
+    source_path: Path
+
+
+def discover_skills(skills_paths: list[str]) -> list[Skill]:
+    """Discover and load all skills from the configured paths."""
+    skills: list[Skill] = []
+    seen_names: set[str] = set()
+
+    for raw_path in skills_paths:
+        path = Path(raw_path).expanduser()
+        if not path.is_dir():
+            continue
+        for md_file in sorted(path.glob("*.md")):
+            skill = parse_skill_file(md_file)
+            if skill and skill.frontmatter.name not in seen_names:
+                skills.append(skill)
+                seen_names.add(skill.frontmatter.name)
+
+    return skills
+
+
+def parse_skill_file(path: Path) -> Skill | None:
+    """Parse a single skill Markdown file."""
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    frontmatter, template = _split_frontmatter(content)
+    if frontmatter is None:
+        return None
+
+    try:
+        data = yaml.safe_load(frontmatter)
+    except yaml.YAMLError:
+        return None
+
+    if not isinstance(data, dict) or "name" not in data:
+        return None
+
+    try:
+        fm = SkillFrontmatter(**data)
+    except Exception:  # noqa: BLE001
+        return None
+
+    return Skill(frontmatter=fm, template=template.strip(), source_path=path)
+
+
+def find_skill(skills: list[Skill], name_or_trigger: str) -> Skill | None:
+    """Find a skill by name or trigger pattern."""
+    # Strip leading slash for matching
+    query = name_or_trigger.lstrip("/").split()[0] if name_or_trigger else ""
+
+    for skill in skills:
+        if skill.frontmatter.name == query:
+            return skill
+        if skill.frontmatter.trigger:
+            if re.search(skill.frontmatter.trigger, name_or_trigger):
+                return skill
+
+    return None
+
+
+def _split_frontmatter(content: str) -> tuple[str | None, str]:
+    """Split YAML frontmatter from Markdown body."""
+    content = content.strip()
+    if not content.startswith("---"):
+        return None, content
+
+    # Find the closing ---
+    end = content.find("---", 3)
+    if end == -1:
+        return None, content
+
+    frontmatter = content[3:end].strip()
+    body = content[end + 3 :].strip()
+    return frontmatter, body

mita/skills/manager.py

@@ -0,0 +1,129 @@
+"""CLI command handlers for skills management."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.table import Table
+
+from mita.config.loader import load_config
+from mita.skills.loader import discover_skills
+
+console = Console()
+
+SKILL_TEMPLATE = """---
+name: {name}
+description: "{description}"
+args: []
+---
+
+{name} skill prompt goes here.
+
+Use {{{{input}}}} to reference the user's input.
+"""
+
+
+def list_skills() -> None:
+    """List all available skills."""
+    config = load_config()
+    skills = discover_skills(config.skills_paths)
+
+    if not skills:
+        console.print("[yellow]No skills found.[/yellow]")
+        _show_paths(config.skills_paths)
+        return
+
+    table = Table(title="Available Skills")
+    table.add_column("Name", style="bold")
+    table.add_column("Description")
+    table.add_column("Args")
+    table.add_column("Source")
+
+    for skill in skills:
+        arg_names = ", ".join(a.name for a in skill.frontmatter.args) or "-"
+        table.add_row(
+            skill.frontmatter.name,
+            skill.frontmatter.description,
+            arg_names,
+            str(skill.source_path),
+        )
+
+    console.print(table)
+
+
+def show_skill(name: str) -> None:
+    """Show details and template for a skill."""
+    config = load_config()
+    skills = discover_skills(config.skills_paths)
+
+    match = None
+    for s in skills:
+        if s.frontmatter.name == name:
+            match = s
+            break
+
+    if not match:
+        console.print(f"[red]Skill '{name}' not found.[/red]")
+        return
+
+    console.print(f"[bold]Skill:[/bold] {match.frontmatter.name}")
+    console.print(f"[bold]Description:[/bold] {match.frontmatter.description}")
+    console.print(f"[bold]Source:[/bold] {match.source_path}")
+
+    if match.frontmatter.args:
+        console.print("[bold]Arguments:[/bold]")
+        for arg in match.frontmatter.args:
+            req = "required" if arg.required else f"optional, default={arg.default}"
+            console.print(f"  - {arg.name} ({arg.type}): {arg.description} [{req}]")
+
+    if match.frontmatter.trigger:
+        console.print(f"[bold]Trigger:[/bold] {match.frontmatter.trigger}")
+
+    console.print("\n[bold]Template:[/bold]")
+    console.print(Markdown(match.template))
+
+
+def create_skill(name: str) -> None:
+    """Create a new skill file from a template."""
+    config = load_config()
+
+    # Use the first writable path (prefer project-local)
+    target_dir = None
+    for raw_path in reversed(config.skills_paths):
+        p = Path(raw_path).expanduser()
+        target_dir = p
+        break
+
+    if target_dir is None:
+        console.print("[red]No skills path configured.[/red]")
+        return
+
+    target_dir.mkdir(parents=True, exist_ok=True)
+    target_file = target_dir / f"{name}.md"
+
+    if target_file.exists():
+        console.print(f"[red]Skill '{name}' already exists at {target_file}.[/red]")
+        return
+
+    content = SKILL_TEMPLATE.format(name=name, description=f"A {name} skill.")
+    target_file.write_text(content, encoding="utf-8")
+    console.print(f"[green]Created skill '{name}' at {target_file}.[/green]")
+    console.print("Edit the file to customize the prompt template.")
+
+
+def show_paths() -> None:
+    """Show skill search paths."""
+    config = load_config()
+    _show_paths(config.skills_paths)
+
+
+def _show_paths(paths: list[str]) -> None:
+    """Display skill search paths."""
+    console.print("[bold]Skill search paths:[/bold]")
+    for raw_path in paths:
+        p = Path(raw_path).expanduser()
+        exists = p.is_dir()
+        style = "bold" if exists else "dim"
+        console.print(f"  {p}", style=style)

mita/tools/__init__.py

@@ -0,0 +1 @@
+"""Tool system: schema, registry, execution, and built-in tools."""

mita/tools/builtins/__init__.py

@@ -0,0 +1,28 @@
+"""Built-in tool definitions and handlers."""
+
+from __future__ import annotations
+
+from mita.tools.builtins.file_edit import TOOL_DEF as FILE_EDIT_DEF
+from mita.tools.builtins.file_edit import execute as file_edit_execute
+from mita.tools.builtins.file_read import TOOL_DEF as FILE_READ_DEF
+from mita.tools.builtins.file_read import execute as file_read_execute
+from mita.tools.builtins.file_write import TOOL_DEF as FILE_WRITE_DEF
+from mita.tools.builtins.file_write import execute as file_write_execute
+from mita.tools.builtins.git import TOOL_DEF as GIT_DEF
+from mita.tools.builtins.git import execute as git_execute
+from mita.tools.builtins.glob_tool import TOOL_DEF as GLOB_DEF
+from mita.tools.builtins.glob_tool import execute as glob_execute
+from mita.tools.builtins.grep_tool import TOOL_DEF as GREP_DEF
+from mita.tools.builtins.grep_tool import execute as grep_execute
+from mita.tools.builtins.shell import TOOL_DEF as SHELL_DEF
+from mita.tools.builtins.shell import execute as shell_execute
+
+BUILTIN_TOOLS: dict[str, tuple[object, object]] = {
+    FILE_READ_DEF.name: (FILE_READ_DEF, file_read_execute),
+    FILE_WRITE_DEF.name: (FILE_WRITE_DEF, file_write_execute),
+    FILE_EDIT_DEF.name: (FILE_EDIT_DEF, file_edit_execute),
+    GLOB_DEF.name: (GLOB_DEF, glob_execute),
+    GREP_DEF.name: (GREP_DEF, grep_execute),
+    SHELL_DEF.name: (SHELL_DEF, shell_execute),
+    GIT_DEF.name: (GIT_DEF, git_execute),
+}

mita/tools/builtins/file_edit.py

@@ -0,0 +1,71 @@
+"""Built-in tool: string-replace edit in a file."""
+
+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_edit",
+    description=(
+        "Edit a file by replacing an exact string match. "
+        "The old_string must appear exactly once in the file."
+    ),
+    parameters=[
+        ToolParameter(name="path", type="string", description="Path to the file to edit."),
+        ToolParameter(
+            name="old_string", type="string", description="The exact text to find and replace."
+        ),
+        ToolParameter(name="new_string", type="string", description="The replacement text."),
+    ],
+    destructive=True,
+)
+
+
+async def execute(args: dict[str, Any]) -> ToolResult:
+    """Perform a string-replace edit on a file."""
+    path_str = str(args.get("path", ""))
+    old_string = str(args.get("old_string", ""))
+    new_string = str(args.get("new_string", ""))
+
+    if not path_str:
+        return ToolResult(tool_call_id="", success=False, error="Missing required parameter: path")
+    if not old_string:
+        return ToolResult(
+            tool_call_id="", success=False, error="Missing required parameter: old_string"
+        )
+
+    path = Path(path_str).expanduser().resolve()
+
+    if not path.is_file():
+        return ToolResult(tool_call_id="", success=False, error=f"File not found: {path}")
+
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError as e:
+        return ToolResult(tool_call_id="", success=False, error=f"Cannot read file: {e}")
+
+    count = content.count(old_string)
+    if count == 0:
+        return ToolResult(
+            tool_call_id="",
+            success=False,
+            error="old_string not found in file. Make sure it matches exactly.",
+        )
+    if count > 1:
+        return ToolResult(
+            tool_call_id="",
+            success=False,
+            error=f"old_string found {count} times. It must be unique. Add more context.",
+        )
+
+    new_content = content.replace(old_string, new_string, 1)
+
+    try:
+        path.write_text(new_content, encoding="utf-8")
+    except OSError as e:
+        return ToolResult(tool_call_id="", success=False, error=f"Cannot write file: {e}")
+
+    return ToolResult(tool_call_id="", success=True, output=f"Edited {path}")