mita-code 0.1.0__py3-none-any.whl

mita/config/__init__.py

@@ -0,0 +1,6 @@
+"""Configuration loading and schema for Mita Code."""
+
+from mita.config.loader import load_config
+from mita.config.schema import MitaConfig
+
+__all__ = ["MitaConfig", "load_config"]

mita/config/defaults.py

@@ -0,0 +1,41 @@
+"""Default configuration paths and values."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# Project-level config directory and file
+PROJECT_CONFIG_DIR = ".mita"
+PROJECT_CONFIG_FILE = "settings.toml"
+
+
+def get_global_config_dir() -> Path:
+    """Return the global config directory."""
+    return Path.home() / ".config" / "mita"
+
+
+def get_global_config_path() -> Path:
+    """Return the path to the global config file."""
+    return get_global_config_dir() / "config.toml"
+
+
+def get_project_config_path(project_root: Path | None = None) -> Path | None:
+    """Return the path to the project config file, or None if not found."""
+    if project_root is None:
+        project_root = _find_project_root(Path.cwd())
+    if project_root is None:
+        return None
+    path = project_root / PROJECT_CONFIG_DIR / PROJECT_CONFIG_FILE
+    return path if path.is_file() else None
+
+
+def _find_project_root(start: Path) -> Path | None:
+    """Walk up from start to find a project root (contains .git or .mita)."""
+    current = start.resolve()
+    while True:
+        if (current / ".git").exists() or (current / PROJECT_CONFIG_DIR).exists():
+            return current
+        parent = current.parent
+        if parent == current:
+            return None
+        current = parent

mita/config/loader.py

@@ -0,0 +1,53 @@
+"""TOML config loading with global → project layered merge."""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from mita.config.defaults import get_global_config_path, get_project_config_path
+from mita.config.schema import MitaConfig
+
+
+def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    """Deep merge override into base. Lists are appended, dicts are merged recursively."""
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        elif key in result and isinstance(result[key], list) and isinstance(value, list):
+            result[key] = result[key] + value
+        else:
+            result[key] = value
+    return result
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    """Load a TOML file and return its contents as a dict."""
+    with open(path, "rb") as f:
+        return tomllib.load(f)
+
+
+def load_config(project_root: Path | None = None) -> MitaConfig:
+    """Load and merge configuration from global and project TOML files.
+
+    Merge strategy:
+    - Scalar values: project overrides global
+    - Dicts: deep merged recursively
+    - Lists (hooks, plugins, skills_paths): project values appended to global
+    """
+    merged: dict[str, Any] = {}
+
+    # Load global config
+    global_path = get_global_config_path()
+    if global_path.is_file():
+        merged = _load_toml(global_path)
+
+    # Load and merge project config
+    project_path = get_project_config_path(project_root)
+    if project_path is not None:
+        project_data = _load_toml(project_path)
+        merged = _deep_merge(merged, project_data)
+
+    return MitaConfig.model_validate(merged)

mita/config/schema.py

@@ -0,0 +1,131 @@
+"""Pydantic models for Mita configuration."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class OllamaSettings(BaseModel):
+    """Ollama server connection settings."""
+
+    host: str = "http://localhost:11434"
+    timeout: int = 120
+    auto_manage: bool = True
+
+
+class OllamaRuntimeOptions(BaseModel):
+    """Ollama model runtime options passed via the API.
+
+    These map to Ollama's /api/chat 'options' field and let users
+    tune inference for their hardware.
+    """
+
+    num_gpu: int | None = None
+    num_thread: int | None = None
+    num_ctx: int | None = None
+    num_batch: int | None = None
+    use_mmap: bool | None = None
+    use_mlock: bool | None = None
+    num_keep: int | None = None
+    main_gpu: int | None = None
+    low_vram: bool | None = None
+    flash_attention: bool | None = None
+
+    def to_api_dict(self) -> dict[str, int | bool]:
+        """Return only non-None options for the Ollama API."""
+        return {k: v for k, v in self.model_dump().items() if v is not None}
+
+
+class ModelSettings(BaseModel):
+    """LLM model settings."""
+
+    default: str = "qwen2.5-coder:7b"
+    embedding: str = "nomic-embed-text"
+    temperature: float = 0.1
+    max_tokens: int = 4096
+    context_window: int = 32768
+    ollama_options: OllamaRuntimeOptions = Field(default_factory=OllamaRuntimeOptions)
+
+
+class ToolSettings(BaseModel):
+    """Tool execution settings."""
+
+    auto_approve: list[str] = Field(default_factory=lambda: ["file_read", "glob", "grep"])
+    confirm_destructive: bool = True
+    shell_timeout: int = 120
+    banned_commands: list[str] = Field(
+        default_factory=lambda: ["rm -rf /", "mkfs", "dd if=/dev/zero"]
+    )
+
+
+class MemorySettings(BaseModel):
+    """MITA.md memory system settings."""
+
+    max_lines_per_file: int = 200
+    max_total_tokens: int = 4000
+
+
+class IndexSettings(BaseModel):
+    """Codebase indexing settings."""
+
+    enabled: bool = True
+    chunk_size: int = 512
+    chunk_overlap: int = 64
+    top_k: int = 10
+    exclude_patterns: list[str] = Field(
+        default_factory=lambda: [
+            "*.lock",
+            ".mita/**",
+            "node_modules/**",
+            ".git/**",
+            "*.min.js",
+            "*.min.css",
+            "dist/**",
+            "build/**",
+            "__pycache__/**",
+        ]
+    )
+
+
+class HookDefinition(BaseModel):
+    """A lifecycle hook definition."""
+
+    event: str
+    command: str
+    match: str | None = None
+
+
+class PluginDefinition(BaseModel):
+    """An MCP plugin server definition."""
+
+    name: str
+    transport: str = "stdio"
+    command: str | None = None
+    args: list[str] = Field(default_factory=list)
+    url: str | None = None
+    env: dict[str, str] = Field(default_factory=dict)
+
+
+class UISettings(BaseModel):
+    """Terminal UI settings."""
+
+    theme: str = "auto"
+    show_token_count: bool = True
+    stream: bool = True
+    markdown: bool = True
+
+
+class MitaConfig(BaseModel):
+    """Root configuration model — result of merging global + project TOML."""
+
+    ollama: OllamaSettings = Field(default_factory=OllamaSettings)
+    model: ModelSettings = Field(default_factory=ModelSettings)
+    tools: ToolSettings = Field(default_factory=ToolSettings)
+    memory: MemorySettings = Field(default_factory=MemorySettings)
+    index: IndexSettings = Field(default_factory=IndexSettings)
+    ui: UISettings = Field(default_factory=UISettings)
+    hooks: list[HookDefinition] = Field(default_factory=list)
+    plugins: list[PluginDefinition] = Field(default_factory=list)
+    skills_paths: list[str] = Field(
+        default_factory=lambda: ["~/.config/mita/skills", ".mita/skills"]
+    )

