wrencode 0.1.4__tar.gz → 0.1.4.2__tar.gz

{wrencode-0.1.4 → wrencode-0.1.4.2}/.gitignore

@@ -17,6 +17,7 @@ dist/
 .venv/
 venv/
 env/
+.tmp/
 
 # WrenCode local state (when pointed at a repo-local config dir)
 .wrencode/

{wrencode-0.1.4 → wrencode-0.1.4.2}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: wrencode
-Version: 0.1.4
+Version: 0.1.4.2
 Summary: A minimal agentic coding assistant in a single Python file
 Project-URL: Homepage, https://github.com/almostly/wrencode
 Project-URL: Repository, https://github.com/almostly/wrencode
 Project-URL: Issues, https://github.com/almostly/wrencode/issues
-Author: Denis Burakov
+Author: Almostly
 License-Expression: MIT
 Keywords: agent,ai,anthropic,cli,coding-assistant,llm,mlx,ollama,openai
 Classifier: Development Status :: 4 - Beta
@@ -55,6 +55,12 @@ saved choice, e.g. for CI.
 The standalone binary can't bundle the heavy ML stack, so the local-weights
 backends (`mlx`, `transformers`) are only offered when running from source.
 
+The default local models are
+[`deburky/gpt-oss-claude-code`](https://huggingface.co/deburky/gpt-oss-claude-code)
+(transformers) and
+[`deburky/gpt-oss-claude-mlx`](https://huggingface.co/deburky/gpt-oss-claude-mlx)
+(MLX) — override either with `MODEL=...`.
+
 ## Tools
 
 The agent has access to seven tools:
@@ -260,4 +266,8 @@ To clear history: use `/c` in the session, or delete `~/.wrencode/history.json`
 
 ## License
 
-MIT - Copyright 2026 Denis Burakov.
+MIT - Copyright 2026 Almostly.
+
+-----
+
+![Almostly](assets/almostly-badge.svg)

{wrencode-0.1.4 → wrencode-0.1.4.2}/README.md

@@ -32,6 +32,12 @@ saved choice, e.g. for CI.
 The standalone binary can't bundle the heavy ML stack, so the local-weights
 backends (`mlx`, `transformers`) are only offered when running from source.
 
+The default local models are
+[`deburky/gpt-oss-claude-code`](https://huggingface.co/deburky/gpt-oss-claude-code)
+(transformers) and
+[`deburky/gpt-oss-claude-mlx`](https://huggingface.co/deburky/gpt-oss-claude-mlx)
+(MLX) — override either with `MODEL=...`.
+
 ## Tools
 
 The agent has access to seven tools:
@@ -237,4 +243,8 @@ To clear history: use `/c` in the session, or delete `~/.wrencode/history.json`
 
 ## License
 
-MIT - Copyright 2026 Denis Burakov.
+MIT - Copyright 2026 Almostly.
+
+-----
+
+![Almostly](assets/almostly-badge.svg)

{wrencode-0.1.4 → wrencode-0.1.4.2}/pyproject.toml

@@ -9,7 +9,7 @@ description = "A minimal agentic coding assistant in a single Python file"
 readme = "README.md"
 requires-python = ">=3.9"
 license = "MIT"
-authors = [{ name = "Denis Burakov" }]
+authors = [{ name = "Almostly" }]
 keywords = [
     "agent",
     "llm",

{wrencode-0.1.4 → wrencode-0.1.4.2}/wrencode.py

@@ -8,14 +8,17 @@ HuggingFace Transformers, Anthropic, OpenAI, OpenRouter, and local proxy.
 Provides a tool-calling agent loop with file read/write/edit, glob, grep,
 and bash — enough to autonomously navigate and modify a codebase.
 
-Copyright 2026 Denis Burakov. All Rights Reserved.
+Copyright (c) 2026 Almostly
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
-furnished to do so.
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
@@ -29,6 +32,7 @@ THE SOFTWARE.
 # flake8: noqa: E501, E203
 
 import contextlib
+import ast
 import getpass
 import glob as globlib
 import json
@@ -67,7 +71,7 @@ for _dir in (os.path.dirname(os.path.abspath(__file__)), os.getcwd()):
 # -----------------------------------------------------------------------------------------------
 # Backend Configuration
 # -----------------------------------------------------------------------------------------------
-WRENCODE_VERSION = "0.1.4"
+WRENCODE_VERSION = "0.1.4.2"
 
 # Per-backend defaults. "kind" controls how a backend is treated:
 #   api         - hosted HTTP API, needs an API key
@@ -80,42 +84,42 @@ BACKEND_SPECS: dict[str, dict[str, str]] = {
         "model": "claude-haiku-4-5-20251001",
         "key_env": "ANTHROPIC_API_KEY",
         "api_base": "https://api.anthropic.com/v1/messages",
-        "label": "Anthropic Claude  (API key)",
+        "label": "Anthropic Claude (API key)",
     },
     "openai": {
         "kind": "api",
         "model": "gpt-4o-mini",
         "key_env": "OPENAI_API_KEY",
         "api_base": "https://api.openai.com/v1/chat/completions",
-        "label": "OpenAI GPT  (API key)",
+        "label": "OpenAI GPT (API key)",
     },
     "openrouter": {
         "kind": "api",
         "model": "anthropic/claude-3-haiku",
         "key_env": "OPENROUTER_API_KEY",
         "api_base": "https://openrouter.ai/api/v1/chat/completions",
-        "label": "OpenRouter — any model  (API key)",
+        "label": "OpenRouter — any model (API key)",
     },
     "local": {
         "kind": "local-proxy",
         "model": "gpt-oss-20b",
         "key_env": "LOCAL_API_KEY",
-        "label": "Local proxy  (Anthropic-compatible server on localhost)",
+        "label": "Local proxy (Anthropic-compatible server on localhost)",
     },
     "ollama": {
         "kind": "local-proxy",
         "model": "llama3.2",
-        "label": "Ollama  (local models via `ollama serve`)",
+        "label": "Ollama (local models via `ollama serve`)",
     },
     "transformers": {
         "kind": "local-ml",
         "model": "deburky/gpt-oss-claude-code",
-        "label": "HuggingFace Transformers  (CPU/GPU, source install)",
+        "label": "HuggingFace Transformers (CPU/GPU, source install)",
     },
     "mlx": {
         "kind": "local-ml",
-        "model": "mlx-community/Qwen2.5-3B-Instruct-4bit",
-        "label": "Apple Silicon via MLX  (source install)",
+        "model": "deburky/gpt-oss-claude-mlx",
+        "label": "Apple Silicon via MLX (source install)",
     },
 }
 
@@ -191,6 +195,7 @@ MAX_READ_LINES = int(os.environ.get("MAX_READ_LINES", "800"))
 GREP_MAX = int(os.environ.get("GREP_MAX_MATCHES", "80"))
 BASH_TIMEOUT = int(os.environ.get("BASH_TIMEOUT", "120"))
 MAX_OUT = int(os.environ.get("MAX_TOOL_OUTPUT_CHARS", "48000"))
+TOOL_ERROR_REPEAT_LIMIT = int(os.environ.get("TOOL_ERROR_REPEAT_LIMIT", "3"))
 _GLOB_SKIP: set[str] = {
     s
     for s in os.environ.get(
@@ -339,7 +344,7 @@ def edit(args: dict[str, Any]) -> str:
     """Replace a unique string in a file with a new string."""
     path = resolve_tool_path(_require_str(args, "path"))
     old = _require_str(args, "old")
-    new = args.get("new", "")
+    new = str(args.get("new", ""))
     if not path.is_file():
         return f"error: not a file: {path}"
     if path.stat().st_size > MAX_READ_BYTES:
@@ -350,14 +355,27 @@ def edit(args: dict[str, Any]) -> str:
     count = text.count(old)
     if not args.get("all") and count > 1:
         return f"error: old_string appears {count} times (use all=true)"
-    if not confirm(f"Edit {path!r}"):
-        return "cancelled"
-    path.write_text(
-        text.replace(old, str(new))
+    updated = (
+        text.replace(old, new)
         if args.get("all")
-        else text.replace(old, str(new), 1),
-        encoding="utf-8",
+        else text.replace(old, new, 1)
     )
+    if updated == text:
+        return "error: edit produced no change"
+    suffix = path.suffix.lower()
+    if suffix == ".py":
+        try:
+            ast.parse(updated)
+        except SyntaxError as exc:
+            return f"error: edit would make invalid Python: {exc}"
+    elif suffix == ".json":
+        try:
+            json.loads(updated)
+        except json.JSONDecodeError as exc:
+            return f"error: edit would make invalid JSON: {exc}"
+    if not confirm(f"Edit {path!r}"):
+        return "cancelled"
+    path.write_text(updated, encoding="utf-8")
     return "ok"
 
 
@@ -383,9 +401,15 @@ def glob(args: dict[str, Any]) -> str:
 def grep(args: dict[str, Any]) -> str:
     """Search files for a regex pattern using ripgrep."""
     pat = _require_str(args, "pat")
-    root = resolve_tool_path(args.get("path", "."))
-    if not root.is_dir():
-        return f"error: grep path must be a directory: {root}"
+    target_raw = args.get("path", ".")
+    try:
+        target = resolve_tool_path(target_raw)
+    except Exception as exc:
+        return f"error: invalid grep path {target_raw!r}: {exc}"
+    if not target.exists():
+        return f"error: grep path not found: {target}"
+    search_dir = target if target.is_dir() else target.parent
+    scope = "." if target.is_dir() else target.name
     rg = shutil.which("rg")
     grep_bin = shutil.which("grep")
     if not rg and not grep_bin:
@@ -393,14 +417,14 @@ def grep(args: dict[str, Any]) -> str:
     tool = rg or grep_bin
     assert tool is not None  # guaranteed by the check above
     cmd = (
-        [tool, "-n", "--color", "never", "--no-heading", "-e", pat, "."]
+        [tool, "-n", "--color", "never", "--no-heading", "-e", pat, scope]
         if rg
-        else [tool, "-R", "-n", "-I", "--", pat, "."]
+        else [tool, "-R", "-n", "-I", "--", pat, scope]
     )
     try:
         proc = subprocess.run(
             cmd,
-            cwd=str(root),
+            cwd=str(search_dir),
             capture_output=True,
             text=True,
             timeout=90,
@@ -575,9 +599,54 @@ def flatten_content(content: Any) -> str:
     return "\n".join(parts)
 
 
+# Lightweight, language-agnostic code coloring — no pygments, keeps the binary lean.
+_CODE_TOKEN = re.compile(
+    r"(?P<comment>#[^\n]*|//[^\n]*)"
+    r"|(?P<string>\"[^\"\n]*\"|'[^'\n]*'|`[^`\n]*`)"
+    r"|(?P<num>\b\d[\d_.]*\b)"
+    r"|(?P<kw>\b(?:def|class|return|import|from|if|elif|else|for|while|try|except|"
+    r"finally|with|as|in|not|and|or|is|lambda|yield|async|await|pass|break|continue|"
+    r"raise|global|nonlocal|assert|True|False|None|const|let|var|function|export|"
+    r"default|new|this|fn|match|struct|enum|pub|use|mut|public|private|static|void)\b)"
+)
+
+
+def _highlight_code(code: str) -> str:
+    """Apply light ANSI syntax coloring to a code block (best-effort, any language)."""
+
+    def color(m: "re.Match[str]") -> str:
+        g = m.lastgroup
+        if g == "comment":
+            return f"{DIM}{m.group()}{RESET}"
+        if g == "string":
+            return f"{GREEN}{m.group()}{RESET}"
+        if g == "num":
+            return f"{YELLOW}{m.group()}{RESET}"
+        if g == "kw":
+            return f"{BLUE}{m.group()}{RESET}"
+        return m.group()
+
+    return _CODE_TOKEN.sub(color, code)
+
+
 def render_markdown(text: str) -> str:
-    """Render basic markdown bold syntax to terminal bold escape codes."""
-    return re.sub(r"\*\*(.+?)\*\*", f"{BOLD}\\1{RESET}", text)
+    """Render fenced code blocks (lightly highlighted), inline code, and bold."""
+    blocks: list[str] = []
+
+    def stash(m: "re.Match[str]") -> str:
+        lang = m.group(1) or ""
+        body = _highlight_code(m.group(2).rstrip("\n"))
+        head = f"{DIM}┌─ {lang}{RESET}\n" if lang else f"{DIM}┌─{RESET}\n"
+        bordered = "\n".join(f"{DIM}│{RESET} {ln}" for ln in body.split("\n"))
+        blocks.append(f"\n{head}{bordered}\n{DIM}└─{RESET}")
+        return f"\x00B{len(blocks) - 1}\x00"
+
+    text = re.sub(r"```(\w*)\n?(.*?)```", stash, text, flags=re.DOTALL)
+    text = re.sub(r"`([^`\n]+)`", f"{CYAN}\\1{RESET}", text)
+    text = re.sub(r"\*\*(.+?)\*\*", f"{BOLD}\\1{RESET}", text)
+    for i, b in enumerate(blocks):
+        text = text.replace(f"\x00B{i}\x00", b)
+    return text
 
 
 # -----------------------------------------------------------------------------------------------
@@ -631,6 +700,56 @@ def _tool_call_complete(text: str) -> int:
     return last
 
 
+def _balance_json_object(raw: str) -> str:
+    """Best-effort brace balancing for a JSON object string."""
+    depth = 0
+    in_string = False
+    escaped = False
+    for ch in raw:
+        if escaped:
+            escaped = False
+            continue
+        if ch == "\\":
+            escaped = True
+            continue
+        if ch == '"':
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+        if ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+    if depth > 0:
+        raw += "}" * depth
+    return raw
+
+
+def _parse_tool_payload(raw_payload: str) -> Optional[dict[str, Any]]:
+    """Best-effort parse of a <tool_call> payload."""
+    raw = raw_payload.strip()
+    if not raw:
+        return None
+    with contextlib.suppress(Exception):
+        parsed = json.loads(raw)
+        if isinstance(parsed, dict):
+            return parsed
+    with contextlib.suppress(Exception):
+        parsed = json.loads(_balance_json_object(raw))
+        if isinstance(parsed, dict):
+            return parsed
+    with contextlib.suppress(Exception):
+        parsed = ast.literal_eval(raw)
+        if isinstance(parsed, dict):
+            return parsed
+    with contextlib.suppress(Exception):
+        parsed = ast.literal_eval(_balance_json_object(raw))
+        if isinstance(parsed, dict):
+            return parsed
+    return None
+
+
 def parse_tool_calls(text: str) -> list[dict[str, Any]]:
     """Parse all <tool_call> blocks from model output into structured dicts.
 
@@ -641,10 +760,15 @@ def parse_tool_calls(text: str) -> list[dict[str, Any]]:
     """
     calls: list[dict[str, Any]] = []
     pos = 0
-    while (start := text.find("<tool_call>", pos)) != -1:
+    open_tag = "<tool_call>"
+    close_tag = "</tool_call>"
+    while (start := text.find(open_tag, pos)) != -1:
         brace = text.find("{", start)
+        close = text.find(close_tag, start)
         if brace == -1:
-            break
+            # malformed block with no JSON payload; skip and keep scanning
+            pos = close + len(close_tag) if close != -1 else start + len(open_tag)
+            continue
         depth, end = 0, -1
         for i, ch in enumerate(text[brace:], brace):
             if ch == "{":
@@ -654,20 +778,24 @@ def parse_tool_calls(text: str) -> list[dict[str, Any]]:
                 if depth == 0:
                     end = i + 1
                     break
-        if end == -1:
-            break  # JSON not yet complete
-        with contextlib.suppress(Exception):
-            d = json.loads(text[brace:end])
-            if d.get("tool") in TOOLS:
-                calls.append(
-                    {
-                        "type": "tool_use",
-                        "id": f"call_{len(calls)}",
-                        "name": d["tool"],
-                        "input": d.get("args", {}),
-                    }
-                )
-        pos = end
+        payload: Optional[dict[str, Any]] = None
+        if end != -1:
+            payload = _parse_tool_payload(text[brace:end])
+            pos = end
+        elif close != -1 and close > brace:
+            payload = _parse_tool_payload(text[brace:close])
+            pos = close + len(close_tag)
+        else:
+            break  # JSON may still be streaming
+        if payload and payload.get("tool") in TOOLS:
+            calls.append(
+                {
+                    "type": "tool_use",
+                    "id": f"call_{len(calls)}",
+                    "name": payload["tool"],
+                    "input": payload.get("args", {}),
+                }
+            )
     return calls
 
 
@@ -1138,6 +1266,8 @@ def run_agent_turn(
     0 means unlimited, preserving the interactive default.
     """
     iters = 0
+    last_tool_error: Optional[str] = None
+    repeated_tool_error_count = 0
     while True:
         if max_iters and iters >= max_iters:
             print(f"{YELLOW}(stopped after {max_iters} iterations){RESET}")
@@ -1167,6 +1297,7 @@ def run_agent_turn(
             if not tool_calls:
                 break
             tool_results: list[dict[str, Any]] = []
+            stop_due_to_repeated_error = False
             for tc in tool_calls:
                 arg_preview = (
                     str(list(tc["input"].values())[0])[:50]
@@ -1200,10 +1331,27 @@ def run_agent_turn(
                             "content": result,
                         }
                     )
+                if result.startswith("error:"):
+                    if result == last_tool_error:
+                        repeated_tool_error_count += 1
+                    else:
+                        last_tool_error = result
+                        repeated_tool_error_count = 1
+                    if repeated_tool_error_count >= TOOL_ERROR_REPEAT_LIMIT:
+                        print(
+                            f"{YELLOW}Stopping: repeated identical tool error {repeated_tool_error_count} times.{RESET}"
+                        )
+                        stop_due_to_repeated_error = True
+                        break
+                else:
+                    last_tool_error = None
+                    repeated_tool_error_count = 0
             if BACKEND == "anthropic":
                 messages.append({"role": "user", "content": tool_results})
             else:
                 messages.extend(tool_results)
+            if stop_due_to_repeated_error:
+                break
             continue
 
         # XML tool call path (mlx, transformers, openrouter, local)
@@ -1219,6 +1367,7 @@ def run_agent_turn(
             [{"type": "text", "text": display_text}] if display_text else []
         )
         xml_tool_results: list[dict[str, Any]] = []
+        stop_due_to_repeated_error = False
         for tc in xml_tool_calls:
             arg_preview = (
                 str(list(tc["input"].values())[0])[:50] if tc["input"] else ""
@@ -1242,9 +1391,24 @@ def run_agent_turn(
                 }
             )
             content_blocks.append(tc)
+            if result.startswith("error:"):
+                if result == last_tool_error:
+                    repeated_tool_error_count += 1
+                else:
+                    last_tool_error = result
+                    repeated_tool_error_count = 1
+                if repeated_tool_error_count >= TOOL_ERROR_REPEAT_LIMIT:
+                    print(
+                        f"{YELLOW}Stopping: repeated identical tool error {repeated_tool_error_count} times.{RESET}"
+                    )
+                    stop_due_to_repeated_error = True
+                    break
+            else:
+                last_tool_error = None
+                repeated_tool_error_count = 0
 
         messages.append({"role": "assistant", "content": content_blocks})
-        if not xml_tool_results:
+        if stop_due_to_repeated_error or not xml_tool_results:
             break
         messages.append({"role": "user", "content": xml_tool_results})
 
@@ -1486,6 +1650,29 @@ def load_model() -> Optional[tuple[Any, Any]]:
     if BACKEND == "local":
         print(f"{DIM}Local proxy at {API_BASE}{RESET}\n")
         return None
+    if BACKEND == "ollama":
+        base = os.environ.get("OLLAMA_HOST", "http://localhost:11434").rstrip("/")
+        try:
+            with urllib.request.urlopen(f"{base}/api/tags", timeout=3) as r:
+                installed = {
+                    m.get("name", "")
+                    for m in json.loads(r.read().decode()).get("models", [])
+                }
+            want = MODEL if ":" in MODEL else f"{MODEL}:latest"
+            if not (
+                MODEL in installed
+                or want in installed
+                or any(n.split(":")[0] == MODEL for n in installed)
+            ):
+                have = ", ".join(sorted(installed)) or "none"
+                print(f"{YELLOW}⚠ Model '{MODEL}' isn't pulled into Ollama.{RESET}")
+                print(f"{DIM}  Run: ollama pull {MODEL}   (installed: {have}){RESET}")
+        except Exception:
+            print(
+                f"{YELLOW}⚠ Couldn't reach Ollama at {base} — is `ollama serve` running?{RESET}"
+            )
+        print(f"{DIM}{BACKEND} ({MODEL}){RESET}\n")
+        return None
     # Hosted API backends — all require a key.
     if not API_KEY:
         key_env = BACKEND_SPECS[BACKEND]["key_env"]
@@ -1539,6 +1726,7 @@ def main() -> None:
     )
     resolve_configuration(force_chooser=force)
 
+    sys.stdout.write("\033]0;wrencode\007")  # set terminal tab/window title
     print(WREN_BANNER)
     print(f"{BOLD}wrencode{RESET} 🐦 | {DIM}{BACKEND}:{MODEL}{RESET}\n")
     mlx_state = load_model()
@@ -1550,7 +1738,7 @@ def main() -> None:
 
     while True:
         try:
-            user_input = input(f"{BOLD}{BLUE}❯{RESET} ").strip()
+            user_input = input(f"{BRIGHT_CYAN}❯{RESET} ").strip()
             if not user_input:
                 continue
             action = handle_slash_command(user_input, messages, mlx_state)
@@ -1568,8 +1756,17 @@ def main() -> None:
         except EOFError:
             break
         except Exception as err:
-            print(f"{RED}Error: {err}{RESET}")
-            traceback.print_exc()
+            msg = str(err)
+            print(f"{RED}Error: {msg}{RESET}")
+            if BACKEND == "ollama" and ("not found" in msg.lower() or "404" in msg):
+                print(
+                    f"{YELLOW}Model '{MODEL}' isn't pulled. "
+                    f"Run: ollama pull {MODEL}  (or `ollama list`).{RESET}"
+                )
+            if os.environ.get("WRENCODE_DEBUG"):
+                traceback.print_exc()
+            else:
+                print(f"{DIM}(set WRENCODE_DEBUG=1 for the full traceback){RESET}")
 
 
 if __name__ == "__main__":