ollama-coding-agent 0.1.0__py3-none-any.whl

coding_agent/intent.py

@@ -0,0 +1,138 @@
+"""Turn a freeform user request into structured intent — task type, target
+files, constraints, risk level — before the agent starts taking actions.
+
+This runs as a single, tool-free model call in strict JSON mode. It is
+deliberately separate from the main agent loop: if it fails or the model
+guesses wrong, the agent still runs — it just does so with less upfront
+context, and a human reviewing the log can see exactly what was inferred.
+"""
+
+import json
+import re
+import asyncio
+from dataclasses import dataclass, field
+from typing import List
+
+from .ollama_client import chat, OllamaError
+
+_CODE_FENCE_RE = re.compile(r"^```(?:json)?\s*|\s*```$", re.MULTILINE)
+
+
+def _strip_code_fence(content: str) -> str:
+    """Models sometimes wrap JSON-mode output in a ```json fence despite
+    being asked for a bare object — strip it before parsing."""
+    return _CODE_FENCE_RE.sub("", content.strip())
+
+INTENT_SCHEMA_PROMPT = """You are a task-intent parser for a coding agent. \
+Given a user's freeform request, output ONLY a JSON object (no markdown \
+fences, no commentary, no explanation) with exactly these keys:
+
+{
+  "task_type": one of "bugfix" | "feature" | "refactor" | "test" | "docs" | "explore" | "other",
+  "summary": a single sentence restating the task in your own words,
+  "target_files": array of file paths the user mentioned or clearly implied — best guess, can be empty,
+  "constraints": array of explicit requirements or limits the user stated (e.g. "don't touch the tests", "keep it under 100 lines") — can be empty,
+  "risk_level": "low" | "medium" | "high" — use "high" if the task involves deleting data, deploying, running migrations, force-pushing, or other hard-to-reverse actions
+}
+
+Respond with the JSON object only."""
+
+_VALID_TASK_TYPES = {"bugfix", "feature", "refactor", "test", "docs", "explore", "other"}
+_VALID_RISK = {"low", "medium", "high"}
+
+
+@dataclass
+class Intent:
+    task_type: str = "other"
+    summary: str = ""
+    target_files: List[str] = field(default_factory=list)
+    constraints: List[str] = field(default_factory=list)
+    risk_level: str = "medium"
+    confident: bool = True   # False if parsing fell back to the default
+    raw: dict = field(default_factory=dict)
+
+    def as_context_block(self, existing_files: dict = None) -> str:
+        """Render as a short block to inject into the agent's messages.
+        `existing_files` optionally maps target file -> bool(exists) so the
+        agent knows upfront which targets are new vs. edits."""
+        files_line = "none specified"
+        if self.target_files:
+            parts = []
+            for f in self.target_files:
+                if existing_files is not None and f in existing_files:
+                    tag = "exists" if existing_files[f] else "new"
+                    parts.append(f"{f} ({tag})")
+                else:
+                    parts.append(f)
+            files_line = ", ".join(parts)
+
+        constraints_line = "; ".join(self.constraints) if self.constraints else "none stated"
+        confidence_note = "" if self.confident else " [low confidence — intent parsing fell back to defaults]"
+
+        return (
+            f"[Parsed intent]{confidence_note}\n"
+            f"task_type: {self.task_type}\n"
+            f"risk_level: {self.risk_level}\n"
+            f"summary: {self.summary}\n"
+            f"target_files: {files_line}\n"
+            f"constraints: {constraints_line}"
+        )
+
+
+def _coerce(data: dict) -> Intent:
+    task_type = data.get("task_type") if data.get("task_type") in _VALID_TASK_TYPES else "other"
+    risk_level = data.get("risk_level") if data.get("risk_level") in _VALID_RISK else "medium"
+
+    target_files = data.get("target_files") or []
+    if not isinstance(target_files, list):
+        target_files = [target_files]
+
+    constraints = data.get("constraints") or []
+    if not isinstance(constraints, list):
+        constraints = [constraints]
+
+    return Intent(
+        task_type=task_type,
+        summary=str(data.get("summary", ""))[:500],
+        target_files=[str(f) for f in target_files][:20],
+        constraints=[str(c) for c in constraints][:20],
+        risk_level=risk_level,
+        confident=True,
+        raw=data,
+    )
+
+
+async def extract_intent(task: str, model: str, max_retries: int = 3, logger=None, base_url: str = None, api_key: str = None) -> Intent:
+    """Ask the model to parse `task` into structured intent. On repeated
+    failure, returns a low-confidence Intent(task_type='other') rather than
+    raising — callers should treat `confident=False` as a signal to fall
+    back to plain freeform behavior, not as ground truth to act on."""
+    messages = [
+        {"role": "system", "content": INTENT_SCHEMA_PROMPT},
+        {"role": "user", "content": task},
+    ]
+
+    last_err = None
+    for attempt in range(1, max_retries + 1):
+        try:
+            message = await chat(model=model, messages=messages, format="json", base_url=base_url, api_key=api_key)
+            content = message["content"]
+            data = json.loads(_strip_code_fence(content))
+            intent = _coerce(data)
+            if logger:
+                logger.info(f"INTENT parsed (attempt {attempt}): {data}")
+            return intent
+        except (json.JSONDecodeError, KeyError, OllamaError) as e:
+            last_err = e
+            if logger:
+                logger.info(f"INTENT parse failed (attempt {attempt}): {e}")
+            await asyncio.sleep(min(2 ** attempt, 5))
+        except Exception as e:
+            last_err = e
+            if logger:
+                logger.info(f"INTENT unexpected error (attempt {attempt}): {e}")
+            await asyncio.sleep(1)
+
+    if logger:
+        logger.info(f"INTENT parsing gave up after {max_retries} attempts ({last_err}); using fallback.")
+    return Intent(summary=task[:200], confident=False, raw={})