mita/hooks/__init__.py

@@ -0,0 +1 @@
+"""Lifecycle hooks — user-configured shell commands at trigger points."""

mita/hooks/manager.py

@@ -0,0 +1,94 @@
+"""Hook management — CLI helpers for listing and adding hooks."""
+
+from __future__ import annotations
+
+from rich.console import Console
+
+from mita.config.loader import load_config
+from mita.hooks.runner import VALID_EVENTS
+
+console = Console()
+
+
+def list_hooks() -> None:
+    """List all configured hooks."""
+    cfg = load_config()
+    if not cfg.hooks:
+        console.print("[dim]No hooks configured.[/dim]")
+        return
+
+    for hook in cfg.hooks:
+        match_str = f" (match: {hook.match})" if hook.match else ""
+        console.print(f"  [{hook.event}] {hook.command}{match_str}")
+
+
+def add_hook(event: str, command: str, match: str | None = None) -> None:
+    """Add a hook to the project config."""
+    if event not in VALID_EVENTS:
+        console.print(f"[red]Invalid event '{event}'.[/red]")
+        console.print(f"Valid events: {', '.join(sorted(VALID_EVENTS))}")
+        return
+
+    from pathlib import Path
+
+    from mita.config.defaults import (
+        PROJECT_CONFIG_DIR,
+        PROJECT_CONFIG_FILE,
+        _find_project_root,
+        get_project_config_path,
+    )
+
+    project_path = get_project_config_path()
+    if not project_path:
+        root = _find_project_root(Path.cwd())
+        if root is None:
+            console.print("[red]Not in a project directory (no .git or .mita/).[/red]")
+            return
+        config_dir = root / PROJECT_CONFIG_DIR
+        config_dir.mkdir(exist_ok=True)
+        project_path = config_dir / PROJECT_CONFIG_FILE
+        project_path.touch()
+
+    lines = [f'\n[[hooks]]\nevent = "{event}"\ncommand = "{command}"']
+    if match:
+        lines.append(f'match = "{match}"')
+
+    block = "\n".join(lines) + "\n"
+
+    with open(project_path, "a") as f:
+        f.write(block)
+
+    console.print(f"[green]Hook added: [{event}] {command}[/green]")
+
+
+def remove_hooks(event: str) -> None:
+    """Remove all hooks for an event from the project config."""
+    import tomllib
+
+    from mita.config.defaults import get_project_config_path
+
+    project_path = get_project_config_path()
+    if not project_path or not project_path.is_file():
+        console.print("[red]No project config found.[/red]")
+        return
+
+    with open(project_path, "rb") as f:
+        data = tomllib.load(f)
+
+    hooks = data.get("hooks", [])
+    new_hooks = [h for h in hooks if h.get("event") != event]
+    if len(new_hooks) == len(hooks):
+        console.print(f"[yellow]No hooks found for event '{event}'.[/yellow]")
+        return
+
+    removed = len(hooks) - len(new_hooks)
+    data["hooks"] = new_hooks
+
+    # Rewrite the TOML file
+    from mita.cli import _dict_to_toml
+
+    lines: list[str] = []
+    _dict_to_toml(data, lines, prefix="")
+
+    project_path.write_text("\n".join(lines) + "\n")
+    console.print(f"[green]Removed {removed} hook(s) for event '{event}'.[/green]")

