nanoPyCodeAgent 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

nanopycodeagent/agent.py

@@ -1,107 +1,88 @@
 """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 ``read`` tool
+to view files and a ``bash`` tool to run shell commands; every call 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
+from importlib.metadata import PackageNotFoundError, version
 
 import anthropic
-import httpx
-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 .read_tool import READ_TOOL, run_read
+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.
+SYSTEM_PROMPT = (
+    "You are nanoPyCodeAgent, a concise and helpful coding assistant. "
+    "Prefer the read tool for viewing files. Use the bash tool to run "
+    "commands, search with grep, and complete tasks that need real command "
+    "output instead of guessing."
+)
 
-    ``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
+# Every tool offered to the model on each request.
+TOOLS = [READ_TOOL, BASH_TOOL]
 
 
-SETTINGS_PATH = _default_settings_path()
+def _package_version() -> str:
+    """Return the installed package version.
 
-
-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:
-
-    - 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).
+    The version comes from the package metadata written at install time
+    (hatch-vcs derives it from the git tag). When the package is not
+    installed — e.g. the module is run straight from a source checkout —
+    there is no metadata to read, so fall back to a placeholder.
     """
-    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}")
+        return version("nanoPyCodeAgent")
+    except PackageNotFoundError:
+        return "unknown"
+
+
+def _run_one_tool(block: ToolUseBlock) -> ToolResultBlockParam:
+    """Execute one ``tool_use`` block, echoing the call and its output."""
+    if block.name == "read":
+        path = block.input["path"]
+        print_tool(f"[read] {path}")
+        output, is_error = run_read(
+            path,
+            offset=block.input.get("offset", 1),
+            limit=block.input.get("limit"),
+        )
+    else:  # bash — the only other tool offered
+        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,
+    }
 
 
 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.
+    """Start the read → ask → answer loop until the user types ``/exit``.
+
+    A reply may include tool calls; they are executed and their results
+    fed back to the model until it finishes the turn without tool use.
+    """
+    # 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:
@@ -114,36 +95,29 @@ 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 v{_package_version()} — 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)
             # Stream the reply so text shows up as it is generated, then grab
             # the accumulated message for the conversation history.
@@ -151,31 +125,24 @@ def run() -> None:
                 model=model,
                 max_tokens=MAX_TOKENS,
                 system=SYSTEM_PROMPT,
+                tools=TOOLS,
                 messages=messages,
             ) as stream:
                 for text in stream.text_stream:
                     print(text, end="", flush=True)
                 message = stream.get_final_message()
             print()
-        except KeyboardInterrupt:
-            # Ctrl-C while streaming 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, httpx.HTTPError) as exc:
-            # httpx.HTTPError: the SDK wraps transport errors only around the
-            # initial send, so a network failure mid-stream surfaces as a raw
-            # httpx error during iteration rather than an anthropic.APIError.
-            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/read_tool.py

@@ -0,0 +1,176 @@
+"""The ``read`` tool: its definition and its execution.
+
+Each call reads a window of a UTF-8 text file and returns it with 1-based
+line numbers, ``cat -n`` style, plus a continuation hint whenever the
+window stops short of the end of the file.
+"""
+
+import shlex
+from pathlib import Path
+
+from anthropic.types import ToolParam
+
+# Guardrails for the read tool: one call returns at most this many lines and
+# this many characters, whichever is hit first, so a single file cannot flood
+# the context. Truncation happens at line boundaries, never mid-line.
+MAX_READ_LINES = 2_000
+MAX_READ_CHARS = 50_000
+
+# The output caps above only bound what reaches the context; the file itself
+# is read whole, so a byte cap is what bounds memory. It is generous next to
+# the output caps because a small window may sit deep inside a large source
+# file — it only has to keep a multi-gigabyte log from being loaded at all.
+MAX_READ_BYTES = 10_000_000
+
+READ_TOOL: ToolParam = {
+    "name": "read",
+    "description": (
+        "Read a UTF-8 text file and return its content with 1-based line "
+        "numbers, `cat -n` style. Use `offset` (first line to read) and "
+        "`limit` (number of lines) to read a window of a large file. Output "
+        "is capped by line count and character count; a truncated result "
+        "names the range returned, the file's total line count, and the "
+        "offset to continue from. Binary files are rejected. Prefer this "
+        "over `cat`/`sed` in bash for viewing files; use bash for searching "
+        "(grep) and for slicing single lines too long to return."
+    ),
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "path": {
+                "type": "string",
+                "description": (
+                    "Path to the file, absolute or relative to the agent's "
+                    "working directory. A leading ~ is expanded."
+                ),
+            },
+            "offset": {
+                "type": "integer",
+                "description": "1-based line number to start from (default 1).",
+            },
+            "limit": {
+                "type": "integer",
+                "description": (
+                    f"Maximum number of lines to return. Omit to read up to "
+                    f"the {MAX_READ_LINES}-line cap; larger values are "
+                    f"clamped to it."
+                ),
+            },
+        },
+        "required": ["path"],
+    },
+}
+
+
+def run_read(
+    path_str: str, offset: int = 1, limit: int | None = None
+) -> tuple[str, bool]:
+    """Read a window of the file and return ``(output, is_error)``.
+
+    ``is_error`` is true when the tool could not produce a reading: a bad
+    argument, a missing file, a directory or any other non-regular file, a
+    file over the byte cap, a binary file, or a single line over the
+    character cap. Only regular files are opened — a FIFO or a device file
+    would block or never end, and there is no timeout here to escape that.
+    Every error message states what to do next — the file's total line
+    count, a bash command to slice an over-long line — rather than just
+    what failed.
+
+    Content is decoded as UTF-8 with invalid bytes replaced, matching the
+    bash tool's tolerance. The whole file is read into memory: fine for
+    source and config files, and the output caps bound what reaches the
+    context either way. Files over the byte cap are turned away before the
+    read, since the output caps would otherwise apply only after the whole
+    file had already been loaded.
+    """
+    if offset < 1:
+        return f"[invalid offset {offset}: line numbers start at 1]", True
+    if limit is not None and limit < 1:
+        return f"[invalid limit {limit}: must be at least 1]", True
+
+    path = Path(path_str).expanduser()
+    if not path.exists():
+        return f"[file not found: {path_str}]", True
+    if path.is_dir():
+        return f"[{path_str} is a directory, not a file]", True
+    if not path.is_file():
+        # A FIFO blocks until something writes to it and a device file like
+        # /dev/zero never ends. Reading either would hang the session, and
+        # unlike the bash tool there is no timeout to escape it.
+        return f"[{path_str} is not a regular file; read is text-only]", True
+    try:
+        size = path.stat().st_size
+        if size > MAX_READ_BYTES:
+            return (
+                f"[{path_str} is {size} bytes, over the "
+                f"{MAX_READ_BYTES}-byte cap; read loads the whole file into "
+                f"memory, so slice it with bash instead, e.g. with "
+                f"sed -n '1,200p']",
+                True,
+            )
+        data = path.read_bytes()
+    except FileNotFoundError:  # the file went away after the check above
+        return f"[file not found: {path_str}]", True
+    except OSError as exc:
+        return f"[cannot read {path_str}: {exc}]", True
+
+    # Null bytes near the start mark a binary file; a text reading of it
+    # would only waste context.
+    if b"\x00" in data[:8192]:
+        return f"[{path_str} looks like a binary file; read is text-only]", True
+
+    # Split on \n alone, not with splitlines(): that also breaks on \x0c,
+    # \x0b, \x85 and U+2028, which would number the lines differently from
+    # sed, grep -n and the user's editor. A trailing \r is dropped so CRLF
+    # files read like LF ones.
+    lines = [
+        line.removesuffix("\r")
+        for line in data.decode("utf-8", errors="replace").split("\n")
+    ]
+    if lines and lines[-1] == "":
+        lines.pop()  # the newline ending the last line starts no new one
+    total = len(lines)
+    if total == 0:
+        return "(empty file)", False
+    if offset > total:
+        return (
+            f"[offset {offset} is past the end of {path_str} ({total} lines)]",
+            True,
+        )
+
+    max_lines = MAX_READ_LINES if limit is None else min(limit, MAX_READ_LINES)
+    window = lines[offset - 1 : offset - 1 + max_lines]
+
+    # A single line over the character cap cannot be returned whole, and
+    # returning a bare fragment would hide where it came from — point at
+    # bash instead. The path goes into a command the model may run, so it
+    # is the expanded one (quoting would stop the shell from expanding ~),
+    # quoted so spaces and $(...) in a filename cannot reshape the command,
+    # and behind -- so a leading dash cannot read as an option.
+    if len(window[0]) > MAX_READ_CHARS:
+        return (
+            f"[line {offset} is {len(window[0])} characters long, over the "
+            f"{MAX_READ_CHARS}-character cap; slice it with bash instead, "
+            f"e.g. sed -n '{offset}p' -- {shlex.quote(str(path))} "
+            f"| cut -c 1-2000]",
+            True,
+        )
+
+    selected: list[str] = []
+    chars = 0
+    for number, line in enumerate(window, start=offset):
+        rendered = f"{number:6}\t{line}"
+        added = len(rendered) + (1 if selected else 0)  # + the joining newline
+        if selected and chars + added > MAX_READ_CHARS:
+            break
+        selected.append(rendered)
+        chars += added
+
+    last = offset + len(selected) - 1
+    body = "\n".join(selected)
+    if last < total:
+        body += (
+            f"\n[showing lines {offset}-{last} of {total}; "
+            f"continue with offset={last + 1}]"
+        )
+    return body, 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.3.0.dist-info → nanopycodeagent-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanoPyCodeAgent
-Version: 0.3.0
+Version: 0.5.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.5.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+nanopycodeagent/__init__.py,sha256=pYFCw7WNkZsGXbqNLkXituX4iBy86RJ4LKKAr78XwM8,70
+nanopycodeagent/agent.py,sha256=AAOnt1q-6FQgcAOODxHv2iM0UwlbqSnPD8kmtPGPo68,5452
+nanopycodeagent/bash_tool.py,sha256=fTaGz4gfFpBykBaw4jyYeKgibOKrIfJMKqBYoBEE4og,2958
+nanopycodeagent/read_tool.py,sha256=4AddoZ8uHGzPNKMFagrskjmOWv5nhpk3oJbG8eBBgcM,7374
+nanopycodeagent/settings.py,sha256=Tn9si3uRTt2IioP4GTYJGuCYVBCyTTJErq9FmuTs0pw,1296
+nanopycodeagent/terminal.py,sha256=ZkRvKbGQGiu7SI8Pe40THVYR1-4CMBEMVEgAH8h8Ytw,995
+nanopycodeagent-0.5.0.dist-info/METADATA,sha256=Bep9XESPN7PJ34J9zPvh4YtXdfQ1h2Yeh1Ht5uZdG9E,3028
+nanopycodeagent-0.5.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+nanopycodeagent-0.5.0.dist-info/entry_points.txt,sha256=4gU7YNzQaf2RKlOdfebOWYNYIUk2LDoyhu3G4Vgole8,57
+nanopycodeagent-0.5.0.dist-info/licenses/LICENSE,sha256=g24TppoiLdeF_1_-Y7H2H_eOavKseWA5utuK83Vq1sA,1067
+nanopycodeagent-0.5.0.dist-info/RECORD,,

nanopycodeagent-0.3.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-nanopycodeagent/__init__.py,sha256=pYFCw7WNkZsGXbqNLkXituX4iBy86RJ4LKKAr78XwM8,70
-nanopycodeagent/agent.py,sha256=ceIw3HuZD3UHPtyxS3eGbfOE6FrKABcGybFIyOMrcmU,7074
-nanopycodeagent-0.3.0.dist-info/METADATA,sha256=BJqRCUQaABx8q8-MKeMKKkBqUgx-CS6KGvvguADFcPY,3028
-nanopycodeagent-0.3.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-nanopycodeagent-0.3.0.dist-info/entry_points.txt,sha256=4gU7YNzQaf2RKlOdfebOWYNYIUk2LDoyhu3G4Vgole8,57
-nanopycodeagent-0.3.0.dist-info/licenses/LICENSE,sha256=g24TppoiLdeF_1_-Y7H2H_eOavKseWA5utuK83Vq1sA,1067
-nanopycodeagent-0.3.0.dist-info/RECORD,,