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

coding_agent/__init__.py

@@ -0,0 +1,4 @@
+"""Local coding agent — drives Qwen Coder (or any Ollama-compatible model)
+through a sandboxed set of file/shell tools via MCP."""
+
+__version__ = "0.1.0"

coding_agent/__main__.py

@@ -0,0 +1,6 @@
+"""Enables `python -m coding_agent`."""
+
+from .cli import app
+
+if __name__ == "__main__":
+    app()

coding_agent/agent.py

@@ -0,0 +1,316 @@
+"""Agent loop: model <-> MCP tool server, with the guardrails a first draft skips.
+
+Tools now live in mcp_server.py and are reached through mcp_client.MCPToolClient
+rather than being called directly — so the loop itself is async (an MCP
+session is async under the hood).
+"""
+
+import asyncio
+import json
+import logging
+import re
+from contextlib import nullcontext
+
+from .ollama_client import chat, OllamaError
+
+from .config import AgentConfig
+from .intent import extract_intent
+from .mcp_client import MCPToolClient
+from .session_store import SessionStore
+
+try:
+    from . import ui
+    _HAS_UI = True
+except ImportError:
+    _HAS_UI = False
+
+SYSTEM_PROMPT = """You are a coding agent working inside a sandboxed project \
+directory. You have tools to read, search, write, and edit files, check git \
+diffs, and run shell commands.
+
+Rules:
+- Prefer edit_file over write_file for existing files — write_file will \
+refuse to overwrite unless you pass overwrite=true.
+- Before running anything destructive or irreversible, check git_diff or \
+read_file first so you understand current state.
+- Keep changes minimal and focused on the task.
+- When the task is fully done, reply with plain text (no tool call) \
+summarizing what changed and how to verify it (e.g. which command to run).
+"""
+
+
+def _setup_logger(log_path: str) -> logging.Logger:
+    logger = logging.getLogger("coding_agent")
+    logger.setLevel(logging.INFO)
+    logger.handlers.clear()
+    fh = logging.FileHandler(log_path, encoding="utf-8")
+    fh.setFormatter(logging.Formatter("%(asctime)s %(message)s"))
+    logger.addHandler(fh)
+    return logger
+
+
+async def _approve(tool_name: str, args: dict, cfg: AgentConfig, client: MCPToolClient, force_approval: bool = False) -> bool:
+    if tool_name in cfg.safe_tools:
+        return True
+    if cfg.auto_approve and not force_approval:
+        return True
+    if _HAS_UI:
+        return await ui.request_approval(tool_name, args, client)
+    print(f"\n--- Approval needed: {tool_name} ---")
+    print(json.dumps(args, indent=2)[:2000])
+    answer = input("Proceed? [y/N] ").strip().lower()
+    return answer == "y"
+
+
+def _find_json_objects(text: str) -> list:
+    """Scan text for top-level {...} objects, tracking string-literal state
+    so braces inside quoted content (e.g. code the model is trying to write)
+    don't throw off the balance count."""
+    objs = []
+    i, n = 0, len(text)
+    while i < n:
+        if text[i] == "{":
+            depth, in_str, esc, j = 0, False, False, i
+            while j < n:
+                c = text[j]
+                if in_str:
+                    if esc:
+                        esc = False
+                    elif c == "\\":
+                        esc = True
+                    elif c == '"':
+                        in_str = False
+                elif c == '"':
+                    in_str = True
+                elif c == "{":
+                    depth += 1
+                elif c == "}":
+                    depth -= 1
+                    if depth == 0:
+                        objs.append(text[i:j + 1])
+                        break
+                j += 1
+            i = j + 1
+        else:
+            i += 1
+    return objs
+
+
+def _recover_text_tool_calls(content: str, tool_names: set) -> list:
+    """Some models print a tool call as plain-text JSON (`{"name": ...,
+    "arguments": {...}}`) instead of using the tool-calling API, which would
+    otherwise look like a final answer and silently end the run without the
+    tool ever executing. Recover any such calls from `content`."""
+    if not content or "{" not in content:
+        return []
+    calls = []
+    for raw in _find_json_objects(content):
+        try:
+            obj = json.loads(raw)
+        except json.JSONDecodeError:
+            continue
+        name, args = obj.get("name"), obj.get("arguments")
+        if name in tool_names and isinstance(args, dict):
+            calls.append({
+                "id": f"fallback_{len(calls)}",
+                "type": "function",
+                "function": {"name": name, "arguments": args},
+            })
+    return calls
+
+
+def _trim_history(messages: list, budget: int) -> list:
+    """Keep the system + user task message plus the most recent turns
+    within a rough character budget. Crude but effective without pulling
+    in a tokenizer dependency."""
+    total = sum(len(str(m.get("content", ""))) for m in messages)
+    if total <= budget:
+        return messages
+    head, tail = messages[:2], messages[2:]
+    while tail and total > budget:
+        removed = tail.pop(0)
+        total -= len(str(removed.get("content", "")))
+    return head + tail
+
+
+class CodingAgent:
+    def __init__(self, cfg: AgentConfig):
+        self.cfg = cfg
+        self.logger = _setup_logger(cfg.log_path)
+        self.force_approval = False  # set True for the run if intent is high-risk
+        self.store = SessionStore(cfg.db_path)
+        self.session_id = None  # set by run() to whichever session the last turn used
+
+    async def _call_model(self, messages: list, tool_schemas: list):
+        """Call Ollama with retries for transient errors (connection refused,
+        5xx, malformed tool-call output — small local models occasionally
+        emit broken JSON)."""
+        last_err = None
+        spinner = ui.thinking() if _HAS_UI else nullcontext()
+        with spinner:
+            for attempt in range(1, self.cfg.max_retries + 1):
+                try:
+                    return await chat(model=self.cfg.model, messages=messages, tools=tool_schemas,
+                                       base_url=self.cfg.ollama_host, api_key=self.cfg.ollama_api_key)
+                except OllamaError as e:
+                    last_err = e
+                    self.logger.info(f"model call failed (attempt {attempt}): {e}")
+                    if _HAS_UI:
+                        spinner.update(f"[bold yellow]Thinking… (retry {attempt}/{self.cfg.max_retries})[/bold yellow]")
+                    await asyncio.sleep(min(2 ** attempt, 10))
+                except Exception as e:
+                    last_err = e
+                    self.logger.info(f"unexpected error (attempt {attempt}): {e}")
+                    if _HAS_UI:
+                        spinner.update(f"[bold yellow]Thinking… (retry {attempt}/{self.cfg.max_retries})[/bold yellow]")
+                    await asyncio.sleep(1)
+        raise RuntimeError(f"Model call failed after {self.cfg.max_retries} attempts: {last_err}")
+
+    async def run(self, task: str = "", resume_session_id: str = None, client: MCPToolClient = None,
+                  session_name: str = None, show_banner: bool = True) -> str:
+        """Run one turn of the agent loop. If `client` is given (an already
+        -open MCPToolClient), it's reused instead of spawning a fresh MCP
+        server subprocess — used by the interactive REPL so each turn
+        doesn't pay subprocess-startup cost. `self.session_id` is set to
+        whichever session this turn ran against, so callers (e.g. the REPL)
+        can pass it back in as `resume_session_id` on the next turn.
+        `resume_session_id` accepts either a session id or a --session-name.
+        `session_name` optionally names a newly-created session. Pass
+        `show_banner=False` when a caller (e.g. the REPL) already prints its
+        own header and doesn't want one repeated every turn."""
+        resuming = resume_session_id is not None
+
+        if resuming:
+            session_id = self.store.resolve_session_id(resume_session_id)
+            if session_id is None:
+                raise ValueError(f"No session found with id or name {resume_session_id!r}")
+            messages = self.store.load_messages(session_id)
+            persisted = len(messages)  # already in the DB, don't re-write these
+            label = task or "[continuing previous task]"
+            if _HAS_UI and show_banner:
+                ui.banner(f"(resumed {session_id}) {label}", self.cfg.model)
+            self.logger.info(f"RESUME session={session_id} TASK: {label}")
+            if task:
+                messages.append({"role": "user", "content": task})
+        else:
+            if _HAS_UI and show_banner:
+                ui.banner(task, self.cfg.model)
+            session_id = self.store.create_session(self.cfg.project_root, self.cfg.model, task, name=session_name)
+            messages = [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": task},
+            ]
+            persisted = 0
+            self.logger.info(f"TASK: {task} (session={session_id})")
+
+        self.session_id = session_id
+
+        try:
+            if client is not None:
+                return await self._run_loop(task, session_id, messages, persisted, resuming, client)
+            async with MCPToolClient(self.cfg.project_root) as owned_client:
+                return await self._run_loop(task, session_id, messages, persisted, resuming, owned_client)
+        except Exception as e:
+            self.store.finish_session(session_id, "error", str(e))
+            raise
+
+    async def _run_loop(self, task: str, session_id: str, messages: list, persisted: int,
+                         resuming: bool, client: MCPToolClient) -> str:
+        tool_schemas = await client.list_llm_tools()
+        tool_names = {t["function"]["name"] for t in tool_schemas}
+
+        if not resuming and self.cfg.parse_intent:
+            intent_model = self.cfg.intent_model or self.cfg.model
+            spinner = ui.thinking("Parsing intent…") if _HAS_UI else nullcontext()
+            with spinner:
+                intent = await extract_intent(task, intent_model, self.cfg.max_retries, self.logger,
+                                               base_url=self.cfg.ollama_host, api_key=self.cfg.ollama_api_key)
+
+            existing = {f: await client.file_exists(f) for f in intent.target_files}
+            context_block = intent.as_context_block(existing)
+            messages.insert(1, {"role": "system", "content": context_block})
+
+            if _HAS_UI:
+                ui.intent_panel(intent, existing)
+            else:
+                print(f"\n{context_block}\n")
+
+            if intent.risk_level == "high":
+                self.force_approval = True
+                warning = "High-risk intent detected — approval required for all write/shell actions this run, even with --auto-approve."
+                if _HAS_UI:
+                    ui.high_risk_warning()
+                else:
+                    print(f"⚠️  {warning}")
+                self.logger.info(warning)
+
+        for m in messages[persisted:]:
+            self.store.append_message(session_id, persisted, m)
+            persisted += 1
+
+        for step in range(1, self.cfg.max_steps + 1):
+            messages = _trim_history(messages, self.cfg.context_char_budget)
+            msg = await self._call_model(messages, tool_schemas)
+
+            tool_calls = msg.get("tool_calls")
+            if not tool_calls:
+                recovered = _recover_text_tool_calls(msg.get("content", ""), tool_names)
+                if recovered:
+                    msg["tool_calls"] = recovered
+                    tool_calls = recovered
+                    self.logger.info(
+                        f"[step {step}] model printed tool call as plain text; "
+                        f"recovered {len(recovered)} call(s) via fallback parsing"
+                    )
+
+            messages.append(msg)
+            self.store.append_message(session_id, persisted, msg)
+            persisted += 1
+
+            if not tool_calls:
+                final = msg.get("content", "")
+                self.logger.info(f"DONE: {final}")
+                self.store.finish_session(session_id, "done", final)
+                return final
+
+            for call in tool_calls:
+                name = call["function"]["name"]
+                args = call["function"]["arguments"]
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args)
+                    except json.JSONDecodeError:
+                        result = f"ERROR: model sent malformed arguments: {args!r}"
+                        messages.append({"role": "tool", "content": result})
+                        self.store.append_message(session_id, persisted, messages[-1])
+                        persisted += 1
+                        self.logger.info(f"[step {step}] {name} -> BAD ARGS")
+                        continue
+
+                if _HAS_UI:
+                    ui.step_header(step, name, args)
+                else:
+                    print(f"\nstep {step} -> {name}({args})")
+
+                if not await _approve(name, args, self.cfg, client, self.force_approval):
+                    result = "Denied by human reviewer. Choose a different approach."
+                else:
+                    try:
+                        result = await client.call_tool(name, args)
+                    except Exception as e:
+                        result = f"ERROR: {name} raised: {e}"
+
+                ok = not str(result).startswith("ERROR") and result != "Denied by human reviewer. Choose a different approach."
+                if _HAS_UI:
+                    ui.tool_result(step, name, str(result), ok)
+                else:
+                    print(f"[step {step}] {name}({args}) -> {str(result)[:200]}")
+                self.logger.info(f"[step {step}] {name}({args}) -> {str(result)[:500]}")
+                messages.append({"role": "tool", "content": str(result)})
+                self.store.append_message(session_id, persisted, messages[-1])
+                persisted += 1
+
+        msg = "Max steps reached without completion. Check the log for progress."
+        self.logger.info(msg)
+        self.store.finish_session(session_id, "max_steps", msg)
+        return msg