mita/hooks/runner.py

@@ -0,0 +1,145 @@
+"""Execute lifecycle hooks with context variable injection."""
+
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+import subprocess
+from typing import Any
+
+from rich.console import Console
+
+from mita.config.schema import HookDefinition
+
+# Valid hook events
+VALID_EVENTS = frozenset(
+    {
+        "session_start",
+        "session_end",
+        "pre_tool_call",
+        "post_tool_call",
+        "on_file_write",
+    }
+)
+
+# Default timeout for hook commands (seconds)
+HOOK_TIMEOUT = 30
+
+
+def _matches(hook: HookDefinition, context: dict[str, Any] | None) -> bool:
+    """Check if a hook's match pattern applies to the context."""
+    if hook.match is None:
+        return True
+    if context is None:
+        return True
+
+    # Match against file_path for on_file_write
+    file_path = context.get("file_path")
+    if file_path and fnmatch.fnmatch(str(file_path), hook.match):
+        return True
+
+    # Match against tool name for pre/post_tool_call
+    tool = context.get("tool")
+    if tool and fnmatch.fnmatch(str(tool), hook.match):
+        return True
+
+    return False
+
+
+def _render_command(command: str, context: dict[str, Any] | None) -> str:
+    """Substitute context variables into a hook command string."""
+    if context is None:
+        return command
+
+    rendered = command
+    for key, value in context.items():
+        rendered = rendered.replace(f"{{{key}}}", str(value))
+    return rendered
+
+
+async def run_hooks(
+    event: str,
+    hooks: list[HookDefinition],
+    context: dict[str, Any] | None = None,
+    console: Console | None = None,
+    timeout: float = HOOK_TIMEOUT,
+) -> list[dict[str, Any]]:
+    """Execute all hooks matching the given event.
+
+    Args:
+        event: Hook event name (e.g., "session_start", "on_file_write").
+        hooks: List of hook definitions from config.
+        context: Optional context dict with vars like {file_path}, {tool}.
+        console: Optional console for displaying hook output.
+        timeout: Timeout in seconds for each hook command.
+
+    Returns:
+        List of result dicts with keys: event, command, returncode, stdout, stderr.
+    """
+    results: list[dict[str, Any]] = []
+
+    matching = [h for h in hooks if h.event == event and _matches(h, context)]
+    if not matching:
+        return results
+
+    for hook in matching:
+        command = _render_command(hook.command, context)
+        result = await _execute_hook(command, timeout=timeout)
+        result["event"] = event
+        results.append(result)
+
+        if console:
+            if result["returncode"] != 0:
+                console.print(
+                    f"  [yellow]Hook ({event}): '{command}' "
+                    f"exited with code {result['returncode']}[/yellow]"
+                )
+                if result["stderr"]:
+                    console.print(f"  [dim]{result['stderr'][:200]}[/dim]")
+            elif result["stdout"]:
+                # Show truncated output for successful hooks
+                stdout = result["stdout"].strip()
+                if stdout:
+                    lines = stdout.split("\n")
+                    preview = lines[0][:100]
+                    if len(lines) > 1:
+                        preview += f" (+{len(lines) - 1} more lines)"
+                    console.print(f"  [dim]Hook ({event}): {preview}[/dim]")
+
+    return results
+
+
+async def _execute_hook(command: str, timeout: float = HOOK_TIMEOUT) -> dict[str, Any]:
+    """Execute a single hook command asynchronously."""
+    try:
+        result = await asyncio.wait_for(
+            asyncio.to_thread(
+                subprocess.run,
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            ),
+            timeout=timeout + 5,  # extra buffer for asyncio
+        )
+        return {
+            "command": command,
+            "returncode": result.returncode,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+        }
+    except (TimeoutError, subprocess.TimeoutExpired):
+        return {
+            "command": command,
+            "returncode": -1,
+            "stdout": "",
+            "stderr": f"Hook timed out after {timeout}s",
+        }
+    except OSError as e:
+        return {
+            "command": command,
+            "returncode": -1,
+            "stdout": "",
+            "stderr": f"Hook execution failed: {e}",
+        }