coding_agent/mcp_client.py

@@ -0,0 +1,88 @@
+"""Thin async MCP client: spawns mcp_server.py as a subprocess scoped to a
+project root, and adapts its tool list into the Ollama function-calling
+schema format the agent already knows how to use.
+
+This is the only file that changed how the agent talks to its tools —
+everything else (approval flow, logging, the loop shape) is unchanged;
+it just goes through an MCP session now instead of direct Python calls.
+"""
+
+import os
+import sys
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+
+
+def _mcp_schema_to_ollama(tool) -> dict:
+    return {
+        "type": "function",
+        "function": {
+            "name": tool.name,
+            "description": tool.description or "",
+            "parameters": tool.inputSchema or {"type": "object", "properties": {}},
+        },
+    }
+
+
+class MCPToolClient:
+    """Use as an async context manager, one instance per agent run:
+
+        async with MCPToolClient(project_root) as client:
+            schemas = await client.list_llm_tools()
+            result = await client.call_tool("edit_file", {...})
+    """
+
+    def __init__(self, project_root: str, server_path: str = None):
+        self.project_root = project_root
+        # Default: run the server as `python -m <package>.mcp_server` rather
+        # than by file path — mcp_server.py uses relative imports (it's part
+        # of this package), which only resolve when it's launched as a
+        # module, not executed as a standalone script. `server_path` is an
+        # escape hatch for pointing at a different server entirely.
+        self.server_args = [server_path] if server_path else ["-m", f"{__package__}.mcp_server"]
+        self._stack = AsyncExitStack()
+        self.session: ClientSession = None
+
+    async def __aenter__(self):
+        params = StdioServerParameters(
+            command=sys.executable,
+            args=self.server_args,
+            env={**os.environ, "AGENT_PROJECT_ROOT": self.project_root},
+        )
+        read, write = await self._stack.enter_async_context(stdio_client(params))
+        self.session = await self._stack.enter_async_context(ClientSession(read, write))
+        await self.session.initialize()
+        return self
+
+    async def __aexit__(self, *exc_info):
+        await self._stack.aclose()
+
+    async def list_llm_tools(self) -> list:
+        """Schemas for tools the LLM is allowed to call — internal
+        underscore-prefixed tools (previews, existence checks) are held
+        back; the agent still calls those directly for its own logic."""
+        result = await self.session.list_tools()
+        return [_mcp_schema_to_ollama(t) for t in result.tools if not t.name.startswith("_")]
+
+    async def call_tool(self, name: str, args: dict) -> str:
+        result = await self.session.call_tool(name, args)
+        text = "".join(c.text for c in result.content if hasattr(c, "text"))
+        return f"ERROR: {text}" if result.isError else text
+
+    async def preview_edit(self, path: str, old_str: str, new_str: str):
+        raw = await self.call_tool("_preview_edit", {"path": path, "old_str": old_str, "new_str": new_str})
+        ok = raw.startswith("OK\n")
+        msg = raw.split("\n", 1)[1] if "\n" in raw else raw
+        return ok, msg
+
+    async def preview_write(self, path: str, content: str, overwrite: bool = False):
+        raw = await self.call_tool("_preview_write", {"path": path, "content": content, "overwrite": overwrite})
+        is_new = raw.startswith("NEW\n")
+        preview = raw.split("\n", 1)[1] if "\n" in raw else raw
+        return is_new, preview
+
+    async def file_exists(self, path: str) -> bool:
+        raw = await self.call_tool("_file_exists", {"path": path})
+        return raw.strip() == "true"

