nanoPyCodeAgent 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

nanopycodeagent/agent.py

@@ -2,8 +2,10 @@
 
 Run the program, type a message, and Agent replies. The full conversation is
 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.
+to view files, a ``write`` tool to create or overwrite them, an ``edit``
+tool to replace part of one, 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.
@@ -28,9 +30,11 @@ import anthropic
 from anthropic.types import MessageParam, ToolResultBlockParam, ToolUseBlock
 
 from .bash_tool import BASH_TOOL, run_bash
+from .edit_tool import EDIT_TOOL, edit_preview, run_edit
 from .read_tool import READ_TOOL, run_read
 from .settings import load_settings_env
-from .terminal import print_tool
+from .terminal import Spinner, print_tool_output, print_tool_use
+from .write_tool import WRITE_TOOL, content_preview, run_write
 
 # The model used when ANTHROPIC_MODEL is set in neither the environment nor
 # the config file.
@@ -38,13 +42,15 @@ DEFAULT_MODEL = "claude-sonnet-4-6"
 MAX_TOKENS = 8192
 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."
+    "Prefer the read tool for viewing files, the edit tool for changing "
+    "part of an existing file, and the write tool for creating files or "
+    "rewriting them whole. Use the bash tool to run commands, search with "
+    "grep, and complete tasks that need real command output instead of "
+    "guessing."
 )
 
 # Every tool offered to the model on each request.
-TOOLS = [READ_TOOL, BASH_TOOL]
+TOOLS = [READ_TOOL, WRITE_TOOL, EDIT_TOOL, BASH_TOOL]
 
 
 def _package_version() -> str:
@@ -65,17 +71,35 @@ 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}")
+        print_tool_use(f"[read] {path}")
         output, is_error = run_read(
             path,
             offset=block.input.get("offset", 1),
             limit=block.input.get("limit"),
         )
+    elif block.name == "write":
+        path = block.input["path"]
+        content = block.input["content"]
+        # The echo folds the content: the terminal shows where the write
+        # goes and how it starts, not hundreds of lines.
+        print_tool_use(f"[write] {path}\n{content_preview(content)}")
+        output, is_error = run_write(path, content)
+    elif block.name == "edit":
+        path = block.input["path"]
+        old_text = block.input["old_text"]
+        new_text = block.input["new_text"]
+        # The echo folds both sides into a small -/+ diff: the terminal
+        # shows what is being swapped, not the whole strings again.
+        print_tool_use(f"[edit] {path}\n{edit_preview(old_text, new_text)}")
+        output, is_error = run_edit(
+            path, old_text, new_text, replace_all=block.input.get("replace_all", False)
+        )
     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)
