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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ollama-coding-agent
-Version: 0.5.0
+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
@@ -17,6 +17,7 @@ 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

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

@@ -32,6 +32,7 @@ Examples:
 
 import asyncio
 import os
+from contextlib import nullcontext
 from typing import List, Optional
 
 import typer
@@ -220,61 +221,78 @@ def main(
 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)."""
+    (fresh on turn 1, then whatever session that turn created/resumed).
+
+    Input is read through a prompt_toolkit PromptSession wrapped in
+    patch_stdout(), so the input line stays pinned to the bottom of the
+    terminal — parsing/thinking spinners, panels, and results all scroll in
+    the region above it instead of interleaving with the prompt. Falls back
+    to a plain input() loop if rich/prompt_toolkit aren't installed."""
     agent = CodingAgent(cfg)
     session_id = resume
 
     try:
         from . import ui
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.patch_stdout import patch_stdout
         ui.interactive_banner(cfg.model, resumed=resume)
+        prompt_session = PromptSession()
+        # raw=True: pass Rich's ANSI-coded output straight through instead of
+        # patch_stdout()'s default write() path, which sanitizes/escapes text
+        # (it assumes plain text) and mangles embedded escape codes into
+        # 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")
+        prompt_session = None
+        stdout_cm = nullcontext()
 
     if resume:
         _show_resumed_history(cfg.db_path, resume)
 
     async with MCPToolClient(cfg.project_root, mcp_config_path=cfg.mcp_config_path or None,
                               extra_servers=cfg.mcp_servers or None) 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)
+        with stdout_cm:
+            while True:
+                try:
+                    task = await _read_task(prompt_session)
+                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):
@@ -298,12 +316,11 @@ def _show_resumed_history(db_path: str, resume: str):
         typer.echo("--- end history ---\n")
 
 
-def _read_task() -> str:
-    try:
+async def _read_task(prompt_session) -> str:
+    if prompt_session is not None:
         from . import ui
-        return ui.prompt_task()
-    except ImportError:
-        return input("> ")
+        return await ui.prompt_task_async(prompt_session)
+    return input("> ")
 
 
 def _print_sessions(sessions: list):

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

@@ -17,7 +17,10 @@ class AgentConfig:
     # 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")
+    safe_tools: tuple = (
+        "read_file", "list_dir", "search_files", "glob_files",
+        "git_diff", "git_status", "git_log", "git_show", "git_branch", "git_fetch",
+    )
 
     auto_approve: bool = False        # True = never prompt (use in CI with care)
     max_steps: int = 25               # hard cap on agent loop iterations

{ollama_coding_agent-0.5.0 → ollama_coding_agent-0.5.2}/coding_agent/mcp_server.py

@@ -59,6 +59,61 @@ def git_diff(path: str = ".") -> str:
     return impl.git_diff(path)
 
 
+@mcp.tool()
+def git_status(path: str = ".") -> str:
+    """Show the working tree status (short format) and current branch."""
+    return impl.git_status(path)
+
+
+@mcp.tool()
+def git_log(path: str = ".", max_count: int = 20) -> str:
+    """Show recent commit history (hash, date, author, subject)."""
+    return impl.git_log(path, max_count)
+
+
+@mcp.tool()
+def git_show(ref: str = "HEAD", path: str = ".") -> str:
+    """Show a commit's metadata and diff (defaults to HEAD)."""
+    return impl.git_show(ref, path)
+
+
+@mcp.tool()
+def git_branch(path: str = ".") -> str:
+    """List local branches, marking the current one and its upstream tracking info."""
+    return impl.git_branch(path)
+
+
+@mcp.tool()
+def git_fetch(remote: str = "origin") -> str:
+    """Update remote-tracking refs from a remote without touching the working tree."""
+    return impl.git_fetch(remote)
+
+
+@mcp.tool()
+def git_add(paths: str = ".") -> str:
+    """Stage files for commit. `paths` is a space-separated list of file \
+paths relative to the project root, or "." to stage all changes."""
+    return impl.git_add(paths)
+
+
+@mcp.tool()
+def git_commit(message: str) -> str:
+    """Commit staged changes with the given commit message."""
+    return impl.git_commit(message)
+
+
+@mcp.tool()
+def git_pull(remote: str = "origin", branch: str = "") -> str:
+    """Fetch and merge from a remote into the current branch."""
+    return impl.git_pull(remote, branch)
+
+
+@mcp.tool()
+def git_push(remote: str = "origin", branch: str = "") -> str:
+    """Push commits to a remote (defaults to pushing the current branch to origin)."""
+    return impl.git_push(remote, branch)
+
+
 @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

