ollama-coding-agent 0.5.2__tar.gz → 0.5.4__tar.gz

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/PKG-INFO

@@ -1,149 +1,149 @@
-Metadata-Version: 2.4
-Name: ollama-coding-agent
-Version: 0.5.2
-Summary: AI coding agent driving Qwen Coder (or any Ollama-compatible model) through a scoped toolset via MCP
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/HarryChen1995/coding_agent
-Project-URL: Repository, https://github.com/HarryChen1995/coding_agent
-Project-URL: Issues, https://github.com/HarryChen1995/coding_agent/issues
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Build Tools
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: httpx>=0.28
-Requires-Dist: rich>=15.0
-Requires-Dist: typer>=0.27
-Requires-Dist: mcp>=1.27
-Requires-Dist: prompt_toolkit>=3.0
-Dynamic: license-file
-
-# Ollama Coding Agent
-
-An AI coding agent that plans, edits, and tests code by driving Qwen Coder
-(or any Ollama-compatible model) through a scoped set of file and shell
-tools, with human approval on every write, edit, or shell command.
-
-## Install
-
-```bash
-pip install ollama-coding-agent
-ollama pull qwen3-coder:30b
-```
-
-## Usage
-
-```bash
-coding-agent "Add type hints to utils.py, then run the test suite" \
-    --project-root ./myrepo
-```
-
-Equivalent: `python -m coding_agent "..." --project-root ./myrepo`.
-
-Omit the task string to enter an interactive session instead:
-
-```bash
-coding-agent --project-root ./myrepo
-```
-
-Run `coding-agent --help` for the full option list.
-
-## Features
-
-- **Structured intent parsing** — the raw task is classified (bug fix,
-  feature, refactor, risk level, target files) before any action is taken,
-  and high-risk tasks force human approval even under `--auto-approve`.
-- **Session persistence** — every message is saved to SQLite as the run
-  happens. Resume a previous run by id or a name you gave it
-  (`--resume`), browse saved sessions (`--list-sessions`), or delete one
-  (`--delete-session`).
-- **Interactive mode** — drop into a REPL that keeps the model connection
-  and tool session alive across turns.
-- **Human-in-the-loop approval** — every write, edit, or shell command
-  shows a diff or command preview before you confirm, unless explicitly
-  marked safe or run with `--auto-approve`.
-- **Retry and recovery** — transient model failures retry with backoff;
-  malformed tool-call output is caught and reported back to the model
-  instead of crashing the run.
-- **Codebase exploration tools** — regex content search with glob
-  filtering, pattern-based file discovery, directory listing, and git diff,
-  all skipping noise directories (`.git`, `node_modules`, build output).
-- **Extensible via custom MCP servers** — point at any MCP server, local
-  (stdio) or remote (SSE / Streamable HTTP), and its tools merge into the
-  model's toolset automatically, no code changes required. Register one
-  permanently (`--add-mcp-server`, available on every future run) or add
-  one per run (`--mcp-server`/`--mcp-config`).
-
-## Architecture
-
-Tools are served over the Model Context Protocol (MCP), not called
-in-process — the agent is an MCP *client* that talks to a tool server over
-stdio:
-
-```
-+-----------------------------+
-|          CLI / REPL         |
-+-----------------------------+
-               |
-               v
-+-----------------------------+
-|          Agent loop         |
-|  parse intent, call model,  |
-|  approve, execute, persist  |
-+-----------------------------+
-               |
-               v
-+-----------------------------+
-|          MCP client         |
-|  built-in + custom servers  |
-|  merged into one tool list  |
-+-----------------------------+
-               |
- stdio / SSE / streamable-http
-               v
-+-----------------------------+
-|        MCP server(s)        |
-+-----------------------------+
-               |
-               v
-+-----------------------------+
-|            Tools            |
-|    read / write / edit /    |
-|        search / shell       |
-+-----------------------------+
-```
-
-Because tools are exposed over MCP, any MCP-compatible client — Claude
-Desktop, another agent framework, a different model entirely — can reach
-the exact same toolset, approval-preview logic, and path scoping. The
-reverse also holds: any additional MCP server — local (stdio) or remote
-(SSE / Streamable HTTP) — can be plugged into this agent, and its tools
-merge into the same list the model already sees —
-```bash
-coding-agent --add-mcp-server "weather=python -m weather_mcp_server"     # local, stdio
-coding-agent --add-mcp-server "weather=https://example.com/mcp/sse"      # remote, SSE
-coding-agent "what's the forecast?"   # picked up automatically, every run from here on
-```
-A value after `name=` starting with `http://`/`https://` is treated as a
-remote server (SSE by default, append `,streamable_http` for that transport
-instead); anything else is a local command spawned over stdio — it doesn't
-need to be `-m`-invokable, a standalone script's absolute path works too
-(e.g. `"myserver=python C:/absolute/path/to/mcp_server.py"`).
-
-## Configuration
-
-Point at any Ollama-compatible host with `--ollama-host` or the
-`OLLAMA_HOST` env var. If it sits behind an authenticated proxy, set
-`OLLAMA_API_KEY` as an environment variable rather than a CLI flag so the
-key doesn't end up in shell history.
-
-## Links
-
-Source, full documentation, and issue tracker:
-https://github.com/HarryChen1995/coding_agent
-
-## License
-
-MIT
+Metadata-Version: 2.4
+Name: ollama-coding-agent
+Version: 0.5.4
+Summary: AI coding agent driving Qwen Coder (or any Ollama-compatible model) through a scoped toolset via MCP
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/HarryChen1995/coding_agent
+Project-URL: Repository, https://github.com/HarryChen1995/coding_agent
+Project-URL: Issues, https://github.com/HarryChen1995/coding_agent/issues
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28
+Requires-Dist: rich>=15.0
+Requires-Dist: typer>=0.27
+Requires-Dist: mcp>=1.27
+Requires-Dist: prompt_toolkit>=3.0
+Dynamic: license-file
+
+# Ollama Coding Agent
+
+An AI coding agent that plans, edits, and tests code by driving Qwen Coder
+(or any Ollama-compatible model) through a scoped set of file and shell
+tools, with human approval on every write, edit, or shell command.
+
+## Install
+
+```bash
+pip install ollama-coding-agent
+ollama pull qwen3-coder:30b
+```
+
+## Usage
+
+```bash
+coding-agent "Add type hints to utils.py, then run the test suite" \
+    --project-root ./myrepo
+```
+
+Equivalent: `python -m coding_agent "..." --project-root ./myrepo`.
+
+Omit the task string to enter an interactive session instead:
+
+```bash
+coding-agent --project-root ./myrepo
+```
+
+Run `coding-agent --help` for the full option list.
+
+## Features
+
+- **Structured intent parsing** — the raw task is classified (bug fix,
+  feature, refactor, risk level, target files) before any action is taken,
+  and high-risk tasks force human approval even under `--auto-approve`.
+- **Session persistence** — every message is saved to SQLite as the run
+  happens. Resume a previous run by id or a name you gave it
+  (`--resume`), browse saved sessions (`--list-sessions`), or delete one
+  (`--delete-session`).
+- **Interactive mode** — drop into a REPL that keeps the model connection
+  and tool session alive across turns.
+- **Human-in-the-loop approval** — every write, edit, or shell command
+  shows a diff or command preview before you confirm, unless explicitly
+  marked safe or run with `--auto-approve`.
+- **Retry and recovery** — transient model failures retry with backoff;
+  malformed tool-call output is caught and reported back to the model
+  instead of crashing the run.
+- **Codebase exploration tools** — regex content search with glob
+  filtering, pattern-based file discovery, directory listing, and git diff,
+  all skipping noise directories (`.git`, `node_modules`, build output).
+- **Extensible via custom MCP servers** — point at any MCP server, local
+  (stdio) or remote (SSE / Streamable HTTP), and its tools merge into the
+  model's toolset automatically, no code changes required. Register one
+  permanently (`--add-mcp-server`, available on every future run) or add
+  one per run (`--mcp-server`/`--mcp-config`).
+
+## Architecture
+
+Tools are served over the Model Context Protocol (MCP), not called
+in-process — the agent is an MCP *client* that talks to a tool server over
+stdio:
+
+```
++-----------------------------+
+|          CLI / REPL         |
++-----------------------------+
+               |
+               v
++-----------------------------+
+|          Agent loop         |
+|  parse intent, call model,  |
+|  approve, execute, persist  |
++-----------------------------+
+               |
+               v
++-----------------------------+
+|          MCP client         |
+|  built-in + custom servers  |
+|  merged into one tool list  |
++-----------------------------+
+               |
+ stdio / SSE / streamable-http
+               v
++-----------------------------+
+|        MCP server(s)        |
++-----------------------------+
+               |
+               v
++-----------------------------+
+|            Tools            |
+|    read / write / edit /    |
+|        search / shell       |
++-----------------------------+
+```
+
+Because tools are exposed over MCP, any MCP-compatible client — Claude
+Desktop, another agent framework, a different model entirely — can reach
+the exact same toolset, approval-preview logic, and path scoping. The
+reverse also holds: any additional MCP server — local (stdio) or remote
+(SSE / Streamable HTTP) — can be plugged into this agent, and its tools
+merge into the same list the model already sees —
+```bash
+coding-agent --add-mcp-server "weather=python -m weather_mcp_server"     # local, stdio
+coding-agent --add-mcp-server "weather=https://example.com/mcp/sse"      # remote, SSE
+coding-agent "what's the forecast?"   # picked up automatically, every run from here on
+```
+A value after `name=` starting with `http://`/`https://` is treated as a
+remote server (SSE by default, append `,streamable_http` for that transport
+instead); anything else is a local command spawned over stdio — it doesn't
+need to be `-m`-invokable, a standalone script's absolute path works too
+(e.g. `"myserver=python C:/absolute/path/to/mcp_server.py"`).
+
+## Configuration
+
+Point at any Ollama-compatible host with `--ollama-host` or the
+`OLLAMA_HOST` env var. If it sits behind an authenticated proxy, set
+`OLLAMA_API_KEY` as an environment variable rather than a CLI flag so the
+key doesn't end up in shell history.
+
+## Links
+
+Source, full documentation, and issue tracker:
+https://github.com/HarryChen1995/coding_agent
+
+## License
+
+MIT

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/coding_agent/agent.py