coding_agent/mcp_server.py

@@ -0,0 +1,109 @@
+"""MCP server exposing the sandboxed coding tools.
+
+Run standalone to test with any MCP client:
+    AGENT_PROJECT_ROOT=/path/to/repo python mcp_server.py
+
+Any MCP-compatible client (not just this agent) can now use these tools —
+Claude Desktop, another agent framework, etc. — all sharing the same
+sandbox/approval-preview logic in tools.py.
+"""
+
+import os
+
+from mcp.server.fastmcp import FastMCP
+
+from .config import AgentConfig
+from .tools import Tools
+
+PROJECT_ROOT = os.environ.get("AGENT_PROJECT_ROOT", ".")
+
+cfg = AgentConfig(project_root=PROJECT_ROOT)
+impl = Tools(cfg)
+
+mcp = FastMCP("coding-agent-tools")
+
+
+# ---- Tools exposed to any MCP client (these are what the LLM sees) ----
+
+@mcp.tool()
+def read_file(path: str, start_line: int = None, end_line: int = None) -> str:
+    """Read a file, optionally a specific line range."""
+    return impl.read_file(path, start_line, end_line)
+
+
+@mcp.tool()
+def list_dir(path: str = ".") -> str:
+    """List files in a directory."""
+    return impl.list_dir(path)
+
+
+@mcp.tool()
+def search_files(pattern: str, path: str = ".", glob: str = None, case_insensitive: bool = False) -> str:
+    """Regex search across files under a path, skipping noise directories
+    (.git, node_modules, __pycache__, build output, etc.). Optionally
+    restrict to filenames matching `glob` (e.g. "*.py")."""
+    return impl.search_files(pattern, path, glob, case_insensitive)
+
+
+@mcp.tool()
+def glob_files(pattern: str, path: str = ".") -> str:
+    """Find files by glob pattern, e.g. "**/*.tsx" or "src/**/test_*.py".
+    Results are sorted newest-first. Use this to discover files by name/
+    location; use search_files to find files by content."""
+    return impl.glob_files(pattern, path)
+
+
+@mcp.tool()
+def git_diff(path: str = ".") -> str:
+    """Show uncommitted git changes in the project."""
+    return impl.git_diff(path)
+
+
+@mcp.tool()
+def write_file(path: str, content: str, overwrite: bool = False) -> str:
+    """Create a NEW file with content. Fails if the file already exists
+    unless overwrite=true. Use edit_file for existing files."""
+    return impl.write_file(path, content, overwrite)
+
+
+@mcp.tool()
+def edit_file(path: str, old_str: str, new_str: str) -> str:
+    """Replace an exact, unique block of text in an existing file. old_str
+    must match precisely (include enough context to be unique)."""
+    return impl.edit_file(path, old_str, new_str)
+
+
+@mcp.tool()
+def run_shell(command: str) -> str:
+    """Run a shell command in the project root. Dangerous commands are
+    blocked by policy."""
+    return impl.run_shell(command)
+
+
+# ---- Internal tools: dry-run previews for the approval UI + existence
+# checks for intent validation. Named with a leading underscore so the
+# client can filter them out of what it hands to the LLM, while still
+# calling them directly for its own approval-flow logic. ----
+
+@mcp.tool()
+def _preview_edit(path: str, old_str: str, new_str: str) -> str:
+    """Internal: dry-run diff preview for edit_file, no write performed."""
+    ok, msg = impl.preview_edit(path, old_str, new_str)
+    return f"OK\n{msg}" if ok else f"ERROR\n{msg}"
+
+
+@mcp.tool()
+def _preview_write(path: str, content: str, overwrite: bool = False) -> str:
+    """Internal: dry-run preview for write_file, no write performed."""
+    is_new, preview = impl.preview_write(path, content, overwrite)
+    return f"{'NEW' if is_new else 'DIFF'}\n{preview}"
+
+
+@mcp.tool()
+def _file_exists(path: str) -> str:
+    """Internal: sandboxed existence check for intent validation."""
+    return "true" if impl.file_exists(path) else "false"
+
+
+if __name__ == "__main__":
+    mcp.run()  # stdio transport by default

