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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.2.1
+Version: 0.2.3
 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.3}/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.3"
 
 
 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.
 
@@ -1949,6 +1995,8 @@ class ModelClient:
 
         self._record_usage(_json_dict(result.get("usage") if isinstance(result, dict) else None))
         content = self._message_content(result)
+        if content is None:
+            return self._invalid_model_response(self._format_missing_message_content(result))
         return self._parse_model_content(content)
 
     def _write_debug_prompt(self, *, activity: str, messages: list[Json]) -> str:
@@ -1978,13 +2026,9 @@ class ModelClient:
 
     def _parse_model_content(self, content: str) -> Json:
         text = content.strip()
-        if text.startswith("```"):
-            lines = text.splitlines()
-            if lines and lines[0].startswith("```"):
-                lines = lines[1:]
-            if lines and lines[-1].strip() == "```":
-                lines = lines[:-1]
-            text = "\n".join(lines).strip()
+        text = self._strip_leaked_think_tags(text)
+        text = self._strip_json_fence(text)
+        text = self._strip_leaked_think_tags(text)
         try:
             value = json.loads(text)
         except json.JSONDecodeError:
@@ -1993,15 +2037,49 @@ class ModelClient:
             return self._invalid_model_response(content)
         return value
 
+    def _strip_json_fence(self, text: str) -> str:
+        if not text.startswith("```"):
+            return text
+        lines = text.splitlines()
+        if lines and lines[0].startswith("```"):
+            lines = lines[1:]
+        if lines and lines[-1].strip() == "```":
+            lines = lines[:-1]
+        return "\n".join(lines).strip()
+
+    def _strip_leaked_think_tags(self, text: str) -> str:
+        text = text.strip()
+        while text.startswith("</think>"):
+            text = text[len("</think>") :].lstrip()
+        while text.startswith("<think>"):
+            end = text.find("</think>")
+            if end < 0:
+                return text
+            text = text[end + len("</think>") :].lstrip()
+            while text.startswith("</think>"):
+                text = text[len("</think>") :].lstrip()
+        return text
+
     def _invalid_model_response(self, content: str) -> Json:
+        guidance = ""
+        if self._looks_like_native_tool_call(content):
+            guidance = (
+                " Native tool_call syntax is not supported; return one JSON object with tool_calls entries like "
+                '{"name":"Read","intention":"...","args":["nanocode.py","0","100"]}.'
+            )
         return {
             "goal_reached": False,
             "tool_calls": None,
             "message_to_user": None,
             "_format_error": "Invalid model output: expected one JSON object matching the Output JSON schema. Return strict JSON only. Bad output: "
-            + _shorten(content),
+            + _shorten(content)
+            + guidance,
         }
 
+    def _looks_like_native_tool_call(self, content: str) -> bool:
+        text = self._strip_leaked_think_tags(content.strip())
+        return text.startswith("<tool_call>")
+
     def _chat_completions_url(self) -> str:
         url = self.session.api_url.rstrip("/")
         if url.endswith("/chat/completions"):
@@ -2015,7 +2093,7 @@ class ModelClient:
             return {"reasoning": {"effort": self.session.reasoning_effort}}
         return {}
 
-    def _message_content(self, result: JsonValue) -> str:
+    def _message_content(self, result: JsonValue) -> str | None:
         data = _json_dict(result)
         choices = _json_list(data.get("choices"))
         if not choices:
@@ -2023,9 +2101,18 @@ class ModelClient:
         message = _json_dict(_json_dict(choices[0]).get("message"))
         content = message.get("content")
         if not isinstance(content, str):
-            raise LLMError("API response missing message content")
+            return None
         return content
 
+    def _format_missing_message_content(self, result: JsonValue) -> str:
+        choice = _json_dict(_json_list(_json_dict(result).get("choices"))[0])
+        message = _json_dict(choice.get("message"))
+        details: Json = {
+            "finish_reason": choice.get("finish_reason"),
+            "message_keys": sorted(str(key) for key in message.keys()),
+        }
+        return "API response missing message content: " + json.dumps(details, ensure_ascii=False)
+
     def _record_usage(self, usage: Json) -> None:
         prompt_tokens = _json_int(usage.get("prompt_tokens"))
         completion_tokens = _json_int(usage.get("completion_tokens"))