{ollama_coding_agent-0.5.0 → ollama_coding_agent-0.5.2}/coding_agent/tools.py

@@ -157,8 +157,141 @@ class Tools:
         except Exception as e:
             return f"ERROR: {e}"
 
+    def git_status(self, path: str = ".") -> str:
+        p = _resolve_in_scope(self.cfg.project_root, path)
+        try:
+            result = subprocess.run(
+                ["git", "status", "--short", "--branch"], cwd=p, capture_output=True, text=True, timeout=15,
+            )
+            return _truncate(result.stdout or "(clean)", self.cfg.max_output_chars)
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    def git_log(self, path: str = ".", max_count: int = 20) -> str:
+        p = _resolve_in_scope(self.cfg.project_root, path)
+        try:
+            result = subprocess.run(
+                ["git", "log", f"-{max_count}", "--pretty=format:%h %ad %an: %s", "--date=short"],
+                cwd=p, capture_output=True, text=True, timeout=15,
+            )
+            if result.returncode != 0:
+                return f"ERROR: {result.stderr.strip()}"
+            return _truncate(result.stdout or "(no commits)", self.cfg.max_output_chars)
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    def git_show(self, ref: str = "HEAD", path: str = ".") -> str:
+        p = _resolve_in_scope(self.cfg.project_root, path)
+        try:
+            result = subprocess.run(
+                ["git", "show", ref], cwd=p, capture_output=True, text=True, timeout=15,
+            )
+            if result.returncode != 0:
+                return f"ERROR: {result.stderr.strip()}"
+            return _truncate(result.stdout, self.cfg.max_output_chars)
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    def git_branch(self, path: str = ".") -> str:
+        p = _resolve_in_scope(self.cfg.project_root, path)
+        try:
+            result = subprocess.run(
+                ["git", "branch", "-vv"], cwd=p, capture_output=True, text=True, timeout=15,
+            )
+            if result.returncode != 0:
+                return f"ERROR: {result.stderr.strip()}"
+            return _truncate(result.stdout or "(no branches)", self.cfg.max_output_chars)
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    def git_fetch(self, remote: str = "origin") -> str:
+        """Update remote-tracking refs without touching the working tree —
+        safe to run without approval, unlike pull/push."""
+        try:
+            result = subprocess.run(
+                ["git", "fetch", remote], cwd=self.cfg.project_root,
+                capture_output=True, text=True, timeout=self.cfg.shell_timeout_s,
+            )
+            out = f"exit_code: {result.returncode}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+            return _truncate(out, self.cfg.max_output_chars)
+        except subprocess.TimeoutExpired:
+            return f"ERROR: git fetch timed out after {self.cfg.shell_timeout_s}s"
+        except Exception as e:
+            return f"ERROR: {e}"
+
     # ---- write tools (require approval unless auto_approve) ----
 