coding_agent/ollama_client.py

@@ -0,0 +1,73 @@
+"""Talks to Ollama directly over HTTP (/api/chat) — no `ollama` python
+package required, just httpx. Mirrors the message shape the rest of the
+agent already expects: chat() returns the `message` dict with
+role/content/tool_calls, same as the ollama library did.
+"""
+
+import os
+
+import httpx
+
+DEFAULT_BASE_URL = os.environ.get("OLLAMA_HOST", "http://localhost:11434")
+DEFAULT_API_KEY = os.environ.get("OLLAMA_API_KEY", "")  # set via env, never hardcode
+
+
+class OllamaError(Exception):
+    pass
+
+
+async def chat(
+    model: str,
+    messages: list,
+    tools: list = None,
+    format: str = None,
+    base_url: str = None,
+    api_key: str = None,
+    timeout: float = 120.0,
+) -> dict:
+    """POST /api/v1/chat/completions (OpenAI-compatible) with stream=false
+    and return the `message` dict.
+
+    This hits our Open WebUI gateway in front of Ollama, not Ollama's native
+    /api/chat — the gateway only exposes the OpenAI-style route. Response
+    shape is `choices[0].message`, but that dict already has the
+    role/content/tool_calls keys the rest of the agent expects, same as
+    Ollama's native `message` field would.
+
+    If an API key is set (via `api_key`, falling back to $OLLAMA_API_KEY),
+    it's sent as `Authorization: Bearer <key>`.
+
+    Raises OllamaError on a non-2xx response, a connection failure, or an
+    unexpected response shape — callers (agent.py, intent.py) already retry
+    on this.
+    """
+    url = f"{(base_url or DEFAULT_BASE_URL).rstrip('/')}/api/v1/chat/completions"
+    payload = {"model": model, "messages": messages, "stream": False}
+    if tools:
+        payload["tools"] = tools
+    if format == "json":
+        payload["response_format"] = {"type": "json_object"}
+
+    key = api_key or DEFAULT_API_KEY
+    headers = {"Authorization": f"Bearer {key}"} if key else {}
+
+    try:
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            resp = await client.post(url, json=payload, headers=headers)
+            resp.raise_for_status()
+            data = resp.json()
+    except httpx.HTTPStatusError as e:
+        body = e.response.text[:300]
+        raise OllamaError(f"Ollama API returned {e.response.status_code} for {model}: {body}") from e
+    except httpx.RequestError as e:
+        raise OllamaError(
+            f"Could not reach Ollama at {url} ({e}). Is `ollama serve` running?"
+        ) from e
+
+    choices = data.get("choices")
+    if not choices:
+        raise OllamaError(f"Unexpected response shape from Ollama (no 'choices' key): {data}")
+    message = choices[0].get("message")
+    if message is None:
+        raise OllamaError(f"Unexpected response shape from Ollama (no 'message' key): {data}")
+    return message

coding_agent/session_store.py

