nanoPyCodeAgent 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

nanopycodeagent/agent.py

@@ -1,106 +1,59 @@
 """A minimal agent loop built on the Anthropic Python SDK.
 
 Run the program, type a message, and Agent replies. The full conversation is
-kept in memory so each turn has context. Type ``/exit`` to quit.
+kept in memory so each turn has context. The model can call a single ``bash``
+tool to run shell commands; every command and its output are echoed to the
+terminal as they happen. Type ``/exit`` to quit.
+
+The loop handles only the happy path: anything unexpected — a network error,
+a Ctrl-C mid-turn — crashes the session, and restarting it is the recovery.
+That trade keeps the core flow readable; the hardened variant it replaced is
+preserved at the ``hardened-agent-loop`` tag.
 """
 
-import json
 import os
-from pathlib import Path
 
 import anthropic
-from anthropic.types import MessageParam
+from anthropic.types import MessageParam, ToolResultBlockParam, ToolUseBlock
 
-# The model used when ANTHROPIC_MODEL is set in neither the environment nor the
-# config file.
+from .bash_tool import BASH_TOOL, run_bash
+from .settings import load_settings_env
+from .terminal import print_tool
+
+# The model used when ANTHROPIC_MODEL is set in neither the environment nor
+# the config file.
 DEFAULT_MODEL = "claude-sonnet-4-6"
 MAX_TOKENS = 8192
-SYSTEM_PROMPT = "You are nanoPyCodeAgent, a concise and helpful coding assistant."
-
-
-# User-level config file. Its ``env`` mapping supplies ANTHROPIC_* values for
-# keys that are not already set in the environment (environment variables win).
-def _default_settings_path() -> Path | None:
-    """Resolve the user-level config path, or ``None`` if home is unknown.
-
-    ``Path.home()`` raises ``RuntimeError`` when the home directory cannot be
-    determined (e.g. ``$HOME`` unset and no passwd entry, common in minimal
-    containers). Guarding it here keeps ``import nanopycodeagent`` — which runs
-    eagerly behind the console script — from crashing at import; a ``None`` path
-    simply means "no user config file".
-    """
-    try:
-        return Path.home() / ".nanoPyCodeAgent" / "settings.json"
-    except RuntimeError:
-        return None
+SYSTEM_PROMPT = (
+    "You are nanoPyCodeAgent, a concise and helpful coding assistant. "
+    "Use the bash tool to inspect files, run code, and complete tasks that "
+    "need real command output instead of guessing."
+)
+
+
+def _run_one_tool(block: ToolUseBlock) -> ToolResultBlockParam:
+    """Execute one ``tool_use`` block, echoing the command and its output."""
+    command = block.input["command"]
+    print_tool(f"[bash]$ {command}")
+    output, is_error = run_bash(command)
+    print_tool(output)
+    return {
+        "type": "tool_result",
+        "tool_use_id": block.id,
+        "content": output,
+        "is_error": is_error,
+    }
 
 
-SETTINGS_PATH = _default_settings_path()
-
-
-def load_settings_env(path: Path | None = None) -> None:
-    """Apply the ``env`` mapping from the config file into ``os.environ``.
-
-    ``path`` defaults to the module-level ``SETTINGS_PATH`` (resolved at call
-    time, so it stays overridable). Only ``ANTHROPIC_*`` keys that are not
-    already present are set, so environment variables take precedence over the
-    config file and unrelated variables are never injected. Behaviour by case:
+def run() -> None:
+    """Start the read → ask → answer loop until the user types ``/exit``.
 