+        print_tool_use(f"[bash]$ {command}")
+        with Spinner("Running..."):
+            output, is_error = run_bash(command)
+    print_tool_output(output)
     return {
         "type": "tool_result",
         "tool_use_id": block.id,
@@ -132,10 +156,13 @@ def run() -> None:
         # 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)
+            # A spinner marks the wait for the reply; the first streamed
+            # token replaces it with the Agent> prompt. A tool-only reply
+            # streams no text, so the prompt is skipped for it entirely.
+            replied = False
             # Stream the reply so text shows up as it is generated, then grab
             # the accumulated message for the conversation history.
-            with client.messages.stream(
+            with Spinner() as spinner, client.messages.stream(
                 model=model,
                 max_tokens=MAX_TOKENS,
                 system=SYSTEM_PROMPT,
@@ -143,9 +170,14 @@ def run() -> None:
                 messages=messages,
             ) as stream:
                 for text in stream.text_stream:
+                    if not replied:
+                        spinner.stop()
+                        print("\nAgent> ", end="", flush=True)
+                        replied = True
                     print(text, end="", flush=True)
                 message = stream.get_final_message()
-            print()
+            if replied:
+                print()
 
             messages.append({"role": "assistant", "content": message.content})
             if message.stop_reason != "tool_use":

nanopycodeagent/edit_tool.py

@@ -0,0 +1,260 @@
+"""The ``edit`` tool: its definition and its execution.
+
+Each call replaces one exact stretch of an existing UTF-8 text file, so a
+small change costs a small message: the model sends the old text and the
+new text instead of regenerating the whole file the way ``write`` needs it
+to. The old text doubles as a precondition — it has to be present, and by
+default exactly once — so an edit fails loudly when the file has moved on,
+where a whole-file overwrite would silently bury the change.
+
+Matching is exact. The only conversions applied to the model's input are
+the UTF-8 BOM and, for a CRLF file, a single LF→CRLF retry; both are
+forced by what ``read`` shows the model, both are stated in the tool
+description, and neither widens the match beyond the literal it was given.
+There is no regex, whitespace, indentation or similarity fallback: with no
+approval step between the match and the write, a fuzzy hit would let the
+tool change more than the model asked for and report success.
+"""
+
+import shlex
+from pathlib import Path
+
+from anthropic.types import ToolParam
+
+from .read_tool import MAX_READ_BYTES
+
+# The terminal echo folds each side of the edit to this many lines, and any
+# one line to this many characters. The full strings are already in the
+# model's tool input, so the echo only has to show what is being swapped.
+EDIT_PREVIEW_LINES = 6
+EDIT_PREVIEW_LINE_CHARS = 200
+
+EDIT_TOOL: ToolParam = {
+    "name": "edit",
+    "description": (
+        "Replace an exact stretch of text in an existing UTF-8 text file. "
+        "Prefer this over write for changing part of a file: only the old "
+        "and new text travel, and the rest of the file is left untouched. "
+        "Use write to create a file or rewrite it whole, and bash to "
+        "transform many files at once. The match is literal, not a regex, "
+        "and must be unique unless replace_all is set; nothing is trimmed, "
+        "re-indented or fuzzily matched, so a call that does not match "
+        "fails instead of guessing a place to edit. The two exceptions are "
+        "the UTF-8 BOM and line endings: in a CRLF file, a multi-line "
+        "old_text written with plain newlines still matches and is written "
+        "back with CRLF. On failure, read the file again rather than "
+        "resending the same call."
+    ),
+    "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. The file "
+                    "must already exist."
+                ),
+            },
+            "old_text": {
+                "type": "string",
+                "description": (
+                    "The text to replace, copied from the file character "
+                    "for character — without read's line-number prefix. Two "
+                    "to four lines are usually enough to be unique; add "
+                    "surrounding lines when they are not."
+                ),
+            },
+            "new_text": {
+                "type": "string",
+                "description": (
+                    "The replacement text. An empty string deletes old_text "
+                    "exactly, taking nothing else with it."
+                ),
+            },
+            "replace_all": {
+                "type": "boolean",
+                "description": (
+                    "Replace every occurrence instead of requiring a unique "
+                    "one (default false). Use it only when every identical "
+                    "occurrence should change, e.g. renaming a local "
+                    "variable."
+                ),
+            },
+        },
+        "required": ["path", "old_text", "new_text"],
+    },
+}
+
+
+def _to_crlf(text: str) -> str:
+    """Return ``text`` with every line ending written as CRLF."""
+    return text.replace("\r\n", "\n").replace("\n", "\r\n")
+
+
+def _fold(text: str, marker: str) -> str:
+    """Fold one side of an edit into a few marked, length-capped lines."""
+    if not text:
+        return ""
+    lines = text.split("\n")
+    if lines and lines[-1] == "":
+        lines.pop()  # the newline ending the last line starts no new one
+    shown = [
+        line
+        if len(line) <= EDIT_PREVIEW_LINE_CHARS
+        else line[:EDIT_PREVIEW_LINE_CHARS] + "..."
+        for line in lines[:EDIT_PREVIEW_LINES]
+    ]
+    hidden = len(lines) - len(shown)
+    if hidden > 0:
+        shown.append(f"... (+{hidden} more lines)")
+    return "\n".join(f"{marker} {line}" for line in shown)
+
+
+def edit_preview(old_text: str, new_text: str) -> str:
+    """Fold both sides of an edit into a small ``-``/``+`` diff for the echo.
+
+    A deletion shows only the removed side, so an empty ``new_text`` reads
+    as a removal rather than as a swap for nothing.
+    """
+    sides = (_fold(old_text, "-"), _fold(new_text, "+"))
+    return "\n".join(side for side in sides if side)
+
+
+def _match(text: str, old_text: str, new_text: str) -> tuple[str, str, int, bool]:
+    """Locate ``old_text`` in ``text``; return what to use and how often.
+
+    The first pass is a raw exact search. Only when it finds nothing does a
+    single CRLF pass follow, and only for the case that makes it necessary:
+    ``read`` drops the ``\\r`` of a CRLF file when it shows it, so a
+    multi-line ``old_text`` copied out of that view can hold LF alone —
+    the model cannot produce the file's real bytes. An ``old_text`` that
+    does carry ``\\r`` is taken at its word and gets the raw pass only.
+
+    The two passes are never merged: whichever one matches decides both
+    uniqueness and the replacement count, so there is no way for hits in
+    different encodings to overlap or to be counted twice. In a file with
+    mixed line endings that means one call reaches one style and the other
+    fails closed, which the caller's error message says out loud.
+
+    Returns ``(old, new, count, crlf_pass_ran)``.
+    """
+    count = text.count(old_text)
+    if count:
+        return old_text, new_text, count, False
+    if "\r\n" in text and "\n" in old_text and "\r" not in old_text:
+        old_crlf = _to_crlf(old_text)
+        return old_crlf, _to_crlf(new_text), text.count(old_crlf), True
+    return old_text, new_text, 0, False
+
+
+def run_edit(
+    path_str: str, old_text: str, new_text: str, replace_all: bool = False
+) -> tuple[str, bool]:
+    """Replace ``old_text`` with ``new_text`` and return ``(output, is_error)``.
+
+    The file has to exist and be a regular UTF-8 text file: creating one and
+    rewriting one whole are ``write``'s job, and an empty ``old_text`` is
+    refused rather than quietly becoming either. ``is_error`` is true for a
+    bad argument, a missing or unreadable target, a file this tool cannot
+    round-trip byte for byte, no match, or an ambiguous match. Every error
+    says what to do next — read again, add context, set ``replace_all``,
+    fall back to bash — instead of only what failed.
+
+    Invalid UTF-8 and NUL bytes are refused: ``read`` shows those files with
+    replacement characters so they can be inspected, and writing that view
+    back would corrupt the original bytes for good. A UTF-8 BOM is stripped
+    before matching and restored on write, since ``read`` leaves it in place
+    and an invisible character would otherwise break every ``old_text``
+    aimed at the first line.
+
+    The write is a plain read-compute-write, like ``write``'s: no mtime
+    check, no compare-and-swap, no atomic replace. The unique ``old_text``
+    is the precondition; in this agent's single-threaded loop the rest
+    would be pretend safety.
+    """
+    if not old_text:
+        return (
+            "[old_text is empty; use write to create a file or replace it whole]",
+            True,
+        )
+    if old_text == new_text:
+        return "[old_text and new_text are identical: nothing to change]", True
+
+    path = Path(path_str).expanduser()
+    if not path.exists():
+        return f"[file not found: {path_str}; use write to create it]", True
+    if path.is_dir():
+        return f"[{path_str} is a directory, not a file]", True
+    if not path.is_file():
+        # Same reasoning as read's and write's: a FIFO blocks until the other
+        # end shows up, and a device file is not workspace text.
+        return f"[{path_str} is not a regular file; edit is text-only]", True
+    try:
+        size = path.stat().st_size
+        if size > MAX_READ_BYTES:
+            return (
+                f"[{path_str} is {size} bytes, over the {MAX_READ_BYTES}-byte "
+                f"cap; edit rewrites the whole file in memory, so change it "
+                f"with bash instead, e.g. with sed -i]",
+                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
+
+    # Unlike read, which samples the head to spot a binary file, edit has to
+    # scan all of it: a NUL anywhere would come back through the round-trip.
+    if b"\x00" in data:
+        return f"[{path_str} contains NUL bytes; edit is text-only]", True
+    try:
+        text = data.decode("utf-8")  # strict: no replacement characters
+    except UnicodeDecodeError as exc:
+        return (
+            f"[{path_str} is not valid UTF-8: {exc}; edit only changes text "
+            f"it can write back byte for byte — use bash instead]",
+            True,
+        )
+
+    bom = text.startswith("\ufeff")
+    if bom:
+        text = text[1:]
+
+    old, new, count, crlf_pass_ran = _match(text, old_text, new_text)
+    if count == 0:
+        retried = " — the CRLF form was already tried" if crlf_pass_ran else ""
+        return (
+            f"[no match for old_text in {path_str}; read the file again and "
+            f"copy the text exactly{retried}]",
+            True,
+        )
+    if count > 1 and not replace_all:
+        return (
+            f"[old_text matches {count} times in {path_str}; add surrounding "
+            f"context to make it unique, or set replace_all=true]",
+            True,
+        )
+
+    # str.replace walks left to right over non-overlapping matches, the same
+    # ones str.count reported, so the count above is what actually changes.
+    line = text.count("\n", 0, text.index(old)) + 1
+    edited = text.replace(old, new) if replace_all else text.replace(old, new, 1)
+    try:
+        path.write_bytes(("\ufeff" + edited if bom else edited).encode("utf-8"))
+    except OSError as exc:
+        return (
+            f"[cannot write {path_str}: {exc}; inspect it with bash, e.g. "
+            f"ls -l -- {shlex.quote(str(path))}]",
+            True,
+        )
+
+    replaced = count if replace_all else 1
+    if replaced == 1:
+        return f"[edited {path_str}: replaced 1 occurrence at line {line}]", False
+    return (
+        f"[edited {path_str}: replaced {replaced} occurrences, "
+        f"first at line {line}]",
+        False,
+    )

nanopycodeagent/terminal.py

@@ -1,11 +1,17 @@
-"""Background shading for tool activity in the terminal."""
+"""Terminal presentation: tool-activity shading and a wait spinner."""
 
+import itertools
 import os
 import sys
+import threading
 
-# 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"
+# Grays from the 256-color palette. The echoed call sits on a lighter shade
+# than its output so the two read apart at a glance, and both read apart
+# from the user's prompts and the model's prose. The output keeps the
+# darker shade: it stays subdued while remaining visible on common dark
+# terminal backgrounds.
+_USE_BG = "\x1b[48;5;238m"
+_OUTPUT_BG = "\x1b[48;5;236m"
 _RESET = "\x1b[0m"
 
 
@@ -14,8 +20,8 @@ def _use_color() -> bool:
     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.
+def _print_shaded(text: str, bg: str) -> None:
+    """Print ``text`` with every line shaded in ``bg``.
 
     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
@@ -23,7 +29,68 @@ def print_tool(text: str) -> None:
     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")
-        )
+        text = "\n".join(f"{bg}{line}\x1b[K{_RESET}" for line in text.split("\n"))
     print(text, flush=True)
+
+
+def print_tool_use(text: str) -> None:
+    """Print an echoed tool call (e.g. ``[bash]$ ls``) on the lighter shade."""
+    _print_shaded(text, _USE_BG)
+
+
+def print_tool_output(text: str) -> None:
+    """Print a tool's output on the darker shade."""
+    _print_shaded(text, _OUTPUT_BG)
+
+
+# The classic braille "dots" spinner: one glyph per frame, different dots
+# raised in each, cycled fast enough to read as rotation.
+_SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+_SPINNER_INTERVAL = 0.08
+
+
+class Spinner:
+    """Animate ``⠋ Working...`` in place on one line until stopped.
+
+    A background thread redraws the line with carriage returns while the
+    caller blocks on slow work, and erases it on stop, so the spinner
+    leaves no trace in the transcript. When stdout is not a terminal (or
+    NO_COLOR is set) nothing is printed at all. ``stop`` is idempotent:
+    stopping early — say, when the first streamed token arrives — and
+    again on context-manager exit is fine.
+    """
+
+    def __init__(self, text: str = "Working..."):
+        self._text = text
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        if not _use_color():
+            return
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        if self._thread is None:
+            return
+        self._stop_event.set()
+        self._thread.join()
+
+    def __enter__(self) -> "Spinner":
+        self.start()
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.stop()
+
+    def _spin(self) -> None:
+        # Draw a frame, then sleep on the stop event so stop() interrupts
+        # the pause instead of waiting out the full interval.
+        for frame in itertools.cycle(_SPINNER_FRAMES):
+            sys.stdout.write(f"\r{frame} {self._text}")
+            sys.stdout.flush()
+            if self._stop_event.wait(_SPINNER_INTERVAL):
+                break
+        sys.stdout.write("\r\x1b[K")  # erase the spinner line
+        sys.stdout.flush()

nanopycodeagent/write_tool.py

@@ -0,0 +1,153 @@
+"""The ``write`` tool: its definition and its execution.
+
+Each call writes a whole UTF-8 text file from a structured
+``{path, content}`` input: the content lands on disk as data, never
+passing through shell expansion, heredoc delimiters or quoting, which is
+what makes a heredoc silently corrupt a file while exiting 0.
+"""
+
+import shlex
+from pathlib import Path
+
+from anthropic.types import ToolParam
+
+# The terminal echo folds the content to this many lines, and any one line
+# to this many characters, so a large write does not flood the terminal the
+# way the heredoc it replaces would. The full content reaches the file (and
+# the model already holds it); only the echo is folded.
+WRITE_PREVIEW_LINES = 10
+WRITE_PREVIEW_LINE_CHARS = 200
+
+WRITE_TOOL: ToolParam = {
+    "name": "write",
+    "description": (
+        "Write a UTF-8 text file: create it if missing (parent directories "
+        "included), or replace its entire content if it exists. The result "
+        "says which of the two happened. Use this for new files and "
+        "whole-file rewrites instead of shell redirection or heredocs; use "
+        "bash to append or to transform many files at once. The write is a "
+        "plain overwrite — last writer wins, with no check that the file "
+        "was read first or is unchanged since."
+    ),
+    "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."
+                ),
+            },
+            "content": {
+                "type": "string",
+                "description": (
+                    "The complete file content, written exactly as given — "
+                    "no newline or whitespace normalization."
+                ),
+            },
+        },
+        "required": ["path", "content"],
+    },
+}
+
+
+def _logical_lines(content: str) -> list[str]:
+    """Split ``content`` into the lines read would number.
+
+    The split is on ``\\n`` alone, and the newline ending the last line
+    starts no new one — so ``"a\\nb\\n"`` is two lines, not three.
+    """
+    lines = content.split("\n")
+    if lines and lines[-1] == "":
+        lines.pop()
+    return lines
+
+
+def content_preview(content: str) -> str:
+    """Fold ``content`` for the terminal echo of a write call.
+
+    The first few lines are shown, over-long lines are cut short, and a
+    closing note counts the hidden lines, so the echo reads as "where the
+    write goes and how it starts" rather than the whole file.
+    """
+    lines = _logical_lines(content)
+    if not lines:
+        return "(empty)"
+    shown = [
+        line
+        if len(line) <= WRITE_PREVIEW_LINE_CHARS
+        else line[:WRITE_PREVIEW_LINE_CHARS] + "..."
+        for line in lines[:WRITE_PREVIEW_LINES]
+    ]
+    hidden = len(lines) - len(shown)
+    if hidden > 0:
+        shown.append(f"... (+{hidden} more lines)")
+    return "\n".join(shown)
+
+
+def run_write(path_str: str, content: str) -> tuple[str, bool]:
+    """Write ``content`` to the file whole and return ``(output, is_error)``.
+
+    The file is created when missing — parent directories included — and
+    replaced entirely when it exists; the result names which of the two
+    happened, plus the byte and line counts the model can check its intent
+    against. ``is_error`` is true when the target is a directory or any
+    other non-regular file, or when the write itself fails. A FIFO is
+    refused because opening one for writing blocks until a reader appears,
+    with no timeout here to escape that; a device file is refused because
+    writing to one changes the machine, not the workspace. A symlink to a
+    regular file is followed: the write lands in its target.
+
+    Content is encoded as UTF-8 and written as given — no newline or
+    whitespace normalization, no trailing-newline fix-up. The write is a
+    plain overwrite: nothing checks that the file was read first or is
+    unchanged since, and there is no atomic-replace step. In this agent's
+    single-threaded loop those guards would only be pretend safety, so the
+    semantics are stated plainly instead: last writer wins.
+    """
+    path = Path(path_str).expanduser()
+    if path.is_dir():
+        return (
+            f"[{path_str} is a directory, not a file; give a path to a file "
+            f"inside it]",
+            True,
+        )
+    existed = path.exists()
+    if existed and not path.is_file():
+        # Opening a FIFO for writing blocks until a reader shows up, and a
+        # device file must not be overwritten as if it were text. Same
+        # check as read's, from the writing side.
+        return (
+            f"[{path_str} is not a regular file; write refuses FIFOs and "
+            f"device files — if it really is the target, write it with "
+            f"bash, whose timeout escapes a blocked open]",
+            True,
+        )
+    try:
+        data = content.encode("utf-8")
+    except UnicodeEncodeError as exc:
+        # A lone surrogate cannot reach disk as UTF-8; writing a replacement
+        # instead would corrupt the file silently — the heredoc failure mode
+        # this tool exists to remove.
+        return f"[content is not encodable as UTF-8: {exc}; resend it]", True
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(data)
+    except OSError as exc:
+        # ``exc`` names the OS reason — permission denied, a file sitting
+        # in the parent path, a full disk. The hint points at the usual
+        # first suspect, following read's bash-hint conventions: expanded
+        # path, quoted, behind -- so it cannot read as an option.
+        return (
+            f"[cannot write {path_str}: {exc}; inspect the parent with "
+            f"bash, e.g. ls -ld -- {shlex.quote(str(path.parent))}]",
+            True,
+        )
+
+    verb = "overwrote" if existed else "created"
+    return (
+        f"[{verb} {path_str}: {len(data)} bytes, "
+        f"{len(_logical_lines(content))} lines]",
+        False,
+    )