coding_agent/cli.py

@@ -0,0 +1,234 @@
+"""CLI entry point (Typer).
+
+Examples:
+    python cli.py "Add type hints to utils.py and run the tests" \\
+        --project-root ./myrepo
+
+    python cli.py "Fix the failing test in test_math.py" \\
+        --project-root ./myrepo --auto-approve
+
+    python cli.py --session-name refactor-utils "Add type hints to utils.py"
+
+    python cli.py --list-sessions
+
+    python cli.py --resume refactor-utils "also add a docstring"
+
+    python cli.py --delete-session refactor-utils
+
+    python cli.py                      # no task -> interactive REPL, fresh session
+    python cli.py --resume refactor-utils   # no task -> interactive REPL, resumed session
+
+    python cli.py --help
+"""
+
+import asyncio
+from typing import Optional
+
+import typer
+
+from .agent import CodingAgent
+from .config import AgentConfig
+from .mcp_client import MCPToolClient
+from .session_store import SessionStore
+
+app = typer.Typer(add_completion=False, help="Local coding agent (Ollama + Qwen Coder)")
+
+
+@app.command()
+def main(
+    task: Optional[str] = typer.Argument(
+        None, help="What you want the agent to do. Optional with --resume (continues "
+                   "with no new instruction) or --list-sessions.",
+    ),
+    project_root: str = typer.Option(".", "--project-root", "-p", help="Sandbox directory"),
+    model: str = typer.Option("qwen3.6:35b", "--model", "-m", help="Ollama model to drive the agent"),
+    ollama_host: Optional[str] = typer.Option(
+        None, "--ollama-host", help="Ollama server URL (defaults to $OLLAMA_HOST or http://localhost:11434)",
+    ),
+    ollama_api_key: Optional[str] = typer.Option(
+        None, "--ollama-api-key",
+        help="Bearer token if Ollama sits behind an authenticated proxy "
+             "(defaults to $OLLAMA_API_KEY — prefer the env var over this flag "
+             "so the key doesn't end up in your shell history).",
+    ),
+    max_steps: int = typer.Option(25, "--max-steps", help="Hard cap on agent loop iterations"),
+    auto_approve: bool = typer.Option(
+        False, "--auto-approve",
+        help="Skip human approval for write/edit/shell tools. Only use in an "
+             "already-sandboxed environment. Overridden if intent parsing flags the task high-risk.",
+    ),
+    log_path: str = typer.Option("agent_run.log", "--log-path", help="Where to write the structured run log"),
+    skip_intent_parsing: bool = typer.Option(
+        False, "--skip-intent-parsing",
+        help="Skip the upfront structured-intent parse and go straight into the agent loop.",
+    ),
+    intent_model: Optional[str] = typer.Option(
+        None, "--intent-model", help="Smaller/faster model to use just for intent parsing (defaults to --model)",
+    ),
+    db_path: str = typer.Option(
+        "agent_sessions.db", "--db-path", help="SQLite file storing session/message history",
+    ),
+    resume: Optional[str] = typer.Option(
+        None, "--resume", help="Resume a previous session by id or --session-name instead of starting a new one",
+    ),
+    session_name: Optional[str] = typer.Option(
+        None, "--session-name", help="Give a new session a memorable name, so you can --resume it by name later",
+    ),
+    list_sessions: bool = typer.Option(
+        False, "--list-sessions", help="List saved sessions (id, name, status, task) and exit",
+    ),
+    delete_session: Optional[str] = typer.Option(
+        None, "--delete-session", help="Delete a saved session (by id or --session-name) and exit",
+    ),
+):
+    """Run the coding agent on TASK inside PROJECT_ROOT. Omit TASK to enter
+    an interactive session (fresh, or resumed with --resume)."""
+    if delete_session:
+        if SessionStore(db_path).delete_session(delete_session):
+            typer.echo(f"Deleted session {delete_session!r}.")
+        else:
+            typer.echo(f"Error: no session found with id or name {delete_session!r}.", err=True)
+            raise typer.Exit(code=1)
+        raise typer.Exit()
+
+    if list_sessions:
+        _print_sessions(SessionStore(db_path).list_sessions())
+        raise typer.Exit()
+
+    cfg = AgentConfig(
+        model=model,
+        ollama_host=ollama_host or "",
+        ollama_api_key=ollama_api_key or "",
+        project_root=project_root,
+        max_steps=max_steps,
+        auto_approve=auto_approve,
+        log_path=log_path,
+        parse_intent=not skip_intent_parsing,
+        intent_model=intent_model or "",
+        db_path=db_path,
+    )
+
+    if task is None:
+        asyncio.run(_interactive(cfg, resume, session_name))
+        return
+
+    if resume:
+        _show_resumed_history(db_path, resume)
+
+    agent = CodingAgent(cfg)
+    try:
+        result = asyncio.run(agent.run(task, resume_session_id=resume, session_name=session_name))
+    except ValueError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    try:
+        from . import ui
+        ui.final_result(result)
+    except ImportError:
+        typer.echo("\n=== FINAL RESULT ===")
+        typer.echo(result)
+
+
+async def _interactive(cfg: AgentConfig, resume: Optional[str], session_name: Optional[str]):
+    """REPL: keep one MCP client open across turns (avoids re-spawning the
+    tool-server subprocess every turn) and keep resuming the same session
+    (fresh on turn 1, then whatever session that turn created/resumed)."""
+    agent = CodingAgent(cfg)
+    session_id = resume
+
+    try:
+        from . import ui
+        ui.interactive_banner(cfg.model, resumed=resume)
+    except ImportError:
+        typer.echo(f"Interactive mode (model: {cfg.model}). Type a task, /sessions to list, /exit to quit.\n")
+
+    if resume:
+        _show_resumed_history(cfg.db_path, resume)
+
+    async with MCPToolClient(cfg.project_root) as client:
+        while True:
+            try:
+                task = _read_task()
+            except (EOFError, KeyboardInterrupt):
+                typer.echo()
+                break
+
+            task = task.strip()
+            if not task:
+                continue
+            if task in ("/exit", "/quit"):
+                break
+            if task == "/sessions":
+                _print_sessions(agent.store.list_sessions())
+                continue
+            if task.startswith("/delete "):
+                target = task[len("/delete "):].strip()
+                if agent.store.delete_session(target):
+                    typer.echo(f"Deleted session {target!r}.")
+                    if session_id is not None and agent.store.resolve_session_id(session_id) is None:
+                        session_id = None  # the session we were resuming just got deleted
+                else:
+                    typer.echo(f"No session found with id or name {target!r}.", err=True)
+                continue
+
+            try:
+                result = await agent.run(task, resume_session_id=session_id, client=client,
+                                          session_name=session_name, show_banner=False)
+            except ValueError as e:
+                typer.echo(f"Error: {e}", err=True)
+                continue
+
+            session_id = agent.session_id
+
+            try:
+                from . import ui
+                ui.final_result(result)
+            except ImportError:
+                typer.echo("\n=== RESULT ===")
+                typer.echo(result)
+
+
+def _show_resumed_history(db_path: str, resume: str):
+    """Print the conversation being resumed so it's visible on screen that
+    context actually carried over — agent.run() feeds it to the model
+    either way, but nothing else displays it."""
+    store = SessionStore(db_path)
+    session_id = store.resolve_session_id(resume)
+    if session_id is None:
+        return  # let agent.run() raise the proper "no session found" error
+    messages = store.load_messages(session_id)
+    try:
+        from . import ui
+        ui.history_panel(messages)
+    except ImportError:
+        typer.echo(f"--- Resumed history ({len(messages)} messages) ---")
+        for m in messages:
+            if m.get("role") == "system":
+                continue
+            typer.echo(f"{m.get('role')}: {str(m.get('content'))[:200]}")
+        typer.echo("--- end history ---\n")
+
+
+def _read_task() -> str:
+    try:
+        from . import ui
+        return ui.prompt_task()
+    except ImportError:
+        return input("> ")
+
+
+def _print_sessions(sessions: list):
+    if not sessions:
+        typer.echo("No saved sessions.")
+        return
+    try:
+        from . import ui
+        ui.sessions_table(sessions)
+    except ImportError:
+        for s in sessions:
+            typer.echo(f"{s['id']}  {s.get('name') or '-'}  [{s['status']}]  {s['updated_at']}  {s['task'][:70]}")
+
+
+if __name__ == "__main__":
+    app()