@@ -2092,25 +2179,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 +2222,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 +2248,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,8 +2668,7 @@ class ConversationCompactor:
 
 @final
 class Agent:
-    EVIDENCE_OUTPUT_LINES: ClassVar[int] = 40
-    EVIDENCE_OUTPUT_CHARS: ClassVar[int] = 4000
+    MAX_CONSECUTIVE_FORMAT_ERRORS: ClassVar[int] = 3
 
     def __init__(self, session: Session):
         self.session = session
@@ -2610,18 +2714,48 @@ class Agent:
         self.session.current.goal_reached = False
         self.maybe_auto_compact()
         self.session.append_conversation(UserMessage(content=user_input))
+        consecutive_format_errors = 0
 
         for _ in range(self.session.max_agent_steps):
             response = self.step()
             format_error = _json_str(response.get("_format_error"))
             if format_error:
+                consecutive_format_errors += 1
                 self.latest_tool_call_results = format_error
+                if consecutive_format_errors >= self.MAX_CONSECUTIVE_FORMAT_ERRORS:
+                    self._report_gate(
+                        on_message,
+                        "Stopped: model returned invalid output "
+                        + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS)
+                        + " times in a row.",
+                        "Format_Gate: stopped after "
+                        + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS)
+                        + " consecutive invalid model outputs. "
+                        + _shorten(format_error, 180),
+                    )
+                    raise LLMError(
+                        "model returned invalid output "
+                        + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS)
+                        + " times in a row: "
+                        + _shorten(format_error, 300)
+                    )
+                self._report_gate(
+                    on_message,
+                    "Retrying: model returned invalid output.",
+                    "Format_Gate: retrying model response. " + _shorten(format_error, 180),
+                )
                 continue
+            consecutive_format_errors = 0
             tool_calls = _json_list(response.get("tool_calls"))
             summary_gate = self._format_tool_summary_gate(tool_calls)
             if summary_gate:
                 self.state_updater.latest_report = ""
                 self.latest_tool_call_results = summary_gate
+                self._report_gate(
+                    on_message,
+                    "Retrying: model needs to summarize the latest tool results.",
+                    self._compact_gate_report(summary_gate),
+                )
                 continue
             self.apply_response(response)
             if on_message is not None and self.state_updater.latest_report:
@@ -2644,13 +2778,35 @@ class Agent:
             if self.session.current.verification.status == VerificationStatus.REQUIRED:
                 self.session.current.goal_reached = False
                 self.latest_tool_call_results = self._format_verification_gate()
+                self._report_gate(
+                    on_message,
+                    "Retrying: verification is required before completion.",
+                    "Verification_Gate: retrying until verification is passed or blocked.",
+                )
                 continue
             if not self.session.current.goal_reached:
                 self.latest_tool_call_results = self._format_continuation_hint()
+                self._report_gate(
+                    on_message,
+                    "Continuing: goal is not complete yet.",
+                    "Continuation_Gate: goal not reached; retrying next useful action.",
+                )
                 continue
             return response
         raise LLMError("agent step limit reached")
 
+    def _report_gate(self, on_message: MessageCallback | None, message: str, debug_message: str) -> None:
+        if on_message is not None:
+            on_message(debug_message if self.session.debug else message)
+
+    def _compact_gate_report(self, gate: str) -> str:
+        lines = gate.splitlines()
+        headline = lines[0] if lines else "Gate"
+        details = [line for line in lines[1:] if line.startswith("- ")]
+        if details:
+            return headline + ": " + _shorten("; ".join(details[:3]), 220)
+        return headline
+
     def step(self) -> Json:
         response = self.request(self.build_system_prompt(), self.build_user_prompt(), activity="main")
         self.state_updater.apply_tool_call_summaries(response)
@@ -2688,49 +2844,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.3/nanocode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.2.1
+Version: 0.2.3
 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.3}/pyproject.toml

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