mita/index/__init__.py

@@ -0,0 +1 @@
+"""Codebase indexing: Tree-sitter parsing, embeddings, LanceDB vector store."""

mita/index/embeddings.py

@@ -0,0 +1,49 @@
+"""Embedding generation via Ollama for code chunks."""
+
+from __future__ import annotations
+
+import ollama
+
+from mita.config.schema import MitaConfig
+
+BATCH_SIZE = 32
+
+
+class EmbeddingClient:
+    """Generate embeddings using Ollama's embedding endpoint."""
+
+    def __init__(self, config: MitaConfig) -> None:
+        self._model = config.model.embedding
+        self._client = ollama.AsyncClient(host=config.ollama.host)
+
+    @property
+    def model(self) -> str:
+        return self._model
+
+    async def embed_texts(self, texts: list[str]) -> list[list[float]]:
+        """Generate embeddings for a batch of texts."""
+        all_embeddings: list[list[float]] = []
+        for i in range(0, len(texts), BATCH_SIZE):
+            batch = texts[i : i + BATCH_SIZE]
+            response = await self._client.embed(model=self._model, input=batch)
+            all_embeddings.extend(list(e) for e in response.embeddings)
+        return all_embeddings
+
+    async def embed_single(self, text: str) -> list[float]:
+        """Generate embedding for a single text."""
+        response = await self._client.embed(model=self._model, input=[text])
+        return list(response.embeddings[0])
+
+    async def is_model_available(self) -> bool:
+        """Check if the embedding model is pulled in Ollama."""
+        try:
+            models = await self._client.list()
+            model_names = [m.model for m in models.models]
+            # Check both exact match and base name (without tag)
+            base_name = self._model.split(":")[0]
+            return any(
+                m == self._model or (m is not None and m.startswith(base_name + ":"))
+                for m in model_names
+            )
+        except Exception:  # noqa: BLE001
+            return False