nanocode-cli 0.2.1__tar.gz → 0.2.2__tar.gz

{nanocode_cli-0.2.1/nanocode_cli.egg-info → nanocode_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.2.1
+Version: 0.2.2
 Summary: A lightweight terminal-based AI coding assistant
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause

{nanocode_cli-0.2.1 → nanocode_cli-0.2.2}/nanocode.py

@@ -41,7 +41,7 @@ from prompt_toolkit.patch_stdout import patch_stdout
 
 JsonValue: TypeAlias = Any
 Json: TypeAlias = dict[str, JsonValue]
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 
 class Error(Exception): ...
@@ -524,6 +524,7 @@ class ToolCallExecution:
     output: str
     result_file: str
     result_file_lines: int
+    log_written: bool = True
 
 
 ConfirmationResult: TypeAlias = bool | str
@@ -565,6 +566,8 @@ def _range_fingerprint(content: str) -> str:
 @final
 @dataclass
 class ReadTool(Tool):
+    MAX_LINES: ClassVar[int] = 1000
+
     filepath: str = ""
     start: int = 0
     end: int = 0
@@ -580,7 +583,8 @@ class ReadTool(Tool):
         return [
             "Read exact file lines with a fingerprint.",
             "Optional range is 0-based [start,end); end=0 means EOF.",
-            "Prefer bounded reads over full-file reads; use LineCount first when unsure.",
+            "Returns at most 1000 lines; truncated results include total lines and next-step guidance.",
+            "Prefer Search before Read for large or unknown files; use bounded reads when exact context is needed.",
             "For ReplaceRange, call Read with the exact same filepath/start/end and reuse that range fingerprint.",
         ]
 
@@ -607,26 +611,64 @@ class ReadTool(Tool):
         return f"Read({self.filepath}, {self.start}, {self.end})"
 
     def call(self) -> str:
-        with open(self.filepath, "r", encoding="utf-8") as f:
-            lines = itertools.islice(f, self.start, self.end or None)
-            content = "".join(lines)
+        total_lines = 0
+        selected_lines = []
+        truncated = False
+        bounded_read_lines = self.end - self.start if self.end else 0
+        if self.end and bounded_read_lines <= self.MAX_LINES:
+            with open(self.filepath, "r", encoding="utf-8") as f:
+                selected_lines = list(itertools.islice(f, self.start, self.end))
+        else:
+            with open(self.filepath, "r", encoding="utf-8") as f:
+                for index, line in enumerate(f):
+                    total_lines = index + 1
+                    if index < self.start:
+                        continue
+                    if self.end and index >= self.end:
+                        continue
+                    if len(selected_lines) < self.MAX_LINES:
+                        selected_lines.append(line)
+                        continue
+                    truncated = True
+        content = "".join(selected_lines)
+        returned_end = self.start + len(selected_lines)
+        fingerprint_end = returned_end if truncated else self.end
         fingerprint = self.range_fingerprints.remember(
             filepath=self.filepath,
             start=self.start,
-            end=self.end,
+            end=fingerprint_end,
             content=content,
         )
-        return "\n".join(
+        lines = [
+            "<ReadToolResult>",
+            "  <range>" + str(self.start) + ":" + str(fingerprint_end) + "</range>",
+            "  <fingerprint>" + fingerprint + "</fingerprint>",
+        ]
+        if truncated:
+            lines.extend(
+                [
+                    "  <truncated>true</truncated>",
+                    "  <total_lines>" + str(total_lines) + "</total_lines>",
+                    "  <note>Read returned "
+                    + str(len(selected_lines))
+                    + " lines from "
+                    + str(self.start)
+                    + ":"
+                    + str(returned_end)
+                    + " of "
+                    + str(total_lines)
+                    + " total lines. Use Search to locate relevant text or Read smaller ranges in batches.</note>",
+                ]
+            )
+        lines.extend(
             [
-                "<ReadToolResult>",
-                "  <range>" + str(self.start) + ":" + str(self.end) + "</range>",
-                "  <fingerprint>" + fingerprint + "</fingerprint>",
                 "  <content no-indention>",
                 content,
                 "  </content>",
                 "</ReadToolResult>",
             ]
         )
+        return "\n".join(lines)
 
 
 @final
@@ -687,18 +729,19 @@ class ListDirTool(Tool):
 
     @classmethod
     def signature(cls) -> str:
-        return "ListDir(dir_path[, glob_pattern]) -> ListDirToolResult<entries>"
+        return 'ListDir(dir_path?: "."[, glob_pattern]) -> ListDirToolResult<entries>'
 
     @classmethod
     def example(cls) -> list[str]:
-        return ['Example args: ["."]', 'Example args: ["src", "*.py"]']
+        return ['Example args: []', 'Example args: ["."]', 'Example args: ["src", "*.py"]']
 
     @classmethod
     def make(cls, session: Session, args: list[str]) -> Self:
-        if len(args) not in (1, 2):
-            raise ToolCallError("requires 1 or 2 args: dir_path[, glob_pattern]")
+        if len(args) not in (0, 1, 2):
+            raise ToolCallError("requires 0 to 2 args: [dir_path][, glob_pattern]")
+        dir_path = str(args[0]) if args else "."
         glob_pattern = str(args[1]) if len(args) == 2 else ""
-        return cls(dirpath=session.resolve_path(args[0]), glob_pattern=glob_pattern, cwd=session.cwd)
+        return cls(dirpath=session.resolve_path(dir_path), glob_pattern=glob_pattern, cwd=session.cwd)
 
     def display(self) -> str:
         if self.glob_pattern:
@@ -1664,8 +1707,11 @@ Tools:
 - Call tools only by emitting JSON in tool_calls. Do not use native tool calls.
 - Use multiple tool calls in one turn when they are independent.
 - Prefer specific tools first; use Bash only when no provided tool fits.
-- Summarize every latest tool result in last_tool_calls_summaries; raw results are shown once only, so key_evidence keeps paths, lines, errors, decisions.
-- If a prior tool result lacks detail, use Read on its result_file.
+- Prefer Search before Read when locating code or facts; Read only known small ranges or exact files needed for editing.
+- Read returns at most 1000 lines; if truncated, use Search or smaller Read ranges in batches.
+- Summarize every latest tool result in last_tool_calls_summaries; raw results are shown once only, so include key_evidence when paths, lines, errors, or decisions matter later.
+- Latest tool results are already shown in Latest_Tool_Call_Results; use result_file logs only as a fallback when needed.
+- If an older tool result lacks detail that is needed for the task, prefer re-running a targeted source tool; Read result_file logs only when that is the cheapest accurate source.
 - known_append is stable memory; current_context_update is task-local memory.
 - tool_call.intention must state the question to answer, not just the action.
 
@@ -2092,25 +2138,32 @@ class ToolCallRunner:
             if call is None:
                 call = self._invalid_tool_call(item)
 
-            result_file, result_file_lines = self._write_tool_result_log(call, outcome, output)
+            log_written = not self._is_tool_result_file_read(call)
+            if log_written:
+                result_file, result_file_lines = self._write_tool_result_log(call, outcome, output)
+            else:
+                result_file = os.path.relpath(self.session.resolve_path(call.args[0]), self.session.cwd)
+                result_file_lines = len(output.splitlines())
             execution = ToolCallExecution(
                 call=call,
                 outcome=outcome,
                 output=output,
                 result_file=result_file,
                 result_file_lines=result_file_lines,
+                log_written=log_written,
             )
-            event = ToolCallEvent(
-                intent=call.intention,
-                executed=call.executed,
-                outcome=outcome,
-                summary="",
-                result_file=result_file,
-                result_file_lines=result_file_lines,
-            )
-            self.session.append_conversation(event)
+            if log_written:
+                event = ToolCallEvent(
+                    intent=call.intention,
+                    executed=call.executed,
+                    outcome=outcome,
+                    summary="",
+                    result_file=result_file,
+                    result_file_lines=result_file_lines,
+                )
+                self.session.append_conversation(event)
+                events.append(event)
             executions.append(execution)
-            events.append(event)
 
         self.latest_events = events
         self.latest_executions = executions
@@ -2128,7 +2181,8 @@ class ToolCallRunner:
             lines.append("  " + str(index) + ". [" + execution.outcome + "] " + execution.call.executed)
             if execution.call.intention:
                 lines.append("     why: " + execution.call.intention)
-            lines.append("     log: " + execution.result_file + " (" + str(execution.result_file_lines) + " lines)")
+            label = "log" if execution.log_written else "source"
+            lines.append("     " + label + ": " + execution.result_file + " (" + str(execution.result_file_lines) + " lines)")
         return "\n".join(lines)
 
     def parse_tool_call(self, value: JsonValue) -> ParsedToolCall:
@@ -2153,6 +2207,16 @@ class ToolCallRunner:
             raise ToolCallError("tool not found: " + call.name)
         return tool_class.make(self.session, call.args)
 
+    def _is_tool_result_file_read(self, call: ParsedToolCall) -> bool:
+        if call.name != ReadTool.name() or not call.args:
+            return False
+        tool_results_dir = os.path.realpath(self.session.tool_results_dir())
+        path = os.path.realpath(self.session.resolve_path(call.args[0]))
+        try:
+            return os.path.commonpath([tool_results_dir, path]) == tool_results_dir
+        except ValueError:
+            return False
+
     def _write_tool_result_log(self, call: ParsedToolCall, outcome: str, output: str) -> tuple[str, int]:
         directory = self.session.tool_results_dir()
         os.makedirs(directory, exist_ok=True)
@@ -2563,9 +2627,6 @@ class ConversationCompactor:
 
 @final
 class Agent:
-    EVIDENCE_OUTPUT_LINES: ClassVar[int] = 40
-    EVIDENCE_OUTPUT_CHARS: ClassVar[int] = 4000
-
     def __init__(self, session: Session):
         self.session = session
         self.prompt_builder = PromptBuilder(session)
@@ -2688,49 +2749,32 @@ class Agent:
 
     def _format_tool_summary_gate(self, tool_calls: list[JsonValue]) -> str:
         missing = self._missing_tool_summaries()
-        missing_evidence = []
         needs_read = []
-        for event, execution in zip(self.tool_runner.latest_events, self.tool_runner.latest_executions):
+        for event in self.tool_runner.latest_events:
             if not event.summary:
                 continue
             is_reading_result_file = self._has_read_result_file_call(tool_calls, event.result_file)
-            if event.needs_raw_read and not is_reading_result_file:
-                needs_read.append(event)
-            if event.outcome in {"failure", "partial"}:
-                if not event.key_details and not is_reading_result_file:
-                    missing_evidence.append(event)
+            if event.needs_raw_read:
+                if not is_reading_result_file:
+                    needs_read.append(event)
                 continue
-            if (
-                self._is_large_tool_output(execution.output)
-                and not event.key_details
-                and not event.needs_raw_read
-                and not is_reading_result_file
-            ):
-                missing_evidence.append(event)
-        if not missing and not missing_evidence and not needs_read:
+        if not missing and not needs_read:
             return ""
 
-        lines = ["Tool_Summary_Gate: extract durable evidence before continuing.", "Raw tool results are visible only once."]
+        lines = ["Tool_Summary_Gate: summarize latest tool results before continuing.", "Raw tool results are visible only once."]
         if missing:
             lines.append("Missing summaries:")
         for event in missing:
             lines.append("- " + event.executed + " -> " + event.result_file)
-        if missing_evidence:
-            lines.append("Missing key_evidence:")
-        for event in missing_evidence:
-            lines.append("- " + event.executed + " -> " + event.result_file)
         if needs_read:
             lines.append("Needs raw read:")
         for event in needs_read:
             lines.append("- Read(" + event.result_file + ") before continuing")
         lines.append(
-            "Next_Action: return last_tool_calls_summaries with key_evidence, update current_context_update for task-local facts, or call Read(result_file) for needs_raw_read logs."
+            "Next_Action: return last_tool_calls_summaries for missing results, read result_file only when it is the cheapest accurate fallback, or continue with source tools such as Search/ListDir."
         )
         return "\n".join(lines)
 
-    def _is_large_tool_output(self, output: str) -> bool:
-        return len(output) > self.EVIDENCE_OUTPUT_CHARS or len(output.splitlines()) > self.EVIDENCE_OUTPUT_LINES
-
     def _has_read_result_file_call(self, tool_calls: list[JsonValue], result_file: str) -> bool:
         if not result_file:
             return False

{nanocode_cli-0.2.1 → nanocode_cli-0.2.2/nanocode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.2.1
+Version: 0.2.2
 Summary: A lightweight terminal-based AI coding assistant
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause

{nanocode_cli-0.2.1 → nanocode_cli-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nanocode-cli"
-version = "0.2.1"
+version = "0.2.2"
 description = "A lightweight terminal-based AI coding assistant"
 readme = "README.md"
 requires-python = ">=3.11"