@@ -114,7 +114,10 @@ def _recover_text_tool_calls(content: str, tool_names: set) -> list:
             calls.append({
                 "id": f"fallback_{len(calls)}",
                 "type": "function",
-                "function": {"name": name, "arguments": args},
+                "function": {
+                    "name": name,
+                    "arguments": json.dumps(args, ensure_ascii=False),
+                },
             })
     return calls
 

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/coding_agent/cli.py

@@ -32,6 +32,7 @@ Examples:
 
 import asyncio
 import os
+import signal
 from contextlib import nullcontext
 from typing import List, Optional
 
@@ -65,7 +66,7 @@ def main(
              "(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"),
+    max_steps: int = typer.Option(100, "--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 "
@@ -243,7 +244,8 @@ async def _interactive(cfg: AgentConfig, resume: Optional[str], session_name: Op
         # literal garbage like "?[32m" on the screen.
         stdout_cm = patch_stdout(raw=True)
     except ImportError:
-        typer.echo(f"Interactive mode (model: {cfg.model}). Type a task, /sessions to list, /exit to quit.\n")
+        typer.echo(f"Interactive mode (model: {cfg.model}). Type a task, /sessions to list, /exit to quit. "
+                   "Ctrl+C interrupts the current turn without leaving the session.\n")
         prompt_session = None
         stdout_cm = nullcontext()
 
@@ -278,12 +280,34 @@ async def _interactive(cfg: AgentConfig, resume: Optional[str], session_name: Op
                         typer.echo(f"No session found with id or name {target!r}.", err=True)
                     continue
 
+                # Run the turn as a Task so Ctrl+C can cancel just this turn
+                # (via the SIGINT handler below) instead of killing the whole
+                # REPL — a raw KeyboardInterrupt raised inside asyncio's own
+                # blocking wait can otherwise escape uncaught past this loop
+                # entirely. task.cancel() injects CancelledError at the
+                # coroutine's next await point (model call, tool call, etc.),
+                # unwinding just that turn; the MCP client and session history
+                # already written to disk are untouched, so the REPL keeps going.
+                run_task = asyncio.ensure_future(
+                    agent.run(task, resume_session_id=session_id, client=client,
+                              session_name=session_name, show_banner=False)
+                )
+                previous_sigint = signal.signal(signal.SIGINT, lambda *_: run_task.cancel())
                 try:
-                    result = await agent.run(task, resume_session_id=session_id, client=client,
-                                              session_name=session_name, show_banner=False)
+                    result = await run_task
+                except asyncio.CancelledError:
+                    session_id = agent.session_id or session_id
+                    try:
+                        from . import ui
+                        ui.interrupted()
+                    except ImportError:
+                        typer.echo("\n[Interrupted — back to prompt. You can keep chatting in this session.]")
+                    continue
                 except ValueError as e:
                     typer.echo(f"Error: {e}", err=True)
                     continue
+                finally:
+                    signal.signal(signal.SIGINT, previous_sigint)
 
                 session_id = agent.session_id
 

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/coding_agent/config.py

@@ -23,7 +23,7 @@ class AgentConfig:
     )
 
     auto_approve: bool = False        # True = never prompt (use in CI with care)
-    max_steps: int = 25               # hard cap on agent loop iterations
+    max_steps: int = 100              # 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.

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/coding_agent/ollama_client.py

@@ -1,73 +1,108 @@
-"""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('/')}/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
+"""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 json
+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
+
+
+def _normalize_tool_call(call: dict) -> dict:
+    if not isinstance(call, dict) or call.get("type") != "function":
+        return call
+
+    function = call.get("function")
+    if not isinstance(function, dict):
+        return call
+
+    args = function.get("arguments")
+    if args is None or isinstance(args, str):
+        return call
+
+    normalized = function.copy()
+    normalized["arguments"] = json.dumps(args, ensure_ascii=False)
+    return {**call, "function": normalized}
+
+
+def _normalize_messages(messages: list) -> list:
+    normalized = []
+    for msg in messages:
+        if not isinstance(msg, dict):
+            normalized.append(msg)
+            continue
+        tool_calls = msg.get("tool_calls")
+        if isinstance(tool_calls, list):
+            normalized.append({
+                **msg,
+                "tool_calls": [_normalize_tool_call(call) for call in tool_calls],
+            })
+        else:
+            normalized.append(msg)
+    return normalized
+
+
+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('/')}/v1/chat/completions"
+    payload = {"model": model, "messages": _normalize_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

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/coding_agent/ui.py

@@ -44,7 +44,8 @@ def interactive_banner(model: str, resumed: str = None):
     console.print(f"[dim]model:[/dim] {model}")
     if resumed:
         console.print(f"[dim]resuming session:[/dim] {resumed}")
-    console.print("[dim]Type a task, /sessions to list saved sessions, /exit to quit.[/dim]\n")
+    console.print("[dim]Type a task, /sessions to list saved sessions, /exit to quit. "
+                  "Ctrl+C interrupts the current turn without leaving the session.[/dim]\n")
 
 
 async def prompt_task_async(session) -> str:
@@ -226,6 +227,13 @@ def sessions_table(sessions: list):
     console.print(table)
 
 
+def interrupted():
+    console.print(
+        "\n[yellow]⏹ Interrupted — back at the prompt. Progress up to the last "
+        "completed step was saved; keep chatting or ask the agent to continue.[/yellow]"
+    )
+
+
 def warning(text: str):
     console.print(f"[yellow]⚠ {text}[/yellow]")
 

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/ollama_coding_agent.egg-info/PKG-INFO

@@ -1,149 +1,149 @@
-Metadata-Version: 2.4
-Name: ollama-coding-agent
-Version: 0.5.2
-Summary: AI coding agent driving Qwen Coder (or any Ollama-compatible model) through a scoped toolset via MCP
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/HarryChen1995/coding_agent
-Project-URL: Repository, https://github.com/HarryChen1995/coding_agent
-Project-URL: Issues, https://github.com/HarryChen1995/coding_agent/issues
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Build Tools
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: httpx>=0.28
-Requires-Dist: rich>=15.0
-Requires-Dist: typer>=0.27
-Requires-Dist: mcp>=1.27
-Requires-Dist: prompt_toolkit>=3.0
-Dynamic: license-file
-
-# Ollama Coding Agent
-
-An AI coding agent that plans, edits, and tests code by driving Qwen Coder
-(or any Ollama-compatible model) through a scoped set of file and shell
-tools, with human approval on every write, edit, or shell command.
-
-## Install
-
-```bash
-pip install ollama-coding-agent
-ollama pull qwen3-coder:30b
-```
-
-## Usage
-
-```bash
-coding-agent "Add type hints to utils.py, then run the test suite" \
-    --project-root ./myrepo
-```
-
-Equivalent: `python -m coding_agent "..." --project-root ./myrepo`.
-
-Omit the task string to enter an interactive session instead:
-
-```bash
-coding-agent --project-root ./myrepo
-```
-
-Run `coding-agent --help` for the full option list.
-
-## Features
-
-- **Structured intent parsing** — the raw task is classified (bug fix,
-  feature, refactor, risk level, target files) before any action is taken,
-  and high-risk tasks force human approval even under `--auto-approve`.
-- **Session persistence** — every message is saved to SQLite as the run
-  happens. Resume a previous run by id or a name you gave it
-  (`--resume`), browse saved sessions (`--list-sessions`), or delete one
-  (`--delete-session`).
-- **Interactive mode** — drop into a REPL that keeps the model connection
-  and tool session alive across turns.
-- **Human-in-the-loop approval** — every write, edit, or shell command
-  shows a diff or command preview before you confirm, unless explicitly
-  marked safe or run with `--auto-approve`.
-- **Retry and recovery** — transient model failures retry with backoff;
-  malformed tool-call output is caught and reported back to the model
-  instead of crashing the run.
-- **Codebase exploration tools** — regex content search with glob
-  filtering, pattern-based file discovery, directory listing, and git diff,
-  all skipping noise directories (`.git`, `node_modules`, build output).
-- **Extensible via custom MCP servers** — point at any MCP server, local
-  (stdio) or remote (SSE / Streamable HTTP), and its tools merge into the
-  model's toolset automatically, no code changes required. Register one
-  permanently (`--add-mcp-server`, available on every future run) or add
-  one per run (`--mcp-server`/`--mcp-config`).
-
-## Architecture
-
-Tools are served over the Model Context Protocol (MCP), not called
-in-process — the agent is an MCP *client* that talks to a tool server over
-stdio:
-
-```
-+-----------------------------+
-|          CLI / REPL         |
-+-----------------------------+
-               |
-               v
-+-----------------------------+
-|          Agent loop         |
-|  parse intent, call model,  |
-|  approve, execute, persist  |
-+-----------------------------+
-               |
-               v
-+-----------------------------+
-|          MCP client         |
-|  built-in + custom servers  |
-|  merged into one tool list  |
-+-----------------------------+
-               |
- stdio / SSE / streamable-http
-               v
-+-----------------------------+
-|        MCP server(s)        |
-+-----------------------------+
-               |
-               v
-+-----------------------------+
-|            Tools            |
-|    read / write / edit /    |
-|        search / shell       |
-+-----------------------------+
-```
-
-Because tools are exposed over MCP, any MCP-compatible client — Claude
-Desktop, another agent framework, a different model entirely — can reach
-the exact same toolset, approval-preview logic, and path scoping. The
-reverse also holds: any additional MCP server — local (stdio) or remote
-(SSE / Streamable HTTP) — can be plugged into this agent, and its tools
-merge into the same list the model already sees —
-```bash
-coding-agent --add-mcp-server "weather=python -m weather_mcp_server"     # local, stdio
-coding-agent --add-mcp-server "weather=https://example.com/mcp/sse"      # remote, SSE
-coding-agent "what's the forecast?"   # picked up automatically, every run from here on
-```
-A value after `name=` starting with `http://`/`https://` is treated as a
-remote server (SSE by default, append `,streamable_http` for that transport
-instead); anything else is a local command spawned over stdio — it doesn't
-need to be `-m`-invokable, a standalone script's absolute path works too
-(e.g. `"myserver=python C:/absolute/path/to/mcp_server.py"`).
-
-## Configuration
-
-Point at any Ollama-compatible host with `--ollama-host` or the
-`OLLAMA_HOST` env var. If it sits behind an authenticated proxy, set
-`OLLAMA_API_KEY` as an environment variable rather than a CLI flag so the
-key doesn't end up in shell history.
-
-## Links
-
-Source, full documentation, and issue tracker:
-https://github.com/HarryChen1995/coding_agent
-
-## License
-
-MIT
+Metadata-Version: 2.4
+Name: ollama-coding-agent
+Version: 0.5.4
+Summary: AI coding agent driving Qwen Coder (or any Ollama-compatible model) through a scoped toolset via MCP
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/HarryChen1995/coding_agent
+Project-URL: Repository, https://github.com/HarryChen1995/coding_agent
+Project-URL: Issues, https://github.com/HarryChen1995/coding_agent/issues
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28
+Requires-Dist: rich>=15.0
+Requires-Dist: typer>=0.27
+Requires-Dist: mcp>=1.27
+Requires-Dist: prompt_toolkit>=3.0
+Dynamic: license-file
+
+# Ollama Coding Agent
+
+An AI coding agent that plans, edits, and tests code by driving Qwen Coder
+(or any Ollama-compatible model) through a scoped set of file and shell
+tools, with human approval on every write, edit, or shell command.
+
+## Install
+
+```bash
+pip install ollama-coding-agent
+ollama pull qwen3-coder:30b
+```
+
+## Usage
+
+```bash
+coding-agent "Add type hints to utils.py, then run the test suite" \
+    --project-root ./myrepo
+```
+
+Equivalent: `python -m coding_agent "..." --project-root ./myrepo`.
+
+Omit the task string to enter an interactive session instead:
+
+```bash
+coding-agent --project-root ./myrepo
+```
+
+Run `coding-agent --help` for the full option list.
+
+## Features
+
+- **Structured intent parsing** — the raw task is classified (bug fix,
+  feature, refactor, risk level, target files) before any action is taken,
+  and high-risk tasks force human approval even under `--auto-approve`.
+- **Session persistence** — every message is saved to SQLite as the run
+  happens. Resume a previous run by id or a name you gave it
+  (`--resume`), browse saved sessions (`--list-sessions`), or delete one
+  (`--delete-session`).
+- **Interactive mode** — drop into a REPL that keeps the model connection
+  and tool session alive across turns.
+- **Human-in-the-loop approval** — every write, edit, or shell command
+  shows a diff or command preview before you confirm, unless explicitly
+  marked safe or run with `--auto-approve`.
+- **Retry and recovery** — transient model failures retry with backoff;
+  malformed tool-call output is caught and reported back to the model
+  instead of crashing the run.
+- **Codebase exploration tools** — regex content search with glob
+  filtering, pattern-based file discovery, directory listing, and git diff,
+  all skipping noise directories (`.git`, `node_modules`, build output).
+- **Extensible via custom MCP servers** — point at any MCP server, local
+  (stdio) or remote (SSE / Streamable HTTP), and its tools merge into the
+  model's toolset automatically, no code changes required. Register one
+  permanently (`--add-mcp-server`, available on every future run) or add
+  one per run (`--mcp-server`/`--mcp-config`).
+
+## Architecture
+
+Tools are served over the Model Context Protocol (MCP), not called
+in-process — the agent is an MCP *client* that talks to a tool server over
+stdio:
+
+```
++-----------------------------+
+|          CLI / REPL         |
++-----------------------------+
+               |
+               v
++-----------------------------+
+|          Agent loop         |
+|  parse intent, call model,  |
+|  approve, execute, persist  |
++-----------------------------+
+               |
+               v
++-----------------------------+
+|          MCP client         |
+|  built-in + custom servers  |
+|  merged into one tool list  |
++-----------------------------+
+               |
+ stdio / SSE / streamable-http
+               v
++-----------------------------+
+|        MCP server(s)        |
++-----------------------------+
+               |
+               v
++-----------------------------+
+|            Tools            |
+|    read / write / edit /    |
+|        search / shell       |
++-----------------------------+
+```
+
+Because tools are exposed over MCP, any MCP-compatible client — Claude
+Desktop, another agent framework, a different model entirely — can reach
+the exact same toolset, approval-preview logic, and path scoping. The
+reverse also holds: any additional MCP server — local (stdio) or remote
+(SSE / Streamable HTTP) — can be plugged into this agent, and its tools
+merge into the same list the model already sees —
+```bash
+coding-agent --add-mcp-server "weather=python -m weather_mcp_server"     # local, stdio
+coding-agent --add-mcp-server "weather=https://example.com/mcp/sse"      # remote, SSE
+coding-agent "what's the forecast?"   # picked up automatically, every run from here on
+```
+A value after `name=` starting with `http://`/`https://` is treated as a
+remote server (SSE by default, append `,streamable_http` for that transport
+instead); anything else is a local command spawned over stdio — it doesn't
+need to be `-m`-invokable, a standalone script's absolute path works too
+(e.g. `"myserver=python C:/absolute/path/to/mcp_server.py"`).
+
+## Configuration
+
+Point at any Ollama-compatible host with `--ollama-host` or the
+`OLLAMA_HOST` env var. If it sits behind an authenticated proxy, set
+`OLLAMA_API_KEY` as an environment variable rather than a CLI flag so the
+key doesn't end up in shell history.
+
+## Links
+
+Source, full documentation, and issue tracker:
+https://github.com/HarryChen1995/coding_agent
+
+## License
+
+MIT

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/pyproject.toml

@@ -1,35 +1,35 @@
-[build-system]
-requires = ["setuptools>=68"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "ollama-coding-agent"
-version = "0.5.2"
-description = "AI coding agent driving Qwen Coder (or any Ollama-compatible model) through a scoped toolset via MCP"
-readme = "PYPI_README.md"
-requires-python = ">=3.10"
-license = "MIT"
-classifiers = [
-    "Environment :: Console",
-    "Intended Audience :: Developers",
-    "Programming Language :: Python :: 3",
-    "Topic :: Software Development :: Build Tools",
-]
-dependencies = [
-    "httpx>=0.28",
-    "rich>=15.0",
-    "typer>=0.27",
-    "mcp>=1.27",
-    "prompt_toolkit>=3.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/HarryChen1995/coding_agent"
-Repository = "https://github.com/HarryChen1995/coding_agent"
-Issues = "https://github.com/HarryChen1995/coding_agent/issues"
-
-[project.scripts]
-coding-agent = "coding_agent.cli:app"
-
-[tool.setuptools.packages.find]
-include = ["coding_agent*"]
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ollama-coding-agent"
+version = "0.5.4"
+description = "AI coding agent driving Qwen Coder (or any Ollama-compatible model) through a scoped toolset via MCP"
+readme = "PYPI_README.md"
+requires-python = ">=3.10"
+license = "MIT"
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Build Tools",
+]
+dependencies = [
+    "httpx>=0.28",
+    "rich>=15.0",
+    "typer>=0.27",
+    "mcp>=1.27",
+    "prompt_toolkit>=3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/HarryChen1995/coding_agent"
+Repository = "https://github.com/HarryChen1995/coding_agent"
+Issues = "https://github.com/HarryChen1995/coding_agent/issues"
+
+[project.scripts]
+coding-agent = "coding_agent.cli:app"
+
+[tool.setuptools.packages.find]
+include = ["coding_agent*"]

{ollama_coding_agent-0.5.2 → ollama_coding_agent-0.5.4}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+