@@ -0,0 +1,141 @@
+"""SQLite-backed persistence for agent sessions and their full message
+history, so a run can be resumed later (`--resume <id>`) or browsed
+(`--list-sessions`) instead of always starting from a blank conversation.
+"""
+
+import json
+import sqlite3
+import uuid
+from datetime import datetime, timezone
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def _connect(db_path: str) -> sqlite3.Connection:
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+class SessionStore:
+    """One instance per agent process. Every message appended to the
+    in-memory conversation is mirrored here in the same order, so
+    `load_messages` reconstructs exactly what the model saw."""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        with _connect(self.db_path) as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS sessions (
+                    id TEXT PRIMARY KEY,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL,
+                    project_root TEXT NOT NULL,
+                    model TEXT NOT NULL,
+                    task TEXT NOT NULL,
+                    status TEXT NOT NULL DEFAULT 'running',
+                    summary TEXT,
+                    name TEXT
+                )
+            """)
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS messages (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL REFERENCES sessions(id),
+                    seq INTEGER NOT NULL,
+                    role TEXT NOT NULL,
+                    content TEXT,
+                    tool_calls TEXT,
+                    created_at TEXT NOT NULL
+                )
+            """)
+            existing_cols = {row["name"] for row in conn.execute("PRAGMA table_info(sessions)")}
+            if "name" not in existing_cols:
+                conn.execute("ALTER TABLE sessions ADD COLUMN name TEXT")
+            conn.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_name ON sessions(name)")
+
+    def create_session(self, project_root: str, model: str, task: str, name: str = None) -> str:
+        session_id = uuid.uuid4().hex[:8]
+        now = _now()
+        try:
+            with _connect(self.db_path) as conn:
+                conn.execute(
+                    "INSERT INTO sessions (id, created_at, updated_at, project_root, model, task, status, name) "
+                    "VALUES (?, ?, ?, ?, ?, ?, 'running', ?)",
+                    (session_id, now, now, project_root, model, task, name),
+                )
+        except sqlite3.IntegrityError:
+            raise ValueError(f"Session name {name!r} is already in use — pick another with --session-name.")
+        return session_id
+
+    def session_exists(self, session_id: str) -> bool:
+        with _connect(self.db_path) as conn:
+            row = conn.execute("SELECT 1 FROM sessions WHERE id = ?", (session_id,)).fetchone()
+        return row is not None
+
+    def resolve_session_id(self, id_or_name: str) -> str:
+        """Accept either a session id or a session --session-name and return
+        the underlying id, or None if neither matches."""
+        with _connect(self.db_path) as conn:
+            row = conn.execute(
+                "SELECT id FROM sessions WHERE id = ? OR name = ?", (id_or_name, id_or_name),
+            ).fetchone()
+        return row["id"] if row else None
+
+    def load_messages(self, session_id: str) -> list:
+        with _connect(self.db_path) as conn:
+            rows = conn.execute(
+                "SELECT role, content, tool_calls FROM messages WHERE session_id = ? ORDER BY seq",
+                (session_id,),
+            ).fetchall()
+        messages = []
+        for row in rows:
+            msg = {"role": row["role"], "content": row["content"]}
+            if row["tool_calls"]:
+                msg["tool_calls"] = json.loads(row["tool_calls"])
+            messages.append(msg)
+        return messages
+
+    def append_message(self, session_id: str, seq: int, message: dict) -> None:
+        tool_calls = message.get("tool_calls")
+        now = _now()
+        with _connect(self.db_path) as conn:
+            conn.execute(
+                "INSERT INTO messages (session_id, seq, role, content, tool_calls, created_at) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (
+                    session_id, seq, message.get("role", ""), message.get("content"),
+                    json.dumps(tool_calls) if tool_calls else None, now,
+                ),
+            )
+            conn.execute("UPDATE sessions SET updated_at = ? WHERE id = ?", (now, session_id))
+
+    def finish_session(self, session_id: str, status: str, summary: str) -> None:
+        with _connect(self.db_path) as conn:
+            conn.execute(
+                "UPDATE sessions SET status = ?, summary = ?, updated_at = ? WHERE id = ?",
+                (status, summary, _now(), session_id),
+            )
+
+    def delete_session(self, id_or_name: str) -> bool:
+        """Delete a session and its full message history. Returns False if
+        no session matches `id_or_name` (id or --session-name), True if
+        deleted."""
+        session_id = self.resolve_session_id(id_or_name)
+        if session_id is None:
+            return False
+        with _connect(self.db_path) as conn:
+            conn.execute("DELETE FROM messages WHERE session_id = ?", (session_id,))
+            conn.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+        return True
+
+    def list_sessions(self, limit: int = 20) -> list:
+        with _connect(self.db_path) as conn:
+            rows = conn.execute(
+                "SELECT id, created_at, updated_at, project_root, model, task, status, summary, name "
+                "FROM sessions ORDER BY updated_at DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+        return [dict(r) for r in rows]