+    def git_add(self, paths: str = ".") -> str:
+        """Stage files for commit. `paths` is a space-separated list of file
+        paths relative to the project root, or "." to stage all changes."""
+        if paths.strip() == ".":
+            args = ["git", "add", "-A"]
+        else:
+            resolved = []
+            for part in paths.split():
+                p = _resolve_in_scope(self.cfg.project_root, part)
+                resolved.append(os.path.relpath(p, self.cfg.project_root))
+            args = ["git", "add"] + resolved
+        try:
+            result = subprocess.run(
+                args, cwd=self.cfg.project_root, capture_output=True, text=True, timeout=15,
+            )
+            if result.returncode != 0:
+                return f"ERROR: {result.stderr.strip()}"
+            return f"Staged: {paths}"
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    def git_commit(self, message: str) -> str:
+        if not message.strip():
+            return "ERROR: commit message cannot be empty"
+        try:
+            result = subprocess.run(
+                ["git", "commit", "-m", message], cwd=self.cfg.project_root,
+                capture_output=True, text=True, timeout=15,
+            )
+            out = f"exit_code: {result.returncode}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+            return _truncate(out, self.cfg.max_output_chars)
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    def git_pull(self, remote: str = "origin", branch: str = "") -> str:
+        """Fetch and merge from a remote into the current branch. Touches
+        the working tree, so this always requires approval (never auto_approve
+        -exempt like the read-only git tools)."""
+        args = ["git", "pull", remote]
+        if branch:
+            args.append(branch)
+        try:
+            result = subprocess.run(
+                args, cwd=self.cfg.project_root, capture_output=True, text=True,
+                timeout=self.cfg.shell_timeout_s,
+            )
+            out = f"exit_code: {result.returncode}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+            return _truncate(out, self.cfg.max_output_chars)
+        except subprocess.TimeoutExpired:
+            return f"ERROR: git pull timed out after {self.cfg.shell_timeout_s}s"
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    def git_push(self, remote: str = "origin", branch: str = "") -> str:
+        """Push commits to a remote. No force-push option is exposed —
+        this tool only ever does a plain push."""
+        args = ["git", "push", remote]
+        if branch:
+            args.append(branch)
+        try:
+            result = subprocess.run(
+                args, cwd=self.cfg.project_root, capture_output=True, text=True,
+                timeout=self.cfg.shell_timeout_s,
+            )
+            out = f"exit_code: {result.returncode}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+            return _truncate(out, self.cfg.max_output_chars)
+        except subprocess.TimeoutExpired:
+            return f"ERROR: git push timed out after {self.cfg.shell_timeout_s}s"
+        except Exception as e:
+            return f"ERROR: {e}"
+
     def write_file(self, path: str, content: str, overwrite: bool = False) -> str:
         p = _resolve_in_scope(self.cfg.project_root, path)
         if os.path.exists(p) and not overwrite:

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

@@ -7,10 +7,11 @@ isn't installed, agent.py falls back to plain print() (see its import guard).
 import json
 import os
 
+from prompt_toolkit.formatted_text import HTML
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.panel import Panel
-from rich.prompt import Confirm, Prompt
+from rich.prompt import Confirm
 from rich.syntax import Syntax
 from rich.rule import Rule
 from rich.table import Table
@@ -46,9 +47,18 @@ def interactive_banner(model: str, resumed: str = None):
     console.print("[dim]Type a task, /sessions to list saved sessions, /exit to quit.[/dim]\n")
 
 
-def prompt_task() -> str:
+async def prompt_task_async(session) -> str:
+    """Read one line of input via a prompt_toolkit PromptSession, so the
+    input line stays pinned to the bottom of the terminal — all other
+    output (parsing/thinking spinners, panels, results) scrolls in the
+    region above it instead of interleaving with the prompt. `session` is
+    a prompt_toolkit.PromptSession the caller creates once and reuses
+    across turns (so up-arrow history works). Must be called inside the
+    caller's `patch_stdout()` context so Rich's output (which resolves
+    sys.stdout lazily on every print) is redrawn above the pinned prompt
+    instead of corrupting it."""
     console.print(Rule(style="dim"))
-    return Prompt.ask("[bold green]❯[/bold green]")
+    return await session.prompt_async(HTML("<ansigreen><b>❯</b></ansigreen> "))
 
 
 def thinking(label: str = "Thinking…"):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ollama-coding-agent
-Version: 0.5.0
+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
@@ -17,6 +17,7 @@ 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

{ollama_coding_agent-0.5.0 → ollama_coding_agent-0.5.2}/ollama_coding_agent.egg-info/requires.txt

@@ -2,3 +2,4 @@ httpx>=0.28
 rich>=15.0
 typer>=0.27
 mcp>=1.27
+prompt_toolkit>=3.0

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ollama-coding-agent"
-version = "0.5.0"
+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"
@@ -20,6 +20,7 @@ dependencies = [
     "rich>=15.0",
     "typer>=0.27",
     "mcp>=1.27",
+    "prompt_toolkit>=3.0",
 ]
 
 [project.urls]