-    - Missing file, or a home directory that cannot be resolved: silently
-      ignored (running without a config file is normal).
-    - Unreadable / non-UTF-8 file, malformed JSON, non-object top level, or a
-      non-object ``env``: a warning is printed and the file is otherwise
-      ignored — a bad config never blocks startup.
-    - Empty, whitespace-only, or non-string values, and values the OS rejects
-      (e.g. an embedded NUL): skipped (the documented example ships these keys
-      as empty-string placeholders).
+    A reply may include bash tool calls; they are executed and their results
+    fed back to the model until it finishes the turn without tool use.
     """
-    if path is None:
-        path = SETTINGS_PATH
-    if path is None:
-        return  # home dir unresolvable → behave as if no config file exists
-    try:
-        raw = path.read_text(encoding="utf-8")
-    except FileNotFoundError:
-        return
-    except (OSError, UnicodeDecodeError) as exc:
-        print(f"Warning: could not read config file {path}: {exc}")
-        return
-
-    try:
-        data = json.loads(raw)
-    except json.JSONDecodeError as exc:
-        print(f"Warning: ignoring malformed config file {path}: {exc}")
-        return
-
-    if not isinstance(data, dict):
-        print(f"Warning: ignoring config file {path}: top level must be an object.")
-        return
-
-    env = data.get("env", {})
-    if not isinstance(env, dict):
-        print(f"Warning: ignoring 'env' in config file {path}: it must be an object.")
-        return
-
-    for key, value in env.items():
-        # Only honor ANTHROPIC_* keys (the config's documented purpose) so a
-        # shared settings.json cannot silently inject unrelated variables such
-        # as HTTPS_PROXY into the process environment.
-        if not key.startswith("ANTHROPIC_"):
-            continue
-        if not (isinstance(value, str) and value.strip()):
-            continue
-        try:
-            os.environ.setdefault(key, value.strip())
-        except ValueError as exc:
-            # e.g. an embedded NUL in the value or '=' in the key name.
-            print(f"Warning: ignoring invalid config entry {key!r}: {exc}")
-
-
-def run() -> None:
-    """Start the read → ask → answer loop until the user types ``/exit``."""
-    # Fill any unset ANTHROPIC_* keys from the config file (environment variables
-    # take precedence), then let the SDK read credentials from os.environ.
+    # Fill any unset ANTHROPIC_* keys from the config file (environment
+    # variables take precedence), then let the SDK read credentials from
+    # os.environ.
     load_settings_env()
     client = anthropic.Anthropic()
     if client.api_key is None and client.auth_token is None:
@@ -113,62 +66,51 @@ def run() -> None:
         )
         return
 
-    # Resolve the model after load_settings_env() so a config-file ANTHROPIC_MODEL
-    # is honored. An empty or whitespace-only value falls back to the default.
-    configured_model = os.environ.get("ANTHROPIC_MODEL", "").strip()
-    model = configured_model or DEFAULT_MODEL
-
-    messages: list[MessageParam] = []
-    if configured_model:
-        print(f"nanoPyCodeAgent — using model {model} (from ANTHROPIC_MODEL).")
-    else:
-        print(
-            f"nanoPyCodeAgent — using default model {model} "
-            "(set ANTHROPIC_MODEL to override)."
-        )
+    model = os.environ.get("ANTHROPIC_MODEL", "").strip() or DEFAULT_MODEL
+    print(f"nanoPyCodeAgent — model {model} (set ANTHROPIC_MODEL to override).")
     print("Type a message to chat, or /exit to quit.")
 
+    messages: list[MessageParam] = []
     while True:
         try:
             user_input = input("\nYou> ").strip()
         except (EOFError, KeyboardInterrupt):
             print()
             break
-
         if not user_input:
             continue
         if user_input == "/exit":
             break
 
         messages.append({"role": "user", "content": user_input})
-
-        try:
+        # The model may ask to run tools; keep streaming replies and feeding
+        # results back until it finishes a reply without tool calls.
+        while True:
             print("\nAgent> ", end="", flush=True)
-            message = client.messages.create(
+            # Stream the reply so text shows up as it is generated, then grab
+            # the accumulated message for the conversation history.
+            with client.messages.stream(
                 model=model,
                 max_tokens=MAX_TOKENS,
                 system=SYSTEM_PROMPT,
+                tools=[BASH_TOOL],
                 messages=messages,
-            )
-            text = "".join(b.text for b in message.content if b.type == "text")
-            print(text, end="", flush=True)
+            ) as stream:
+                for text in stream.text_stream:
+                    print(text, end="", flush=True)
+                message = stream.get_final_message()
             print()
-        except KeyboardInterrupt:
-            # Ctrl-C while waiting on the reply cancels cleanly, mirroring the
-            # graceful quit offered at the input prompt.
-            print()
-            break
-        except anthropic.AuthenticationError:
-            print(
-                "\nAuthentication failed. Check that ANTHROPIC_API_KEY is set correctly."
-            )
-            break
-        except anthropic.APIError as exc:
-            print(f"\nRequest failed: {exc}")
-            messages.pop()  # drop the unanswered user turn so history stays valid
-            continue
 
-        # Append the full content blocks so the next turn carries complete context.
-        messages.append({"role": "assistant", "content": message.content})
+            messages.append({"role": "assistant", "content": message.content})
+            if message.stop_reason != "tool_use":
+                break
+            # Every tool_use block needs a matching tool_result in the next
+            # user message, or the API rejects the request.
+            results = [
+                _run_one_tool(block)
+                for block in message.content
+                if block.type == "tool_use"
+            ]
+            messages.append({"role": "user", "content": results})
 
     print("Bye!")

nanopycodeagent/bash_tool.py

@@ -0,0 +1,77 @@
+"""The ``bash`` tool: its definition and its execution.
+
+Each call runs a command with ``bash -c`` in a fresh shell and returns one
+result string: stdout, then labelled stderr, then the exit code when non-zero.
+"""
+
+import subprocess
+
+from anthropic.types import ToolParam
+
+# Guardrails for the bash tool: a hung command is killed after this many
+# seconds, and results are truncated so one command cannot flood the context.
+BASH_TIMEOUT_SECONDS = 120
+MAX_TOOL_OUTPUT_CHARS = 20_000
+
+BASH_TOOL: ToolParam = {
+    "name": "bash",
+    "description": (
+        "Run a command with `bash -c` on the user's machine and return its "
+        "output: stdout, then stderr (labelled), then the exit code when "
+        "non-zero. Each call is a fresh shell in the agent's working "
+        "directory, so environment variables and `cd` do not persist between "
+        "calls. Long output is truncated and long-running commands are killed "
+        "after a timeout."
+    ),
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "command": {
+                "type": "string",
+                "description": "The bash command to run.",
+            }
+        },
+        "required": ["command"],
+    },
+}
+
+
+def run_bash(command: str) -> tuple[str, bool]:
+    """Run ``command`` with ``bash -c`` and return ``(output, is_error)``.
+
+    ``is_error`` is true only when the tool itself failed — here, a timeout.
+    A command that ran to completion is a successful tool call whatever its
+    exit code: the code is reported in the output text, where the model can
+    tell a negative answer (``grep`` finding nothing) from a failure.
+    Non-UTF-8 output bytes are replaced rather than raising, and stdin is
+    ``/dev/null`` so a command that prompts sees EOF instead of eating the
+    user's keystrokes.
+
+    Known trades for simplicity: a background child inherits the output
+    pipes, so ``some_server &`` blocks until the timeout; the timeout kills
+    bash itself, not necessarily everything it forked; and text mode
+    translates ``\\r`` in output to ``\\n`` (universal newlines).
+    """
+    try:
+        process = subprocess.run(
+            ["bash", "-c", command],
+            capture_output=True,
+            text=True,
+            errors="replace",
+            stdin=subprocess.DEVNULL,
+            timeout=BASH_TIMEOUT_SECONDS,
+        )
+    except subprocess.TimeoutExpired:
+        return f"[command timed out after {BASH_TIMEOUT_SECONDS} seconds]", True
+
+    parts = []
+    if stdout := process.stdout.rstrip("\n"):
+        parts.append(stdout)
+    if stderr := process.stderr.rstrip("\n"):
+        parts.append("[stderr]\n" + stderr)
+    if process.returncode != 0:
+        parts.append(f"[exit code: {process.returncode}]")
+    output = "\n".join(parts) or "(no output)"
+    if len(output) > MAX_TOOL_OUTPUT_CHARS:
+        output = output[:MAX_TOOL_OUTPUT_CHARS] + "\n[... output truncated ...]"
+    return output, False

nanopycodeagent/settings.py

@@ -0,0 +1,35 @@
+"""User-level configuration for nanoPyCodeAgent.
+
+The config file at ``~/.nanoPyCodeAgent/settings.json`` may carry an ``env``
+mapping that supplies ``ANTHROPIC_*`` values for keys that are not already set
+in the environment (environment variables win).
+"""
+
+import json
+import os
+from pathlib import Path
+
+SETTINGS_PATH = Path.home() / ".nanoPyCodeAgent" / "settings.json"
+
+
+def load_settings_env(path: Path | None = None) -> None:
+    """Apply the ``env`` mapping from the config file into ``os.environ``.
+
+    Only ``ANTHROPIC_*`` keys that are not already present are set, so
+    environment variables take precedence over the config file and unrelated
+    variables are never injected. Empty, whitespace-only, and non-string
+    values are skipped (the documented example ships the keys as empty-string
+    placeholders). A missing file is normal; a malformed one raises — fix or
+    delete it.
+    """
+    if path is None:
+        path = SETTINGS_PATH
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        return
+    for key, value in json.loads(raw).get("env", {}).items():
+        if not key.startswith("ANTHROPIC_"):
+            continue
+        if isinstance(value, str) and value.strip():
+            os.environ.setdefault(key, value.strip())

nanopycodeagent/terminal.py

@@ -0,0 +1,29 @@
+"""Background shading for tool activity in the terminal."""
+
+import os
+import sys
+
+# Dark gray from the 256-color palette, so echoed commands and their output
+# read apart from the user's prompts and the model's prose.
+_TOOL_BG = "\x1b[48;5;236m"
+_RESET = "\x1b[0m"
+
+
+def _use_color() -> bool:
+    """Whether to emit ANSI colors: a real terminal, and NO_COLOR unset."""
+    return sys.stdout.isatty() and not os.environ.get("NO_COLOR")
+
+
+def print_tool(text: str) -> None:
+    """Print tool activity (an echoed command or its output) shaded.
+
+    Each line carries its own set-background / erase-to-EOL / reset, so the
+    shading spans the full terminal width and never leaks past a line
+    boundary. Escape sequences inside ``text`` are printed as-is and may
+    disrupt the shading — a cosmetic trade for staying simple.
+    """
+    if _use_color():
+        text = "\n".join(
+            f"{_TOOL_BG}{line}\x1b[K{_RESET}" for line in text.split("\n")
+        )
+    print(text, flush=True)

{nanopycodeagent-0.2.0.dist-info → nanopycodeagent-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanoPyCodeAgent
-Version: 0.2.0
+Version: 0.4.0
 Summary: A nano code agent built from scratch in pure Python.
 Project-URL: Homepage, https://github.com/minixalpha/nanoPyCodeAgent
 Project-URL: Repository, https://github.com/minixalpha/nanoPyCodeAgent

nanopycodeagent-0.4.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+nanopycodeagent/__init__.py,sha256=pYFCw7WNkZsGXbqNLkXituX4iBy86RJ4LKKAr78XwM8,70
+nanopycodeagent/agent.py,sha256=AvfiDvaPVycbA3H_jJhD8DA_gELbcPOxrZWrZfa2hek,4354
+nanopycodeagent/bash_tool.py,sha256=fTaGz4gfFpBykBaw4jyYeKgibOKrIfJMKqBYoBEE4og,2958
+nanopycodeagent/settings.py,sha256=Tn9si3uRTt2IioP4GTYJGuCYVBCyTTJErq9FmuTs0pw,1296
+nanopycodeagent/terminal.py,sha256=ZkRvKbGQGiu7SI8Pe40THVYR1-4CMBEMVEgAH8h8Ytw,995
+nanopycodeagent-0.4.0.dist-info/METADATA,sha256=a0FBbVdPfx9K8zYiGA6fMZh2ZqC6tvFUm2OZTymLeUs,3028
+nanopycodeagent-0.4.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+nanopycodeagent-0.4.0.dist-info/entry_points.txt,sha256=4gU7YNzQaf2RKlOdfebOWYNYIUk2LDoyhu3G4Vgole8,57
+nanopycodeagent-0.4.0.dist-info/licenses/LICENSE,sha256=g24TppoiLdeF_1_-Y7H2H_eOavKseWA5utuK83Vq1sA,1067
+nanopycodeagent-0.4.0.dist-info/RECORD,,

nanopycodeagent-0.2.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-nanopycodeagent/__init__.py,sha256=pYFCw7WNkZsGXbqNLkXituX4iBy86RJ4LKKAr78XwM8,70
-nanopycodeagent/agent.py,sha256=aAY60px0CuXllg3qICFFOz9_iJKIjf2OWWjmo6PDfzk,6628
-nanopycodeagent-0.2.0.dist-info/METADATA,sha256=etl0E9_jsVOXrRHhTD7lcODGNzSY1VjJ5t-LKxP5adE,3028
-nanopycodeagent-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-nanopycodeagent-0.2.0.dist-info/entry_points.txt,sha256=4gU7YNzQaf2RKlOdfebOWYNYIUk2LDoyhu3G4Vgole8,57
-nanopycodeagent-0.2.0.dist-info/licenses/LICENSE,sha256=g24TppoiLdeF_1_-Y7H2H_eOavKseWA5utuK83Vq1sA,1067
-nanopycodeagent-0.2.0.dist-info/RECORD,,