coding_agent/config.py

@@ -0,0 +1,40 @@
+"""Configuration for the coding agent."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class AgentConfig:
+    model: str = "qwen3.6:35b"
+    ollama_host: str = ""   # empty = use OLLAMA_HOST env var or http://localhost:11434
+    ollama_api_key: str = ""  # empty = use OLLAMA_API_KEY env var; never hardcode this
+
+    # All file/shell operations are confined to this directory. Paths that
+    # resolve outside it are rejected before any tool runs.
+    project_root: str = "."
+
+    # Tool names that execute WITHOUT asking for human approval first.
+    # Anything not listed here (write_file, edit_file, run_shell by default)
+    # will print what it's about to do and wait for confirmation, unless
+    # auto_approve=True.
+    safe_tools: tuple = ("read_file", "list_dir", "search_files", "glob_files", "git_diff")
+
+    auto_approve: bool = False        # True = never prompt (use in CI with care)
+    max_steps: int = 25               # hard cap on agent loop iterations
+
+    # Parse the freeform task into structured intent (task_type, target_files,
+    # constraints, risk_level) before the agent starts acting.
+    parse_intent: bool = True
+    intent_model: str = ""            # empty = reuse `model` for intent parsing too
+    max_retries: int = 3              # retries per model call on bad/malformed output
+    shell_timeout_s: int = 30
+    max_output_chars: int = 8000      # truncate tool output before feeding back to model
+    context_char_budget: int = 200_000  # rough trim threshold (chars, not tokens)
+    log_path: str = "agent_run.log"
+    db_path: str = "agent_sessions.db"  # SQLite file storing session/message history
+
+    # Commands the agent is never allowed to run, regardless of approval.
+    denied_shell_patterns: tuple = field(default_factory=lambda: (
+        "rm -rf /", "rm -rf /*", ":(){ :|:& };:", "mkfs", "dd if=",
+        "> /dev/sda", "shutdown", "reboot", "sudo ", "curl | sh", "wget | sh",
+    ))