{nanopycodeagent-0.5.1.dist-info → nanopycodeagent-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: nanoPyCodeAgent
-Version: 0.5.1
+Version: 0.7.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.7.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+nanopycodeagent/__init__.py,sha256=pYFCw7WNkZsGXbqNLkXituX4iBy86RJ4LKKAr78XwM8,70
+nanopycodeagent/agent.py,sha256=FFRhra91Du9DOyir-3NSOwj4uI6JVsTqitdXH3pBPwc,7893
+nanopycodeagent/bash_tool.py,sha256=fTaGz4gfFpBykBaw4jyYeKgibOKrIfJMKqBYoBEE4og,2958
+nanopycodeagent/edit_tool.py,sha256=eOK-yREnkIKwgTZqsFy0y7N9iRCyC2JFzM1LBCRInQ0,11131
+nanopycodeagent/read_tool.py,sha256=4AddoZ8uHGzPNKMFagrskjmOWv5nhpk3oJbG8eBBgcM,7374
+nanopycodeagent/settings.py,sha256=Tn9si3uRTt2IioP4GTYJGuCYVBCyTTJErq9FmuTs0pw,1296
+nanopycodeagent/terminal.py,sha256=jSe0CXayttR25RBt_qmCsFURVDW0uha391hBKgW3XwQ,3340
+nanopycodeagent/write_tool.py,sha256=dnHoNGT6HpQvJXQvxXPQcS4yBTtfwCkSV4hLAn9_YgY,6168
+nanopycodeagent-0.7.0.dist-info/METADATA,sha256=c-rPxaUijIsCE2aI9Xg7-NAXwiMYfr_Uxad6sG5-Ec8,3028
+nanopycodeagent-0.7.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+nanopycodeagent-0.7.0.dist-info/entry_points.txt,sha256=4gU7YNzQaf2RKlOdfebOWYNYIUk2LDoyhu3G4Vgole8,57
+nanopycodeagent-0.7.0.dist-info/licenses/LICENSE,sha256=g24TppoiLdeF_1_-Y7H2H_eOavKseWA5utuK83Vq1sA,1067
+nanopycodeagent-0.7.0.dist-info/RECORD,,

{nanopycodeagent-0.5.1.dist-info → nanopycodeagent-0.7.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.31.0
+Generator: hatchling 1.32.0
 Root-Is-Purelib: true
 Tag: py3-none-any

nanopycodeagent-0.5.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-nanopycodeagent/__init__.py,sha256=pYFCw7WNkZsGXbqNLkXituX4iBy86RJ4LKKAr78XwM8,70
-nanopycodeagent/agent.py,sha256=vGu7Nry0wCd_DQr2024vxkSuyFwR7Wwp5U-BZz-3U4Y,6157
-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.1.dist-info/METADATA,sha256=Z4OVaX6JxPWB3Gg2qpamtUBShim2D35epNKKNorIIN8,3028
-nanopycodeagent-0.5.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-nanopycodeagent-0.5.1.dist-info/entry_points.txt,sha256=4gU7YNzQaf2RKlOdfebOWYNYIUk2LDoyhu3G4Vgole8,57
-nanopycodeagent-0.5.1.dist-info/licenses/LICENSE,sha256=g24TppoiLdeF_1_-Y7H2H_eOavKseWA5utuK83Vq1sA,1067
-nanopycodeagent-0.5.1.dist-info/RECORD,,