From 19b0d8dd6871d346d9a3d66cd2cde8b14aec8edc Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 01:31:14 -0700 Subject: [PATCH 001/144] reasoning_payload --- nanocode.py | 69 ++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 52 insertions(+), 17 deletions(-) diff --git a/nanocode.py b/nanocode.py index d3061a1..04c0125 100644 --- a/nanocode.py +++ b/nanocode.py @@ -26,6 +26,7 @@ import time import tomllib import urllib.error +import urllib.parse import urllib.request import uuid from dataclasses import dataclass, field @@ -417,7 +418,7 @@ class ProviderConfig: temperature: float | None = None reasoning: bool | None = True reasoning_effort: str = "medium" - reasoning_payload: str = "" + reasoning_payload: str = "auto" stream: bool | None = True timeout: int | None = 180 first_token_timeout: int | None = 90 @@ -442,10 +443,24 @@ def from_dict(cls, data: Json) -> "ProviderConfig": @classmethod def _reasoning_payload(cls, data: Json, default: str) -> str: value = Config.str(data, "reasoning_payload", default) - if value not in ("", "reasoning", "reasoning_effort"): - raise ConfigError("config provider.reasoning_payload must be one of: reasoning, reasoning_effort, empty") + if value not in ("auto", "", "reasoning", "reasoning_effort", "thinking", "enable_thinking"): + raise ConfigError("config provider.reasoning_payload must be one of: auto, reasoning, reasoning_effort, thinking, enable_thinking, empty") return value + def resolved_reasoning_payload(self) -> str: + if self.reasoning_payload != "auto": + return self.reasoning_payload + host = (urllib.parse.urlparse(self.url).hostname or "").lower() + if host == "api.deepseek.com": + return "thinking" + if host in ("openrouter.ai", "opencode.ai"): + return "reasoning" + if host in ("dashscope.aliyuncs.com", "dashscope-intl.aliyuncs.com", "dashscope-us.aliyuncs.com"): + return "enable_thinking" + if host == "api.openai.com": + return "reasoning_effort" + return "" + @dataclass class ModelUsage: @@ -612,10 +627,12 @@ class ConfigFile: # temperature = 0.7 reasoning = true reasoning_effort = "medium" -# Optional reasoning payload shape. Leave unset for broad OpenAI-compatible -# compatibility. Set only for providers that require it, for example OpenRouter: +# Optional reasoning payload shape. Default "auto" detects common providers +# by URL. Override only when provider auto-detection is wrong: # reasoning_payload = "reasoning" sends {"reasoning":{"effort":...}} # reasoning_payload = "reasoning_effort" sends a top-level effort. +# reasoning_payload = "thinking" sends {"thinking":{"type":"enabled/disabled"}, "reasoning_effort":"high/max"}. +# reasoning_payload = "enable_thinking" sends {"enable_thinking": true/false}. stream = true timeout = 180 # Stream mode only: retry if no first content token arrives within this many seconds. @@ -3394,10 +3411,18 @@ def request( payload["stream"] = True payload["stream_options"] = {"include_usage": True} timeout, first_token_timeout = self._request_timeouts(config, activity=activity) - if config.reasoning is not False and config.reasoning_payload == "reasoning": + reasoning_payload = config.resolved_reasoning_payload() + if config.reasoning is not False and reasoning_payload == "reasoning": payload["reasoning"] = {"effort": config.reasoning_effort or "medium"} - if config.reasoning is not False and config.reasoning_payload == "reasoning_effort": + if config.reasoning is not False and reasoning_payload == "reasoning_effort": payload["reasoning_effort"] = config.reasoning_effort or "medium" + if reasoning_payload == "thinking": + payload["thinking"] = {"type": "enabled" if config.reasoning is not False else "disabled"} + if config.reasoning is not False: + effort = config.reasoning_effort or "medium" + payload["reasoning_effort"] = "max" if effort in ("max", "xhigh") else "high" + if reasoning_payload == "enable_thinking": + payload["enable_thinking"] = config.reasoning is not False self._write_debug_prompt(activity=activity, messages=messages) url = config.url.rstrip("/") @@ -3486,8 +3511,8 @@ def _request_timeouts(self, config: ProviderConfig, *, activity: str) -> tuple[i def _read_streaming_content(self, response: Any, *, request_deadline: float, first_token_timeout: int | None) -> tuple[str, Json]: parts: list[str] = [] usage: Json = {} - first_content_seen = False - self._arm_stream_timeout(request_deadline=request_deadline, first_content_seen=False, first_token_timeout=first_token_timeout) + first_output_seen = False + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) for raw_line in response: line = raw_line.decode("utf-8", errors="replace").strip() if not line or line.startswith(":") or not line.startswith("data:"): @@ -3508,25 +3533,35 @@ def _read_streaming_content(self, response: Any, *, request_deadline: float, fir continue delta = _json_dict(_json_dict(choices[0]).get("delta")) content = delta.get("content") - if not isinstance(content, str) or not content: + output_chars = self._stream_output_chars(delta) + if output_chars <= 0: continue - if not first_content_seen: - first_content_seen = True + if not first_output_seen: + first_output_seen = True self.session.state.current_model_call_has_content = True - self._arm_stream_timeout(request_deadline=request_deadline, first_content_seen=True, first_token_timeout=first_token_timeout) - parts.append(content) - self.session.state.current_model_call_streaming_chars += len(content) + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) + if isinstance(content, str) and content: + parts.append(content) + self.session.state.current_model_call_streaming_chars += output_chars return "".join(parts), usage + def _stream_output_chars(self, delta: Json) -> int: + for key in ("content", "reasoning_content", "reasoning"): + value = delta.get(key) + if isinstance(value, str) and value: + return len(value) + details = _json_list(delta.get("reasoning_details")) + return len(json.dumps(details, ensure_ascii=False)) if details else 0 + def _estimate_stream_rate(self, elapsed: float) -> float: return self.session.state.current_model_call_streaming_chars / 4 / elapsed if elapsed > 0 else 0.0 - def _arm_stream_timeout(self, *, request_deadline: float, first_content_seen: bool, first_token_timeout: int | None) -> None: + def _arm_stream_timeout(self, *, request_deadline: float, first_output_seen: bool, first_token_timeout: int | None) -> None: remaining = request_deadline - time.monotonic() if remaining <= 0: raise ModelRequestTimeout("request model timeout") self._timeout_reason = "request model timeout" - if not first_content_seen and first_token_timeout is not None and first_token_timeout > 0: + if not first_output_seen and first_token_timeout is not None and first_token_timeout > 0: if first_token_timeout < remaining: remaining = first_token_timeout self._timeout_reason = "request first token timeout" From 908c6c74f702dedaeacfc5c305fe632570e40ec8 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 02:25:33 -0700 Subject: [PATCH 002/144] Add provider-aware OpenAI SDK transport --- README.md | 3 +- nanocode.py | 439 ++++++++++++++------ pyproject.toml | 2 + tests/test_nanocode_agent.py | 683 +++++++++++++++++++++----------- tests/test_nanocode_commands.py | 52 ++- tests/test_nanocode_loop.py | 4 +- 6 files changed, 822 insertions(+), 361 deletions(-) diff --git a/README.md b/README.md index 95f8f14..12573a6 100644 --- a/README.md +++ b/README.md @@ -95,7 +95,8 @@ Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/model` lists co Run `nanocode --init-config` to create `~/.nanocode/config.toml`. -- Provider config: `[provider] active = ""` plus `[provider.]` url, key, model, `available_models`, and model options. `reasoning_payload` controls whether effort is sent as `reasoning`, `reasoning_effort`, or not sent. +- Provider config: `[provider] active = ""` plus `[provider.]` url, key, model, `available_models`, and model options. `api` selects `chat`, `responses`, or `auto`; auto uses exact-host profiles. Responses uses standard `reasoning.effort`; Chat reasoning is mapped by provider/model profile when known. +- Provider auto-detection covers common providers: OpenAI/OpenRouter prefer Responses API; DeepSeek, OpenRouter/OpenCode, and DashScope models use their matching Chat reasoning payload shapes. - Path config: `[paths] data_dir = "~/.nanocode"`. - Runtime config: `[runtime]`. - Session data: debug prompts and tool-result logs are stored under `~/.nanocode/sessions//`. diff --git a/nanocode.py b/nanocode.py index 04c0125..793e7f4 100644 --- a/nanocode.py +++ b/nanocode.py @@ -19,23 +19,21 @@ import selectors import shutil import signal -import socket import subprocess import sys import threading import time import tomllib -import urllib.error -import urllib.parse -import urllib.request import uuid from dataclasses import dataclass, field from datetime import datetime from enum import StrEnum from typing import Any, Callable, ClassVar, Iterator, Iterable, Self, Type, TypeAlias +from urllib.parse import urlparse import json_repair +from openai import APIConnectionError, APIError, APIStatusError, APITimeoutError, OpenAI from prompt_toolkit.application import Application from prompt_toolkit import PromptSession, print_formatted_text from prompt_toolkit.completion import Completer, Completion @@ -409,16 +407,74 @@ def source_result_keys(self) -> set[str]: return keys +@dataclass(frozen=True) +class ChatReasoningRule: + payload: str + model_prefixes: tuple[str, ...] + + +@dataclass(frozen=True) +class ProviderProfile: + api: str = "chat" + chat_reasoning_payload: str = "" + chat_reasoning_rules: tuple[ChatReasoningRule, ...] = () + + +ALIYUN_CHAT_PROFILE = ProviderProfile( + chat_reasoning_rules=( + ChatReasoningRule("enable_thinking", ("qwen", "qwq", "qvq")), + ChatReasoningRule("thinking", ("deepseek-v4",)), + ) +) + + +# Exact host matches only. Keep provider quirks here instead of scattering +# vendor-specific branches through request construction. DashScope intentionally +# defaults to Chat because Responses support differs by model family and region. +PROVIDER_PROFILES: dict[str, ProviderProfile] = { + "api.openai.com": ProviderProfile( + api="responses", + chat_reasoning_rules=(ChatReasoningRule("reasoning_effort", ("o1", "o3", "o4", "gpt-5")),), + ), + "openrouter.ai": ProviderProfile(api="responses", chat_reasoning_payload="reasoning"), + "opencode.ai": ProviderProfile(chat_reasoning_payload="reasoning"), + "api.deepseek.com": ProviderProfile(chat_reasoning_payload="thinking"), + "dashscope.aliyuncs.com": ALIYUN_CHAT_PROFILE, + "dashscope-intl.aliyuncs.com": ALIYUN_CHAT_PROFILE, + "dashscope-us.aliyuncs.com": ALIYUN_CHAT_PROFILE, +} + + +ALIYUN_THINKING_BUDGET_BY_EFFORT = { + "minimal": 256, + "low": 1024, + "medium": 4096, + "high": 8192, + "xhigh": 16384, + "max": 16384, +} + +DEEPSEEK_REASONING_EFFORT_BY_EFFORT = { + "minimal": "high", + "low": "high", + "medium": "high", + "high": "high", + "xhigh": "max", + "max": "max", +} + + @dataclass class ProviderConfig: url: str = "" key: str = "" model: str = "" + api: str = "auto" available_models: tuple[str, ...] = () temperature: float | None = None reasoning: bool | None = True reasoning_effort: str = "medium" - reasoning_payload: str = "auto" + chat_reasoning_payload: str = "auto" stream: bool | None = True timeout: int | None = 180 first_token_timeout: int | None = 90 @@ -430,36 +486,55 @@ def from_dict(cls, data: Json) -> "ProviderConfig": url=Config.str(data, "url", defaults.url), key=Config.str(data, "key", defaults.key), model=Config.str(data, "model", defaults.model), + api=cls._api(data, defaults.api), available_models=Config.str_tuple(data, "available_models"), temperature=Config.float(data, "temperature", defaults.temperature), reasoning=Config.bool(data, "reasoning", defaults.reasoning), reasoning_effort=Config.str(data, "reasoning_effort", defaults.reasoning_effort), - reasoning_payload=cls._reasoning_payload(data, defaults.reasoning_payload), + chat_reasoning_payload=cls._chat_reasoning_payload(data, defaults.chat_reasoning_payload), stream=Config.bool(data, "stream", defaults.stream), timeout=Config.int(data, "timeout", defaults.timeout), first_token_timeout=Config.int(data, "first_token_timeout", defaults.first_token_timeout), ) @classmethod - def _reasoning_payload(cls, data: Json, default: str) -> str: - value = Config.str(data, "reasoning_payload", default) + def _api(cls, data: Json, default: str) -> str: + value = Config.str(data, "api", default) + if value not in ("chat", "responses", "auto"): + raise ConfigError("config provider.api must be one of: chat, responses, auto") + return value + + @classmethod + def _chat_reasoning_payload(cls, data: Json, default: str) -> str: + value = Config.str(data, "chat_reasoning_payload", default) if value not in ("auto", "", "reasoning", "reasoning_effort", "thinking", "enable_thinking"): - raise ConfigError("config provider.reasoning_payload must be one of: auto, reasoning, reasoning_effort, thinking, enable_thinking, empty") + raise ConfigError("config provider.chat_reasoning_payload must be one of: auto, reasoning, reasoning_effort, thinking, enable_thinking, empty") return value - def resolved_reasoning_payload(self) -> str: - if self.reasoning_payload != "auto": - return self.reasoning_payload - host = (urllib.parse.urlparse(self.url).hostname or "").lower() - if host == "api.deepseek.com": - return "thinking" - if host in ("openrouter.ai", "opencode.ai"): - return "reasoning" - if host in ("dashscope.aliyuncs.com", "dashscope-intl.aliyuncs.com", "dashscope-us.aliyuncs.com"): - return "enable_thinking" - if host == "api.openai.com": - return "reasoning_effort" - return "" + def resolved_chat_reasoning_payload(self) -> str: + if self.chat_reasoning_payload != "auto": + return self.chat_reasoning_payload + profile = PROVIDER_PROFILES.get(self.host()) + if not profile: + return "" + model = self.model.lower() + for rule in profile.chat_reasoning_rules: + if any(model.startswith(prefix) for prefix in rule.model_prefixes): + return rule.payload + return profile.chat_reasoning_payload + + def host(self) -> str: + return (urlparse(self.url).hostname or "").lower() + + def base_url(self) -> str: + url = self.url.rstrip("/") + return url[: -len("/chat/completions")] if url.endswith("/chat/completions") else url + + def resolved_api(self) -> str: + if self.api != "auto": + return self.api + profile = PROVIDER_PROFILES.get(self.host()) + return profile.api if profile else "chat" @dataclass @@ -621,18 +696,22 @@ class ConfigFile: key = "" # Default model used by nanocode. model = "" +# API backend: "auto" (default), "chat", or "responses". +# "auto" uses nanocode's exact-host provider profile table. +# api = "auto" # Optional: add available_models = ["model-a", "model-b"] manually to pin preferred # /model choices above automatically discovered provider models. # Optional. Uncomment only for models/providers that support temperature. # temperature = 0.7 reasoning = true reasoning_effort = "medium" -# Optional reasoning payload shape. Default "auto" detects common providers -# by URL. Override only when provider auto-detection is wrong: -# reasoning_payload = "reasoning" sends {"reasoning":{"effort":...}} -# reasoning_payload = "reasoning_effort" sends a top-level effort. -# reasoning_payload = "thinking" sends {"thinking":{"type":"enabled/disabled"}, "reasoning_effort":"high/max"}. -# reasoning_payload = "enable_thinking" sends {"enable_thinking": true/false}. +# Optional advanced override. Chat Completions reasoning shape is auto-detected +# by provider/model profile where nanocode knows the provider. Responses API +# always uses the standard reasoning.effort payload. +# chat_reasoning_payload = "reasoning" sends {"reasoning":{"effort":...}} +# chat_reasoning_payload = "reasoning_effort" sends a top-level effort. +# chat_reasoning_payload = "thinking" sends {"thinking":{"type":"enabled/disabled"}, "reasoning_effort":"high/max"}. +# chat_reasoning_payload = "enable_thinking" sends enable_thinking plus a budget mapped from effort. stream = true timeout = 180 # Stream mode only: retry if no first content token arrives within this many seconds. @@ -3400,41 +3479,16 @@ def request( {"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}, ] - payload: Json = { - "model": model, - "messages": messages, - } - if config.temperature is not None: - payload["temperature"] = config.temperature stream = config.stream is not False - if stream: - payload["stream"] = True - payload["stream_options"] = {"include_usage": True} timeout, first_token_timeout = self._request_timeouts(config, activity=activity) - reasoning_payload = config.resolved_reasoning_payload() - if config.reasoning is not False and reasoning_payload == "reasoning": - payload["reasoning"] = {"effort": config.reasoning_effort or "medium"} - if config.reasoning is not False and reasoning_payload == "reasoning_effort": - payload["reasoning_effort"] = config.reasoning_effort or "medium" - if reasoning_payload == "thinking": - payload["thinking"] = {"type": "enabled" if config.reasoning is not False else "disabled"} - if config.reasoning is not False: - effort = config.reasoning_effort or "medium" - payload["reasoning_effort"] = "max" if effort in ("max", "xhigh") else "high" - if reasoning_payload == "enable_thinking": - payload["enable_thinking"] = config.reasoning is not False - self._write_debug_prompt(activity=activity, messages=messages) - url = config.url.rstrip("/") - - request = urllib.request.Request( - url=url if url.endswith("/chat/completions") else url + "/chat/completions", - data=json.dumps(payload).encode("utf-8"), - headers={ - "Authorization": "Bearer " + config.key, - "Content-Type": "application/json", - "User-Agent": HTTP_USER_AGENT, - }, + api = config.resolved_api() + params = ( + self._responses_params(config, model=model, system_prompt=system_prompt, user_prompt=user_prompt, stream=stream) + if api == "responses" + else self._chat_completion_params(config, model=model, messages=messages, stream=stream) ) + self._write_debug_prompt(activity=activity, messages=messages) + client = self._client(config, timeout=timeout) request_elapsed = 0.0 try: self.session.state.current_model_call_started_at = time.monotonic() @@ -3449,16 +3503,24 @@ def request( self._timeout_reason = "request model timeout" signal.setitimer(signal.ITIMER_REAL, max(0, timeout)) try: - with urllib.request.urlopen(request, timeout=timeout) as response: - if stream: - content, usage = self._read_streaming_content( - response, + completion = ( + client.responses.create(**params, timeout=timeout) + if api == "responses" + else client.chat.completions.create(**params, timeout=timeout) + ) + if stream: + content, usage = ( + self._read_responses_stream(completion, request_deadline=request_deadline, first_token_timeout=first_token_timeout) + if api == "responses" + else self._read_streaming_content( + completion, request_deadline=request_deadline, first_token_timeout=first_token_timeout, ) - result: Json = {"usage": usage} - else: - body = response.read().decode("utf-8") + ) + result: Json = {"usage": usage} + else: + result = self._sdk_json(completion) finally: signal.setitimer(signal.ITIMER_REAL, 0) signal.signal(signal.SIGALRM, previous_handler) @@ -3474,33 +3536,73 @@ def request( self.session.state.current_model_call_streaming_chars = 0 except ModelRequestTimeout as error: raise LLMError(str(error) or "request model timeout") - except (socket.timeout, TimeoutError): + except APITimeoutError: raise LLMError("request model timeout") - except urllib.error.HTTPError as error: - body = error.read().decode("utf-8", errors="replace") - raise LLMError("API request failed: HTTP " + str(error.code) + ": " + _shorten(body)) - except urllib.error.URLError as error: - if isinstance(error.reason, (socket.timeout, TimeoutError)): - raise LLMError("request model timeout") + except APIStatusError as error: + body = getattr(error.response, "text", "") or str(getattr(error, "body", "")) or str(error) + raise LLMError("API request failed: HTTP " + str(error.status_code) + ": " + _shorten(body)) + except APIConnectionError as error: + raise LLMError(str(error)) + except APIError as error: raise LLMError(str(error)) except Exception as error: raise LLMError(str(error)) - if not stream: - try: - result = json.loads(body) - except json.JSONDecodeError: - raise LLMError("API response is not JSON: " + _shorten(body)) - self._record_usage(_json_dict(result.get("usage") if isinstance(result, dict) else None), config, elapsed=request_elapsed) if not stream: - content = self._message_content(result) + content = self._responses_content(result) if api == "responses" else self._message_content(result) if content is None: return self._invalid_model_response(self._format_missing_message_content(result)) if not parse_actions: return self._parse_json_content(content) return self._parse_model_content(content) + def _client(self, config: ProviderConfig, *, timeout: int) -> OpenAI: + return OpenAI( + api_key=config.key, + base_url=config.base_url(), + timeout=timeout, + max_retries=0, + default_headers={"User-Agent": HTTP_USER_AGENT}, + ) + + @staticmethod + def _reasoning_effort(config: ProviderConfig) -> str: + return config.reasoning_effort or "medium" + + def _chat_completion_params(self, config: ProviderConfig, *, model: str, messages: list[Json], stream: bool) -> Json: + params: Json = {"model": model, "messages": messages, "stream": stream} + extra_body: Json = {} + if config.temperature is not None: + params["temperature"] = config.temperature + if stream: + params["stream_options"] = {"include_usage": True} + chat_reasoning_payload = config.resolved_chat_reasoning_payload() + if config.reasoning is not False and chat_reasoning_payload == "reasoning": + extra_body["reasoning"] = {"effort": self._reasoning_effort(config)} + if config.reasoning is not False and chat_reasoning_payload == "reasoning_effort": + params["reasoning_effort"] = self._reasoning_effort(config) + if chat_reasoning_payload == "thinking": + extra_body["thinking"] = {"type": "enabled" if config.reasoning is not False else "disabled"} + if config.reasoning is not False: + params["reasoning_effort"] = DEEPSEEK_REASONING_EFFORT_BY_EFFORT.get(self._reasoning_effort(config), "high") + if chat_reasoning_payload == "enable_thinking": + extra_body["enable_thinking"] = config.reasoning is not False + if config.reasoning is not False: + extra_body["thinking_budget"] = ALIYUN_THINKING_BUDGET_BY_EFFORT.get(self._reasoning_effort(config), ALIYUN_THINKING_BUDGET_BY_EFFORT["medium"]) + if extra_body: + params["extra_body"] = extra_body + return params + + def _responses_params(self, config: ProviderConfig, *, model: str, system_prompt: str, user_prompt: str, stream: bool) -> Json: + params: Json = {"model": model, "instructions": system_prompt, "input": user_prompt, "stream": stream, "store": False} + if config.temperature is not None: + params["temperature"] = config.temperature + if config.reasoning is not False: + effort = self._reasoning_effort(config) + params["reasoning"] = {"effort": "high" if effort in ("max", "xhigh") else effort} + return params + def _request_timeouts(self, config: ProviderConfig, *, activity: str) -> tuple[int, int | None]: timeout = config.timeout if config.timeout is not None else 180 first_token_timeout = config.first_token_timeout if config.first_token_timeout is not None else timeout @@ -3508,23 +3610,13 @@ def _request_timeouts(self, config: ProviderConfig, *, activity: str) -> tuple[i return self.session.settings.plan_timeout, self.session.settings.plan_first_token_timeout return timeout, first_token_timeout - def _read_streaming_content(self, response: Any, *, request_deadline: float, first_token_timeout: int | None) -> tuple[str, Json]: + def _read_streaming_content(self, stream: Any, *, request_deadline: float, first_token_timeout: int | None) -> tuple[str, Json]: parts: list[str] = [] usage: Json = {} first_output_seen = False self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) - for raw_line in response: - line = raw_line.decode("utf-8", errors="replace").strip() - if not line or line.startswith(":") or not line.startswith("data:"): - continue - data = line[len("data:") :].strip() - if data == "[DONE]": - break - try: - event = json.loads(data) - except json.JSONDecodeError: - continue - event_data = _json_dict(event) + for event in stream: + event_data = self._sdk_json(event) event_usage = _json_dict(event_data.get("usage")) if event_usage: usage = event_usage @@ -3545,6 +3637,95 @@ def _read_streaming_content(self, response: Any, *, request_deadline: float, fir self.session.state.current_model_call_streaming_chars += output_chars return "".join(parts), usage + def _read_responses_stream(self, stream: Any, *, request_deadline: float, first_token_timeout: int | None) -> tuple[str, Json]: + parts: list[str] = [] + usage: Json = {} + completed_content = "" + first_output_seen = False + + def mark_output(chars: int) -> None: + nonlocal first_output_seen + if chars <= 0: + return + if not first_output_seen: + first_output_seen = True + self.session.state.current_model_call_has_content = True + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) + self.session.state.current_model_call_streaming_chars += chars + + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) + for event in stream: + data = self._sdk_json(event) + event_type = _json_str(data.get("type")) + self._raise_responses_stream_error(data) + event_usage = _json_dict(data.get("usage")) + if event_usage: + usage = event_usage + if event_type == "response.completed": + response = _json_dict(data.get("response")) + usage = _json_dict(response.get("usage")) or usage + response_content = self._responses_content(response) + if response_content and not parts and not completed_content: + completed_content = response_content + mark_output(len(response_content)) + continue + fallback_content = self._responses_event_content(data) + if fallback_content and not parts and not completed_content: + completed_content = fallback_content + mark_output(len(fallback_content)) + continue + output = self._responses_stream_output(data) + if not output: + continue + if output[0] == "content": + parts.append(output[1]) + mark_output(len(output[1])) + return "".join(parts) or completed_content, usage + + def _raise_responses_stream_error(self, event: Json) -> None: + code = _json_str(event.get("code")) + message = _json_str(event.get("message")) + if code or message: + raise LLMError("API request failed: " + (code or "error") + (": " + message if message else "")) + + def _responses_event_content(self, event: Json) -> str: + event_type = _json_str(event.get("type")) + if event_type == "response.output_text.done": + return _json_str(event.get("text")) + if event_type == "response.content_part.done": + return _json_str(_json_dict(event.get("part")).get("text")) + if event_type == "response.output_item.done": + item = _json_dict(event.get("item")) + return self._responses_content({"output": [item]}) or "" + if event_type == "response.done": + return self._responses_content(_json_dict(event.get("response"))) or "" + return "" + + def _responses_stream_output(self, event: Json) -> tuple[str, str] | None: + event_type = _json_str(event.get("type")) + if event_type in ("response.output_text.delta", "response.message.delta"): + text = event.get("delta") + if isinstance(text, str) and text: + return ("content", text) + if event_type == "response.reasoning.delta": + text = event.get("delta") + if isinstance(text, str) and text: + return ("reasoning", text) + return None + + def _sdk_json(self, value: Any) -> Json: + if isinstance(value, dict): + return value + if hasattr(value, "model_dump"): + dumped = value.model_dump(mode="json") + if not isinstance(dumped, dict): + return {} + output_text = getattr(value, "output_text", None) + if isinstance(output_text, str): + dumped["_sdk_output_text"] = output_text + return dumped + return {} + def _stream_output_chars(self, delta: Json) -> int: for key in ("content", "reasoning_content", "reasoning"): value = delta.get(key) @@ -3899,8 +4080,32 @@ def _message_content(self, result: JsonValue) -> str | None: return None return content + def _responses_content(self, result: JsonValue) -> str | None: + data = _json_dict(result) + output_text = data.get("_sdk_output_text") + if isinstance(output_text, str) and output_text: + return output_text + parts = [] + for item in _json_list(data.get("output")): + if _json_str(_json_dict(item).get("type")) != "message": + continue + for content in _json_list(_json_dict(item).get("content")): + text = _json_dict(content).get("text") + if isinstance(text, str): + parts.append(text) + return "".join(parts) if parts else None + def _format_missing_message_content(self, result: JsonValue) -> str: - choice = _json_dict(_json_list(_json_dict(result).get("choices"))[0]) + data = _json_dict(result) + if "output" in data: + details: Json = { + "output_types": [_json_str(_json_dict(item).get("type")) for item in _json_list(data.get("output"))], + } + return "API response missing output text: " + json.dumps(details, ensure_ascii=False) + choices = _json_list(data.get("choices")) + if not choices: + return "API response missing message content: " + json.dumps({"top_level_keys": sorted(str(key) for key in data)}, ensure_ascii=False) + choice = _json_dict(choices[0]) message = _json_dict(choice.get("message")) details: Json = { "finish_reason": choice.get("finish_reason"), @@ -3909,8 +4114,8 @@ def _format_missing_message_content(self, result: JsonValue) -> str: return "API response missing message content: " + json.dumps(details, ensure_ascii=False) def _record_usage(self, usage: Json, config: ProviderConfig, *, elapsed: float = 0.0) -> None: - prompt_tokens = self._json_int(usage.get("prompt_tokens")) - completion_tokens = self._json_int(usage.get("completion_tokens")) + prompt_tokens = self._json_int(usage.get("prompt_tokens")) or self._json_int(usage.get("input_tokens")) + completion_tokens = self._json_int(usage.get("completion_tokens")) or self._json_int(usage.get("output_tokens")) total_tokens = self._json_int(usage.get("total_tokens")) if completion_tokens > 0 and elapsed > 0: self.session.state.last_model_call_rate = completion_tokens / elapsed @@ -5559,9 +5764,6 @@ def _forget_active_hypothesis_error(self, actions: list[Json]) -> str: conflict = sorted((forgotten & protected) - released) return "active hypothesis source: " + ", ".join(conflict) if conflict else "" - def _plan_items_from_json(self, value: JsonValue) -> list[PlanItem]: - return [item for item in (self.state_updater._plan_item_from_json(raw) for raw in _json_list(value)) if item] - def _repeated_tool_retry_error(self, tool_calls: list[JsonValue]) -> str: if self.failed_tool_call_key is None or self.failed_tool_call_count < 2: return "" @@ -6399,21 +6601,19 @@ def _model_choices(self, provider: ProviderConfig) -> tuple[str, ...]: def _fetch_remote_models(self, provider: ProviderConfig) -> tuple[str, ...]: if not provider.url or not provider.key: return () - base_url = provider.url.rstrip("/") - if base_url.endswith("/chat/completions"): - base_url = base_url[: -len("/chat/completions")] - request = urllib.request.Request( - base_url + "/models", - headers={"Authorization": "Bearer " + provider.key, "User-Agent": HTTP_USER_AGENT}, - ) try: - with urllib.request.urlopen(request, timeout=3) as response: - data = json.loads(response.read().decode("utf-8")) + response = OpenAI( + api_key=provider.key, + base_url=provider.base_url(), + timeout=3, + max_retries=0, + default_headers={"User-Agent": HTTP_USER_AGENT}, + ).models.list(timeout=3) except Exception: return () ids = [] - for item in _json_list(_json_dict(data).get("data")): - model_id = _json_dict(item).get("id") + for item in getattr(response, "data", response): + model_id = item.get("id") if isinstance(item, dict) else getattr(item, "id", None) if isinstance(model_id, str) and model_id: ids.append(model_id) return tuple(dict.fromkeys(sorted(ids))) @@ -6507,7 +6707,8 @@ def _status(self, args: str) -> str: session = self.agent.session blackboard = self.agent.blackboard provider = session.config.provider - reasoning = provider.reasoning_effort if provider.reasoning else "off" + reasoning = self._format_provider_reasoning(provider) + api = provider.resolved_api() + ("(" + provider.api + ")" if provider.api == "auto" else "") model_usage = ( "\n".join( " " + (model.rsplit("/", 1)[-1] or model) + ": calls=" + str(usage.calls) + " tokens=" + _format_count(usage.total_tokens) @@ -6520,7 +6721,7 @@ def _status(self, args: str) -> str: return "\n".join( [ "provider: " + session.config.active_provider, - "model: " + (provider.model or "(empty)") + " reasoning=" + (reasoning or "(empty)") + " stream=" + self._format_bool(provider.stream), + "model: " + (provider.model or "(empty)") + " api=" + api + " reasoning=" + (reasoning or "(empty)") + " stream=" + self._format_bool(provider.stream), "session: " + session.session_id, "runtime: yolo=" + self._format_bool(session.settings.yolo) @@ -6568,10 +6769,12 @@ def _config(self, args: str) -> str: "provider.url: " + (provider_config.url or "(empty)"), "provider.key: " + ("(set)" if provider_config.key else "(empty)"), "provider.model: " + (provider_config.model or "(empty)"), + "provider.api: " + provider_config.api, "provider.available_models: " + (", ".join(provider_config.available_models) or "(empty)"), "provider.reasoning: " + self._format_bool(provider_config.reasoning), "provider.effort: " + (provider_config.reasoning_effort or "(empty)"), - "provider.reasoning_payload: " + (provider_config.reasoning_payload or "(empty)"), + "provider.chat_reasoning_payload: " + (provider_config.chat_reasoning_payload or "(empty)"), + "provider.resolved_chat_reasoning_payload: " + (provider_config.resolved_chat_reasoning_payload() or "(empty)"), "provider.stream: " + self._format_bool(provider_config.stream), "provider.temperature: " + self._format_optional(provider_config.temperature), "provider.timeout: " + self._format_optional(provider_config.timeout), @@ -6696,6 +6899,14 @@ def _clean(self, args: str) -> str: def _format_bool(self, value: bool | None) -> str: return "(fallback)" if value is None else ("on" if value else "off") + def _format_provider_reasoning(self, provider: ProviderConfig) -> str: + if provider.reasoning is False: + return "off" + effort = provider.reasoning_effort or "medium" + if provider.resolved_api() != "chat": + return effort + return effort + "(" + (provider.resolved_chat_reasoning_payload() or "no-payload") + ")" + def _format_optional(self, value: object) -> str: return str(value) if value is not None else "(fallback)" diff --git a/pyproject.toml b/pyproject.toml index 39f082e..2cffb49 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,7 +28,9 @@ classifiers = [ ] dependencies = [ "json-repair>=0.39", + "openai>=2.37.0", "prompt-toolkit>=3.0", + "socksio>=1.0.0", ] [project.urls] diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 78bfdd5..8872b67 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1,4 +1,3 @@ -import json import os import nanocode @@ -36,12 +35,15 @@ def _session( first_token_timeout: int | None = None, temperature: float | None = None, reasoning_effort: str = "", - reasoning_payload: str = "", + chat_reasoning_payload: str = "", yolo: bool = False, plan_mode: bool = False, debug: bool = False, + api: str = "", ) -> Session: provider: dict[str, object] = {"url": api_url, "key": api_key, "model": model} + if api: + provider["api"] = api if stream is not None: provider["stream"] = stream if timeout is not None: @@ -52,8 +54,8 @@ def _session( provider["temperature"] = temperature if reasoning_effort: provider["reasoning_effort"] = reasoning_effort - if reasoning_payload: - provider["reasoning_payload"] = reasoning_payload + if chat_reasoning_payload: + provider["chat_reasoning_payload"] = chat_reasoning_payload data = {"provider": {"active": "default", "default": provider}, "paths": {"data_dir": str(tmp_path / ".nanocode")}} return Session( cwd=str(tmp_path), @@ -62,6 +64,69 @@ def _session( ) +def _chat_response(content: str = '{"type":"message","text":"ok"}', usage: dict | None = None) -> dict: + return {"choices": [{"message": {"content": content}}], "usage": usage or {}} + + +def _stream_chunk(delta: dict | None = None, usage: dict | None = None, choices: bool = True) -> dict: + return {"choices": [{"delta": delta or {}}] if choices else [], "usage": usage} + + +def _responses_response(content: str = '{"type":"message","text":"ok"}', usage: dict | None = None) -> dict: + return {"output": [{"type": "message", "content": [{"type": "output_text", "text": content}]}], "usage": usage or {}} + + +def _responses_text_delta(text: str) -> dict: + return {"type": "response.output_text.delta", "delta": text} + + +def _responses_reasoning_delta(text: str) -> dict: + return {"type": "response.reasoning.delta", "delta": text} + + +def _responses_completed(usage: dict | None = None) -> dict: + return {"type": "response.completed", "response": {"usage": usage or {}}} + + +def _sdk_payload(call: dict) -> dict: + payload = dict(call) + payload.update(payload.pop("extra_body", {}) or {}) + payload.pop("timeout", None) + return payload + + +def _patch_openai(monkeypatch, responses): + calls = [] + response_calls = [] + client_kwargs = [] + queue = list(responses) if isinstance(responses, tuple) else [responses] + + class FakeCompletions: + def create(self, **kwargs): + calls.append(kwargs) + response = responses() if callable(responses) else queue.pop(0) + if isinstance(response, Exception): + raise response + return response + + class FakeResponses: + def create(self, **kwargs): + response_calls.append(kwargs) + response = responses() if callable(responses) else queue.pop(0) + if isinstance(response, Exception): + raise response + return response + + class FakeOpenAI: + def __init__(self, **kwargs): + client_kwargs.append(kwargs) + self.chat = type("FakeChat", (), {"completions": FakeCompletions()})() + self.responses = FakeResponses() + + monkeypatch.setattr(nanocode, "OpenAI", FakeOpenAI) + return calls, response_calls, client_kwargs + + def test_agent_tool_results_go_to_latest_tool_results_and_store(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\n", encoding="utf-8") @@ -836,73 +901,80 @@ def test_agent_prunes_tool_result_store_but_keeps_referenced_result_keys(tmp_pat def test_agent_request_calls_chat_completions_and_parses_json(tmp_path, monkeypatch): - captured = {} - - class FakeResponse: - def __enter__(self): - return self - - def __exit__(self, *args): - return None - - def read(self): - return json.dumps( - { - "choices": [{"message": {"content": json.dumps({"type": "message", "text": "ok"})}}], - "usage": {"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, - } - ).encode("utf-8") - - def fake_urlopen(request, timeout): - captured["url"] = request.full_url - captured["timeout"] = timeout - captured["payload"] = json.loads(request.data.decode("utf-8")) - captured["authorization"] = request.headers["Authorization"] - return FakeResponse() - - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) + calls, _response_calls, client_kwargs = _patch_openai(monkeypatch, _chat_response(usage={"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5})) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", timeout=12, stream=False) response = Agent(session).request("system", "user") + payload = _sdk_payload(calls[0]) assert response == {"actions": [{"type": "message", "text": "ok"}]} - assert captured["url"] == "https://example.test/v1/chat/completions" - assert captured["timeout"] == 12 - assert captured["authorization"] == "Bearer key" - assert captured["payload"]["model"] == "model" - assert captured["payload"]["messages"] == [{"role": "system", "content": "system"}, {"role": "user", "content": "user"}] - assert "temperature" not in captured["payload"] - assert "response_format" not in captured["payload"] - assert "reasoning_effort" not in captured["payload"] - assert "reasoning" not in captured["payload"] + assert client_kwargs[0]["base_url"] == "https://example.test/v1" + assert client_kwargs[0]["api_key"] == "key" + assert client_kwargs[0]["timeout"] == 12 + assert calls[0]["timeout"] == 12 + assert payload["model"] == "model" + assert payload["messages"] == [{"role": "system", "content": "system"}, {"role": "user", "content": "user"}] + assert "temperature" not in payload + assert "response_format" not in payload + assert "reasoning_effort" not in payload + assert "reasoning" not in payload assert session.state.last_prompt_tokens == 2 assert session.state.last_completion_tokens == 3 assert session.state.last_total_tokens == 5 def test_agent_request_sends_temperature_only_when_configured(tmp_path, monkeypatch): - captured = {} + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False, temperature=0.2) + + Agent(session).request("system", "user") + + assert _sdk_payload(calls[0])["temperature"] == 0.2 + +def test_agent_request_uses_responses_api_and_sdk_output_text(tmp_path, monkeypatch): class FakeResponse: - def __enter__(self): - return self + output_text = '{"type":"message","text":"ok"}' - def __exit__(self, *args): - return None + def model_dump(self, mode="json"): + return {"output": [], "usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}} - def read(self): - return json.dumps({"choices": [{"message": {"content": json.dumps({"type": "message", "text": "ok"})}}]}).encode("utf-8") + calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, FakeResponse()) + session = _session( + tmp_path, + api_url="https://api.openai.com/v1", + api_key="key", + model="model", + api="responses", + stream=False, + reasoning_effort="high", + ) - def fake_urlopen(request, timeout): - captured["payload"] = json.loads(request.data.decode("utf-8")) - return FakeResponse() + response = Agent(session).request("system", "user") + payload = _sdk_payload(response_calls[0]) - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False, temperature=0.2) + assert response == {"actions": [{"type": "message", "text": "ok"}]} + assert calls == [] + assert payload["model"] == "model" + assert payload["instructions"] == "system" + assert payload["input"] == "user" + assert payload["store"] is False + assert payload["reasoning"] == {"effort": "high"} + assert session.state.last_prompt_tokens == 2 + assert session.state.last_completion_tokens == 3 + assert session.state.last_total_tokens == 5 + + +def test_agent_request_responses_api_omits_reasoning_when_disabled(tmp_path, monkeypatch): + calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, _responses_response()) + session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses", stream=False) + session.config.provider.reasoning = False Agent(session).request("system", "user") + payload = _sdk_payload(response_calls[0]) - assert captured["payload"]["temperature"] == 0.2 + assert calls == [] + assert "reasoning" not in payload def test_plan_mode_uses_runtime_plan_timeouts(tmp_path): @@ -1085,41 +1157,20 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): def test_agent_request_streams_and_reports_completed_actions(tmp_path, monkeypatch): - captured = {} - - class FakeResponse: - def __enter__(self): - return self - - def __exit__(self, *args): - return None - - def __iter__(self): - chunks = [ - '{"type":"tool","name":"Read",', - '"intention":"read sample","args":["sample.txt"]}__END_ACTION__', - '{"type":"message","text":"done"}__END_ACTION__', - ] - for chunk in chunks: - yield ("data: " + json.dumps({"choices": [{"delta": {"content": chunk}}]}) + "\n").encode("utf-8") - yield ( - "data: " - + json.dumps({"choices": [], "usage": {"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}}) - + "\n" - ).encode("utf-8") - yield b"data: [DONE]\n" - - def fake_urlopen(request, timeout): - captured["payload"] = json.loads(request.data.decode("utf-8")) - return FakeResponse() - - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) + stream = [ + _stream_chunk({"content": '{"type":"tool","name":"Read",'}), + _stream_chunk({"content": '"intention":"read sample","args":["sample.txt"]}__END_ACTION__'}), + _stream_chunk({"content": '{"type":"message","text":"done"}__END_ACTION__'}), + _stream_chunk(usage={"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, choices=False), + ] + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, stream) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") response = Agent(session).request("system", "user") + payload = _sdk_payload(calls[0]) - assert captured["payload"]["stream"] is True - assert captured["payload"]["stream_options"] == {"include_usage": True} + assert payload["stream"] is True + assert payload["stream_options"] == {"include_usage": True} assert response["actions"] == [ {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt"]}, {"type": "message", "text": "done"}, @@ -1132,20 +1183,34 @@ def fake_urlopen(request, timeout): def test_agent_request_stream_uses_first_token_timeout_until_content(tmp_path, monkeypatch): timers = [] + _patch_openai( + monkeypatch, + [ + _stream_chunk({"role": "assistant"}), + _stream_chunk({"content": '{"type":"message","text":"ok"}__END_ACTION__'}), + ], + ) + monkeypatch.setattr(nanocode.signal, "setitimer", lambda timer, seconds: timers.append(seconds)) + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", timeout=90, first_token_timeout=4) - class FakeResponse: - def __enter__(self): - return self + response = Agent(session).request("system", "user") - def __exit__(self, *args): - return None + assert response["actions"][0]["text"] == "ok" + assert timers[0] == 90 + assert 4 in timers + assert timers[-1] == 0 - def __iter__(self): - yield ("data: " + json.dumps({"choices": [{"delta": {"role": "assistant"}}]}) + "\n").encode("utf-8") - yield ("data: " + json.dumps({"choices": [{"delta": {"content": '{"type":"message","text":"ok"}__END_ACTION__'}}]}) + "\n").encode("utf-8") - yield b"data: [DONE]\n" - monkeypatch.setattr(nanocode.urllib.request, "urlopen", lambda request, timeout: FakeResponse()) +def test_agent_request_stream_reasoning_chunks_count_as_first_output(tmp_path, monkeypatch): + timers = [] + _patch_openai( + monkeypatch, + [ + _stream_chunk({"reasoning_content": "thinking"}), + _stream_chunk({"reasoning_details": [{"type": "reasoning.text", "text": "more"}]}), + _stream_chunk({"content": '{"type":"message","text":"ok"}__END_ACTION__'}), + ], + ) monkeypatch.setattr(nanocode.signal, "setitimer", lambda timer, seconds: timers.append(seconds)) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", timeout=90, first_token_timeout=4) @@ -1157,21 +1222,108 @@ def __iter__(self): assert timers[-1] == 0 -def test_agent_request_records_stream_rate_from_usage(tmp_path, monkeypatch): - class FakeResponse: - def __enter__(self): - return self +def test_agent_request_responses_stream_reasoning_counts_as_first_output(tmp_path, monkeypatch): + timers = [] + stream = [ + _responses_reasoning_delta("thinking"), + _responses_text_delta('{"type":"message","text":"ok"}__END_ACTION__'), + _responses_completed({"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}), + ] + calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, stream) + monkeypatch.setattr(nanocode.signal, "setitimer", lambda timer, seconds: timers.append(seconds)) + session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses", timeout=90, first_token_timeout=4) + + response = Agent(session).request("system", "user") + payload = _sdk_payload(response_calls[0]) + + assert response["actions"][0]["text"] == "ok" + assert calls == [] + assert payload["stream"] is True + assert payload["reasoning"] == {"effort": "medium"} + assert timers[0] == 90 + assert 4 in timers + assert timers[-1] == 0 + assert session.state.last_prompt_tokens == 2 + assert session.state.last_completion_tokens == 3 + assert session.state.last_total_tokens == 5 + + +def test_agent_request_responses_stream_uses_completed_output_when_no_delta(tmp_path, monkeypatch): + stream = [ + _responses_completed({"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}) + | {"response": _responses_response(usage={"input_tokens": 2, "output_tokens": 3, "total_tokens": 5})}, + ] + calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, stream) + session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses") + + response = Agent(session).request("system", "user") + + assert response["actions"][0]["text"] == "ok" + assert calls == [] + assert response_calls[0]["stream"] is True + assert session.state.last_prompt_tokens == 2 + assert session.state.last_completion_tokens == 3 + assert session.state.last_total_tokens == 5 + + +def test_agent_request_responses_stream_uses_output_text_done_when_no_delta(tmp_path, monkeypatch): + timers = [] + stream = [ + {"type": "response.output_text.done", "text": '{"type":"message","text":"ok"}__END_ACTION__'}, + _responses_completed({"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}), + ] + calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, stream) + monkeypatch.setattr(nanocode.signal, "setitimer", lambda timer, seconds: timers.append(seconds)) + session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses", timeout=90, first_token_timeout=4) - def __exit__(self, *args): - return None + response = Agent(session).request("system", "user") + + assert response["actions"][0]["text"] == "ok" + assert calls == [] + assert response_calls[0]["stream"] is True + assert 4 in timers + assert timers[-2] > 80 - def __iter__(self): - yield ("data: " + json.dumps({"choices": [{"delta": {"content": '{"type":"message","text":"ok"}'}}]}) + "\n").encode("utf-8") - yield ("data: " + json.dumps({"choices": [], "usage": {"completion_tokens": 20, "total_tokens": 30}}) + "\n").encode("utf-8") - yield b"data: [DONE]\n" +def test_agent_request_responses_stream_does_not_count_done_after_delta_twice(tmp_path, monkeypatch): + chars_seen = [] + delta = '{"type":"message","text":"ok"}__END_ACTION__' + stream = [ + _responses_text_delta(delta), + {"type": "response.output_text.done", "text": delta}, + _responses_completed(), + ] + _patch_openai(monkeypatch, stream) + monkeypatch.setattr(nanocode.ModelClient, "_estimate_stream_rate", lambda self, elapsed: chars_seen.append(self.session.state.current_model_call_streaming_chars) or 0) + session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses") + + response = Agent(session).request("system", "user") + + assert response["actions"][0]["text"] == "ok" + assert chars_seen == [len(delta)] + + +def test_agent_request_responses_stream_error_event_raises_llm_error(tmp_path, monkeypatch): + _patch_openai(monkeypatch, [{"code": "InvalidParameter", "message": "Unsupported model: 'deepseek-v4-flash'."}]) + session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses") + + try: + Agent(session).request("system", "user") + except LLMError as error: + assert str(error) == "API request failed: InvalidParameter: Unsupported model: 'deepseek-v4-flash'." + else: + raise AssertionError("expected LLMError") + + +def test_agent_request_records_stream_rate_from_usage(tmp_path, monkeypatch): times = [100.0, 100.0, 100.0, 102.0] - monkeypatch.setattr(nanocode.urllib.request, "urlopen", lambda request, timeout: FakeResponse()) + _patch_openai( + monkeypatch, + [ + _stream_chunk({"content": '{"type":"message","text":"ok"}'}), + _stream_chunk(usage={"completion_tokens": 20, "total_tokens": 30}, choices=False), + ], + ) monkeypatch.setattr(nanocode.time, "monotonic", lambda: times.pop(0) if times else 102.0) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") @@ -1182,19 +1334,15 @@ def __iter__(self): def test_agent_request_stream_hard_timeout_becomes_model_timeout(tmp_path, monkeypatch): - class FakeResponse: - def __enter__(self): - return self - - def __exit__(self, *args): - return None - - def __iter__(self): + def stream(): + if False: + yield {} + while True: nanocode.signal.raise_signal(nanocode.signal.SIGALRM) - yield b"" + yield {} sleeps = [] - monkeypatch.setattr(nanocode.urllib.request, "urlopen", lambda request, timeout: FakeResponse()) + _patch_openai(monkeypatch, stream) monkeypatch.setattr(nanocode.time, "sleep", sleeps.append) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", timeout=12) @@ -1212,7 +1360,6 @@ def __iter__(self): def test_agent_run_reports_streamed_tool_actions_after_execution(tmp_path, monkeypatch): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") (tmp_path / "other.txt").write_text("beta\n", encoding="utf-8") - captured_payloads = [] responses = [ [ '{"type":"tool","name":"Read",', @@ -1228,27 +1375,7 @@ def test_agent_run_reports_streamed_tool_actions_after_execution(tmp_path, monke '{"type":"goal","text":"read sample","complete":true,"message_for_complete":"done"}__END_ACTION__', ], ] - - class FakeResponse: - def __init__(self, chunks): - self.chunks = chunks - - def __enter__(self): - return self - - def __exit__(self, *args): - return None - - def __iter__(self): - for chunk in self.chunks: - yield ("data: " + json.dumps({"choices": [{"delta": {"content": chunk}}]}) + "\n").encode("utf-8") - yield b"data: [DONE]\n" - - def fake_urlopen(request, timeout): - captured_payloads.append(json.loads(request.data.decode("utf-8"))) - return FakeResponse(responses.pop(0)) - - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, tuple([_stream_chunk({"content": chunk}) for chunk in chunks] for chunks in responses)) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") agent = Agent(session) agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 1 @@ -1256,6 +1383,7 @@ def fake_urlopen(request, timeout): messages = [] response = agent.run("read sample", on_message=messages.append) + captured_payloads = [_sdk_payload(call) for call in calls] assert response["actions"][-1] == {"type": "goal", "text": "read sample", "complete": True, "message_for_complete": "done"} assert len(captured_payloads) == 3 @@ -1265,94 +1393,230 @@ def fake_urlopen(request, timeout): assert messages[-1] == "done" -def test_agent_request_uses_configured_reasoning_payload(tmp_path, monkeypatch): - captured = {} - - class FakeResponse: - def __enter__(self): - return self +def test_agent_request_uses_configured_chat_reasoning_payload(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) + session = _session( + tmp_path, + api_url="https://example.test/v1", + api_key="key", + model="model", + reasoning_effort="high", + chat_reasoning_payload="reasoning", + stream=False, + ) - def __exit__(self, *args): - return None + Agent(session).request("system", "user") + payload = _sdk_payload(calls[0]) - def read(self): - return json.dumps({"choices": [{"message": {"content": json.dumps({"type": "message", "text": "ok"})}}], "usage": {}}).encode("utf-8") + assert payload["reasoning"] == {"effort": "high"} + assert "reasoning_effort" not in payload - def fake_urlopen(request, timeout): - captured["payload"] = json.loads(request.data.decode("utf-8")) - return FakeResponse() - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) +def test_agent_request_uses_configured_reasoning_effort_payload(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) session = _session( tmp_path, api_url="https://example.test/v1", api_key="key", model="model", reasoning_effort="high", - reasoning_payload="reasoning", + chat_reasoning_payload="reasoning_effort", stream=False, ) Agent(session).request("system", "user") + payload = _sdk_payload(calls[0]) - assert captured["payload"]["reasoning"] == {"effort": "high"} - assert "reasoning_effort" not in captured["payload"] + assert payload["reasoning_effort"] == "high" + assert "reasoning" not in payload -def test_agent_request_uses_configured_reasoning_effort_payload(tmp_path, monkeypatch): - captured = {} - - class FakeResponse: - def __enter__(self): - return self +def test_agent_request_uses_configured_thinking_payload(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) + session = _session( + tmp_path, + api_url="https://example.test/v1", + api_key="key", + model="model", + reasoning_effort="xhigh", + chat_reasoning_payload="thinking", + stream=False, + ) - def __exit__(self, *args): - return None + Agent(session).request("system", "user") + payload = _sdk_payload(calls[0]) - def read(self): - return json.dumps({"choices": [{"message": {"content": json.dumps({"type": "message", "text": "ok"})}}], "usage": {}}).encode("utf-8") + assert payload["thinking"] == {"type": "enabled"} + assert payload["reasoning_effort"] == "max" + assert "reasoning" not in payload - def fake_urlopen(request, timeout): - captured["payload"] = json.loads(request.data.decode("utf-8")) - return FakeResponse() - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) +def test_agent_request_uses_configured_thinking_disabled_payload(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) session = _session( tmp_path, api_url="https://example.test/v1", api_key="key", model="model", - reasoning_effort="high", - reasoning_payload="reasoning_effort", + chat_reasoning_payload="thinking", stream=False, ) + session.config.provider.reasoning = False Agent(session).request("system", "user") + payload = _sdk_payload(calls[0]) - assert captured["payload"]["reasoning_effort"] == "high" - assert "reasoning" not in captured["payload"] + assert payload["thinking"] == {"type": "disabled"} + assert "reasoning_effort" not in payload -def test_agent_request_accepts_json_fenced_model_content(tmp_path, monkeypatch): - class FakeResponse: - def __enter__(self): - return self +def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, tuple(_chat_response() for _ in range(8))) + + Agent( + _session( + tmp_path, + api_url="https://api.deepseek.com", + api_key="key", + model="model", + reasoning_effort="xhigh", + stream=False, + ) + ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://openrouter.ai/api/v1", + api_key="key", + model="model", + api="chat", + reasoning_effort="high", + stream=False, + ) + ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", + api_key="key", + model="qwen3.6-plus", + api="chat", + reasoning_effort="high", + stream=False, + ) + ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", + api_key="key", + model="deepseek-v4-flash", + api="chat", + reasoning_effort="xhigh", + stream=False, + ) + ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", + api_key="key", + model="glm-5.1", + api="chat", + reasoning_effort="high", + stream=False, + ) + ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://api.openai.com/v1", + api_key="key", + model="gpt-5", + api="chat", + reasoning_effort="medium", + stream=False, + ) + ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://not-openrouter.ai/api/v1", + api_key="key", + model="model", + stream=False, + ) + ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://example.test/v1", + api_key="key", + model="model", + stream=False, + ) + ).request("system", "user") + + payloads = [_sdk_payload(call) for call in calls] + assert payloads[0]["thinking"] == {"type": "enabled"} + assert payloads[0]["reasoning_effort"] == "max" + assert payloads[1]["reasoning"] == {"effort": "high"} + assert payloads[2]["enable_thinking"] is True + assert payloads[2]["thinking_budget"] == nanocode.ALIYUN_THINKING_BUDGET_BY_EFFORT["high"] + assert payloads[3]["thinking"] == {"type": "enabled"} + assert payloads[3]["reasoning_effort"] == "max" + assert payloads[4] == {"model": "glm-5.1", "messages": [{"role": "system", "content": "system"}, {"role": "user", "content": "user"}], "stream": False} + assert payloads[5]["reasoning_effort"] == "medium" + for payload in payloads[6:]: + assert "reasoning" not in payload + assert "reasoning_effort" not in payload + assert "thinking" not in payload + assert "enable_thinking" not in payload + + +def test_provider_config_auto_resolves_api_and_chat_reasoning_payload_from_profiles(): + openai_provider = nanocode.ProviderConfig.from_dict({"url": "https://api.openai.com/v1", "api": "auto"}) + openai_reasoning_provider = nanocode.ProviderConfig.from_dict({"url": "https://api.openai.com/v1", "api": "chat", "model": "gpt-5"}) + openrouter_provider = nanocode.ProviderConfig.from_dict({"url": "https://openrouter.ai/api/v1", "api": "auto"}) + dashscope_provider = nanocode.ProviderConfig.from_dict({"url": "https://dashscope.aliyuncs.com/compatible-mode/v1", "api": "auto", "model": "qwen3.6-plus"}) + dashscope_deepseek_provider = nanocode.ProviderConfig.from_dict({"url": "https://dashscope.aliyuncs.com/compatible-mode/v1", "api": "auto", "model": "deepseek-v4-flash"}) + unknown_provider = nanocode.ProviderConfig.from_dict({"url": "https://example.test/v1", "api": "auto"}) + + assert openai_provider.resolved_api() == "responses" + assert openai_provider.resolved_chat_reasoning_payload() == "" + assert openai_reasoning_provider.resolved_api() == "chat" + assert openai_reasoning_provider.resolved_chat_reasoning_payload() == "reasoning_effort" + assert openrouter_provider.resolved_api() == "responses" + assert openrouter_provider.resolved_chat_reasoning_payload() == "reasoning" + assert dashscope_provider.resolved_api() == "chat" + assert dashscope_provider.resolved_chat_reasoning_payload() == "enable_thinking" + assert dashscope_deepseek_provider.resolved_api() == "chat" + assert dashscope_deepseek_provider.resolved_chat_reasoning_payload() == "thinking" + assert unknown_provider.resolved_api() == "chat" + assert unknown_provider.resolved_chat_reasoning_payload() == "" + + +def test_agent_request_empty_chat_reasoning_payload_disables_auto_detection(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) + session = _session( + tmp_path, + api_url="https://api.deepseek.com", + api_key="key", + model="model", + stream=False, + ) + session.config.provider.chat_reasoning_payload = "" - def __exit__(self, *args): - return None + Agent(session).request("system", "user") + payload = _sdk_payload(calls[0]) - def read(self): - return json.dumps( - { - "choices": [{"message": {"content": '```json\n{"type":"message","text":"ok"}\n__END_ACTION__\n```'}}], - "usage": {}, - } - ).encode("utf-8") + assert "reasoning" not in payload + assert "reasoning_effort" not in payload + assert "thinking" not in payload - def fake_urlopen(request, timeout): - return FakeResponse() - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) +def test_agent_request_accepts_json_fenced_model_content(tmp_path, monkeypatch): + _patch_openai(monkeypatch, _chat_response('```json\n{"type":"message","text":"ok"}\n__END_ACTION__\n```')) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) response = Agent(session).request("system", "user") @@ -1678,20 +1942,7 @@ def test_agent_request_rejects_native_tool_call_syntax(tmp_path): def test_agent_request_wraps_non_json_model_content_as_format_error(tmp_path, monkeypatch): - class FakeResponse: - def __enter__(self): - return self - - def __exit__(self, *args): - return None - - def read(self): - return json.dumps({"choices": [{"message": {"content": "plain answer"}}], "usage": {}}).encode("utf-8") - - def fake_urlopen(request, timeout): - return FakeResponse() - - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) + _patch_openai(monkeypatch, _chat_response("plain answer")) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) response = Agent(session).request("system", "user") @@ -1711,30 +1962,18 @@ def test_agent_request_rejects_invalid_unmarked_json_action_array(tmp_path): def test_agent_request_wraps_missing_message_content_as_format_error(tmp_path, monkeypatch): - class FakeResponse: - def __enter__(self): - return self - - def __exit__(self, *args): - return None - - def read(self): - return json.dumps( + _patch_openai( + monkeypatch, + { + "choices": [ { - "choices": [ - { - "finish_reason": "stop", - "message": {"role": "assistant", "content": None}, - } - ], - "usage": {}, + "finish_reason": "stop", + "message": {"role": "assistant", "content": None}, } - ).encode("utf-8") - - def fake_urlopen(request, timeout): - return FakeResponse() - - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) + ], + "usage": {}, + }, + ) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) response = Agent(session).request("system", "user") diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index f5742ab..474e589 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -16,6 +16,25 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): return {"summary": self.summary} +def patch_openai_models(monkeypatch, models=None, error: Exception | None = None): + seen = {} + + class FakeModels: + def list(self, **kwargs): + seen["list_kwargs"] = kwargs + if error is not None: + raise error + return type("ModelList", (), {"data": [type("Model", (), {"id": model})() for model in (models or ())]})() + + class FakeOpenAI: + def __init__(self, **kwargs): + seen["client_kwargs"] = kwargs + self.models = FakeModels() + + monkeypatch.setattr(nanocode, "OpenAI", FakeOpenAI) + return seen + + def make_session(tmp_path, *, model: str = "", stream: bool | None = None, compact_at: int = 50) -> Session: provider: dict[str, object] = {"model": model} if stream is not None: @@ -75,7 +94,7 @@ def test_status_reports_tokens_in_human_readable_format(tmp_path): assert result.status == CommandStatus.HANDLED assert "tokens: last=1k session=2m" in result.message - assert "model: model reasoning=medium stream=on" in result.message + assert "model: model api=chat(auto) reasoning=medium(no-payload) stream=on" in result.message assert "session: " + session.session_id in result.message assert "runtime: yolo=off plan=off compact_at=50" in result.message assert "models:" in result.message @@ -317,37 +336,26 @@ def test_model_command_lists_configured_models_before_remote_models(tmp_path, mo session.config.provider.url = "https://provider.example/v1" session.config.provider.key = "key" session.config.provider.available_models = ("old", "manual") - seen = {} - - def fake_urlopen(request, timeout): - assert request.full_url == "https://provider.example/v1/models" - seen["auth"] = request.headers["Authorization"] - - class Response: - def __enter__(self): - return self - - def __exit__(self, exc_type, exc, tb): - return False - - @staticmethod - def read(): - return b'{"data":[{"id":"remote-b"},{"id":"manual"},{"id":"remote-a"}]}' - - return Response() + seen = patch_openai_models(monkeypatch, ("remote-b", "manual", "remote-a")) def select_model(models, current): seen["models"] = models seen["current"] = current return "remote-a" - monkeypatch.setattr(nanocode.urllib.request, "urlopen", fake_urlopen) dispatcher = CommandDispatcher(Agent(session), select_model=select_model) result = dispatcher.dispatch("/model") assert seen == { - "auth": "Bearer key", + "client_kwargs": { + "api_key": "key", + "base_url": "https://provider.example/v1", + "timeout": 3, + "max_retries": 0, + "default_headers": {"User-Agent": "nanocode/" + nanocode.__version__}, + }, + "list_kwargs": {"timeout": 3}, "models": ( CommandDispatcher.MODEL_CONFIGURED_LABEL, "old", @@ -373,7 +381,7 @@ def select_model(models, current): seen["models"] = models return "manual" - monkeypatch.setattr(nanocode.urllib.request, "urlopen", lambda request, timeout: (_ for _ in ()).throw(OSError("offline"))) + patch_openai_models(monkeypatch, error=OSError("offline")) dispatcher = CommandDispatcher(Agent(session), select_model=select_model) result = dispatcher.dispatch("/model") diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index b6a0138..91f5935 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -79,7 +79,7 @@ def test_init_config_file_writes_default_toml(tmp_path): assert config["provider"]["default"]["url"] == "" assert "available_models" not in config["provider"]["default"] assert "temperature" not in config["provider"]["default"] - assert "reasoning_payload" not in config["provider"]["default"] + assert "chat_reasoning_payload" not in config["provider"]["default"] assert config["provider"]["default"]["timeout"] == 180 assert config["provider"]["default"]["first_token_timeout"] == 90 assert config["runtime"]["compact_at"] == 50 @@ -508,7 +508,7 @@ def run(self, user_input, *, confirm=None, on_auto_approve=None, on_message=None assert result == 0 assert any("nanocode - AI coding assistant" in output for output in outputs) - assert any("model: model reasoning=medium stream=on" in output for output in outputs) + assert any("model: model api=chat(auto) reasoning=medium(no-payload) stream=on" in output for output in outputs) assert "assistant response" in outputs assert loop.agent.runs == ["hello"] From 094b11999464d3fca0de5154729fd044b1afa08b Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 04:38:35 -0700 Subject: [PATCH 003/144] Add in-flight model retry shortcut --- README.md | 3 + nanocode.py | 161 ++++++++++++++++++++++++++--------- tests/test_nanocode_agent.py | 24 ++++++ tests/test_nanocode_loop.py | 20 +++++ 4 files changed, 166 insertions(+), 42 deletions(-) diff --git a/README.md b/README.md index 12573a6..33059be 100644 --- a/README.md +++ b/README.md @@ -75,6 +75,8 @@ If you do not fully trust the model, tools, prompts, or workspace, run nanocode USE AT YOUR OWN RISK. +nanocode currently targets macOS and Linux. Windows is not supported. + ## Tools - File: `Read`, `LineCount`, `ListDir`, `Search`. @@ -90,6 +92,7 @@ USE AT YOUR OWN RISK. - Exit: `/exit`, `/quit`. Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model ` and `/reason` are direct shortcuts. +During a slow model request, press `Ctrl-G` to cancel that request and resend the same prompt. ## Configuration diff --git a/nanocode.py b/nanocode.py index 793e7f4..548d68d 100644 --- a/nanocode.py +++ b/nanocode.py @@ -79,6 +79,9 @@ class ConfigError(Error): ... class ModelRequestTimeout(Error): ... +class ModelRequestRetry(Error): ... + + class Cancellation(Error): ... @@ -921,6 +924,7 @@ class RuntimeState: current_model_call_has_content: bool = False current_model_call_streaming_chars: int = 0 last_model_call_rate: float = 0.0 + manual_model_retry_requested: bool = False status_notice: str = "" status_notice_until: float = 0.0 conversation: list[ConversationItem] = field(default_factory=list) @@ -3491,49 +3495,57 @@ def request( client = self._client(config, timeout=timeout) request_elapsed = 0.0 try: - self.session.state.current_model_call_started_at = time.monotonic() - self.session.state.current_model_call_label = model - self.session.state.current_model_call_reasoning_label = config.reasoning_effort if config.reasoning else "off" - self.session.state.current_model_call_activity = activity - self.session.state.current_model_call_has_content = False - self.session.state.current_model_call_streaming_chars = 0 - request_deadline = self.session.state.current_model_call_started_at + max(0, timeout) - previous_handler = signal.getsignal(signal.SIGALRM) - signal.signal(signal.SIGALRM, self._timeout_handler) - self._timeout_reason = "request model timeout" - signal.setitimer(signal.ITIMER_REAL, max(0, timeout)) - try: - completion = ( - client.responses.create(**params, timeout=timeout) - if api == "responses" - else client.chat.completions.create(**params, timeout=timeout) - ) - if stream: - content, usage = ( - self._read_responses_stream(completion, request_deadline=request_deadline, first_token_timeout=first_token_timeout) - if api == "responses" - else self._read_streaming_content( - completion, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, - ) - ) - result: Json = {"usage": usage} - else: - result = self._sdk_json(completion) - finally: - signal.setitimer(signal.ITIMER_REAL, 0) - signal.signal(signal.SIGALRM, previous_handler) - if self.session.state.current_model_call_started_at > 0: - request_elapsed = max(0.0, time.monotonic() - self.session.state.current_model_call_started_at) - if request_elapsed > 0 and self.session.state.current_model_call_streaming_chars > 0: - self.session.state.last_model_call_rate = self._estimate_stream_rate(request_elapsed) - self.session.state.current_model_call_started_at = 0.0 - self.session.state.current_model_call_label = "" - self.session.state.current_model_call_reasoning_label = "" - self.session.state.current_model_call_activity = "" + with ModelRetryShortcut(self.session): + self.session.state.current_model_call_started_at = time.monotonic() + self.session.state.current_model_call_label = model + self.session.state.current_model_call_reasoning_label = config.reasoning_effort if config.reasoning else "off" + self.session.state.current_model_call_activity = activity self.session.state.current_model_call_has_content = False self.session.state.current_model_call_streaming_chars = 0 + request_deadline = self.session.state.current_model_call_started_at + max(0, timeout) + previous_handler = signal.getsignal(signal.SIGALRM) + signal.signal(signal.SIGALRM, self._timeout_handler) + self._timeout_reason = "request model timeout" + signal.setitimer(signal.ITIMER_REAL, max(0, timeout)) + try: + completion = ( + client.responses.create(**params, timeout=timeout) + if api == "responses" + else client.chat.completions.create(**params, timeout=timeout) + ) + if stream: + content, usage = ( + self._read_responses_stream(completion, request_deadline=request_deadline, first_token_timeout=first_token_timeout) + if api == "responses" + else self._read_streaming_content( + completion, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + ) + result: Json = {"usage": usage} + else: + result = self._sdk_json(completion) + finally: + signal.setitimer(signal.ITIMER_REAL, 0) + signal.signal(signal.SIGALRM, previous_handler) + if self.session.state.current_model_call_started_at > 0: + request_elapsed = max(0.0, time.monotonic() - self.session.state.current_model_call_started_at) + if request_elapsed > 0 and self.session.state.current_model_call_streaming_chars > 0: + self.session.state.last_model_call_rate = self._estimate_stream_rate(request_elapsed) + self.session.state.current_model_call_started_at = 0.0 + self.session.state.current_model_call_label = "" + self.session.state.current_model_call_reasoning_label = "" + self.session.state.current_model_call_activity = "" + self.session.state.current_model_call_has_content = False + self.session.state.current_model_call_streaming_chars = 0 + except KeyboardInterrupt: + if self.session.state.manual_model_retry_requested: + self.session.state.manual_model_retry_requested = False + raise ModelRequestRetry() + raise + except ModelRequestRetry: + raise except ModelRequestTimeout as error: raise LLMError(str(error) or "request model timeout") except APITimeoutError: @@ -5169,10 +5181,15 @@ def request( activity: str = "agent", on_message: MessageCallback | None = None, ) -> Json: - for attempt in range(len(self.MODEL_TIMEOUT_RETRY_DELAYS) + 1): + attempt = 0 + while attempt <= len(self.MODEL_TIMEOUT_RETRY_DELAYS): try: self.session.state.turn_model_calls += 1 return self.model_client.request(system_prompt, user_prompt, activity=activity) + except ModelRequestRetry: + if on_message is not None and self.session.settings.debug: + on_message("Retrying: manual model retry requested.") + continue except LLMError as error: timeout_reason = str(error) if timeout_reason not in ("request model timeout", "request first token timeout") or attempt >= len(self.MODEL_TIMEOUT_RETRY_DELAYS): @@ -5189,6 +5206,7 @@ def request( + str(delay) + "s." ) + attempt += 1 time.sleep(delay) raise LLMError("request model timeout") @@ -7065,6 +7083,64 @@ def _sweep_fragments(self, text: str, now: float) -> list[tuple[str, str]]: return fragments +class ModelRetryShortcut: + CTRL_G = 0x07 + + def __init__(self, session: Session): + self.session = session + self.fd: int | None = None + self.original_attrs = None + self.previous_handler = None + + def __enter__(self) -> Self: + if not sys.stdin.isatty() or not hasattr(signal, "SIGQUIT"): + return self + try: + import termios + except ImportError: + return self + try: + self.fd = sys.stdin.fileno() + self.original_attrs = termios.tcgetattr(self.fd) + attrs = list(self.original_attrs) + attrs[6] = list(attrs[6]) + attrs[6][termios.VQUIT] = self._control_char(attrs[6], self.CTRL_G) + if hasattr(termios, "VREPRINT"): + attrs[6][termios.VREPRINT] = self._control_char(attrs[6], os.fpathconf(self.fd, "PC_VDISABLE")) + termios.tcsetattr(self.fd, termios.TCSADRAIN, attrs) + self.previous_handler = signal.getsignal(signal.SIGQUIT) + signal.signal(signal.SIGQUIT, self._handle_signal) + except (AttributeError, OSError, ValueError, termios.error): + self.fd = None + self.original_attrs = None + return self + + def __exit__(self, *args) -> None: + try: + import termios + except ImportError: + return + if self.previous_handler is not None: + signal.signal(signal.SIGQUIT, self.previous_handler) + self.previous_handler = None + if self.fd is not None and self.original_attrs is not None: + try: + termios.tcsetattr(self.fd, termios.TCSADRAIN, self.original_attrs) + except termios.error: + pass + self.fd = None + self.original_attrs = None + + @staticmethod + def _control_char(chars: list[Any], value: int) -> int | bytes: + return bytes([value]) if chars and isinstance(chars[0], bytes) else value + + def _handle_signal(self, signum: int, frame: Any) -> None: + if self.session.state.current_model_call_started_at > 0: + self.session.state.manual_model_retry_requested = True + raise KeyboardInterrupt + + class AgentLoop: LIVE_PREVIEW_MAX_LINES: ClassVar[int] = 10 LIVE_PREVIEW_MAX_CHARS: ClassVar[int] = 20_000 @@ -7511,6 +7587,7 @@ def _run_agent(self, user_input: str) -> None: except Exception as error: self._emit("Error: " + str(error)) finally: + self.agent.session.state.manual_model_retry_requested = False self._finish_live_tool_output() self.status_bar.pause() diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 8872b67..dc7ddcd 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -923,6 +923,30 @@ def test_agent_request_calls_chat_completions_and_parses_json(tmp_path, monkeypa assert session.state.last_total_tokens == 5 +def test_agent_request_manual_retry_resends_same_model_prompt(tmp_path): + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) + agent = Agent(session) + + class FakeModelClient: + def __init__(self): + self.calls = 0 + + def request(self, system_prompt, user_prompt, *, activity="agent"): + self.calls += 1 + if self.calls == 1: + raise nanocode.ModelRequestRetry() + return {"actions": [{"type": "message", "text": system_prompt + "/" + user_prompt + "/" + activity}]} + + fake_client = FakeModelClient() + agent.model_client = fake_client + + response = agent.request("system", "user", activity="observe") + + assert response == {"actions": [{"type": "message", "text": "system/user/observe"}]} + assert fake_client.calls == 2 + assert session.state.status_notice == "" + + def test_agent_request_sends_temperature_only_when_configured(tmp_path, monkeypatch): calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False, temperature=0.2) diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 91f5935..2891926 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -487,6 +487,26 @@ def tcflush(fd, queue): assert outputs == ["Answer: yes"] +def test_model_retry_shortcut_signal_only_retries_active_model_request(tmp_path): + session = make_session(tmp_path, model="model") + shortcut = nanocode.ModelRetryShortcut(session) + + shortcut._handle_signal(0, None) + + assert session.state.manual_model_retry_requested is False + + session.state.current_model_call_started_at = 1.0 + try: + shortcut._handle_signal(0, None) + except KeyboardInterrupt: + interrupted = True + else: + interrupted = False + + assert interrupted is True + assert session.state.manual_model_retry_requested is True + + def test_agent_loop_dispatches_commands_and_user_input(tmp_path): class FakeAgent: def __init__(self): From 62a9ce0671686439acf7b016e47529dd2bf27915 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 04:43:28 -0700 Subject: [PATCH 004/144] Prevent chat from ending active tasks early --- nanocode.py | 14 +++++++++- tests/test_nanocode_agent.py | 52 ++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+), 1 deletion(-) diff --git a/nanocode.py b/nanocode.py index 548d68d..ee5ef8e 100644 --- a/nanocode.py +++ b/nanocode.py @@ -5156,6 +5156,7 @@ def __init__(self, session: Session): self.agent_feedback_errors: list[str] = [] self.observe_feedback_errors: list[str] = [] self.task_alignment_required = False + self.incomplete_task_context_at_turn_start = False self.mode = AgentMode.ACT def build_user_prompt(self) -> str: @@ -5870,6 +5871,16 @@ def _build_response_context(self, response: Json) -> ResponseContext: def _handle_chat_response(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: if ctx.chat_message is None: return None + if ctx.completion_message: + return None + if ctx.state_or_work_requested or self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start: + return self._reject_result( + self._remember_agent_error, + on_message, + self._error("chat cannot finish an active task.", self.RULE_FINAL_ACTION), + "Retrying: active task is not complete.", + "Completion_Gate: chat before task completion.", + ) self.blackboard.task_code = TaskCode.DONE self.session.append_conversation(AssistantMessage(content=ctx.chat_message)) if on_message is not None: @@ -6323,12 +6334,13 @@ def run( old_task_context = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) self.blackboard.user_input = user_input previous_task_done = self.blackboard.task_code == TaskCode.DONE + self.incomplete_task_context_at_turn_start = old_task_context and not previous_task_done if previous_task_done: self.blackboard.work_mode = WorkMode.NORMAL # Keep previous task state at a new user turn so short follow-ups like # "continue" can resume. The first response must align with it before work # when the new request does not match the previous goal. - self.task_alignment_required = old_task_context and self._task_text_key(user_input) != self._task_text_key(old_goal) + self.task_alignment_required = self.incomplete_task_context_at_turn_start and self._task_text_key(user_input) != self._task_text_key(old_goal) self.blackboard.task_code = TaskCode.NEW self.blackboard.goal_reached = False self.blackboard.verification_required = False diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index dc7ddcd..0e5e063 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -3774,6 +3774,58 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.blackboard.goal_reached is False +def test_agent_run_allows_chat_without_task_context(tmp_path): + class FakeModelClient: + def request(self, system_prompt, user_prompt, *, activity="agent"): + return {"actions": [{"type": "chat", "text": "hello"}]} + + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + agent.model_client = FakeModelClient() + messages = [] + + response = agent.run("hi", on_message=messages.append) + + assert response["actions"] == [{"type": "chat", "text": "hello"}] + assert messages == ["hello"] + assert session.state.conversation[-1].content == "hello" + + +def test_agent_run_retries_chat_with_unfinished_task_context(tmp_path): + class FakeModelClient: + def __init__(self): + self.user_prompts = [] + self.responses = [ + {"actions": [{"type": "chat", "text": "done too early"}]}, + { + "actions": [ + {"type": "plan", "mode": "patch", "items": [{"id": "p1", "status": "done", "context": "answered"}]}, + *_final_actions("answer"), + ] + }, + ] + + def request(self, system_prompt, user_prompt, *, activity="agent"): + self.user_prompts.append(user_prompt) + return self.responses.pop(0) + + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + agent.blackboard.goal = "answer" + agent.blackboard.task_code = nanocode.TaskCode.WORKING + agent.blackboard.plan = [nanocode.PlanItem(id="p1", text="answer", status=nanocode.PlanStatus.DOING)] + agent.model_client = FakeModelClient() + messages = [] + + response = agent.run("answer", on_message=messages.append) + + assert response["actions"][-1]["message_for_complete"] == "done" + assert messages[-1] == "done" + assert len(agent.model_client.user_prompts) == 2 + assert "done too early" not in [item.content for item in session.state.conversation] + assert any("chat cannot finish an active task" in error for error in agent.agent_feedback_errors) + + def test_agent_run_retries_goal_complete_with_unfinished_plan(tmp_path): class FakeModelClient: def __init__(self): From 20628b3bc4b60ec0138ec1bf590e4c8f606aa19d Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 04:47:52 -0700 Subject: [PATCH 005/144] Allow CreateFile to create cwd-local parent dirs --- nanocode.py | 9 +++++++-- tests/test_nanocode_create_file_tool.py | 22 ++++++++++++++++++++++ 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index ee5ef8e..3b6374d 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2243,7 +2243,7 @@ def call(self) -> str: class CreateFileTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Create a new UTF-8 file with short initial content; parent directory must exist and target file must not exist.", + "Create a new UTF-8 file with short initial content; target file must not exist.", "For substantial new files, create only a small skeleton first, then grow it with focused ReplaceRange edits.", ) SIGNATURE: ClassVar[str] = "CreateFile(filepath, content) -> CreateFileToolResult" @@ -2252,6 +2252,7 @@ class CreateFileTool(Tool): filepath: str = "" content: str = "" cwd: str = "" + can_create_parent: bool = False @classmethod def cli_args(cls, args: list[str]) -> list[str]: @@ -2263,7 +2264,8 @@ def cli_args(cls, args: list[str]) -> list[str]: def make(cls, session: Session, args: list[str]) -> Self: if len(args) != 2: raise ToolCallArgError('requires exactly 2 args: filepath, content. Example: CreateFile("new.py", "content\\n")') - return cls(filepath=session.resolve_path(args[0]), content=str(args[1]), cwd=session.cwd) + filepath = session.resolve_path(args[0]) + return cls(filepath=filepath, content=str(args[1]), cwd=session.cwd, can_create_parent=session.is_path_in_cwd(os.path.dirname(filepath))) def preview(self) -> str: label = f"CreateFile({self.filepath})" @@ -2272,6 +2274,9 @@ def preview(self) -> str: return _make_unified_diff("", self.content, self.filepath) or label def call(self) -> str: + parent = os.path.dirname(self.filepath) + if parent and not os.path.isdir(parent) and self.can_create_parent: + os.makedirs(parent, exist_ok=True) try: with open(self.filepath, "x", encoding="utf-8") as f: f.write(self.content) diff --git a/tests/test_nanocode_create_file_tool.py b/tests/test_nanocode_create_file_tool.py index 1fb95c1..46ebdbb 100644 --- a/tests/test_nanocode_create_file_tool.py +++ b/tests/test_nanocode_create_file_tool.py @@ -37,6 +37,28 @@ def test_create_file_tool_rejects_existing_file(tmp_path): assert path.read_text(encoding="utf-8") == "existing\n" +def test_create_file_tool_creates_missing_parent_inside_cwd(tmp_path): + path = tmp_path / "nested" / "created.txt" + session = Session(cwd=str(tmp_path)) + + tool = CreateFileTool.make(session, ["nested/created.txt", "alpha\n"]) + result = tool.call() + + assert path.read_text(encoding="utf-8") == "alpha\n" + assert "* path: nested/created.txt" in result + + +def test_create_file_tool_rejects_missing_parent_outside_cwd(tmp_path): + outside = tmp_path.parent / (tmp_path.name + "-outside") / "created.txt" + session = Session(cwd=str(tmp_path)) + + tool = CreateFileTool.make(session, [str(outside), "alpha\n"]) + + with pytest.raises(ToolCallError, match="No such file or directory"): + tool.call() + assert not outside.exists() + + def test_main_agent_can_execute_create_file_tool(tmp_path): path = tmp_path / "created.txt" session = Session(cwd=str(tmp_path)) From 050573709cf6d23cf7436975aab4344df8447dc6 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 04:53:00 -0700 Subject: [PATCH 006/144] Surface tool cancellation reasons in agent feedback --- nanocode.py | 9 +++++++++ tests/test_nanocode_agent.py | 2 ++ 2 files changed, 11 insertions(+) diff --git a/nanocode.py b/nanocode.py index 3b6374d..1e8370d 100644 --- a/nanocode.py +++ b/nanocode.py @@ -5515,6 +5515,15 @@ def _should_observe_after_tools(self) -> bool: def _after_tool_execution(self, execution: ToolCallExecution) -> None: self._remember_tool_failure(execution) + if execution.error_type is Cancellation: + detail = " ".join(execution.output.split()) + detail = detail.removeprefix("Cancelled: ") + self._remember_agent_error( + self._error( + "tool call was cancelled: " + _format_tool_call_summary(execution.call) + " -> " + detail + ".", + "do not repeat it unchanged; follow the cancellation or refusal reason.", + ) + ) if execution.error_type is not None and issubclass(execution.error_type, ToolCallArgError): detail = self._format_tool_arg_error(execution) rule = self.RULE_TOOL_SIGNATURE diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 0e5e063..9bc610b 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2602,6 +2602,8 @@ def test_agent_execute_tool_calls_records_refusal_reason(tmp_path): assert path.read_text(encoding="utf-8") == "old\n" assert session.state.conversation == [] assert os.path.isdir(session.tool_results_dir()) + assert any("please inspect tests first" in error for error in agent.agent_feedback_errors) + assert "please inspect tests first" in agent.build_user_prompt() def test_agent_execute_tool_calls_stops_batch_after_refusal(tmp_path): From 19463582be0e01eb35fac053c672d77d5ef09ba2 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 05:21:17 -0700 Subject: [PATCH 007/144] Confirm selector search before selecting --- nanocode.py | 4 +++ tests/test_nanocode_loop.py | 53 +++++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+) diff --git a/nanocode.py b/nanocode.py index 1e8370d..c6c0c1c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -7420,6 +7420,10 @@ def _cancel_search(event): @bindings.add("enter", eager=True) def _accept(event): + if state["searching"]: + state["searching"] = False + event.app.invalidate() + return options = enabled() if options: event.app.exit(result=options[int(state["selected"])]) diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 2891926..80d818b 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -663,6 +663,59 @@ def __init__(self): assert "old" not in outputs[-1] +def test_agent_loop_choice_prompt_enter_confirms_search_before_select(tmp_path, monkeypatch): + class FakeStdin: + @staticmethod + def isatty(): + return True + + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="old") + + class FakePromptApp: + result = None + + def invalidate(self): + pass + + def exit(self, result=None, exception=None): + if exception is not None: + raise exception + self.result = result + + def handler(bindings, key): + return next(binding.handler for binding in bindings.bindings if binding.keys == (key,)) + + class FakeEvent: + def __init__(self, app, data=""): + self.app = app + self.data = data + + class FakeApplication: + def __init__(self, **kwargs): + self.bindings = kwargs["key_bindings"] + + def run(self): + app = FakePromptApp() + handler(self.bindings, "/")(FakeEvent(app, "/")) + any_key = handler(self.bindings, nanocode.Keys.Any) + for char in "remote": + any_key(FakeEvent(app, char)) + enter = handler(self.bindings, nanocode.Keys.ControlM) + enter(FakeEvent(app, "\r")) + assert app.result is None + enter(FakeEvent(app, "\r")) + return app.result + + monkeypatch.setattr(nanocode.sys, "stdin", FakeStdin()) + monkeypatch.setattr(nanocode, "Application", FakeApplication) + + loop = AgentLoop(FakeAgent(), prompt_session=object()) + + assert loop._select_choice("Model", ("old", "remote-a", "remote-b"), current="old") == "remote-a" + + def test_agent_loop_uses_prompt_toolkit_session(tmp_path): calls = [] From c406f4d77c3309363966ebde59396453814b5430 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 05:24:29 -0700 Subject: [PATCH 008/144] Relax ReplaceRange boundary context for replacements --- nanocode.py | 7 ++++--- tests/test_nanocode_replace_range_tool.py | 25 +++++++++++++++++++++++ 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/nanocode.py b/nanocode.py index c6c0c1c..5502fed 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2310,7 +2310,7 @@ class ReplaceRangeTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Replace one or more small Read-backed [start,end) ranges in an existing file; best when exact line ranges are known or target text is not unique.", "For several independent ranges in the same file, pass a batch as ReplaceRange(filepath, [[start,end,fingerprint,before_context,after_context,content], ...]).", - "Pass exact before_context and after_context boundary lines; use empty string at BOF/EOF.", + "Pass exact before_context and after_context when known; empty boundary context is allowed for non-empty replacements.", "Content is only the replacement for that range; do not include boundary lines.", ) SIGNATURE: ClassVar[str] = ( @@ -2526,9 +2526,10 @@ def _reject_overlapping_ranges(replacements: list[tuple[RangeFingerprintStore.Re def _validate_boundary_context(lines: list[str], resolved: RangeFingerprintStore.Resolved, edit: ReplaceRangeEdit, replacement: list[str]) -> None: before_context = "" if resolved.start == 0 else lines[resolved.start - 1] after_context = "" if resolved.end >= len(lines) else lines[resolved.end] - if edit.before_context != before_context: + inserting = resolved.start == resolved.end + if edit.before_context != before_context and (edit.before_context or inserting): raise ToolCallError("before_context mismatch; Read the target range with one line before and retry") - if edit.after_context != after_context: + if edit.after_context != after_context and (edit.after_context or inserting): raise ToolCallError("after_context mismatch; Read the target range with one line after and retry") if before_context and replacement and replacement[0] == before_context: raise ToolCallError("content includes before_context; expand start or remove the boundary line from content") diff --git a/tests/test_nanocode_replace_range_tool.py b/tests/test_nanocode_replace_range_tool.py index 5fbc02c..eca8359 100644 --- a/tests/test_nanocode_replace_range_tool.py +++ b/tests/test_nanocode_replace_range_tool.py @@ -66,6 +66,17 @@ def test_replace_range_tool_rejects_after_context_mismatch(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" +def test_replace_range_tool_allows_empty_boundary_context_for_non_empty_range(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + + ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "", "", "BETA\n")).call() + + assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" + + def test_replace_range_tool_rejects_content_that_repeats_boundary_context(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") @@ -362,6 +373,20 @@ def test_replace_range_tool_inserts_when_start_equals_end(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" +def test_replace_range_tool_requires_boundary_context_for_insert_range(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "1"]).call()) + + tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 1, fingerprint, "", "", "beta\n")) + + assert "# preview unavailable: before_context mismatch" in tool.preview() + with pytest.raises(ToolCallError, match="before_context mismatch"): + tool.call() + assert path.read_text(encoding="utf-8") == "alpha\ngamma\n" + + def test_replace_range_tool_rejects_wide_fingerprint_for_empty_insert_range(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") From dfa3511c982a047f33dac51b6758ebc001ec18a4 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 05:46:40 -0700 Subject: [PATCH 009/144] Stream action frames during model responses --- nanocode.py | 258 ++++++++++++++++++++++++++++++++++- tests/test_nanocode_agent.py | 46 +++++++ 2 files changed, 297 insertions(+), 7 deletions(-) diff --git a/nanocode.py b/nanocode.py index 5502fed..c0331da 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2900,6 +2900,7 @@ def _content(self, item: ToolResultItem) -> str: 3. start: only when Task Code is new; set goal, work_mode normal|investigate, and a short plan. 4. plan/known/hypothesis: only when direction, target, hypothesis status, or verification path changes. If a frontier tool/verify/goal is already known, include it in the same turn instead of stopping on state updates. 5. tool: execute the current action frontier. Frontier = useful next actions with known args and no dependency between them. Batch broad related searches/reads/recalls/checks; serialize only when later args depend on earlier results. + When context is missing, emit the first broad readonly tool batch quickly instead of spending a long turn speculating. 6. verify: after edits or explicit check/test/build requests, use the smallest relevant check; if the exact check already passed in recent results, record passed. 7. goal: complete only when the goal is done, all Plan items are done/blocked with result context, and verification passed or is blocked by the user. @@ -3461,6 +3462,39 @@ class ModelClient: ACTION_FRAME_END: ClassVar[str] = "__END_ACTION__" ACTION_FRAME_END_SPLIT_PATTERN: ClassVar[re.Pattern[str]] = re.compile(r"\**_*\s*END[\s_-]*ACTION\s*_*\**", re.IGNORECASE) + class ActionStreamParser: + def __init__(self, client: "ModelClient"): + self.client = client + self.buffer = "" + self.frame_number = 0 + self.committed = 0 + self.stopped = False + + def feed(self, text: str, on_action: Callable[[Json], bool]) -> bool: + self.buffer += text + while True: + match = self.client.ACTION_FRAME_END_SPLIT_PATTERN.search(self.buffer) + if match is None: + return False + frame = self.client._strip_fence_marker_lines(self.buffer[: match.start()]) + self.buffer = self.buffer[match.end() :] + self.frame_number += 1 + actions, error = self.client._parse_action_frame(frame, self.frame_number) + if error: + self.buffer = frame + self.client.ACTION_FRAME_END + self.buffer + return False + for action in actions: + self.committed += 1 + if on_action(action): + self.stopped = True + return True + + def trailing_error(self) -> str: + if self.stopped: + return "" + trailing = self.client._strip_fence_marker_lines(self.buffer).strip() + return "unexpected text after committed action frame" if trailing else "" + def __init__(self, session: Session): self.session = session self._timeout_reason = "request model timeout" @@ -3475,6 +3509,7 @@ def request( *, activity: str = "agent", parse_actions: bool = True, + on_stream_action: Callable[[Json], bool] | None = None, ) -> Json: config = self.session.config.provider if not config.url: @@ -3500,6 +3535,7 @@ def request( self._write_debug_prompt(activity=activity, messages=messages) client = self._client(config, timeout=timeout) request_elapsed = 0.0 + stream_parser = self.ActionStreamParser(self) if stream and parse_actions and on_stream_action is not None else None try: with ModelRetryShortcut(self.session): self.session.state.current_model_call_started_at = time.monotonic() @@ -3521,12 +3557,20 @@ def request( ) if stream: content, usage = ( - self._read_responses_stream(completion, request_deadline=request_deadline, first_token_timeout=first_token_timeout) + self._read_responses_stream( + completion, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + stream_parser=stream_parser, + on_stream_action=on_stream_action, + ) if api == "responses" else self._read_streaming_content( completion, request_deadline=request_deadline, first_token_timeout=first_token_timeout, + stream_parser=stream_parser, + on_stream_action=on_stream_action, ) ) result: Json = {"usage": usage} @@ -3567,6 +3611,13 @@ def request( raise LLMError(str(error)) self._record_usage(_json_dict(result.get("usage") if isinstance(result, dict) else None), config, elapsed=request_elapsed) + if stream_parser is not None and stream_parser.committed: + response: Json = {"actions": [], "_stream_committed": True} + error = stream_parser.trailing_error() + if error: + response["_format_bad_output"] = content + response["_format_error"] = "Invalid model output: " + error + ". Return action frames only. Bad output: " + _shorten(content) + return response if not stream: content = self._responses_content(result) if api == "responses" else self._message_content(result) if content is None: @@ -3628,7 +3679,15 @@ def _request_timeouts(self, config: ProviderConfig, *, activity: str) -> tuple[i return self.session.settings.plan_timeout, self.session.settings.plan_first_token_timeout return timeout, first_token_timeout - def _read_streaming_content(self, stream: Any, *, request_deadline: float, first_token_timeout: int | None) -> tuple[str, Json]: + def _read_streaming_content( + self, + stream: Any, + *, + request_deadline: float, + first_token_timeout: int | None, + stream_parser: "ModelClient.ActionStreamParser | None" = None, + on_stream_action: Callable[[Json], bool] | None = None, + ) -> tuple[str, Json]: parts: list[str] = [] usage: Json = {} first_output_seen = False @@ -3650,12 +3709,29 @@ def _read_streaming_content(self, stream: Any, *, request_deadline: float, first first_output_seen = True self.session.state.current_model_call_has_content = True self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) + self.session.state.current_model_call_streaming_chars += output_chars if isinstance(content, str) and content: parts.append(content) - self.session.state.current_model_call_streaming_chars += output_chars + if stream_parser is not None and on_stream_action is not None: + signal.setitimer(signal.ITIMER_REAL, 0) + callback_started = time.monotonic() + try: + if stream_parser.feed(content, on_stream_action): + break + finally: + request_deadline += max(0.0, time.monotonic() - callback_started) + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) return "".join(parts), usage - def _read_responses_stream(self, stream: Any, *, request_deadline: float, first_token_timeout: int | None) -> tuple[str, Json]: + def _read_responses_stream( + self, + stream: Any, + *, + request_deadline: float, + first_token_timeout: int | None, + stream_parser: "ModelClient.ActionStreamParser | None" = None, + on_stream_action: Callable[[Json], bool] | None = None, + ) -> tuple[str, Json]: parts: list[str] = [] usage: Json = {} completed_content = "" @@ -3695,9 +3771,18 @@ def mark_output(chars: int) -> None: output = self._responses_stream_output(data) if not output: continue + mark_output(len(output[1])) if output[0] == "content": parts.append(output[1]) - mark_output(len(output[1])) + if stream_parser is not None and on_stream_action is not None: + signal.setitimer(signal.ITIMER_REAL, 0) + callback_started = time.monotonic() + try: + if stream_parser.feed(output[1], on_stream_action): + break + finally: + request_deadline += max(0.0, time.monotonic() - callback_started) + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) return "".join(parts) or completed_content, usage def _raise_responses_stream_error(self, event: Json) -> None: @@ -5163,6 +5248,7 @@ def __init__(self, session: Session): self.observe_feedback_errors: list[str] = [] self.task_alignment_required = False self.incomplete_task_context_at_turn_start = False + self.stream_stop_requested = False self.mode = AgentMode.ACT def build_user_prompt(self) -> str: @@ -5187,11 +5273,14 @@ def request( *, activity: str = "agent", on_message: MessageCallback | None = None, + on_stream_action: Callable[[Json], bool] | None = None, ) -> Json: attempt = 0 while attempt <= len(self.MODEL_TIMEOUT_RETRY_DELAYS): try: self.session.state.turn_model_calls += 1 + if on_stream_action is not None and isinstance(self.model_client, ModelClient): + return self.model_client.request(system_prompt, user_prompt, activity=activity, on_stream_action=on_stream_action) return self.model_client.request(system_prompt, user_prompt, activity=activity) except ModelRequestRetry: if on_message is not None and self.session.settings.debug: @@ -5280,6 +5369,62 @@ def run_loop( self.cancel_current_goal() raise + def run_stream_loop( + self, + *, + max_steps: int, + on_message: MessageCallback | None = None, + confirm: ConfirmCallback | None = None, + on_auto_approve: ToolDisplayCallback | None = None, + on_live_output: ToolLiveOutputCallback | None = None, + on_live_done: ToolLiveDoneCallback | None = None, + on_step_limit: Callable[[], JsonValue], + ) -> JsonValue: + consecutive_format_errors = 0 + try: + for _ in range(max_steps): + result, response, committed = self.stream_step( + confirm=confirm, + on_auto_approve=on_auto_approve, + on_live_output=on_live_output, + on_live_done=on_live_done, + on_message=on_message, + ) + format_error = _json_str(response.get("_format_error")) + if format_error: + consecutive_format_errors += 1 + self._set_status_notice("err:format") + remember_error = self._remember_observe_error if self.mode == AgentMode.OBSERVE else self._remember_agent_error + remember_error( + self._format_gate_user_message("Error: model returned invalid output", format_error) + " Rule: " + self.RULE_ACTION_FRAMES + ) + 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. " + + self._format_gate_debug_details(response, format_error), + ) + 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, + self._format_gate_user_message("Retrying: model returned invalid output", format_error), + "Format_Gate: retrying model response. " + self._format_gate_debug_details(response, format_error), + ) + continue + if not committed: + consecutive_format_errors = 0 + if result.done: + return result.value + return on_step_limit() + except KeyboardInterrupt: + self.cancel_current_goal() + raise + def _finish_current_goal(self) -> None: self.blackboard.task_code = TaskCode.DONE self.blackboard.goal_reached = False @@ -5356,6 +5501,7 @@ def _warn_observe(self, text: str, rule: str = "") -> None: self._remember_observe_error(self._warning(text, rule)) def _reject_agent(self, on_message: MessageCallback | None, feedback: str, retry: str, debug: str) -> bool: + self.stream_stop_requested = True self._remember_agent_error(feedback) self._report_gate(on_message, retry, debug) return True @@ -5368,6 +5514,7 @@ def _reject_result( retry: str, debug: str, ) -> AgentRunResult: + self.stream_stop_requested = True remember_error(feedback) self._report_gate(on_message, retry, debug) return AgentRunResult() @@ -5413,7 +5560,7 @@ def _format_gate_debug_details(self, response: Json, format_error: str) -> str: return _shorten(format_error, 180) return _shorten(format_error, 180) + "\nFull bad output:\n" + bad_output - def step(self, *, on_message: MessageCallback | None = None) -> Json: + def _step_prompts(self) -> tuple[str, str, str]: if self.mode == AgentMode.OBSERVE: system_prompt = self.prompt_builder.system_prompt(AGENT_OBSERVE_SYSTEM_PROMPT, tools=()) user_prompt = self.build_observe_prompt() @@ -5425,6 +5572,10 @@ def step(self, *, on_message: MessageCallback | None = None) -> Json: ) user_prompt = self.build_user_prompt() activity = "agent" + return system_prompt, user_prompt, activity + + def step(self, *, on_message: MessageCallback | None = None) -> Json: + system_prompt, user_prompt, activity = self._step_prompts() response = self.request(system_prompt, user_prompt, activity=activity, on_message=on_message) if _json_str(response.get("_format_error")): return response @@ -5433,6 +5584,88 @@ def step(self, *, on_message: MessageCallback | None = None) -> Json: return invalid_response return response + def stream_step( + self, + *, + confirm: ConfirmCallback | None = None, + on_auto_approve: ToolDisplayCallback | None = None, + on_live_output: ToolLiveOutputCallback | None = None, + on_live_done: ToolLiveDoneCallback | None = None, + on_message: MessageCallback | None = None, + ) -> tuple[AgentRunResult, Json, bool]: + if not self._can_stream_action_frames(): + response = self.step(on_message=on_message) + if _json_str(response.get("_format_error")): + return AgentRunResult(), response, False + return self.handle_response( + response, + confirm=confirm, + on_auto_approve=on_auto_approve, + on_live_output=on_live_output, + on_live_done=on_live_done, + on_message=on_message, + ), response, False + + committed = False + latest_result = AgentRunResult() + + def on_stream_action(action: Json) -> bool: + nonlocal committed, latest_result + committed = True + self.stream_stop_requested = False + response = {"actions": [action]} + invalid_response = self._validate_action_response(response) + latest_result = ( + self.handle_response( + response, + confirm=confirm, + on_auto_approve=on_auto_approve, + on_live_output=on_live_output, + on_live_done=on_live_done, + on_message=on_message, + ) + if invalid_response is None + else self._reject_result( + self._remember_agent_error, + on_message, + _json_str(invalid_response.get("_format_error")) or self._error("invalid streamed action."), + "Retrying: invalid streamed action.", + "Format_Gate: invalid streamed action.", + ) + ) + if latest_result.done or self.stream_stop_requested: + return True + if _json_str(action.get("type")) == "tool" and any(execution.outcome != "success" for execution in self.tool_runner.latest_executions): + return True + return self.mode == AgentMode.OBSERVE + + system_prompt, user_prompt, activity = self._step_prompts() + response = self.request( + system_prompt, + user_prompt, + activity=activity, + on_message=on_message, + on_stream_action=on_stream_action, + ) + if committed: + return latest_result, response, True + if _json_str(response.get("_format_error")): + return AgentRunResult(), response, False + invalid_response = self._validate_action_response(response) + if invalid_response is not None: + return AgentRunResult(), invalid_response, False + return self.handle_response( + response, + confirm=confirm, + on_auto_approve=on_auto_approve, + on_live_output=on_live_output, + on_live_done=on_live_done, + on_message=on_message, + ), response, False + + def _can_stream_action_frames(self) -> bool: + return self.mode == AgentMode.ACT and isinstance(self.model_client, ModelClient) and self.session.config.provider.stream is not False + def apply_response(self, response: Json) -> list[str]: actions = self._response_actions(response) if self._has_pending_verification(actions): @@ -6355,7 +6588,7 @@ def run( # Keep previous task state at a new user turn so short follow-ups like # "continue" can resume. The first response must align with it before work # when the new request does not match the previous goal. - self.task_alignment_required = self.incomplete_task_context_at_turn_start and self._task_text_key(user_input) != self._task_text_key(old_goal) + self.task_alignment_required = old_task_context and self._task_text_key(user_input) != self._task_text_key(old_goal) self.blackboard.task_code = TaskCode.NEW self.blackboard.goal_reached = False self.blackboard.verification_required = False @@ -6364,6 +6597,17 @@ def run( self.compactor.maybe_compact() self.session.append_conversation(UserMessage(content=user_input)) + if self._can_stream_action_frames(): + return self.run_stream_loop( + max_steps=self.session.settings.max_agent_steps, + on_message=on_message, + confirm=confirm, + on_auto_approve=on_auto_approve, + on_live_output=on_live_output, + on_live_done=on_live_done, + on_step_limit=lambda: (_ for _ in ()).throw(LLMError("agent step limit reached")), + ) + return self.run_loop( max_steps=self.session.settings.max_agent_steps, on_message=on_message, diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 9bc610b..640c603 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1417,6 +1417,52 @@ def test_agent_run_reports_streamed_tool_actions_after_execution(tmp_path, monke assert messages[-1] == "done" +def test_agent_run_executes_action_frame_before_stream_finishes(tmp_path, monkeypatch): + (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") + agent = Agent(session) + _seed_plan(agent, "read sample") + + def stream(): + yield _stream_chunk({"content": '{"type":"tool","name":"Read","intention":"read sample","args":["sample.txt","0","1"]}__END_ACTION__'}) + assert session.state.tool_result_counter == 1 + yield _stream_chunk({"content": '{"type":"verify","method":"unit","status":"passed","context":"checked"}__END_ACTION__'}) + yield _stream_chunk({"content": '{"type":"goal","text":"read sample","complete":true,"message_for_complete":"done"}__END_ACTION__'}) + + _patch_openai(monkeypatch, stream) + messages = [] + + response = agent.run("read sample", on_message=messages.append) + + assert response["actions"][0]["message_for_complete"] == "done" + assert messages[0].startswith("[success] Read sample.txt 0:1 -> tr.1") + assert session.state.tool_result_counter == 1 + + +def test_agent_run_stops_stream_after_tool_failure(tmp_path, monkeypatch): + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") + agent = Agent(session) + _seed_plan(agent, "read sample") + + def stream(): + yield _stream_chunk({"content": '{"type":"tool","name":"Read","intention":"read missing","args":["missing.txt","0","1"]}__END_ACTION__'}) + raise AssertionError("stream should stop after failed tool") + + _patch_openai( + monkeypatch, + ( + stream(), + [_stream_chunk({"content": '{"type":"goal","text":"read sample","complete":true,"message_for_complete":"done"}__END_ACTION__'})], + ), + ) + + response = agent.run("read sample") + + assert response["actions"][0]["message_for_complete"] == "done" + assert session.state.tool_result_counter == 1 + assert session.state.tool_result_store["tr.1"].description.startswith("failure Read") + + def test_agent_request_uses_configured_chat_reasoning_payload(tmp_path, monkeypatch): calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) session = _session( From 492a25173992bb93519ab369c45446c5caa7d511 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 07:44:24 -0700 Subject: [PATCH 010/144] Adopt function tools for agent actions --- README.md | 2 +- design.md | 16 +- nanocode.py | 1534 ++++++++++----------- pyproject.toml | 1 - tests/test_nanocode_agent.py | 964 ++++--------- tests/test_nanocode_context_tool.py | 2 +- tests/test_nanocode_loop.py | 7 +- tests/test_nanocode_replace_range_tool.py | 6 +- 8 files changed, 1056 insertions(+), 1476 deletions(-) diff --git a/README.md b/README.md index 33059be..b991281 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ Pre-1.0 note: nanocode is still evolving quickly. Functionality, commands, confi ## Features -- **Constrained Output**: Force model replies into auditable action frames. +- **Function Tools**: Route model decisions through auditable tools. - **Verified Edits**: Reject stale range edits before they touch files. - **Autonomous Loop**: Chain reading, editing, running, and verification. - **Live Telemetry**: Stream tool intent, token use, and status. diff --git a/design.md b/design.md index 811a9af..64e9410 100644 --- a/design.md +++ b/design.md @@ -17,6 +17,18 @@ The agent has a work path and a cleanup path: Conversation compaction is a background maintenance path. It summarizes old conversation history when the conversation list grows too large. +## Model Output Protocol + +Model decisions use function tools: + +- state tools update goal, plan, hypotheses, known facts, verification, and result retention +- repository tools read, search, edit, run commands, and recall stored results +- compaction uses a dedicated `compact` function tool + +Assistant text is optional user-facing text. It must not replace the next useful +function tool. Completing work still requires a `goal` function tool call with +`complete=true`. + ## Task State The main task state lives in the blackboard: @@ -33,14 +45,14 @@ The main task state lives in the blackboard: New user input keeps the previous task state available for follow-ups like "continue". -Old task state is cleared only when the model explicitly starts a different goal. When that happens, transient investigation state such as hypotheses and selected tool-result context is reset, while durable knowledge is kept. +Old task state is cleared only when the model explicitly sets a different goal. When that happens, transient investigation state such as hypotheses and selected tool-result context is reset, while durable knowledge is kept. ## New Goal Handling New user input does not immediately clear the previous task. This keeps short follow-ups such as "continue" usable. -When the model outputs `start` with a different goal: +When the model outputs `goal` with a different current-task goal: - goal and plan are replaced - hypotheses are cleared diff --git a/nanocode.py b/nanocode.py index c0331da..7e3a913 100644 --- a/nanocode.py +++ b/nanocode.py @@ -32,7 +32,6 @@ from typing import Any, Callable, ClassVar, Iterator, Iterable, Self, Type, TypeAlias from urllib.parse import urlparse -import json_repair from openai import APIConnectionError, APIError, APIStatusError, APITimeoutError, OpenAI from prompt_toolkit.application import Application from prompt_toolkit import PromptSession, print_formatted_text @@ -175,7 +174,6 @@ class HypothesisStatus(StrEnum): ALL_HYPOTHESIS_STATUSES = frozenset(HypothesisStatus) -HYPOTHESIS_STATUS_SCHEMA = "|".join(status.value for status in HypothesisStatus) HYPOTHESIS_STATUS_TEXT = ", ".join(status.value for status in HypothesisStatus) @@ -1034,6 +1032,27 @@ def missing_required_config(self) -> list[str]: ############################ +def _tool_object_schema(properties: Json, required: list[str]) -> Json: + return {"type": "object", "properties": properties, "required": required, "additionalProperties": False} + + +def _function_tool_schema(name: str, description: str, parameters: Json) -> Json: + return {"type": "function", "function": {"name": name, "description": description, "parameters": parameters}} + + +def _json_value_schema(depth: int = 3) -> Json: + values: list[Json] = [{"type": "string"}, {"type": "number"}, {"type": "boolean"}, {"type": "null"}] + if depth > 0: + child = _json_value_schema(depth - 1) + values.extend( + [ + {"type": "array", "items": child}, + {"type": "object", "additionalProperties": child}, + ] + ) + return {"anyOf": values} + + class ToolEffect(StrEnum): READONLY = "readonly" EDIT = "edit" @@ -1041,20 +1060,17 @@ class ToolEffect(StrEnum): MAX_TOOL_OUTPUT_CHARS = 12_000 +TOOL_JSON_VALUE_SCHEMA: Json = _json_value_schema() class Tool: - NAME: ClassVar[str] = "" + NAME: ClassVar[str] DESCRIPTION: ClassVar[tuple[str, ...]] = () SIGNATURE: ClassVar[str] EXAMPLE: ClassVar[tuple[str, ...]] = () EFFECT: ClassVar[ToolEffect] = ToolEffect.OTHER REQUIRES_CONFIRMATION: ClassVar[bool | None] = None - @classmethod - def name(cls) -> str: - return cls.NAME or cls.__name__.removesuffix("Tool") - @classmethod def cli_args(cls, args: list[JsonValue]) -> list[str]: return [cls.cli_token(arg) for arg in args] @@ -1079,11 +1095,21 @@ def cli_token(value: JsonValue) -> str: return json.dumps(text, ensure_ascii=False) @classmethod - def effect(cls) -> ToolEffect: - return cls.EFFECT + def tool_schema(cls) -> Json: + return _function_tool_schema( + cls.NAME, + " ".join((*cls.DESCRIPTION, cls.SIGNATURE, *cls.EXAMPLE)), + _tool_object_schema( + { + "intention": {"type": "string", "description": "Question being answered or concrete outcome needed."}, + "args": {"type": "array", "items": TOOL_JSON_VALUE_SCHEMA, "description": "Arguments exactly matching the tool signature."}, + }, + ["intention", "args"], + ), + ) def requires_confirmation(self, session: Session) -> bool: - return self.REQUIRES_CONFIRMATION if self.REQUIRES_CONFIRMATION is not None else self.effect() == ToolEffect.EDIT + return self.REQUIRES_CONFIRMATION if self.REQUIRES_CONFIRMATION is not None else self.EFFECT == ToolEffect.EDIT def call_live(self, sink: Callable[[str], None] | None = None) -> str: return self.call() @@ -1505,6 +1531,7 @@ def _range_fingerprint(content: str) -> str: @dataclass class ReadTool(Tool): + NAME: ClassVar[str] = "Read" MAX_LINES: ClassVar[int] = 600 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( @@ -1692,6 +1719,7 @@ def _format_range_result( @dataclass class LineCountTool(Tool): + NAME: ClassVar[str] = "LineCount" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ("Count lines for one or more files. Useful before reading large files or deciding Read ranges.",) SIGNATURE: ClassVar[str] = "LineCount(*filepaths) -> LineCountToolResult" @@ -1732,6 +1760,7 @@ def call(self) -> str: @dataclass class ListDirTool(Tool): + NAME: ClassVar[str] = "ListDir" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "List one directory non-recursively; optional glob filters immediate entry names.", @@ -1797,6 +1826,7 @@ def call(self) -> str: @dataclass class SearchTool(Tool): + NAME: ClassVar[str] = "Search" MAX_MATCHES: ClassVar[int] = 100 MAX_FILE_BYTES: ClassVar[int] = 2_000_000 RG_MAX_FILESIZE: ClassVar[str] = "2M" @@ -2160,6 +2190,7 @@ def call(self) -> str: @dataclass class EditTool(Tool): + NAME: ClassVar[str] = "Edit" EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Replace/delete one unique exact literal text block in an existing file; best for tiny unambiguous edits, not regex.", @@ -2241,6 +2272,7 @@ def call(self) -> str: @dataclass class CreateFileTool(Tool): + NAME: ClassVar[str] = "CreateFile" EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Create a new UTF-8 file with short initial content; target file must not exist.", @@ -2306,20 +2338,18 @@ class ReplaceRangeEdit: @dataclass class ReplaceRangeTool(Tool): + NAME: ClassVar[str] = "ReplaceRange" EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Replace one or more small Read-backed [start,end) ranges in an existing file; best when exact line ranges are known or target text is not unique.", - "For several independent ranges in the same file, pass a batch as ReplaceRange(filepath, [[start,end,fingerprint,before_context,after_context,content], ...]).", + "Pass ranges as [[start,end,fingerprint,before_context,after_context,content], ...].", "Pass exact before_context and after_context when known; empty boundary context is allowed for non-empty replacements.", "Content is only the replacement for that range; do not include boundary lines.", ) - SIGNATURE: ClassVar[str] = ( - "ReplaceRange(filepath, start, end, fingerprint, before_context, after_context, content) " - "or ReplaceRange(filepath, ranges) -> ReplaceRangeToolResult" - ) + SIGNATURE: ClassVar[str] = "ReplaceRange(filepath, [[start,end,fingerprint,before_context,after_context,content], ...]) -> ReplaceRangeToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Example args: ["code.py", "10", "12", "a1b2c3", "line before\\n", "line after\\n", "replacement lines\\n"]', - 'Batch args: ["code.py", [["10", "12", "a1b2c3", "before\\n", "after\\n", "replacement\\n"]]]', + 'Single range: ["code.py", [["10", "12", "a1b2c3", "before\\n", "after\\n", "replacement\\n"]]]', + 'Two ranges: ["code.py", [["10", "12", "a1b2c3", "before\\n", "after\\n", "replacement\\n"], ["20", "20", "d4e5f6", "prev\\n", "next\\n", "inserted\\n"]]]', ) filepath: str = "" @@ -2370,7 +2400,7 @@ def merge_calls(cls, session: Session, calls: list[ParsedToolCall]) -> PreparedT if call.intention: intentions.append(call.intention) tool = cls._from_edits(session, filepath=filepath, edits=edits) - call = ParsedToolCall(name=cls.name(), intention="; ".join(intentions), args=list(calls[0].args)) + call = ParsedToolCall(name=cls.NAME, intention="; ".join(intentions), args=list(calls[0].args)) return PreparedToolCall(call=call, tool=tool) @classmethod @@ -2381,7 +2411,7 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: raise ToolCallArgError("ranges cannot be empty") return cls._from_edits(session, filepath=str(args[0]), edits=[cls._edit_from_args(_json_list(item)) for item in ranges]) if len(args) != 7: - raise ToolCallArgError("requires exactly 7 args or batch args: filepath, ranges") + raise ToolCallArgError("requires args: filepath, ranges where each range is [start,end,fingerprint,before_context,after_context,content]") return cls._from_edits(session, filepath=str(args[0]), edits=[cls._edit_from_args(args[1:])]) @staticmethod @@ -2490,7 +2520,7 @@ def _preview(self) -> tuple[str, str, list[tuple[RangeFingerprintStore.Resolved, for edit in self.edits: if file_missing: if len(self.edits) != 1 or edit.start != 0 or edit.end != 0 or edit.fingerprint or edit.before_context or edit.after_context: - raise ToolCallError('file does not exist; use ReplaceRange(filepath, "0", "0", "", "", "", content) to create') + raise ToolCallError('file does not exist; use ReplaceRange(filepath, [["0", "0", "", "", "", content]]) to create') resolved = RangeFingerprintStore.Resolved(start=0, end=0, fingerprint=_range_fingerprint("")) else: resolved = self.range_fingerprints.resolve( @@ -2546,6 +2576,7 @@ def _replacement_lines(content: str, *, has_following_line: bool) -> list[str]: @dataclass class BashTool(Tool): + NAME: ClassVar[str] = "Bash" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run one explicit shell command via bash -lc in cwd; not for search, listing, or file edits when dedicated tools exist.", ) @@ -2713,6 +2744,7 @@ def _read_stream_chunk( @dataclass class GitTool(Tool): + NAME: ClassVar[str] = "Git" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run git without a shell for repository state, history, status, diff, and changed files.", "Pass each git argument separately; optional first arg cwd=path changes repository directory.", @@ -2848,20 +2880,84 @@ def _content(self, item: ToolResultItem) -> str: TOOL_REGISTRY: dict[str, ToolClass] = { - ReadTool.name(): ReadTool, - LineCountTool.name(): LineCountTool, - ListDirTool.name(): ListDirTool, - SearchTool.name(): SearchTool, - CreateFileTool.name(): CreateFileTool, - EditTool.name(): EditTool, - ReplaceRangeTool.name(): ReplaceRangeTool, - BashTool.name(): BashTool, - GitTool.name(): GitTool, - ToolResultTool.name(): ToolResultTool, + ReadTool.NAME: ReadTool, + LineCountTool.NAME: LineCountTool, + ListDirTool.NAME: ListDirTool, + SearchTool.NAME: SearchTool, + CreateFileTool.NAME: CreateFileTool, + EditTool.NAME: EditTool, + ReplaceRangeTool.NAME: ReplaceRangeTool, + BashTool.NAME: BashTool, + GitTool.NAME: GitTool, + ToolResultTool.NAME: ToolResultTool, } PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListDirTool, SearchTool, PlanModeGitTool, ToolResultTool) +TOOL_STRING_SCHEMA: Json = {"type": "string"} +TOOL_NULLABLE_STRING_SCHEMA: Json = {"type": ["string", "null"]} +TOOL_ITEMS_SCHEMA: Json = {"type": "array", "items": TOOL_JSON_VALUE_SCHEMA} +TOOL_STRING_LIST_SCHEMA: Json = {"type": "array", "items": {"type": "string"}} + + +STATE_TOOL_PARAMS: dict[str, tuple[str, Json, list[str]]] = { + "goal": ( + "Set, update, or complete the current goal. Use work_mode=investigate for root-cause/debug work; use message_for_complete for the final user message.", + { + "text": TOOL_STRING_SCHEMA, + "work_mode": {"type": ["string", "null"], "enum": ["normal", "investigate", None]}, + "complete": {"type": "boolean"}, + "message_for_complete": TOOL_NULLABLE_STRING_SCHEMA, + }, + ["text", "complete", "message_for_complete"], + ), + "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_ITEMS_SCHEMA}, ["items"]), + "hypothesis": ("Update investigation hypotheses.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), + "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), + "stable_knowledge": ("Record rare reusable codebase facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), + "user_rule": ( + "Remember an explicit future behavior rule from the user.", + {"text": TOOL_STRING_SCHEMA, "message": TOOL_STRING_SCHEMA}, + ["text", "message"], + ), + "forget": ( + "Remove visible tool result keys from active context while keeping them recallable.", + {"source": TOOL_STRING_LIST_SCHEMA, "reason": TOOL_STRING_SCHEMA}, + ["source", "reason"], + ), + "verify": ( + "Record concrete verification status.", + { + "kind": TOOL_STRING_SCHEMA, + "method": TOOL_NULLABLE_STRING_SCHEMA, + "criteria": TOOL_STRING_LIST_SCHEMA, + "status": {"type": "string", "enum": ["passed", "failed", "blocked"]}, + "blocker": {"type": ["string", "null"], "enum": ["user", "environment", "tool", "unknown", None]}, + "context": TOOL_NULLABLE_STRING_SCHEMA, + }, + ["kind", "method", "criteria", "status", "blocker", "context"], + ), + "keep": ("Keep visible raw tool result keys in context during observe.", {"source": TOOL_STRING_LIST_SCHEMA, "reason": TOOL_STRING_SCHEMA}, ["source", "reason"]), +} + + +def _state_tool_schema(name: str) -> Json: + description, properties, required = STATE_TOOL_PARAMS[name] + return _function_tool_schema(name, description, _tool_object_schema(properties, required)) + + +COMPACT_TOOL_SCHEMA = _function_tool_schema( + "compact", + "Return a compact continuation summary and retained known facts.", + _tool_object_schema( + { + "summary": TOOL_STRING_SCHEMA, + "known": TOOL_ITEMS_SCHEMA, + }, + ["summary", "known"], + ), +) + ############################ # Agent Prompt ############################ @@ -2869,18 +2965,19 @@ def _content(self, item: ToolResultItem) -> str: AGENT_SYSTEM_PROMPT = """You are nanocode, a coding agent. OUTPUT -- Return JSON action frames only: no prose, no native/function tool calls. -- Separate multiple actions with __END_ACTION__. -- Valid action types: chat, start, goal, plan, hypothesis, known, stable_knowledge, progress, user_rule, tool, verify, forget. -- Tool names such as Read, Search, Edit, Git, and Recall belong in tool.name, never in action type. -- Tool actions require name, intention, and args. +- Use function tools for state updates and repository actions. +- Assistant text is optional; never use it instead of the next useful function tool. +- A completed task still needs goal.complete=true; assistant text alone does not complete work. +- State tools: goal, plan, hypothesis, known, stable_knowledge, user_rule, verify, forget. +- Repository tools: { __tool_names__ }. +- Repository tool calls require intention and args. - Use the latest user language for user-facing text; keep it plain, concise, and direct. PRIORITY AND STATE - Priority: Latest User Request > User Rules > Current Goal > Plan/Known/Stable Knowledge > Conversation History. -- Latest User Request overrides stale Goal, but Task Code decides whether to start a new task. -- Task Code: new = align latest request with start; working = continue current Goal; verifying = run/record verification; done = wait for next request. -- If Task Code is working or verifying, do not output start or rewrite Goal. +- Latest User Request overrides stale Goal, but Task Code decides whether to begin a new task. +- Task Code: new = align latest request with goal/plan or readonly discovery; working = continue current Goal; verifying = run/record verification; done = wait for next request. +- If Task Code is working or verifying, do not rewrite Goal unless the user changed the task. - Never repeat a previous completion as the answer. - User Rules are mandatory long-term behavior rules; add them only when the user explicitly asks to remember future behavior. @@ -2893,16 +2990,18 @@ def _content(self, item: ToolResultItem) -> str: - OBSERVE keeps useful raw results and forgets noise. ACT must not keep results. - In ACT, use forget only when a visible result is already irrelevant; first preserve any needed conclusion in Plan, Known, Hypotheses, or Verify. Forget preserves logs and Recall. -DECISION ORDER -Choose the main next action and include tightly related state updates in the same turn. -1. chat: casual chat or direct non-coding answers. -2. user_rule: only explicit future-behavior memory requests. -3. start: only when Task Code is new; set goal, work_mode normal|investigate, and a short plan. -4. plan/known/hypothesis: only when direction, target, hypothesis status, or verification path changes. If a frontier tool/verify/goal is already known, include it in the same turn instead of stopping on state updates. -5. tool: execute the current action frontier. Frontier = useful next actions with known args and no dependency between them. Batch broad related searches/reads/recalls/checks; serialize only when later args depend on earlier results. - When context is missing, emit the first broad readonly tool batch quickly instead of spending a long turn speculating. -6. verify: after edits or explicit check/test/build requests, use the smallest relevant check; if the exact check already passed in recent results, record passed. -7. goal: complete only when the goal is done, all Plan items are done/blocked with result context, and verification passed or is blocked by the user. +WORKFLOW +- No Goal: set goal. If enough context is known, also set plan or call the first useful readonly tools. +- Goal but no Plan: set a short plan, or call readonly discovery first when planning needs context. +- Goal and Plan: execute the next useful frontier with tools. Batch independent searches/reads/recalls/checks; serialize only when later args depend on earlier results. +- After edits or explicit checks: verify with the smallest relevant test/build/lint/static check. +- Complete only when the goal is done, Plan items are done/blocked with context, and verification passed or is blocked by the user. +- Never repeat an unchanged goal, unchanged plan, or no-op state update. Move to the next workflow state. + +STATE UPDATES +- user_rule: only explicit future-behavior memory requests. +- known/hypothesis: only when facts or investigation status changed. +- Pair state updates with the next frontier action when its args are known. PLANNING - Use plans only for real tasks; usually 2-5 concrete outcome steps. @@ -2944,52 +3043,19 @@ def _content(self, item: ToolResultItem) -> str: - Git is for status, diff, history, and changed files. - Recall fetches stored result keys; batch distinct keys and recall each needed key at most once. - Every tool intention must state the question being answered or concrete outcome needed. - -ACTIONS: - -{"type":"chat","text":""} - -{"type":"start","goal":"","work_mode":"normal|investigate","plan":[{"id":"p1","text":"","status":"todo|doing|done|blocked","context":null}]} - -{"type":"goal","text":"","complete":true|false,"message_for_complete":null|""} - -{"type":"plan","items":[{"id":"p1","text":"","status":"todo|doing|done|blocked","context":null|""}]} - -{"type":"plan","mode":"patch","items":[{"id":"p1","status":"todo|doing|done|blocked","context":null|""}]} - -{"type":"hypothesis","items":[{"id":"h1","text":"","status":"{ __hypothesis_statuses__ }","source":["tr.1"],"context":null|""}]} - -{"type":"known","items":[""]} -{"type":"known","items":[{"source":["tr.1"],"text":""}]} - -{"type":"stable_knowledge","items":[{"category":"stack|structure|workflow|convention|gotcha","text":""}]} - -{"type":"progress","text":""} - -{"type":"user_rule","text":"","message":""} - -{"type":"forget","source":["tr.1"],"reason":""} - -{"type":"tool","name":"{ __tool_names__ }","intention":"","args":[""]} - -{"type":"verify","kind":"syntax_check|change_syntax_check|lint|test|build|change_check|other|kind+kind","method":null|"","criteria":[""],"status":"passed|failed|blocked","blocker":null|"user|environment|tool|unknown","context":null|""} - -TOOL SPECS: -{ __tools__ } """ AGENT_PLAN_SYSTEM_PROMPT = """You are nanocode in PLAN MODE. You are a planning agent, not an implementation agent. OUTPUT PROTOCOL -- Return JSON action frames only. -- No prose outside JSON. -- No native/function tool calls. -- Separate multiple actions with __END_ACTION__. -- Allowed action types: start, goal, plan, hypothesis, known, stable_knowledge, progress, tool, verify. -- Tool names such as Read, Search, Git, Recall, LineCount, and ListDir belong in tool.name, never in action type. -- Every action must be a single valid JSON object. -- Do not invent fields when a listed action shape already fits. +- Use function tools for state updates and readonly repository actions. +- Assistant text is optional; never use it instead of the next useful function tool. +- A completed plan-mode task still needs goal.complete=true. +- Allowed state tools: goal, plan, hypothesis, known, stable_knowledge, verify. +- Allowed repository tools: Read, LineCount, ListDir, Search, Recall, and readonly Git. +- Repository tool calls require intention and args. +- Do not invent fields when a tool schema already fits. MODE BOUNDARIES - Produce an implementation plan for the latest user request. @@ -3006,7 +3072,7 @@ def _content(self, item: ToolResultItem) -> str: READONLY DISCOVERY - Allowed tools: Read, LineCount, ListDir, Search, Recall. - Git is allowed only for readonly inspection: status, diff, log, show, rev-parse, ls-files, grep, blame. -- Use only the readonly tools listed in TOOL SPECS. Do not request any other tools. +- Use only the provided readonly function tools. Do not request any other tools. - Use the smallest useful discovery batch. - Prefer targeted Search/Read over broad surveys. - Prefer reading the owning file and nearby tests over unrelated code. @@ -3026,7 +3092,7 @@ def _content(self, item: ToolResultItem) -> str: - Respect existing naming, style, dependency direction, error handling, and data flow. - Do not introduce a new architectural style when a local change fits the current one. -Start from concerns: +Begin from concerns: - Identify relevant functional concerns. - Identify relevant non-functional concerns when they may affect design: performance, consistency, availability, latency, scalability, compatibility, maintainability, security, debuggability, and migration cost. - State tradeoffs only when they affect the proposed implementation. @@ -3042,7 +3108,7 @@ def _content(self, item: ToolResultItem) -> str: Module and layer judgment: - Decompose top-down for broad changes: subsystem -> module -> file -> symbol. -- For local changes, start at the owning symbol and expand only as needed. +- For local changes, begin at the owning symbol and expand only as needed. - Keep modules focused on one topic. - Keep high-cohesion logic together and low-coupling boundaries explicit. - Prefer dependency flow from higher-level orchestration toward lower-level capabilities. @@ -3089,7 +3155,7 @@ def _content(self, item: ToolResultItem) -> str: - Verification steps must be executable by a coding agent, but you must not run them. DISCOVERY STRATEGY -1. For a new Task Code, start with one concise planning goal and 2-4 discovery steps. +1. For a new Task Code, set one concise planning goal and 2-4 discovery steps when enough context is known. 2. Search for owners before reading large files. 3. Prefer support from code, tests, docs, and recent relevant Git history. 4. After tool results, use Latest Tool Results, Unreduced Tool Results, and Kept Tool Results; use known for settled current-task facts and stable_knowledge only for rare reusable codebase facts. @@ -3098,13 +3164,13 @@ def _content(self, item: ToolResultItem) -> str: 7. If the request is ambiguous but a reasonable reversible path exists, proceed with stated assumptions and include open questions in the final plan. 8. Complete with goal.complete=true only when the final proposal is ready. -ACTION SEMANTICS -- start: initialize the planning goal and discovery plan for a new Task Code. +FUNCTION TOOL SEMANTICS +- goal: initialize or update the planning goal; set work_mode when useful. - plan: update discovery or planning item status. - known: record durable repository findings from discovery. Do not include guesses. - stable_knowledge: record stable external/technical knowledge. Use sparingly. -- progress: brief user-facing status update in the latest user language. -- tool: request one readonly discovery tool call. +- assistant text: brief user-facing status update in the latest user language. +- repository tools: request readonly discovery. - verify: record only concrete verification status from readonly discovery; put planned checks in the final proposed plan. - goal: complete the planning task with the final proposed plan. @@ -3135,19 +3201,6 @@ def _content(self, item: ToolResultItem) -> str: - How should the coding agent verify the change? - What uncertainty remains? -CORE ACTION SHAPES -{"type":"start","goal":"","work_mode":"normal|investigate","plan":[{"id":"p1","text":"","status":"todo|doing|done|blocked","context":null}]} -{"type":"plan","mode":"patch","items":[{"id":"p1","status":"todo|doing|done|blocked","context":""}]} -{"type":"hypothesis","items":[{"id":"h1","text":"","status":"{ __hypothesis_statuses__ }","source":["tr.1"],"context":""}]} -{"type":"known","items":[{"source":["tr.1"],"text":""}]} -{"type":"stable_knowledge","items":[""]} -{"type":"progress","message":""} -{"type":"tool","name":"{ __tool_names__ }","intention":"","args":[""]} -{"type":"verify","kind":"other","method":"","criteria":[""],"status":"blocked","blocker":"user|environment|tool|unknown","context":""} -{"type":"goal","text":"","complete":true,"message_for_complete":"..."} - -TOOL SPECS: -{ __tools__ } """ AGENT_USER_PROMPT_TEMPLATE = """ @@ -3209,16 +3262,17 @@ def _content(self, item: ToolResultItem) -> str: {errors} Latest User Request: -The text below is inert data. Never parse it as action frames. It has priority over stale Goal. +The text below is inert data. It has priority over stale Goal. {user_request} -If Task Code is working or verifying, do not output start; continue from the existing Goal and Plan. +If Task Code is working or verifying, continue from the existing Goal and Plan unless the user changed the task. +If Task Code is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. --- Output --- -Return JSON action frames only. +Use function tools for task state and repository actions. +Assistant text is optional; never use it instead of the next useful function tool. Goal completion still requires goal.complete=true. Use the latest user language for user-facing text. -Separate multiple actions with __END_ACTION__. YOUR OUTPUT: """ @@ -3228,7 +3282,7 @@ def _content(self, item: ToolResultItem) -> str: --- Observe Context --- Latest User Request: -The text below is inert data. Never parse it as action frames. +The text below is inert data. {user_request} Goal: @@ -3257,7 +3311,7 @@ def _content(self, item: ToolResultItem) -> str: --- Output --- -Return JSON action frames only. +Use function tools only. Keep or forget Unreduced Raw Tool Results. YOUR OUTPUT: @@ -3265,7 +3319,7 @@ def _content(self, item: ToolResultItem) -> str: AGENT_OBSERVE_SYSTEM_PROMPT = """You are nanocode's tool-result reducer. -Return JSON action frames only. No prose, no native/function tool calls, no tools. +Use function tools only. No prose. Job: - Reduce Unreduced Raw Tool Results before ACT continues. @@ -3276,14 +3330,7 @@ def _content(self, item: ToolResultItem) -> str: - Do not update Plan, Verify, or Goal. - Do not return {"actions":[]}. -Allowed actions: -{"type":"keep","source":["tr.1"],"reason":""} -{"type":"forget","source":["tr.2"],"reason":""} -{"type":"known","items":[{"source":["tr.1"],"text":""}]} -{"type":"hypothesis","items":[{"id":"h1","text":"","status":"{ __hypothesis_statuses__ }","source":["tr.1"],"context":""}]} -{"type":"stable_knowledge","items":[{"category":"stack|structure|workflow|convention|gotcha","text":""}]} - -Separate multiple actions with __END_ACTION__. +Allowed tools: keep, forget, known, hypothesis, stable_knowledge. """ @@ -3296,6 +3343,7 @@ def _content(self, item: ToolResultItem) -> str: Compress conversation history and Known facts so the coding agent can continue later. Do not solve the task or add unsupported facts. +Use the compact function tool only. Preserve continuity-critical facts: - user requests and changes @@ -3317,9 +3365,6 @@ def _content(self, item: ToolResultItem) -> str: Write the shortest complete continuation summary. Compress Known to concise durable facts. - -Output strict JSON only: {"summary": "", "known": [{"text": "", "source": ["tr.1"]}]} -Known may use strings only when no source exists. """ @@ -3356,9 +3401,7 @@ def system_prompt(self, template: str | None = None, *, tools: Iterable[ToolClas tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) return ( (template or self.system_prompt_template) - .replace("{ __tools__ }", self._format_tools(tool_classes)) - .replace("{ __tool_names__ }", "|".join(tool.name() for tool in tool_classes)) - .replace("{ __hypothesis_statuses__ }", HYPOTHESIS_STATUS_SCHEMA) + .replace("{ __tool_names__ }", "|".join(tool.NAME for tool in tool_classes)) .replace("{ __hypothesis_status_text__ }", HYPOTHESIS_STATUS_TEXT) .strip() ) @@ -3414,16 +3457,6 @@ def _format_user_request(self) -> str: fence = "`" * max(3, max((len(match.group(0)) for match in re.finditer(r"`{3,}", user_request)), default=0) + 1) return fence + "text\n" + user_request + "\n" + fence - def _format_tools(self, tools: Iterable[ToolClass]) -> str: - lines = [] - for tool in tools: - lines.append("- " + tool.SIGNATURE) - for item in tool.DESCRIPTION: - lines.append(" - " + item) - for item in tool.EXAMPLE: - lines.append(" - " + item) - return "\n".join(lines) - def _format_stable_knowledge(self) -> str: knowledge = self.blackboard.stable_knowledge if not any(knowledge.values()): @@ -3459,42 +3492,6 @@ def format_archived_tool_result_index(self, visible_result_keys: set[str] | None class ModelClient: - ACTION_FRAME_END: ClassVar[str] = "__END_ACTION__" - ACTION_FRAME_END_SPLIT_PATTERN: ClassVar[re.Pattern[str]] = re.compile(r"\**_*\s*END[\s_-]*ACTION\s*_*\**", re.IGNORECASE) - - class ActionStreamParser: - def __init__(self, client: "ModelClient"): - self.client = client - self.buffer = "" - self.frame_number = 0 - self.committed = 0 - self.stopped = False - - def feed(self, text: str, on_action: Callable[[Json], bool]) -> bool: - self.buffer += text - while True: - match = self.client.ACTION_FRAME_END_SPLIT_PATTERN.search(self.buffer) - if match is None: - return False - frame = self.client._strip_fence_marker_lines(self.buffer[: match.start()]) - self.buffer = self.buffer[match.end() :] - self.frame_number += 1 - actions, error = self.client._parse_action_frame(frame, self.frame_number) - if error: - self.buffer = frame + self.client.ACTION_FRAME_END + self.buffer - return False - for action in actions: - self.committed += 1 - if on_action(action): - self.stopped = True - return True - - def trailing_error(self) -> str: - if self.stopped: - return "" - trailing = self.client._strip_fence_marker_lines(self.buffer).strip() - return "unexpected text after committed action frame" if trailing else "" - def __init__(self, session: Session): self.session = session self._timeout_reason = "request model timeout" @@ -3508,8 +3505,9 @@ def request( user_prompt: str, *, activity: str = "agent", - parse_actions: bool = True, on_stream_action: Callable[[Json], bool] | None = None, + tool_schemas: list[Json] | None = None, + required_tool: str | None = None, ) -> Json: config = self.session.config.provider if not config.url: @@ -3528,14 +3526,21 @@ def request( timeout, first_token_timeout = self._request_timeouts(config, activity=activity) api = config.resolved_api() params = ( - self._responses_params(config, model=model, system_prompt=system_prompt, user_prompt=user_prompt, stream=stream) + self._responses_params( + config, + model=model, + system_prompt=system_prompt, + user_prompt=user_prompt, + stream=stream, + tool_schemas=tool_schemas, + required_tool=required_tool, + ) if api == "responses" - else self._chat_completion_params(config, model=model, messages=messages, stream=stream) + else self._chat_completion_params(config, model=model, messages=messages, stream=stream, tool_schemas=tool_schemas, required_tool=required_tool) ) self._write_debug_prompt(activity=activity, messages=messages) client = self._client(config, timeout=timeout) request_elapsed = 0.0 - stream_parser = self.ActionStreamParser(self) if stream and parse_actions and on_stream_action is not None else None try: with ModelRetryShortcut(self.session): self.session.state.current_model_call_started_at = time.monotonic() @@ -3550,39 +3555,62 @@ def request( self._timeout_reason = "request model timeout" signal.setitimer(signal.ITIMER_REAL, max(0, timeout)) try: - completion = ( - client.responses.create(**params, timeout=timeout) - if api == "responses" - else client.chat.completions.create(**params, timeout=timeout) - ) - if stream: - content, usage = ( - self._read_responses_stream( - completion, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, - stream_parser=stream_parser, - on_stream_action=on_stream_action, - ) - if api == "responses" - else self._read_streaming_content( - completion, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, - stream_parser=stream_parser, - on_stream_action=on_stream_action, - ) + if api == "chat" and stream and tool_schemas: + response, usage = self._read_chat_tool_stream( + client, + params, + timeout=timeout, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + on_stream_action=on_stream_action, + ) + result = {"usage": usage, **response} + content = "" + elif api == "responses" and stream and tool_schemas: + response, usage = self._read_responses_tool_stream( + client, + params, + timeout=timeout, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + on_stream_action=on_stream_action, ) - result: Json = {"usage": usage} + result = {"usage": usage, **response} + content = "" else: - result = self._sdk_json(completion) + completion = ( + client.responses.create(**params, timeout=timeout) + if api == "responses" + else client.chat.completions.create(**params, timeout=timeout) + ) + if stream: + content, usage = ( + self._read_responses_stream( + completion, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + if api == "responses" + else self._read_streaming_content( + completion, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + ) + result = {"usage": usage} + else: + result = self._sdk_json(completion) + if api == "chat" and tool_schemas: + result = {"usage": _json_dict(result.get("usage")), **self._chat_tool_response(result)} + elif api == "responses" and tool_schemas: + result = {"usage": _json_dict(result.get("usage")), **self._responses_tool_response(result)} finally: signal.setitimer(signal.ITIMER_REAL, 0) signal.signal(signal.SIGALRM, previous_handler) if self.session.state.current_model_call_started_at > 0: request_elapsed = max(0.0, time.monotonic() - self.session.state.current_model_call_started_at) if request_elapsed > 0 and self.session.state.current_model_call_streaming_chars > 0: - self.session.state.last_model_call_rate = self._estimate_stream_rate(request_elapsed) + self.session.state.last_model_call_rate = self.session.state.current_model_call_streaming_chars / 4 / request_elapsed self.session.state.current_model_call_started_at = 0.0 self.session.state.current_model_call_label = "" self.session.state.current_model_call_reasoning_label = "" @@ -3611,20 +3639,13 @@ def request( raise LLMError(str(error)) self._record_usage(_json_dict(result.get("usage") if isinstance(result, dict) else None), config, elapsed=request_elapsed) - if stream_parser is not None and stream_parser.committed: - response: Json = {"actions": [], "_stream_committed": True} - error = stream_parser.trailing_error() - if error: - response["_format_bad_output"] = content - response["_format_error"] = "Invalid model output: " + error + ". Return action frames only. Bad output: " + _shorten(content) - return response + if tool_schemas and isinstance(result.get("actions"), list): + return self._action_response(_json_list(result.get("actions")), _json_str(result.get("_assistant_text")) or "") if not stream: content = self._responses_content(result) if api == "responses" else self._message_content(result) if content is None: return self._invalid_model_response(self._format_missing_message_content(result)) - if not parse_actions: - return self._parse_json_content(content) - return self._parse_model_content(content) + return {"actions": [], "_assistant_text": content} def _client(self, config: ProviderConfig, *, timeout: int) -> OpenAI: return OpenAI( @@ -3639,13 +3660,26 @@ def _client(self, config: ProviderConfig, *, timeout: int) -> OpenAI: def _reasoning_effort(config: ProviderConfig) -> str: return config.reasoning_effort or "medium" - def _chat_completion_params(self, config: ProviderConfig, *, model: str, messages: list[Json], stream: bool) -> Json: + def _chat_completion_params( + self, + config: ProviderConfig, + *, + model: str, + messages: list[Json], + stream: bool, + tool_schemas: list[Json] | None = None, + required_tool: str | None = None, + ) -> Json: params: Json = {"model": model, "messages": messages, "stream": stream} extra_body: Json = {} if config.temperature is not None: params["temperature"] = config.temperature if stream: params["stream_options"] = {"include_usage": True} + if tool_schemas: + params["tools"] = tool_schemas + params["tool_choice"] = {"type": "function", "function": {"name": required_tool}} if required_tool else "auto" + params["parallel_tool_calls"] = True chat_reasoning_payload = config.resolved_chat_reasoning_payload() if config.reasoning is not False and chat_reasoning_payload == "reasoning": extra_body["reasoning"] = {"effort": self._reasoning_effort(config)} @@ -3663,8 +3697,216 @@ def _chat_completion_params(self, config: ProviderConfig, *, model: str, message params["extra_body"] = extra_body return params - def _responses_params(self, config: ProviderConfig, *, model: str, system_prompt: str, user_prompt: str, stream: bool) -> Json: + def _responses_tool_schemas(self, tool_schemas: list[Json] | None) -> list[Json]: + converted = [] + for schema in tool_schemas or []: + function = _json_dict(schema.get("function")) + if not function: + converted.append(schema) + continue + converted.append({"type": "function", **function}) + return converted + + def _read_chat_tool_stream( + self, + client: OpenAI, + params: Json, + *, + timeout: int, + request_deadline: float, + first_token_timeout: int | None, + on_stream_action: Callable[[Json], bool] | None = None, + ) -> tuple[Json, Json]: + usage: Json = {} + actions: list[Json] = [] + text_parts: list[str] = [] + first_output_seen = False + + stream_params = dict(params) + stream_params.pop("stream", None) + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) + stopped = False + with client.beta.chat.completions.stream(**stream_params, timeout=timeout) as stream: + for event in stream: + data = self._sdk_json(event) + event_type = _json_str(data.get("type")) or str(getattr(event, "type", "") or "") + if event_type == "content.delta": + text = str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "") + first_output_seen = self._mark_stream_output( + len(text), + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + if text: + text_parts.append(text) + continue + if event_type == "tool_calls.function.arguments.delta": + first_output_seen = self._mark_stream_output( + len(str(getattr(event, "arguments_delta", "") or _json_str(data.get("arguments_delta")) or "")), + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + continue + if event_type != "tool_calls.function.arguments.done": + continue + action = self._action_from_function_call( + str(getattr(event, "name", "") or _json_str(data.get("name")) or ""), + str(getattr(event, "arguments", "") or _json_str(data.get("arguments")) or "{}"), + ) + if text_parts and on_stream_action is not None: + action["_assistant_text"] = "".join(text_parts).strip() + text_parts.clear() + actions.append(action) + stopped, request_deadline = self._call_stream_action( + on_stream_action, + action, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + if stopped: + break + if not stopped: + final = self._sdk_json(stream.get_final_completion()) + usage = _json_dict(final.get("usage")) + if not actions: + return self._chat_tool_response(final), usage + return self._action_response(actions, "".join(text_parts)), usage + + def _read_responses_tool_stream( + self, + client: OpenAI, + params: Json, + *, + timeout: int, + request_deadline: float, + first_token_timeout: int | None, + on_stream_action: Callable[[Json], bool] | None = None, + ) -> tuple[Json, Json]: + usage: Json = {} + actions: list[Json] = [] + text_parts: list[str] = [] + first_output_seen = False + + stream_params = dict(params) + stream_params.pop("stream", None) + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) + stopped = False + with client.responses.stream(**stream_params, timeout=timeout) as stream: + for event in stream: + data = self._sdk_json(event) + event_type = _json_str(data.get("type")) or str(getattr(event, "type", "") or "") + if event_type in ("response.output_text.delta", "response.reasoning.delta"): + text = str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "") + first_output_seen = self._mark_stream_output( + len(text), + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + if event_type == "response.output_text.delta" and text: + text_parts.append(text) + continue + if event_type == "response.function_call_arguments.delta": + first_output_seen = self._mark_stream_output( + len(str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "")), + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + continue + if event_type != "response.function_call_arguments.done": + continue + action = self._action_from_function_call( + str(getattr(event, "name", "") or _json_str(data.get("name")) or ""), + str(getattr(event, "arguments", "") or _json_str(data.get("arguments")) or "{}"), + ) + if text_parts and on_stream_action is not None: + action["_assistant_text"] = "".join(text_parts).strip() + text_parts.clear() + actions.append(action) + stopped, request_deadline = self._call_stream_action( + on_stream_action, + action, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + if stopped: + break + if not stopped: + final = self._sdk_json(stream.get_final_response()) + usage = _json_dict(final.get("usage")) + if not actions: + return self._responses_tool_response(final), usage + return self._action_response(actions, "".join(text_parts)), usage + + def _chat_tool_response(self, result: JsonValue) -> Json: + data = _json_dict(result) + choices = _json_list(data.get("choices")) + if not choices: + raise LLMError("API response missing choices") + message = _json_dict(_json_dict(choices[0]).get("message")) + actions = [ + self._action_from_function_call( + _json_str(_json_dict(call.get("function")).get("name")) or "", + _json_str(_json_dict(call.get("function")).get("arguments")) or "{}", + ) + for call in (_json_dict(raw) for raw in _json_list(message.get("tool_calls"))) + if call + ] + if actions: + content = message.get("content") + return self._action_response(actions, content if isinstance(content, str) else "") + content = message.get("content") + return self._action_response([], content if isinstance(content, str) else "") + + def _responses_tool_response(self, result: JsonValue) -> Json: + actions = [ + self._action_from_function_call(_json_str(item.get("name")) or "", _json_str(item.get("arguments")) or "{}") + for item in (_json_dict(raw) for raw in _json_list(_json_dict(result).get("output"))) + if _json_str(item.get("type")) == "function_call" + ] + if actions: + return self._action_response(actions, self._responses_content(result) or "") + return self._action_response([], self._responses_content(result) or "") + + @staticmethod + def _action_response(actions: list[Json], assistant_text: str = "") -> Json: + response: Json = {"actions": actions} + assistant_text = assistant_text.strip() + if assistant_text: + response["_assistant_text"] = assistant_text + return response + + def _action_from_function_call(self, name: str, arguments: str) -> Json: + try: + value = json.loads(arguments or "{}") + except Exception as error: + return {"type": name or "invalid_tool_call", "_format_error": "invalid tool arguments: " + str(error)} + args = _json_dict(value) + if name in TOOL_REGISTRY: + return {"type": "tool", "name": name, "intention": _json_str(args.get("intention")) or "", "args": _json_list(args.get("args"))} + action = {"type": name} + action.update(args) + return action + + def _responses_params( + self, + config: ProviderConfig, + *, + model: str, + system_prompt: str, + user_prompt: str, + stream: bool, + tool_schemas: list[Json] | None = None, + required_tool: str | None = None, + ) -> Json: params: Json = {"model": model, "instructions": system_prompt, "input": user_prompt, "stream": stream, "store": False} + if tool_schemas: + params["tools"] = self._responses_tool_schemas(tool_schemas) + params["tool_choice"] = {"type": "function", "name": required_tool} if required_tool else "auto" + params["parallel_tool_calls"] = True if config.temperature is not None: params["temperature"] = config.temperature if config.reasoning is not False: @@ -3679,14 +3921,40 @@ def _request_timeouts(self, config: ProviderConfig, *, activity: str) -> tuple[i return self.session.settings.plan_timeout, self.session.settings.plan_first_token_timeout return timeout, first_token_timeout + def _mark_stream_output(self, chars: int, seen: bool, *, request_deadline: float, first_token_timeout: int | None) -> bool: + if chars <= 0: + return seen + if not seen: + self.session.state.current_model_call_has_content = True + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) + self.session.state.current_model_call_streaming_chars += chars + return True + + def _call_stream_action( + self, + callback: Callable[[Json], bool] | None, + action: Json, + *, + request_deadline: float, + first_token_timeout: int | None, + ) -> tuple[bool, float]: + if callback is None: + return False, request_deadline + signal.setitimer(signal.ITIMER_REAL, 0) + callback_started = time.monotonic() + try: + stopped = callback(action) + finally: + request_deadline += max(0.0, time.monotonic() - callback_started) + self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) + return stopped, request_deadline + def _read_streaming_content( self, stream: Any, *, request_deadline: float, first_token_timeout: int | None, - stream_parser: "ModelClient.ActionStreamParser | None" = None, - on_stream_action: Callable[[Json], bool] | None = None, ) -> tuple[str, Json]: parts: list[str] = [] usage: Json = {} @@ -3705,22 +3973,14 @@ def _read_streaming_content( output_chars = self._stream_output_chars(delta) if output_chars <= 0: continue - if not first_output_seen: - first_output_seen = True - self.session.state.current_model_call_has_content = True - self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) - self.session.state.current_model_call_streaming_chars += output_chars + first_output_seen = self._mark_stream_output( + output_chars, + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) if isinstance(content, str) and content: parts.append(content) - if stream_parser is not None and on_stream_action is not None: - signal.setitimer(signal.ITIMER_REAL, 0) - callback_started = time.monotonic() - try: - if stream_parser.feed(content, on_stream_action): - break - finally: - request_deadline += max(0.0, time.monotonic() - callback_started) - self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) return "".join(parts), usage def _read_responses_stream( @@ -3729,24 +3989,12 @@ def _read_responses_stream( *, request_deadline: float, first_token_timeout: int | None, - stream_parser: "ModelClient.ActionStreamParser | None" = None, - on_stream_action: Callable[[Json], bool] | None = None, ) -> tuple[str, Json]: parts: list[str] = [] usage: Json = {} completed_content = "" first_output_seen = False - def mark_output(chars: int) -> None: - nonlocal first_output_seen - if chars <= 0: - return - if not first_output_seen: - first_output_seen = True - self.session.state.current_model_call_has_content = True - self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) - self.session.state.current_model_call_streaming_chars += chars - self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) for event in stream: data = self._sdk_json(event) @@ -3761,28 +4009,34 @@ def mark_output(chars: int) -> None: response_content = self._responses_content(response) if response_content and not parts and not completed_content: completed_content = response_content - mark_output(len(response_content)) + first_output_seen = self._mark_stream_output( + len(response_content), + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) continue fallback_content = self._responses_event_content(data) if fallback_content and not parts and not completed_content: completed_content = fallback_content - mark_output(len(fallback_content)) + first_output_seen = self._mark_stream_output( + len(fallback_content), + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) continue output = self._responses_stream_output(data) if not output: continue - mark_output(len(output[1])) + first_output_seen = self._mark_stream_output( + len(output[1]), + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) if output[0] == "content": parts.append(output[1]) - if stream_parser is not None and on_stream_action is not None: - signal.setitimer(signal.ITIMER_REAL, 0) - callback_started = time.monotonic() - try: - if stream_parser.feed(output[1], on_stream_action): - break - finally: - request_deadline += max(0.0, time.monotonic() - callback_started) - self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=True, first_token_timeout=first_token_timeout) return "".join(parts) or completed_content, usage def _raise_responses_stream_error(self, event: Json) -> None: @@ -3837,9 +4091,6 @@ def _stream_output_chars(self, delta: Json) -> int: details = _json_list(delta.get("reasoning_details")) return len(json.dumps(details, ensure_ascii=False)) if details else 0 - def _estimate_stream_rate(self, elapsed: float) -> float: - return self.session.state.current_model_call_streaming_chars / 4 / elapsed if elapsed > 0 else 0.0 - def _arm_stream_timeout(self, *, request_deadline: float, first_output_seen: bool, first_token_timeout: int | None) -> None: remaining = request_deadline - time.monotonic() if remaining <= 0: @@ -3876,300 +4127,11 @@ def _format_debug_prompt(self, *, messages: list[Json]) -> str: lines.append("") return "\n".join(lines).rstrip() + "\n" - def _parse_model_content(self, content: str) -> Json: - text = content.strip() - text = self._strip_leaked_think_tags(text) - text = self._strip_leaked_tool_code(text) - text = self._strip_json_fence(text) - text = self._strip_fence_marker_lines(text) - text = self._strip_leaked_think_tags(text) - text = self._strip_leaked_tool_code(text) - if not self._has_action_frame_end(text): - actions, error = self._parse_unmarked_actions(text) - if actions: - return {"actions": actions} - if error == "": - return {"actions": []} - return self._invalid_model_response(content, "expected one JSON action object or action frames ending with " + self.ACTION_FRAME_END + "; " + error) - actions: list[Json] = [] - frame_errors: list[str] = [] - for frame_number, frame in enumerate(self._action_frames(text), start=1): - parsed_actions, error = self._parse_action_frame(frame, frame_number) - if parsed_actions: - actions.extend(parsed_actions) - continue - if error: - frame_errors.append(error) - if not actions: - if not frame_errors: - return {"actions": []} - reason = "expected at least one valid action frame ending with " + self.ACTION_FRAME_END - if frame_errors: - reason += "; " + "; ".join(frame_errors[:3]) - return self._invalid_model_response(content, reason) - response: Json = {"actions": actions} - if frame_errors: - response["_format_frame_errors"] = frame_errors - return response - - def _parse_json_content(self, content: str) -> Json: - text = content.strip() - text = self._strip_leaked_think_tags(text) - text = self._strip_json_fence(text) - text = self._strip_leaked_think_tags(text) - try: - value = json_repair.loads(text) - except Exception as error: - raise LLMError("model returned invalid JSON: " + str(error)) - if not isinstance(value, dict): - raise LLMError("model returned JSON that is not an object") - return value - - def _action_frames(self, text: str) -> list[str]: - frames: list[str] = [] - current: list[str] = [] - for line in text.splitlines(): - if not self._has_action_frame_end(line): - current.append(line) - continue - parts = self.ACTION_FRAME_END_SPLIT_PATTERN.split(line) - for index, part in enumerate(parts): - if part: - current.append(part) - if index < len(parts) - 1: - frames.append("\n".join(current).strip()) - current = [] - trailing = "\n".join(current).strip() - if trailing: - frames.append(trailing) - return frames - - def _parse_action_frame(self, frame: str, frame_number: int) -> tuple[list[Json], str]: - frame = frame.strip() - if not frame: - return [], "" - try: - value = json_repair.loads(frame) - except Exception as error: - return [], "frame " + str(frame_number) + ": " + str(error) - actions, error = self._actions_from_json_value(value) - if error: - return [], "frame " + str(frame_number) + ": " + error - return actions, "" - - def _actions_from_json_value(self, value: JsonValue) -> tuple[list[Json], str]: - if isinstance(value, dict): - if "actions" in value: - return self._actions_from_json_value(value.get("actions")) - self._normalize_tool_type(value) - if not _json_str(value.get("type")): - return [], "action missing type" - return [value], "" - if isinstance(value, list): - actions = [] - for index, raw in enumerate(value, start=1): - action = _json_dict(raw) - if not action: - return [], "array item " + str(index) + ": expected JSON object action" - self._normalize_tool_type(action) - if not _json_str(action.get("type")): - return [], "array item " + str(index) + ": action missing type" - actions.append(action) - return actions, "" - return [], "expected JSON object action" - - def _normalize_tool_type(self, action: Json) -> None: - action_type = _json_str(action.get("type")) - tool_name = next((name for name in TOOL_REGISTRY if name.lower() == action_type.lower()), "") if action_type else "" - if tool_name: - action["type"] = "tool" - action.setdefault("name", tool_name) - - def _parse_unmarked_actions(self, text: str) -> tuple[list[Json], str]: - actions: list[Json] = [] - decoder = json.JSONDecoder() - index = 0 - while index < len(text) and text[index].isspace(): - index += 1 - prefix = "" - if index < len(text) and text[index] != "{": - if text[index] == "[": - try: - value, index = self._decode_json_array_text(text, index) - except (json.JSONDecodeError, ValueError) as error: - return [], str(error) - parsed, error = self._actions_from_json_value(value) - if error: - return [], error - while index < len(text) and text[index].isspace(): - index += 1 - if index < len(text): - progress = self._trailing_progress_text(text[index:]) - if progress: - parsed.append({"type": "progress", "text": progress}) - return parsed, "" - return [], "unexpected text after JSON action array" - return parsed, "" - action_start = text.find("{", index) - if action_start < 0: - progress = self._plain_progress_text(text[index:]) - if progress: - return [{"type": "progress", "text": progress}], "" - try: - decoder.raw_decode(text, index) - except json.JSONDecodeError as error: - return [], str(error) - return [], "expected JSON object action" - prefix = self._progress_text(text[:action_start]) - index = action_start - while True: - while index < len(text) and text[index].isspace(): - index += 1 - if index >= len(text): - if prefix and actions: - actions.insert(0, {"type": "progress", "text": prefix}) - return actions, "" - try: - value, index = decoder.raw_decode(text, index) - except json.JSONDecodeError as error: - if actions: - return [], str(error) - if self._should_repair_json_decode_error(str(error), text): - repaired, repair_error = self._repair_single_json_action(text) - if not repair_error: - if prefix: - repaired.insert(0, {"type": "progress", "text": prefix}) - return repaired, "" - return [], str(error) - parsed, error = self._actions_from_json_value(value) - if error: - return [], error - actions.extend(parsed) - while index < len(text) and text[index].isspace(): - index += 1 - if index < len(text) and text[index] == ",": - index += 1 - continue - if index < len(text) and text[index] != "{": - next_action = text.find("{", index) - if next_action < 0: - if self._should_repair_trailing_json_text(text[index:]): - repaired, error = self._repair_single_json_action(text) - if not error: - return repaired, "" - progress = self._trailing_progress_text(text[index:]) - if progress: - actions.append({"type": "progress", "text": progress}) - return actions, "" - return [], "unexpected text after JSON action" - progress = self._progress_text(text[index:next_action]) - if progress: - actions.append({"type": "progress", "text": progress}) - index = next_action - - def _progress_text(self, text: str) -> str: - text = re.sub(r"```[a-zA-Z0-9_-]*", "", text) - text = text.replace("```", "") - return _shorten(" ".join(text.split()), 500) - - def _plain_progress_text(self, text: str) -> str: - progress = self._progress_text(text) - if not progress or "{" in progress or "}" in progress: - return "" - starters = ( - "let me ", - "i need ", - "i will ", - "i'll ", - "now ", - "next ", - "我需要", - "让我", - "我会", - "现在", - "接下来", - ) - return progress if progress.lower().startswith(starters) else "" - - def _trailing_progress_text(self, text: str) -> str: - progress = self._progress_text(text) - if not progress or "{" in progress or "}" in progress: - return "" - return progress - - def _decode_json_array_text(self, text: str, index: int) -> tuple[JsonValue, int]: - decoder = json.JSONDecoder() - value, end = decoder.raw_decode(text, index) - cursor = end - while cursor < len(text) and text[cursor].isspace(): - cursor += 1 - if cursor >= len(text): - return value, cursor - if not self._should_repair_trailing_json_text(text[cursor:]): - return value, cursor - value = json_repair.loads(text[index:]) - if not isinstance(value, list): - raise ValueError("expected JSON action array") - return value, len(text) - - def _repair_single_json_action(self, text: str) -> tuple[list[Json], str]: - try: - value = json_repair.loads(text) - except Exception as error: - return [], str(error) - if isinstance(value, list): - return [], "unexpected text after JSON action" - return self._actions_from_json_value(value) - - def _should_repair_json_decode_error(self, error: str, text: str) -> bool: - return "Invalid control character" in error or re.fullmatch(r".*[}\]]\s*[}\]]+\s*", text, re.DOTALL) is not None - - def _should_repair_trailing_json_text(self, text: str) -> bool: - return re.fullmatch(r"\s*[}\]]+\s*", text) is not None - - def _has_action_frame_end(self, line: str) -> bool: - return self.ACTION_FRAME_END_SPLIT_PATTERN.search(line) is not None - - 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_fence_marker_lines(self, text: str) -> str: - return re.sub(r"(?m)^\s*```[a-zA-Z0-9_-]*\s*$\n?", "", text).strip() - - def _strip_leaked_think_tags(self, text: str) -> str: - text = text.strip() - while text.startswith(""): - text = text[len("") :].lstrip() - while text.startswith(""): - end = text.find("") - if end < 0: - return text - text = text[end + len("") :].lstrip() - while text.startswith(""): - text = text[len("") :].lstrip() - return text - - def _strip_leaked_tool_code(self, text: str) -> str: - return re.sub(r".*?", "", text, flags=re.DOTALL).strip() - - def _invalid_model_response(self, content: str, reason: str = "expected one JSON object matching the Output JSON schema") -> Json: - guidance = "" - if self._strip_leaked_think_tags(content.strip()).startswith(""): - guidance = ( - " Native tool_call syntax is not supported; return an action frame like " - '{"type":"tool","name":"Read","intention":"...","args":["nanocode.py","0,100"]}\n__END_ACTION__.' - ) + def _invalid_model_response(self, content: str, reason: str = "expected a function tool call") -> Json: return { "actions": [], "_format_bad_output": content, - "_format_error": "Invalid model output: " + reason + ". Return action frames only. Bad output: " + _shorten(content) + guidance, + "_format_error": "Invalid function-tool response: " + reason + ". Use the provided function tools. Bad output: " + _shorten(content), } def _message_content(self, result: JsonValue) -> str | None: @@ -4328,7 +4290,7 @@ def execute( else: call = item if isinstance(item, ParsedToolCall) else self.parse_tool_call(item) tool = self._make_tool(call) - requires_verification = tool.effect() == ToolEffect.EDIT + requires_verification = tool.EFFECT == ToolEffect.EDIT preview_error = getattr(tool, "preview_error", None) if callable(preview_error): preview_error_text = str(preview_error()) @@ -4364,7 +4326,7 @@ def execute( call = self._invalid_tool_call(item) result_key = "" result_excerpted = False - if call.name != ToolResultTool.name(): + if call.name != ToolResultTool.NAME: result_key = self._store_tool_result(call, outcome, output) item = self.session.state.tool_result_store[result_key] output = item.value @@ -4431,7 +4393,7 @@ def _dedupe_readonly_tool_calls(self, tool_calls: list[JsonValue]) -> list[JsonV if key is not None and filtered and isinstance(filtered[-1], ParsedToolCall) and self._readonly_call_key(filtered[-1]) == key: filtered[-1] = call continue - if call.name == ToolResultTool.name() and filtered and isinstance(filtered[-1], ParsedToolCall) and filtered[-1].name == call.name: + if call.name == ToolResultTool.NAME and filtered and isinstance(filtered[-1], ParsedToolCall) and filtered[-1].name == call.name: merged_args = list(filtered[-1].args) merged_args.extend(arg for arg in call.args if arg not in merged_args) filtered[-1] = ParsedToolCall(name=call.name, intention=call.intention, args=merged_args) @@ -4471,7 +4433,7 @@ def _merge_adjacent_tool_calls(self, tool_calls: list[JsonValue | ParsedToolCall return merged def _merge_key(self, item: JsonValue | ParsedToolCall) -> tuple[str, tuple[str, ...]] | None: - if not isinstance(item, ParsedToolCall) or item.name != ReplaceRangeTool.name(): + if not isinstance(item, ParsedToolCall) or item.name != ReplaceRangeTool.NAME: return None key = ReplaceRangeTool.merge_key(item) if key is None: @@ -4482,7 +4444,7 @@ def _merge_calls(self, group: list[JsonValue | ParsedToolCall]) -> PreparedToolC parsed_group = [item for item in group if isinstance(item, ParsedToolCall)] if len(parsed_group) != len(group): return None - if parsed_group[0].name != ReplaceRangeTool.name(): + if parsed_group[0].name != ReplaceRangeTool.NAME: return None return ReplaceRangeTool.merge_calls(self.session, parsed_group) @@ -4539,7 +4501,7 @@ def parse_tool_call(self, value: JsonValue) -> ParsedToolCall: name = next((registered_name for registered_name in TOOL_REGISTRY if registered_name.lower() == name), name) intention = _json_str(item.get("intention")) or "" raw_args = _json_list(item.get("args")) - args: list[JsonValue] = list(raw_args) if name == ReplaceRangeTool.name() else [_json_str(arg) or "" for arg in raw_args] + args: list[JsonValue] = list(raw_args) if name == ReplaceRangeTool.NAME else [_json_str(arg) or "" for arg in raw_args] return ParsedToolCall(name=name, intention=intention, args=args) def _invalid_tool_call(self, value: JsonValue) -> ParsedToolCall: @@ -4752,13 +4714,6 @@ def _apply_goal(self, actions: list[Json]) -> bool: changed = False for action in actions: action_type = _json_str(action.get("type")) - if action_type == "start": - update = _json_str(action.get("goal")) - if update: - goal_changed = update != self.blackboard.goal - changed = changed or goal_changed - self.blackboard.goal = update - self.blackboard.goal_reached = False if action_type == "goal": update = _json_str(action.get("text")) complete = action.get("complete") @@ -4772,12 +4727,6 @@ def _apply_goal(self, actions: list[Json]) -> bool: def _apply_plan(self, actions: list[Json]) -> bool: replaced = False - for start in [action for action in actions if _json_str(action.get("type")) == "start"]: - items = [item for item in (self._plan_item_from_json(raw) for raw in _json_list(start.get("plan"))) if item] - if items: - self._normalize_doing_items(items) - self.blackboard.plan = items - replaced = True for update in [action for action in actions if _json_str(action.get("type")) == "plan"]: items = _json_list(update.get("items")) if update.get("mode") != "patch": @@ -4867,7 +4816,9 @@ def _apply_hypotheses(self, actions: list[Json]) -> None: def _apply_work_mode(self, actions: list[Json]) -> None: for action in actions: - if _json_str(action.get("type")) != "start": + if _json_str(action.get("type")) != "goal": + continue + if "work_mode" not in action: continue mode = _json_str(action.get("work_mode")) or WorkMode.NORMAL self.blackboard.work_mode = WorkMode(mode) if mode in ALL_WORK_MODES else WorkMode.NORMAL @@ -4951,10 +4902,7 @@ def _apply_task_code(self, actions: list[Json]) -> None: if "verify" in action_types: self.blackboard.task_code = TaskCode.WORKING return - if "start" in action_types: - self.blackboard.task_code = TaskCode.WORKING - return - if any(action_type in action_types for action_type in ("goal", "plan", "known", "stable_knowledge", "progress", "tool")) and not self.blackboard.goal_reached: + if any(action_type in action_types for action_type in ("goal", "plan", "known", "stable_knowledge", "tool")) and not self.blackboard.goal_reached: self.blackboard.task_code = TaskCode.WORKING def _append_state_section(self, lines: list[str], title: str, rows: list[str] | None = None) -> None: @@ -5129,8 +5077,13 @@ def _summarize(self, items: list[ConversationItem]) -> tuple[str, list[KnownItem known="\n".join(KnownItem.format_item(item) for item in self.blackboard.known) or "(empty)", conversation="\n\n".join(item.format() for item in items), ).strip() - kwargs = {"parse_actions": False} if isinstance(self.model_client, ModelClient) else {} + kwargs = {"tool_schemas": [COMPACT_TOOL_SCHEMA], "required_tool": "compact"} if isinstance(self.model_client, ModelClient) else {} response = self.model_client.request(COMPACTOR_PROMPT.strip(), user_prompt, activity="compact", **kwargs) + if "actions" in response: + response = next( + (_json_dict(action) for action in _json_list(response.get("actions")) if _json_str(_json_dict(action).get("type")) == "compact"), + {}, + ) summary = _json_str(response.get("summary")) if not summary: raise LLMError("compact response missing summary") @@ -5157,15 +5110,14 @@ def _summarize(self, items: list[ConversationItem]) -> tuple[str, list[KnownItem class ResponseContext: response: Json actions: list[Json] + assistant_text: str goal_was_empty: bool plan_was_empty: bool plan_was_complete: bool verification_was_settled: bool goal_will_change: bool - chat_message: str | None tool_calls: list[JsonValue] pending_verify_requested: bool - progress_messages: list[str] user_rule_message: str | None completion_message: str has_goal_action: bool @@ -5188,20 +5140,17 @@ class Agent: MODEL_TIMEOUT_RETRY_DELAYS: ClassVar[tuple[int, ...]] = (3, 10, 20, 30, 60, 120) blackboard: Blackboard ACT_ACTION_TYPES: ClassVar[set[str]] = { - "chat", - "start", "goal", "plan", "hypothesis", "known", "stable_knowledge", - "progress", "tool", "verify", "user_rule", "forget", } - PLAN_ACTION_TYPES: ClassVar[set[str]] = ACT_ACTION_TYPES - {"chat", "user_rule", "forget"} + PLAN_ACTION_TYPES: ClassVar[set[str]] = ACT_ACTION_TYPES - {"user_rule", "forget"} OBSERVE_ACTION_TYPES: ClassVar[set[str]] = {"keep", "hypothesis", "known", "stable_knowledge", "forget"} COMPLETED_PLAN_STATUSES: ClassVar[set[PlanStatus]] = {PlanStatus.DONE, PlanStatus.BLOCKED} MAX_COMPLETED_GOAL_TOOL_RESULTS: ClassVar[int] = 50 @@ -5225,7 +5174,7 @@ class Agent: RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked verification only when blocker=user." RULE_FINAL_ACTION: ClassVar[str] = "continue with a useful action or finish with goal.complete=true." - RULE_ACTION_FRAMES: ClassVar[str] = "return valid JSON action frames only." + RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." def __init__(self, session: Session): self.session = session @@ -5274,13 +5223,20 @@ def request( activity: str = "agent", on_message: MessageCallback | None = None, on_stream_action: Callable[[Json], bool] | None = None, + tool_schemas: list[Json] | None = None, ) -> Json: attempt = 0 while attempt <= len(self.MODEL_TIMEOUT_RETRY_DELAYS): try: self.session.state.turn_model_calls += 1 - if on_stream_action is not None and isinstance(self.model_client, ModelClient): - return self.model_client.request(system_prompt, user_prompt, activity=activity, on_stream_action=on_stream_action) + if isinstance(self.model_client, ModelClient): + return self.model_client.request( + system_prompt, + user_prompt, + activity=activity, + on_stream_action=on_stream_action, + tool_schemas=tool_schemas, + ) return self.model_client.request(system_prompt, user_prompt, activity=activity) except ModelRequestRetry: if on_message is not None and self.session.settings.debug: @@ -5335,30 +5291,11 @@ def run_loop( format_error = _json_str(response.get("_format_error")) if format_error: consecutive_format_errors += 1 - self._set_status_notice("err:format") - remember_error = self._remember_observe_error if self.mode == AgentMode.OBSERVE else self._remember_agent_error - remember_error( - self._format_gate_user_message("Error: model returned invalid output", format_error) + " Rule: " + self.RULE_ACTION_FRAMES - ) if consecutive_format_errors >= self.MAX_CONSECUTIVE_FORMAT_ERRORS: if on_format_error_limit is not None: + self._remember_format_gate(format_error) return on_format_error_limit(response, format_error) - 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. " - + self._format_gate_debug_details(response, format_error), - ) - 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, - self._format_gate_user_message("Retrying: model returned invalid output", format_error), - "Format_Gate: retrying model response. " + self._format_gate_debug_details(response, format_error), - ) + self._handle_format_gate(response, format_error, consecutive_format_errors, on_message) continue consecutive_format_errors = 0 result = on_step(response) @@ -5393,28 +5330,7 @@ def run_stream_loop( format_error = _json_str(response.get("_format_error")) if format_error: consecutive_format_errors += 1 - self._set_status_notice("err:format") - remember_error = self._remember_observe_error if self.mode == AgentMode.OBSERVE else self._remember_agent_error - remember_error( - self._format_gate_user_message("Error: model returned invalid output", format_error) + " Rule: " + self.RULE_ACTION_FRAMES - ) - 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. " - + self._format_gate_debug_details(response, format_error), - ) - 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, - self._format_gate_user_message("Retrying: model returned invalid output", format_error), - "Format_Gate: retrying model response. " + self._format_gate_debug_details(response, format_error), - ) + self._handle_format_gate(response, format_error, consecutive_format_errors, on_message) continue if not committed: consecutive_format_errors = 0 @@ -5425,6 +5341,29 @@ def run_stream_loop( self.cancel_current_goal() raise + def _remember_format_gate(self, format_error: str) -> None: + remember_error = self._remember_observe_error if self.mode == AgentMode.OBSERVE else self._remember_agent_error + remember_error(self._format_gate_user_message("Error: invalid function/tool response", format_error) + " Rule: " + self.RULE_FUNCTION_TOOLS) + + def _handle_format_gate(self, response: Json, format_error: str, consecutive_errors: int, on_message: MessageCallback | None) -> None: + self._set_status_notice("err:format") + self._remember_format_gate(format_error) + if consecutive_errors >= self.MAX_CONSECUTIVE_FORMAT_ERRORS: + self._report_gate( + on_message, + "Stopped: invalid function/tool response " + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS) + " times in a row.", + "Format_Gate: stopped after " + + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS) + + " consecutive invalid function/tool responses. " + + self._format_gate_debug_details(response, format_error), + ) + raise LLMError("invalid function/tool response " + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS) + " times in a row: " + _shorten(format_error, 300)) + self._report_gate( + on_message, + self._format_gate_user_message("Retrying: invalid function/tool response", format_error), + "Format_Gate: retrying function/tool response. " + self._format_gate_debug_details(response, format_error), + ) + def _finish_current_goal(self) -> None: self.blackboard.task_code = TaskCode.DONE self.blackboard.goal_reached = False @@ -5550,8 +5489,9 @@ def _format_gate_user_message(self, prefix: str, format_error: str) -> str: if marker in detail: detail = detail.split(marker, 1)[0] break - if detail.startswith("Invalid model output: "): - detail = detail[len("Invalid model output: ") :] + marker = "Invalid function-tool response: " + if detail.startswith(marker): + detail = detail[len(marker) :] return prefix + ": " + _shorten(detail, 180) def _format_gate_debug_details(self, response: Json, format_error: str) -> str: @@ -5562,7 +5502,7 @@ def _format_gate_debug_details(self, response: Json, format_error: str) -> str: def _step_prompts(self) -> tuple[str, str, str]: if self.mode == AgentMode.OBSERVE: - system_prompt = self.prompt_builder.system_prompt(AGENT_OBSERVE_SYSTEM_PROMPT, tools=()) + system_prompt = self.prompt_builder.system_prompt(AGENT_OBSERVE_SYSTEM_PROMPT) user_prompt = self.build_observe_prompt() activity = "observe" else: @@ -5574,9 +5514,22 @@ def _step_prompts(self) -> tuple[str, str, str]: activity = "agent" return system_prompt, user_prompt, activity + def _tool_schemas(self) -> list[Json]: + if self.mode == AgentMode.OBSERVE: + action_names = self.OBSERVE_ACTION_TYPES + tool_classes: Iterable[ToolClass] = () + elif self.session.settings.plan_mode: + action_names = self.PLAN_ACTION_TYPES - {"tool"} + tool_classes = PLAN_MODE_TOOLS + else: + action_names = self.ACT_ACTION_TYPES - {"tool"} + tool_classes = TOOL_REGISTRY.values() + actions = [_state_tool_schema(name) for name in STATE_TOOL_PARAMS if name in action_names] + return actions + [tool.tool_schema() for tool in tool_classes] + def step(self, *, on_message: MessageCallback | None = None) -> Json: system_prompt, user_prompt, activity = self._step_prompts() - response = self.request(system_prompt, user_prompt, activity=activity, on_message=on_message) + response = self.request(system_prompt, user_prompt, activity=activity, on_message=on_message, tool_schemas=self._tool_schemas()) if _json_str(response.get("_format_error")): return response invalid_response = self._validate_action_response(response) @@ -5593,7 +5546,7 @@ def stream_step( on_live_done: ToolLiveDoneCallback | None = None, on_message: MessageCallback | None = None, ) -> tuple[AgentRunResult, Json, bool]: - if not self._can_stream_action_frames(): + if not self._can_stream_tools(): response = self.step(on_message=on_message) if _json_str(response.get("_format_error")): return AgentRunResult(), response, False @@ -5613,7 +5566,10 @@ def on_stream_action(action: Json) -> bool: nonlocal committed, latest_result committed = True self.stream_stop_requested = False + assistant_text = _json_str(action.pop("_assistant_text", None)) or "" response = {"actions": [action]} + if assistant_text: + response["_assistant_text"] = assistant_text invalid_response = self._validate_action_response(response) latest_result = ( self.handle_response( @@ -5646,6 +5602,7 @@ def on_stream_action(action: Json) -> bool: activity=activity, on_message=on_message, on_stream_action=on_stream_action, + tool_schemas=self._tool_schemas(), ) if committed: return latest_result, response, True @@ -5663,15 +5620,15 @@ def on_stream_action(action: Json) -> bool: on_message=on_message, ), response, False - def _can_stream_action_frames(self) -> bool: + def _can_stream_tools(self) -> bool: return self.mode == AgentMode.ACT and isinstance(self.model_client, ModelClient) and self.session.config.provider.stream is not False def apply_response(self, response: Json) -> list[str]: actions = self._response_actions(response) - if self._has_pending_verification(actions): + if any(self._is_pending_verify_action(action) for action in actions): response = {**response, "actions": [action for action in actions if not self._is_pending_verify_action(action)]} actions = self._response_actions(response) - if self._start_changes_goal(actions): + if self._goal_changes_task(actions): self.tool_context.kept_results = [] self.tool_context.compact_observed(self.tool_context.recent + self.tool_context.latest) self._mark_memory_checkpoint() @@ -5682,10 +5639,13 @@ def apply_response(self, response: Json) -> list[str]: self._mark_memory_checkpoint() return forgotten - def _start_changes_goal(self, actions: list[Json]) -> bool: + def _goal_changes_task(self, actions: list[Json]) -> bool: + if not self.blackboard.goal: + return False return any( - _json_str(action.get("type")) == "start" - and bool(goal := _json_str(action.get("goal"))) + _json_str(action.get("type")) == "goal" + and action.get("complete") is not True + and bool(goal := _json_str(action.get("text"))) and goal != self.blackboard.goal for action in actions ) @@ -5761,7 +5721,7 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: if execution.error_type is not None and issubclass(execution.error_type, ToolCallArgError): detail = self._format_tool_arg_error(execution) rule = self.RULE_TOOL_SIGNATURE - if execution.call.name in {EditTool.name(), ReplaceRangeTool.name()}: + if execution.call.name in {EditTool.NAME, ReplaceRangeTool.NAME}: rule = self.RULE_EDIT_SIGNATURE self._remember_agent_error( self._error( @@ -5802,7 +5762,7 @@ def _format_tool_arg_error(self, execution: ToolCallExecution) -> str: tool_class = TOOL_REGISTRY.get(call.name) if tool_class is None: return execution.output - params = self._exact_signature_params(tool_class.SIGNATURE) + params = ["filepath", "ranges"] if call.name == ReplaceRangeTool.NAME else self._exact_signature_params(tool_class.SIGNATURE) if not params or len(call.args) == len(params): return execution.output detail = "got " + str(len(call.args)) + " args, expected " + str(len(params)) @@ -5836,27 +5796,20 @@ def _remember_recent_edit(self, execution: ToolCallExecution) -> None: def _invalid_action_response(self, response: Json, reason: str) -> Json: return { "actions": [], - "_format_error": "Invalid model output: " + "_format_error": "Invalid function-tool response: " + reason - + ". Return action frames only. Bad output: " + + ". Use the provided function tools. Bad output: " + _shorten(json.dumps(response, ensure_ascii=False)), } def _validate_action_response(self, response: Json) -> Json | None: if not isinstance(response.get("actions"), list): return self._invalid_action_response(response, "expected actions array") - extra_keys = sorted(str(key) for key in response.keys() if key != "actions" and not str(key).startswith("_format_")) + extra_keys = sorted(str(key) for key in response.keys() if key not in {"actions", "_assistant_text"} and not str(key).startswith("_format_")) if extra_keys: return self._invalid_action_response(response, "unexpected top-level keys: " + ", ".join(extra_keys)) return None - def _format_frame_error_report(self, response: Json) -> str: - errors = [_json_str(error) or "" for error in _json_list(response.get("_format_frame_errors"))] - errors = [error for error in errors if error] - if not errors: - return "" - return "Format_Warning: ignored invalid action frame(s).\n" + "\n".join("- " + _shorten(error, 220) for error in errors) - def _response_actions(self, response: Json) -> list[Json]: actions = [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action] for action in actions: @@ -5868,13 +5821,6 @@ def _normalize_response_action(self, action: Json) -> None: if not action_type: return lowered = action_type.lower() - if lowered == "message": - action["type"] = "chat" - if _json_str(action.get("text")) is None: - text = _json_str(action.get("message")) or _json_str(action.get("content")) - if text is not None: - action["text"] = text - return if lowered in (self.ACT_ACTION_TYPES | self.OBSERVE_ACTION_TYPES): action["type"] = lowered @@ -5895,59 +5841,29 @@ def _gate_action_types( self._report_gate( on_message, retry_message, - "ActionType_Gate: invalid action type(s): " + ", ".join(invalid) + ".", + "Protocol_Gate: invalid action type(s): " + ", ".join(invalid) + ".", ) return AgentRunResult() - def _chat_message_from_actions(self, actions: list[Json]) -> str | None: - for action in actions: - action_type = _json_str(action.get("type")) - if action_type == "chat": - return _json_str(action.get("text")) or "" - return None - return None - - def _progress_messages_from_actions(self, actions: list[Json]) -> list[str]: - messages = [] - for action in actions: - if _json_str(action.get("type")) == "progress": - message = _json_str(action.get("text")) or _json_str(action.get("message")) or "" - else: - message = "" - if message: - messages.append(message) - return messages - - def _completion_message_from_actions(self, actions: list[Json]) -> str: - for action in reversed(actions): - if _json_str(action.get("type")) == "goal" and action.get("complete") is True: - return _json_str(action.get("message_for_complete")) or "" - return "" - def _completion_fallback_message(self, ctx: ResponseContext) -> str: if ctx.completion_message: return ctx.completion_message - return next((message for message in reversed(ctx.progress_messages) if message.strip()), "Done.") + if ctx.assistant_text: + return ctx.assistant_text + return "Done." def _incomplete_goal_update_from_actions(self, actions: list[Json]) -> str: update = "" for action in actions: action_type = _json_str(action.get("type")) - if action_type == "start": - update = _json_str(action.get("goal")) or update - elif action_type == "goal" and action.get("complete") is not True: + if action_type == "goal" and action.get("complete") is not True: update = _json_str(action.get("text")) or update return update def _has_fresh_plan_action(self, actions: list[Json]) -> bool: - def has_items(value: JsonValue) -> bool: - return any(_json_str(_json_dict(raw).get("text")) for raw in _json_list(value)) - for action in actions: action_type = _json_str(action.get("type")) - if action_type == "start" and has_items(action.get("plan")): - return True - if action_type == "plan" and action.get("mode") != "patch" and has_items(action.get("items")): + if action_type == "plan" and action.get("mode") != "patch" and any(_json_str(_json_dict(raw).get("text")) for raw in _json_list(action.get("items"))): return True return False @@ -5994,13 +5910,6 @@ def _user_rule_message_from_actions(self, actions: list[Json]) -> str | None: return _json_str(action.get("message")) or "Rule saved." return None - def _has_pending_verification(self, actions: list[Json]) -> bool: - return any(self._is_pending_verify_action(action) for action in actions) - - @staticmethod - def _has_state_update_action(actions: list[Json]) -> bool: - return any(_json_str(action.get("type")) in {"plan", "known", "hypothesis", "stable_knowledge"} for action in actions) - @staticmethod def _is_pending_verify_action(action: Json) -> bool: return _json_str(action.get("type")) == "verify" and _json_str(action.get("status")) == "pending" @@ -6054,7 +5963,7 @@ def _plan_mode_tool_error(self, tool_calls: list[JsonValue]) -> str: tool_class = TOOL_REGISTRY.get(call.name) if tool_class is None: return "plan mode allows registered readonly tools only; blocked " + _format_tool_call_summary(call) - if tool_class.effect() == ToolEffect.READONLY: + if tool_class.EFFECT == ToolEffect.READONLY: continue if tool_class is GitTool: args = call.args[1:] if call.args and isinstance(call.args[0], str) and call.args[0].startswith("cwd=") else call.args @@ -6070,36 +5979,43 @@ def _has_non_readonly_tool_call(self, tool_calls: list[JsonValue]) -> bool: except ToolCallArgError: return True tool_class = TOOL_REGISTRY.get(call.name) - if tool_class is None or tool_class.effect() != ToolEffect.READONLY: + if tool_class is None or tool_class.EFFECT != ToolEffect.READONLY: return True return False def _build_response_context(self, response: Json) -> ResponseContext: raw_actions = self._response_actions(response) - pending_verify_requested = self._has_pending_verification(raw_actions) + assistant_text = _json_str(response.get("_assistant_text")) or "" + pending_verify_requested = any(self._is_pending_verify_action(action) for action in raw_actions) actions = [action for action in raw_actions if not self._is_pending_verify_action(action)] tool_calls = [action for action in actions if _json_str(action.get("type")) == "tool"] - progress_messages = self._progress_messages_from_actions(actions) - has_goal_action = any(_json_str(action.get("type")) in {"goal", "start"} for action in actions) - has_plan_action = any(_json_str(action.get("type")) in {"plan", "start"} for action in actions) + has_goal_action = any(_json_str(action.get("type")) == "goal" for action in actions) + has_plan_action = any(_json_str(action.get("type")) == "plan" for action in actions) has_forget_action = any(_json_str(action.get("type")) == "forget" for action in actions) has_hypothesis_action = any(_json_str(action.get("type")) == "hypothesis" for action in actions) - has_state_update_action = self._has_state_update_action(actions) + has_state_update_action = any(_json_str(action.get("type")) in {"goal", "plan", "known", "hypothesis", "stable_knowledge"} for action in actions) goal_update = self._incomplete_goal_update_from_actions(actions) + completion_message = next( + ( + _json_str(action.get("message_for_complete")) or "" + for action in reversed(actions) + if _json_str(action.get("type")) == "goal" and action.get("complete") is True + ), + "", + ) return ResponseContext( response=response, actions=actions, + assistant_text=assistant_text, goal_was_empty=not self.blackboard.goal, plan_was_empty=not self.blackboard.plan, plan_was_complete=self._plan_is_complete(), verification_was_settled=self._verification_is_settled(), goal_will_change=bool(self.blackboard.goal and goal_update and goal_update != self.blackboard.goal), - chat_message=self._chat_message_from_actions(actions), tool_calls=tool_calls, pending_verify_requested=pending_verify_requested, - progress_messages=progress_messages, user_rule_message=self._user_rule_message_from_actions(actions), - completion_message=self._completion_message_from_actions(actions), + completion_message=completion_message, has_goal_action=has_goal_action, has_plan_action=has_plan_action, has_fresh_plan_action=self._has_fresh_plan_action(actions), @@ -6108,7 +6024,8 @@ def _build_response_context(self, response: Json) -> ResponseContext: state_or_work_requested=bool( tool_calls or pending_verify_requested - or progress_messages + or (assistant_text and actions and not completion_message) + or has_goal_action or has_plan_action or has_forget_action or has_hypothesis_action @@ -6116,26 +6033,31 @@ def _build_response_context(self, response: Json) -> ResponseContext: ), ) - def _handle_chat_response(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: - if ctx.chat_message is None: - return None - if ctx.completion_message: + def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: + if ctx.actions or not ctx.assistant_text: return None if ctx.state_or_work_requested or self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start: return self._reject_result( self._remember_agent_error, on_message, - self._error("chat cannot finish an active task.", self.RULE_FINAL_ACTION), + self._error("assistant text cannot finish an active task.", self.RULE_FINAL_ACTION), "Retrying: active task is not complete.", - "Completion_Gate: chat before task completion.", + "Completion_Gate: assistant text before task completion.", ) self.blackboard.task_code = TaskCode.DONE - self.session.append_conversation(AssistantMessage(content=ctx.chat_message)) + self.session.append_conversation(AssistantMessage(content=ctx.assistant_text)) if on_message is not None: - on_message(ctx.chat_message) + on_message(ctx.assistant_text) return AgentRunResult(done=True, value=ctx.response) def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: + return ( + self._gate_protocol_actions(ctx, on_message) + or self._gate_tool_actions(ctx, on_message) + or self._gate_task_state(ctx, on_message) + ) + + def _gate_protocol_actions(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: action_gate = self._gate_action_types( ctx.actions, allowed=self.PLAN_ACTION_TYPES if self.session.settings.plan_mode else self.ACT_ACTION_TYPES, @@ -6145,22 +6067,11 @@ def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | ) if action_gate is not None: return True - forget_error = self._forget_tool_result_error(ctx.actions) - if forget_error: - return self._reject_agent( - on_message, - self._error("invalid forget: " + forget_error + ".", self.RULE_VISIBLE_RESULTS), - "Retrying: forget only visible tool result keys.", - "ToolResult_Gate: " + forget_error + ".", - ) - forget_hypothesis_error = self._forget_active_hypothesis_error(ctx.actions) - if forget_hypothesis_error: - return self._reject_agent( - on_message, - self._error("forget conflicts with active hypothesis: " + forget_hypothesis_error + ".", self.RULE_CLOSE_SOURCE), - "Retrying: close hypothesis before forgetting its source result.", - "ToolResult_Gate: " + forget_hypothesis_error + ".", - ) + return False + + def _gate_tool_actions(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: + if self._gate_forget_actions(ctx.actions, on_message, self._remember_agent_error) is not None: + return True repeated_tool_retry_error = self._repeated_tool_retry_error(ctx.tool_calls) if repeated_tool_retry_error: return self._reject_agent( @@ -6177,6 +6088,9 @@ def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | "Retrying: plan mode only allows readonly discovery.", "PlanMode_Gate: " + plan_mode_tool_error + ".", ) + return False + + def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: if ( self.blackboard.task_code == TaskCode.NEW and self.task_alignment_required @@ -6188,7 +6102,7 @@ def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | self._remember_agent_error( self._error( "previous task context is still present.", - "emit start for a new task; otherwise update or confirm the current plan.", + "emit goal for a new task; otherwise update or confirm the current plan.", ) ) self._report_gate( @@ -6197,8 +6111,6 @@ def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | "GoalPlan_Gate: work before task alignment with previous task context.", ) return True - if self.blackboard.task_code != TaskCode.NEW and any(_json_str(action.get("type")) == "start" for action in ctx.actions): - self._warn_agent("ignored repeated start after the current task became active.") if self.blackboard.task_code != TaskCode.NEW and ctx.goal_will_change and not ctx.has_fresh_plan_action: self._remember_agent_error( self._error("cannot rewrite Goal after the task is active.", "continue the existing Goal/Plan.") @@ -6223,8 +6135,8 @@ def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | "Retrying: set goal and plan before tools.", "GoalPlan_Gate: Goal is empty before task state/work.", ) - if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.tool_calls or ctx.pending_verify_requested): - self._remember_agent_error(self._error("changed Goal without replacing Plan.", "include start.plan or a full plan action.")) + if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or self._has_non_readonly_tool_call(ctx.tool_calls)): + self._remember_agent_error(self._error("changed Goal without replacing Plan.", "include a full plan action before mutating work.")) self._report_gate( on_message, "Retrying: new goal requires a fresh plan.", @@ -6233,23 +6145,16 @@ def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | return True return False - def _emit_debug_frame_errors(self, response: Json, on_message: MessageCallback | None) -> None: - if not self.session.settings.debug or on_message is None: - return - frame_error_report = self._format_frame_error_report(response) - if frame_error_report: - on_message(frame_error_report) - - def _emit_state_and_progress(self, ctx: ResponseContext, on_message: MessageCallback | None) -> None: + def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback | None) -> None: if on_message is not None and self.state_updater.latest_report: report = self.state_updater.latest_report if self.session.settings.debug else self.state_updater.compact_report() if report: on_message(report) - if on_message is not None: - for message in ctx.progress_messages: - on_message(message) + if on_message is not None and ctx.assistant_text and ctx.actions and not ctx.completion_message: + on_message(ctx.assistant_text) def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: + has_progress_text = bool(ctx.assistant_text and ctx.actions and not ctx.completion_message) if ( ctx.plan_was_empty and not self.blackboard.plan @@ -6285,20 +6190,29 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | ctx.state_or_work_requested and not ctx.tool_calls and not ctx.pending_verify_requested - and not ctx.progress_messages + and not has_progress_text and not ctx.completion_message and not self.state_updater.changed + and not self.blackboard.goal_reached ): - self._warn_agent("response made no effective state change; continue with tool, verify, or goal.") + rule = "do not repeat unchanged state; call readonly discovery if context is missing, set plan if ready, verify, or finish." + if self.blackboard.goal and not self.blackboard.plan: + rule = "Goal is already set; do not repeat it. Call readonly discovery if context is missing, or set plan if ready." + return self._reject_result( + self._remember_agent_error, + on_message, + self._error("response made no effective state change.", rule), + "Retrying: move to the next workflow state.", + "Progress_Gate: no effective state change.", + ) if ( not self.session.settings.plan_mode and ctx.has_state_update_action and self.state_updater.changed - and not ctx.has_goal_action + and not ctx.goal_was_empty and not ctx.tool_calls and not ctx.pending_verify_requested and not ctx.completion_message - and ctx.chat_message is None and ctx.user_rule_message is None ): self._warn_agent("state update-only turn; include frontier tool, verify, or goal when arguments are known.") @@ -6392,24 +6306,9 @@ def _handle_observe_response( ) if gate_result is not None: return gate_result - forget_error = self._forget_tool_result_error(ctx.actions) - if forget_error: - return self._reject_result( - self._remember_observe_error, - on_message, - self._error("invalid forget: " + forget_error + ".", self.RULE_VISIBLE_RESULTS), - "Retrying: forget only visible tool result keys.", - "ToolResult_Gate: " + forget_error + ".", - ) - forget_hypothesis_error = self._forget_active_hypothesis_error(ctx.actions) - if forget_hypothesis_error: - return self._reject_result( - self._remember_observe_error, - on_message, - self._error("forget conflicts with active hypothesis: " + forget_hypothesis_error + ".", self.RULE_CLOSE_SOURCE), - "Retrying: close hypothesis before forgetting its source result.", - "ToolResult_Gate: " + forget_hypothesis_error + ".", - ) + forget_gate = self._gate_forget_actions(ctx.actions, on_message, self._remember_observe_error) + if forget_gate is not None: + return forget_gate if not ctx.actions: return self._reject_result( self._remember_observe_error, @@ -6438,9 +6337,8 @@ def _handle_observe_response( "Observe_Gate: missing coverage for result keys: " + ", ".join(missing_observe_keys) + ".", ) return AgentRunResult() - self._emit_debug_frame_errors(response, on_message) forgotten_keys = self.apply_response(response) - self._emit_state_and_progress(ctx, on_message) + self._emit_state_and_text(ctx, on_message) kept_keys: list[str] = [] if any(_json_str(action.get("type")) in {"keep", "forget", "known", "stable_knowledge"} for action in ctx.actions): self.mode = AgentMode.ACT @@ -6469,6 +6367,32 @@ def _forget_tool_result_error(self, actions: list[Json]) -> str: missing = [key for key in keys if key not in visible_keys] return "not in visible tool results: " + ", ".join(missing) if missing else "" + def _gate_forget_actions( + self, + actions: list[Json], + on_message: MessageCallback | None, + remember_error: Callable[[str], None], + ) -> AgentRunResult | None: + forget_error = self._forget_tool_result_error(actions) + if forget_error: + return self._reject_result( + remember_error, + on_message, + self._error("invalid forget: " + forget_error + ".", self.RULE_VISIBLE_RESULTS), + "Retrying: forget only visible tool result keys.", + "ToolResult_Gate: " + forget_error + ".", + ) + forget_hypothesis_error = self._forget_active_hypothesis_error(actions) + if forget_hypothesis_error: + return self._reject_result( + remember_error, + on_message, + self._error("forget conflicts with active hypothesis: " + forget_hypothesis_error + ".", self.RULE_CLOSE_SOURCE), + "Retrying: close hypothesis before forgetting its source result.", + "ToolResult_Gate: " + forget_hypothesis_error + ".", + ) + return None + def _emit_tool_context_update(self, kept: list[str], forgotten: list[str], on_message: MessageCallback | None) -> None: if on_message is None or not (kept or forgotten): return @@ -6480,6 +6404,31 @@ def _emit_tool_context_update(self, kept: list[str], forgotten: list[str], on_me on_message("Tool Result Context: " + " / ".join(parts)) def _finish_or_continue(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult: + completion_gate = self._gate_completion(ctx, on_message) + if completion_gate is not None: + return completion_gate + if self.blackboard.goal_reached and not ctx.completion_message: + self._warn_agent("filled missing message_for_complete with a fallback completion message.") + completion_message = self._completion_fallback_message(ctx) if self.blackboard.goal_reached else "" + if self.blackboard.goal_reached: + self.session.append_conversation(AssistantMessage(content=completion_message)) + if on_message is not None: + on_message(completion_message) + self._finish_current_goal() + return AgentRunResult(done=True, value=ctx.response) + self.blackboard.goal_reached = False + if not ctx.actions: + self._remember_agent_error( + self._error("no actions while goal is incomplete.", self.RULE_FINAL_ACTION) + ) + self._report_gate( + on_message, + "Continuing: assistant must set current task's goal.", + "GoalPlan_Gate: goal not reached; retrying next useful action.", + ) + return AgentRunResult() + + def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: if self.blackboard.verification.status == VerificationStatus.REQUIRED: if self.blackboard.verification_required: return self._reject_completion( @@ -6525,8 +6474,6 @@ def _finish_or_continue(self, ctx: ResponseContext, on_message: MessageCallback "Retrying: confirm a hypothesis before completing.", "Completion_Gate: " + investigate_completion_error + ".", ) - if self.blackboard.goal_reached and not ctx.completion_message: - self._warn_agent("filled missing message_for_complete with a fallback completion message.") completion_message = self._completion_fallback_message(ctx) if self.blackboard.goal_reached else "" plan_mode_completion_error = self._plan_mode_completion_error(completion_message) if self.blackboard.goal_reached else "" if plan_mode_completion_error: @@ -6536,23 +6483,7 @@ def _finish_or_continue(self, ctx: ResponseContext, on_message: MessageCallback "Retrying: finish plan mode with a proposed_plan block.", "PlanMode_Gate: " + plan_mode_completion_error + ".", ) - if self.blackboard.goal_reached: - self.session.append_conversation(AssistantMessage(content=completion_message)) - if on_message is not None: - on_message(completion_message) - self._finish_current_goal() - return AgentRunResult(done=True, value=ctx.response) - self.blackboard.goal_reached = False - if not ctx.actions: - self._remember_agent_error( - self._error("no actions while goal is incomplete.", self.RULE_FINAL_ACTION) - ) - self._report_gate( - on_message, - "Continuing: assistant must set current task's goal.", - "GoalPlan_Gate: goal not reached; retrying next useful action.", - ) - return AgentRunResult() + return None def run( self, @@ -6597,7 +6528,7 @@ def run( self.compactor.maybe_compact() self.session.append_conversation(UserMessage(content=user_input)) - if self._can_stream_action_frames(): + if self._can_stream_tools(): return self.run_stream_loop( max_steps=self.session.settings.max_agent_steps, on_message=on_message, @@ -6646,13 +6577,12 @@ def handle_response( if self._gate_before_apply(ctx, on_message): return AgentRunResult() - chat_result = self._handle_chat_response(ctx, on_message) - if chat_result is not None: - return chat_result + text_result = self._handle_text_response(ctx, on_message) + if text_result is not None: + return text_result - self._emit_debug_frame_errors(response, on_message) forgotten_keys = self.apply_response(response) - self._emit_state_and_progress(ctx, on_message) + self._emit_state_and_text(ctx, on_message) self._emit_tool_context_update([], forgotten_keys, on_message) if ctx.has_user_rule_action and not ctx.tool_calls and not ctx.pending_verify_requested: message = ctx.user_rule_message or "Rule saved." @@ -8004,7 +7934,7 @@ def _print_tool_call_display( [("ansibrightblack", " Why "), ("ansimagenta", call.intention + "\n")], " Why " + call.intention, ) - if tool.effect() == ToolEffect.EDIT: + if tool.EFFECT == ToolEffect.EDIT: preview = tool.preview() if preview: self._emit_segments(self._preview_segments(preview), " Preview\n" + preview) diff --git a/pyproject.toml b/pyproject.toml index 2cffb49..828786a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,7 +27,6 @@ classifiers = [ "Topic :: Terminals", ] dependencies = [ - "json-repair>=0.39", "openai>=2.37.0", "prompt-toolkit>=3.0", "socksio>=1.0.0", diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 640c603..3dbe541 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -64,7 +64,7 @@ def _session( ) -def _chat_response(content: str = '{"type":"message","text":"ok"}', usage: dict | None = None) -> dict: +def _chat_response(content: str = "ok", usage: dict | None = None) -> dict: return {"choices": [{"message": {"content": content}}], "usage": usage or {}} @@ -72,7 +72,7 @@ def _stream_chunk(delta: dict | None = None, usage: dict | None = None, choices: return {"choices": [{"delta": delta or {}}] if choices else [], "usage": usage} -def _responses_response(content: str = '{"type":"message","text":"ok"}', usage: dict | None = None) -> dict: +def _responses_response(content: str = "ok", usage: dict | None = None) -> dict: return {"output": [{"type": "message", "content": [{"type": "output_text", "text": content}]}], "usage": usage or {}} @@ -367,7 +367,7 @@ def test_agent_act_context_keeps_pending_raw_after_latest_rotates(tmp_path): assert "output:\n" not in index -def test_observe_progress_does_not_checkpoint_tool_results(tmp_path): +def test_observe_text_does_not_checkpoint_tool_results(tmp_path): (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) @@ -377,7 +377,7 @@ def test_observe_progress_does_not_checkpoint_tool_results(tmp_path): agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0", "1"]}]) agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0", "1"]}]) - agent.handle_response({"actions": [{"type": "progress", "text": "checking result"}]}) + agent.handle_response({"actions": [], "_assistant_text": "checking result"}) assert agent.blackboard.memory_checkpoint_tool_result_counter == 0 assert agent.mode == nanocode.AgentMode.OBSERVE @@ -386,12 +386,12 @@ def test_observe_progress_does_not_checkpoint_tool_results(tmp_path): assert "two.txt" in unreduced -def test_progress_does_not_mark_memory_checkpoint(tmp_path): +def test_assistant_text_does_not_mark_memory_checkpoint(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) - agent.apply_response({"actions": [{"type": "progress", "text": "reading sample"}]}) + agent.apply_response({"actions": [], "_assistant_text": "reading sample"}) assert agent.blackboard.memory_checkpoint_tool_result_counter == 0 @@ -722,13 +722,13 @@ def test_keep_action_is_observe_only(tmp_path): assert any("Invalid action(s): keep" in error for error in agent.agent_feedback_errors) -def test_observe_rejects_progress_and_empty_actions(tmp_path): +def test_observe_rejects_invalid_action_and_empty_actions(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) agent.mode = nanocode.AgentMode.OBSERVE - agent.handle_response({"actions": [{"type": "progress", "text": "checking"}]}) + agent.handle_response({"actions": [{"type": "goal", "text": "answer", "complete": False}]}) agent.handle_response({"actions": []}) assert any("latest results must be observed" in error for error in agent.observe_feedback_errors) @@ -900,14 +900,14 @@ def test_agent_prunes_tool_result_store_but_keeps_referenced_result_keys(tmp_pat assert "tr.52" in session.state.tool_result_store -def test_agent_request_calls_chat_completions_and_parses_json(tmp_path, monkeypatch): +def test_agent_request_calls_chat_completions_and_returns_text(tmp_path, monkeypatch): calls, _response_calls, client_kwargs = _patch_openai(monkeypatch, _chat_response(usage={"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5})) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", timeout=12, stream=False) response = Agent(session).request("system", "user") payload = _sdk_payload(calls[0]) - assert response == {"actions": [{"type": "message", "text": "ok"}]} + assert response == {"actions": [], "_assistant_text": "ok"} assert client_kwargs[0]["base_url"] == "https://example.test/v1" assert client_kwargs[0]["api_key"] == "key" assert client_kwargs[0]["timeout"] == 12 @@ -958,7 +958,7 @@ def test_agent_request_sends_temperature_only_when_configured(tmp_path, monkeypa def test_agent_request_uses_responses_api_and_sdk_output_text(tmp_path, monkeypatch): class FakeResponse: - output_text = '{"type":"message","text":"ok"}' + output_text = "ok" def model_dump(self, mode="json"): return {"output": [], "usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}} @@ -977,7 +977,7 @@ def model_dump(self, mode="json"): response = Agent(session).request("system", "user") payload = _sdk_payload(response_calls[0]) - assert response == {"actions": [{"type": "message", "text": "ok"}]} + assert response == {"actions": [], "_assistant_text": "ok"} assert calls == [] assert payload["model"] == "model" assert payload["instructions"] == "system" @@ -1180,151 +1180,182 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert sleeps == [] -def test_agent_request_streams_and_reports_completed_actions(tmp_path, monkeypatch): - stream = [ - _stream_chunk({"content": '{"type":"tool","name":"Read",'}), - _stream_chunk({"content": '"intention":"read sample","args":["sample.txt"]}__END_ACTION__'}), - _stream_chunk({"content": '{"type":"message","text":"done"}__END_ACTION__'}), - _stream_chunk(usage={"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, choices=False), - ] - calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, stream) - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") +def test_agent_request_sends_function_tool_schema_and_parses_tool_call(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai( + monkeypatch, + { + "choices": [ + { + "message": { + "content": "Reading the file.", + "tool_calls": [ + { + "function": { + "name": "Read", + "arguments": '{"intention":"read sample","args":["sample.txt","0","1"]}', + } + } + ], + } + } + ], + "usage": {"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, + }, + ) + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) - response = Agent(session).request("system", "user") + response = Agent(session).request("system", "user", tool_schemas=[nanocode.ReadTool.tool_schema()]) payload = _sdk_payload(calls[0]) - assert payload["stream"] is True - assert payload["stream_options"] == {"include_usage": True} - assert response["actions"] == [ - {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt"]}, - {"type": "message", "text": "done"}, - ] - assert session.state.last_prompt_tokens == 2 - assert session.state.last_completion_tokens == 3 + assert payload["tools"][0]["function"]["name"] == "Read" + assert payload["tool_choice"] == "auto" + assert payload["parallel_tool_calls"] is True + assert response == { + "actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}], + "_assistant_text": "Reading the file.", + } assert session.state.last_total_tokens == 5 - assert session.state.session_total_tokens == 5 -def test_agent_request_stream_uses_first_token_timeout_until_content(tmp_path, monkeypatch): - timers = [] - _patch_openai( +def test_function_tool_schemas_define_items_for_every_array(): + def walk(value, path="schema"): + if isinstance(value, dict): + schema_type = value.get("type") + if schema_type == "array" or (isinstance(schema_type, list) and "array" in schema_type): + assert "items" in value, path + for key, child in value.items(): + walk(child, path + "." + str(key)) + elif isinstance(value, list): + for index, child in enumerate(value): + walk(child, path + "[" + str(index) + "]") + + state_schemas = [nanocode._state_tool_schema(name) for name in nanocode.STATE_TOOL_PARAMS] + repo_schemas = [tool.tool_schema() for tool in nanocode.TOOL_REGISTRY.values()] + for schema in [*state_schemas, *repo_schemas, nanocode.COMPACT_TOOL_SCHEMA]: + walk(schema) + + +def test_agent_request_responses_api_parses_function_call(tmp_path, monkeypatch): + _calls, response_calls, _client_kwargs = _patch_openai( monkeypatch, - [ - _stream_chunk({"role": "assistant"}), - _stream_chunk({"content": '{"type":"message","text":"ok"}__END_ACTION__'}), - ], + { + "output": [ + { + "type": "function_call", + "name": "known", + "arguments": '{"items":["Project uses pytest."]}', + } + ], + "usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}, + }, ) - monkeypatch.setattr(nanocode.signal, "setitimer", lambda timer, seconds: timers.append(seconds)) - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", timeout=90, first_token_timeout=4) + session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses", stream=False) - response = Agent(session).request("system", "user") + response = Agent(session).request("system", "user", tool_schemas=[nanocode._state_tool_schema("known")]) + payload = _sdk_payload(response_calls[0]) - assert response["actions"][0]["text"] == "ok" - assert timers[0] == 90 - assert 4 in timers - assert timers[-1] == 0 + assert payload["tools"][0]["name"] == "known" + assert payload["tool_choice"] == "auto" + assert response == {"actions": [{"type": "known", "items": ["Project uses pytest."]}]} + assert session.state.last_total_tokens == 5 -def test_agent_request_stream_reasoning_chunks_count_as_first_output(tmp_path, monkeypatch): - timers = [] - _patch_openai( - monkeypatch, - [ - _stream_chunk({"reasoning_content": "thinking"}), - _stream_chunk({"reasoning_details": [{"type": "reasoning.text", "text": "more"}]}), - _stream_chunk({"content": '{"type":"message","text":"ok"}__END_ACTION__'}), - ], - ) - monkeypatch.setattr(nanocode.signal, "setitimer", lambda timer, seconds: timers.append(seconds)) - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", timeout=90, first_token_timeout=4) +def test_agent_request_chat_stream_parses_function_tool_event(tmp_path, monkeypatch): + calls = [] - response = Agent(session).request("system", "user") + class FakeStream: + def __enter__(self): + return self - assert response["actions"][0]["text"] == "ok" - assert timers[0] == 90 - assert 4 in timers - assert timers[-1] == 0 + def __exit__(self, *_args): + return False + def __iter__(self): + return iter( + [ + {"type": "content.delta", "delta": "Reading."}, + { + "type": "tool_calls.function.arguments.done", + "name": "Read", + "arguments": '{"intention":"read sample","args":["sample.txt","0","1"]}', + }, + ] + ) -def test_agent_request_responses_stream_reasoning_counts_as_first_output(tmp_path, monkeypatch): - timers = [] - stream = [ - _responses_reasoning_delta("thinking"), - _responses_text_delta('{"type":"message","text":"ok"}__END_ACTION__'), - _responses_completed({"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}), - ] - calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, stream) - monkeypatch.setattr(nanocode.signal, "setitimer", lambda timer, seconds: timers.append(seconds)) - session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses", timeout=90, first_token_timeout=4) + def get_final_completion(self): + return {"usage": {"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, "choices": [{"message": {}}]} - response = Agent(session).request("system", "user") - payload = _sdk_payload(response_calls[0]) + class FakeStreamCompletions: + def stream(self, **kwargs): + calls.append(kwargs) + return FakeStream() - assert response["actions"][0]["text"] == "ok" - assert calls == [] - assert payload["stream"] is True - assert payload["reasoning"] == {"effort": "medium"} - assert timers[0] == 90 - assert 4 in timers - assert timers[-1] == 0 - assert session.state.last_prompt_tokens == 2 - assert session.state.last_completion_tokens == 3 + class FakeOpenAI: + def __init__(self, **_kwargs): + self.beta = type("FakeBeta", (), {"chat": type("FakeChat", (), {"completions": FakeStreamCompletions()})()})() + + monkeypatch.setattr(nanocode, "OpenAI", FakeOpenAI) + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") + + response = Agent(session).request("system", "user", tool_schemas=[nanocode.ReadTool.tool_schema()]) + + assert calls[0]["tools"][0]["function"]["name"] == "Read" + assert response == { + "actions": [ + { + "type": "tool", + "name": "Read", + "intention": "read sample", + "args": ["sample.txt", "0", "1"], + } + ], + "_assistant_text": "Reading.", + } assert session.state.last_total_tokens == 5 -def test_agent_request_responses_stream_uses_completed_output_when_no_delta(tmp_path, monkeypatch): - stream = [ - _responses_completed({"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}) - | {"response": _responses_response(usage={"input_tokens": 2, "output_tokens": 3, "total_tokens": 5})}, - ] - calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, stream) - session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses") +def test_agent_request_responses_stream_parses_function_tool_event(tmp_path, monkeypatch): + response_calls = [] - response = Agent(session).request("system", "user") + class FakeStream: + def __enter__(self): + return self - assert response["actions"][0]["text"] == "ok" - assert calls == [] - assert response_calls[0]["stream"] is True - assert session.state.last_prompt_tokens == 2 - assert session.state.last_completion_tokens == 3 - assert session.state.last_total_tokens == 5 + def __exit__(self, *_args): + return False + def __iter__(self): + return iter( + [ + {"type": "response.output_text.delta", "delta": "Recording."}, + { + "type": "response.function_call_arguments.done", + "name": "known", + "arguments": '{"items":["Project uses pytest."]}', + }, + ] + ) -def test_agent_request_responses_stream_uses_output_text_done_when_no_delta(tmp_path, monkeypatch): - timers = [] - stream = [ - {"type": "response.output_text.done", "text": '{"type":"message","text":"ok"}__END_ACTION__'}, - _responses_completed({"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}), - ] - calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, stream) - monkeypatch.setattr(nanocode.signal, "setitimer", lambda timer, seconds: timers.append(seconds)) - session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses", timeout=90, first_token_timeout=4) + def get_final_response(self): + return {"usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}, "output": []} - response = Agent(session).request("system", "user") + class FakeResponses: + def stream(self, **kwargs): + response_calls.append(kwargs) + return FakeStream() - assert response["actions"][0]["text"] == "ok" - assert calls == [] - assert response_calls[0]["stream"] is True - assert 4 in timers - assert timers[-2] > 80 - - -def test_agent_request_responses_stream_does_not_count_done_after_delta_twice(tmp_path, monkeypatch): - chars_seen = [] - delta = '{"type":"message","text":"ok"}__END_ACTION__' - stream = [ - _responses_text_delta(delta), - {"type": "response.output_text.done", "text": delta}, - _responses_completed(), - ] - _patch_openai(monkeypatch, stream) - monkeypatch.setattr(nanocode.ModelClient, "_estimate_stream_rate", lambda self, elapsed: chars_seen.append(self.session.state.current_model_call_streaming_chars) or 0) + class FakeOpenAI: + def __init__(self, **_kwargs): + self.responses = FakeResponses() + + monkeypatch.setattr(nanocode, "OpenAI", FakeOpenAI) session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses") - response = Agent(session).request("system", "user") + response = Agent(session).request("system", "user", tool_schemas=[nanocode._state_tool_schema("known")]) - assert response["actions"][0]["text"] == "ok" - assert chars_seen == [len(delta)] + assert response_calls[0]["tools"][0]["name"] == "known" + assert response == {"actions": [{"type": "known", "items": ["Project uses pytest."]}], "_assistant_text": "Recording."} + assert session.state.last_total_tokens == 5 def test_agent_request_responses_stream_error_event_raises_llm_error(tmp_path, monkeypatch): @@ -1344,7 +1375,7 @@ def test_agent_request_records_stream_rate_from_usage(tmp_path, monkeypatch): _patch_openai( monkeypatch, [ - _stream_chunk({"content": '{"type":"message","text":"ok"}'}), + _stream_chunk({"content": "ok"}), _stream_chunk(usage={"completion_tokens": 20, "total_tokens": 30}, choices=False), ], ) @@ -1353,7 +1384,7 @@ def test_agent_request_records_stream_rate_from_usage(tmp_path, monkeypatch): response = Agent(session).request("system", "user") - assert response["actions"][0]["text"] == "ok" + assert response == {"actions": [], "_assistant_text": "ok"} assert session.state.last_model_call_rate == 10.0 @@ -1381,88 +1412,6 @@ def stream(): assert sleeps == [3, 10, 20, 30, 60, 120] -def test_agent_run_reports_streamed_tool_actions_after_execution(tmp_path, monkeypatch): - (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") - (tmp_path / "other.txt").write_text("beta\n", encoding="utf-8") - responses = [ - [ - '{"type":"tool","name":"Read",', - '"intention":"read sample","args":["sample.txt","0","1"]}__END_ACTION__', - '{"type":"tool","name":"Read",', - '"intention":"read other","args":["other.txt","0","1"]}__END_ACTION__', - ], - [ - '{"type":"keep","source":["tr.1","tr.2"],"reason":"sample and other reads remain useful"}__END_ACTION__', - ], - [ - '{"type":"verify","method":"unit","status":"passed","context":"checked"}__END_ACTION__', - '{"type":"goal","text":"read sample","complete":true,"message_for_complete":"done"}__END_ACTION__', - ], - ] - calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, tuple([_stream_chunk({"content": chunk}) for chunk in chunks] for chunks in responses)) - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") - agent = Agent(session) - agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 1 - _seed_plan(agent, "read sample") - messages = [] - - response = agent.run("read sample", on_message=messages.append) - captured_payloads = [_sdk_payload(call) for call in calls] - - assert response["actions"][-1] == {"type": "goal", "text": "read sample", "complete": True, "message_for_complete": "done"} - assert len(captured_payloads) == 3 - assert [payload["stream"] for payload in captured_payloads] == [True, True, True] - assert messages[0].startswith("[success] Read sample.txt 0:1 -> tr.1") - assert "why:" not in messages[0] - assert messages[-1] == "done" - - -def test_agent_run_executes_action_frame_before_stream_finishes(tmp_path, monkeypatch): - (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") - agent = Agent(session) - _seed_plan(agent, "read sample") - - def stream(): - yield _stream_chunk({"content": '{"type":"tool","name":"Read","intention":"read sample","args":["sample.txt","0","1"]}__END_ACTION__'}) - assert session.state.tool_result_counter == 1 - yield _stream_chunk({"content": '{"type":"verify","method":"unit","status":"passed","context":"checked"}__END_ACTION__'}) - yield _stream_chunk({"content": '{"type":"goal","text":"read sample","complete":true,"message_for_complete":"done"}__END_ACTION__'}) - - _patch_openai(monkeypatch, stream) - messages = [] - - response = agent.run("read sample", on_message=messages.append) - - assert response["actions"][0]["message_for_complete"] == "done" - assert messages[0].startswith("[success] Read sample.txt 0:1 -> tr.1") - assert session.state.tool_result_counter == 1 - - -def test_agent_run_stops_stream_after_tool_failure(tmp_path, monkeypatch): - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") - agent = Agent(session) - _seed_plan(agent, "read sample") - - def stream(): - yield _stream_chunk({"content": '{"type":"tool","name":"Read","intention":"read missing","args":["missing.txt","0","1"]}__END_ACTION__'}) - raise AssertionError("stream should stop after failed tool") - - _patch_openai( - monkeypatch, - ( - stream(), - [_stream_chunk({"content": '{"type":"goal","text":"read sample","complete":true,"message_for_complete":"done"}__END_ACTION__'})], - ), - ) - - response = agent.run("read sample") - - assert response["actions"][0]["message_for_complete"] == "done" - assert session.state.tool_result_counter == 1 - assert session.state.tool_result_store["tr.1"].description.startswith("failure Read") - - def test_agent_request_uses_configured_chat_reasoning_payload(tmp_path, monkeypatch): calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) session = _session( @@ -1685,134 +1634,6 @@ def test_agent_request_empty_chat_reasoning_payload_disables_auto_detection(tmp_ assert "thinking" not in payload -def test_agent_request_accepts_json_fenced_model_content(tmp_path, monkeypatch): - _patch_openai(monkeypatch, _chat_response('```json\n{"type":"message","text":"ok"}\n__END_ACTION__\n```')) - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) - - response = Agent(session).request("system", "user") - - assert response == {"actions": [{"type": "message", "text": "ok"}]} - - -def test_agent_request_accepts_leaked_think_tags_before_json(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - assert client._parse_model_content('{"type":"message","text":"ok"}\n__END_ACTION__') == { - "actions": [{"type": "message", "text": "ok"}], - } - assert client._parse_model_content('reasoning\n{"type":"message","text":"ok"}\n__END_ACTION__') == { - "actions": [{"type": "message", "text": "ok"}], - } - - -def test_agent_request_accepts_pretty_action_frames_and_marker_variants(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - '{\n "type": "message",\n "text": "ok"\n}\n**END_ACTION**\n{"type":"goal","text":"next"}\nEND_ACTION' - ) - - assert response == {"actions": [{"type": "message", "text": "ok"}, {"type": "goal", "text": "next"}]} - - -def test_agent_request_accepts_inline_action_frame_markers(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('{"type":"message","text":"ok"}__END_ACTION__{"type":"goal","text":"next"}__END_ACTION__') - - assert response == {"actions": [{"type": "message", "text": "ok"}, {"type": "goal", "text": "next"}]} - - -def test_agent_request_accepts_single_unmarked_json_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('{"type":"message","text":"ok"}') - - assert response == {"actions": [{"type": "message", "text": "ok"}]} - - -def test_agent_request_accepts_adjacent_unmarked_json_actions(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - '{"type":"known","items":["Project is single-file."]}\n' - '{"type":"stable_knowledge","items":[{"category":"structure","text":"All runtime code lives in nanocode.py."}]}' - ) - - assert response == { - "actions": [ - {"type": "known", "items": ["Project is single-file."]}, - { - "type": "stable_knowledge", - "items": [{"category": "structure", "text": "All runtime code lives in nanocode.py."}], - }, - ], - } - - -def test_agent_request_accepts_unmarked_json_action_array(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('[{"type":"tool","name":"Read","args":["nanocode.py","0,1"],"intention":"read source"}]') - - assert response == {"actions": [{"type": "tool", "name": "Read", "args": ["nanocode.py", "0,1"], "intention": "read source"}]} - - -def test_agent_request_repairs_fenced_json_action_array_with_extra_brace(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - '```json\n[{"type":"tool","name":"ListDir","intention":"Find the demo directory in the project root.","args":[""]}]}\n```' - ) - - assert response == { - "actions": [ - {"type": "tool", "name": "ListDir", "intention": "Find the demo directory in the project root.", "args": [""]} - ] - } - - -def test_agent_request_accepts_empty_actions_response_object(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - assert client._parse_model_content('{"actions": []}') == {"actions": []} - assert client._parse_model_content('{"actions": []}__END_ACTION__') == {"actions": []} - - -def test_agent_request_accepts_comma_separated_unmarked_json_actions(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - '{"type":"tool","name":"Read","args":["nanocode.py","3893,3910"]},' - '{"type":"tool","name":"Search","args":["STABLE_KNOWLEDGE_CATEGORIES","path=nanocode.py","context=2"]}' - ) - - assert response == { - "actions": [ - {"type": "tool", "name": "Read", "args": ["nanocode.py", "3893,3910"]}, - {"type": "tool", "name": "Search", "args": ["STABLE_KNOWLEDGE_CATEGORIES", "path=nanocode.py", "context=2"]}, - ] - } - - -def test_agent_request_normalizes_tool_name_as_action_type(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - '{"type":"ListDir","intention":"list root","args":["."]}\n' - '{"type":"search","intention":"find tests","args":["pytest","path=.", "context=2"]}\n' - '{"type":"recall","intention":"recall result","args":["tr.1"]}' - ) - - assert response == { - "actions": [ - {"type": "tool", "name": "ListDir", "intention": "list root", "args": ["."]}, - {"type": "tool", "name": "Search", "intention": "find tests", "args": ["pytest", "path=.", "context=2"]}, - {"type": "tool", "name": "Recall", "intention": "recall result", "args": ["tr.1"]}, - ] - } - - def test_agent_normalizes_harmless_action_type_aliases(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) @@ -1820,197 +1641,17 @@ def test_agent_normalizes_harmless_action_type_aliases(tmp_path): { "actions": [ {"type": "Plan", "items": []}, - {"type": "Message", "content": "ok"}, + {"type": "Known", "items": []}, ] } ) assert actions == [ {"type": "plan", "items": []}, - {"type": "chat", "content": "ok", "text": "ok"}, + {"type": "known", "items": []}, ] -def test_agent_request_converts_prefixed_unmarked_text_to_progress_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - "The test is failing because the expected message changed. Let me read the test.\n\n" - '{"type":"tool","name":"Read","intention":"read the failing test","args":["tests/test_nanocode_commands.py","140,165"]}' - ) - - assert response == { - "actions": [ - {"type": "progress", "text": "The test is failing because the expected message changed. Let me read the test."}, - {"type": "tool", "name": "Read", "intention": "read the failing test", "args": ["tests/test_nanocode_commands.py", "140,165"]}, - ], - } - - -def test_agent_request_converts_plain_unmarked_text_to_progress_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content("Let me read the StatusBar class and the streaming content logic.") - - assert response == { - "actions": [ - {"type": "progress", "text": "Let me read the StatusBar class and the streaming content logic."}, - ] - } - - response = client._parse_model_content("让我读取 `_format_line` 的当前状态，以找到确切插入点。") - - assert response == { - "actions": [ - {"type": "progress", "text": "让我读取 `_format_line` 的当前状态，以找到确切插入点。"}, - ] - } - - -def test_agent_request_rejects_cli_context_transcript_as_plain_progress(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content("}") - - assert response["actions"] == [] - assert "expected one JSON action object or action frames ending with __END_ACTION__" in response["_format_error"] - - response = client._parse_model_content("Now }") - - assert response["actions"] == [] - assert "expected one JSON action object or action frames ending with __END_ACTION__" in response["_format_error"] - - response = client._parse_model_content(" ctx: -tr.61 -tr.62") - - assert response["actions"] == [] - assert "expected one JSON action object or action frames ending with __END_ACTION__" in response["_format_error"] - - -def test_agent_request_converts_interleaved_unmarked_text_to_progress_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - '{"type":"plan","items":[{"id":"p1","text":"Inspect","status":"doing"}]}\n\n' - "Now I will read the file.\n\n" - '{"type":"tool","name":"Read","intention":"read source","args":["demo/astar_demo.cpp"]}' - ) - - assert response == { - "actions": [ - {"type": "plan", "items": [{"id": "p1", "text": "Inspect", "status": "doing"}]}, - {"type": "progress", "text": "Now I will read the file."}, - {"type": "tool", "name": "Read", "intention": "read source", "args": ["demo/astar_demo.cpp"]}, - ], - } - - -def test_agent_request_ignores_fence_only_interleaved_progress(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - '{"type":"plan","items":[{"id":"p1","text":"Inspect","status":"doing"}]}\n```json\n' - '{"type":"tool","name":"Read","intention":"read source","args":["demo/astar_demo.cpp"]}' - ) - - assert response == { - "actions": [ - {"type": "plan", "items": [{"id": "p1", "text": "Inspect", "status": "doing"}]}, - {"type": "tool", "name": "Read", "intention": "read source", "args": ["demo/astar_demo.cpp"]}, - ], - } - - -def test_agent_request_strips_leaked_tool_code_after_valid_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content( - "我正在分析这些更改。让我仔细检查速率计算部分是否存在潜在的 bug。\n\n" - "```json\n" - '{"type":"Read","args":["nanocode.py","3500,3510"],"intention":"检查速率计算时 elapsed 是否可能为0"}\n' - "```\n" - "\n" - "{\n" - " tool: 'Read',\n" - " args: [\"nanocode.py\", \"3500,3510\"],\n" - " intention: '检查速率计算时 elapsed 是否可能为0'\n" - "}\n" - "" - ) - - assert response == { - "actions": [ - {"type": "progress", "text": "我正在分析这些更改。让我仔细检查速率计算部分是否存在潜在的 bug。"}, - {"type": "tool", "name": "Read", "args": ["nanocode.py", "3500,3510"], "intention": "检查速率计算时 elapsed 是否可能为0"}, - ] - } - - -def test_agent_request_converts_trailing_unmarked_text_to_progress_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('{"type":"message","text":"ok"}\nDone.') - - assert response == { - "actions": [ - {"type": "message", "text": "ok"}, - {"type": "progress", "text": "Done."}, - ] - } - - -def test_agent_request_converts_trailing_unmarked_text_after_action_array_to_progress_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('[{"type":"progress","text":"checking"}]\nNow I will read the file.') - - assert response == { - "actions": [ - {"type": "progress", "text": "checking"}, - {"type": "progress", "text": "Now I will read the file."}, - ] - } - - -def test_agent_request_repairs_unescaped_newlines_in_unmarked_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('{"type":"chat","text":"line 1\n\n1. item\n2. item"}') - - assert response == { - "actions": [ - {"type": "chat", "text": "line 1\n\n1. item\n2. item"}, - ] - } - - -def test_agent_request_repairs_extra_closing_brace_after_unmarked_action(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('{"type":"progress","text":"ok"}}') - - assert response == {"actions": [{"type": "progress", "text": "ok"}]} - - -def test_agent_request_ignores_bad_action_frames_when_other_actions_are_valid(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('plain answer\n__END_ACTION__\n{"type":"message","text":"ok"}\n__END_ACTION__') - - assert response["actions"] == [{"type": "message", "text": "ok"}] - assert response["_format_frame_errors"] == ["frame 1: expected JSON object action"] - - -def test_agent_request_rejects_native_tool_call_syntax(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('Read("nanocode.py", 0, 100)') - - assert response["actions"] == [] - assert "Native tool_call syntax is not supported" in response["_format_error"] - assert '"name":"Read"' in response["_format_error"] - assert '"args":["nanocode.py","0,100"]' in response["_format_error"] - - def test_agent_request_wraps_non_json_model_content_as_format_error(tmp_path, monkeypatch): _patch_openai(monkeypatch, _chat_response("plain answer")) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) @@ -2018,17 +1659,7 @@ def test_agent_request_wraps_non_json_model_content_as_format_error(tmp_path, mo response = Agent(session).request("system", "user") assert response["actions"] == [] - assert "expected one JSON action object or action frames ending with __END_ACTION__" in response["_format_error"] - assert "plain answer" in response["_format_error"] - - -def test_agent_request_rejects_invalid_unmarked_json_action_array(tmp_path): - client = Agent(Session(cwd=str(tmp_path))).model_client - - response = client._parse_model_content('[{"text":"ok"}]') - - assert response["actions"] == [] - assert "action missing type" in response["_format_error"] + assert response["_assistant_text"] == "plain answer" def test_agent_request_wraps_missing_message_content_as_format_error(tmp_path, monkeypatch): @@ -2049,7 +1680,7 @@ def test_agent_request_wraps_missing_message_content_as_format_error(tmp_path, m response = Agent(session).request("system", "user") assert response["actions"] == [] - assert "expected one JSON object" in response["_format_error"] + assert "expected a function tool call" in response["_format_error"] assert "API response missing message content" in response["_format_error"] @@ -2257,10 +1888,10 @@ def test_main_agent_state_updates_are_compact_without_debug(tmp_path): agent.apply_response( { "actions": [ + {"type": "goal", "text": "inspect project", "complete": False}, { - "type": "start", - "goal": "inspect project", - "plan": [ + "type": "plan", + "items": [ {"id": "p1", "text": "List files", "status": "done"}, {"id": "p2", "text": "Read config", "status": "done"}, {"id": "p3", "text": "Update code", "status": "doing"}, @@ -2427,17 +2058,17 @@ def test_agent_applies_partial_plan_patch(tmp_path): ] -def test_agent_applies_start_action_to_goal_and_plan(tmp_path): +def test_agent_applies_goal_and_plan_actions(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) agent.apply_response( { "actions": [ + {"type": "goal", "text": "change map", "complete": False}, { - "type": "start", - "goal": "change map", - "plan": [ + "type": "plan", + "items": [ {"id": "p1", "text": "Find map code", "status": "doing", "context": "need location"}, {"id": "p2", "text": "Edit map size", "status": "todo"}, ], @@ -2455,7 +2086,21 @@ def test_agent_applies_start_action_to_goal_and_plan(tmp_path): assert " Plan\n" in agent.state_updater.latest_report -def test_start_new_goal_clears_task_local_kept_results_only(tmp_path): +def test_agent_accepts_goal_without_plan_for_new_task(tmp_path): + agent = Agent(_session(tmp_path, debug=True)) + agent.blackboard.task_code = nanocode.TaskCode.NEW + messages = [] + + result = agent.handle_response({"actions": [{"type": "goal", "text": "change map", "work_mode": "normal", "complete": False}]}, on_message=messages.append) + + assert result.done is False + assert agent.blackboard.goal == "change map" + assert agent.blackboard.task_code == nanocode.TaskCode.WORKING + assert agent.blackboard.plan == [] + assert messages == ["State Updated | VERIFY:idle\n Goal change map"] + + +def test_new_goal_clears_task_local_kept_results_only(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.blackboard.goal = "old goal" agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] @@ -2465,11 +2110,11 @@ def test_start_new_goal_clears_task_local_kept_results_only(tmp_path): agent.apply_response( { "actions": [ + {"type": "goal", "text": "new goal", "complete": False}, { - "type": "start", - "goal": "new goal", - "plan": [{"id": "p1", "text": "Inspect new target", "status": "doing"}], - } + "type": "plan", + "items": [{"id": "p1", "text": "Inspect new target", "status": "doing"}], + }, ] } ) @@ -2480,7 +2125,7 @@ def test_start_new_goal_clears_task_local_kept_results_only(tmp_path): assert "recent.py" in _blocks_text(agent.tool_context.recent) -def test_start_same_goal_keeps_task_local_tool_results(tmp_path): +def test_same_goal_keeps_task_local_tool_results(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.blackboard.goal = "same goal" agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] @@ -2489,11 +2134,11 @@ def test_start_same_goal_keeps_task_local_tool_results(tmp_path): agent.apply_response( { "actions": [ + {"type": "goal", "text": "same goal", "complete": False}, { - "type": "start", - "goal": "same goal", - "plan": [{"id": "p1", "text": "Continue current target", "status": "doing"}], - } + "type": "plan", + "items": [{"id": "p1", "text": "Continue current target", "status": "doing"}], + }, ] } ) @@ -2511,11 +2156,11 @@ def test_agent_state_report_does_not_repeat_goal_for_restarted_task_when_text_ma agent.apply_response( { "actions": [ + {"type": "goal", "text": "change map", "complete": False}, { - "type": "start", - "goal": "change map", - "plan": [{"id": "p1", "text": "Find map code", "status": "doing"}], - } + "type": "plan", + "items": [{"id": "p1", "text": "Find map code", "status": "doing"}], + }, ] } ) @@ -2747,8 +2392,8 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): latest = agent.execute_tool_calls([{"name": "ReplaceRange", "intention": "bad edit", "args": ["sample.txt", "0", "1", "abc", "", ""]}]) - assert "ToolCallError: requires exactly 7 args" in latest - assert "got 6 args, expected 7, missing: content" in agent.agent_feedback_errors[0] + assert "ToolCallError: requires args: filepath, ranges where each range is [start,end,fingerprint,before_context,after_context,content]" in latest + assert "got 6 args, expected 2, extra: 4" in agent.agent_feedback_errors[0] assert "use ReplaceRange for read ranges" in agent.agent_feedback_errors[0] @@ -2947,15 +2592,15 @@ def test_agent_plan_mode_rejects_mutating_tool_before_execution(tmp_path): assert messages == ['PlanMode_Gate: plan mode allows readonly discovery only; blocked tool=Edit args=["sample.txt","old","new"].'] -def test_agent_plan_mode_rejects_chat_instead_of_completing(tmp_path): +def test_agent_plan_mode_rejects_invalid_action_instead_of_completing(tmp_path): agent = Agent(_session(tmp_path, plan_mode=True, debug=True)) messages = [] - result = agent.handle_response({"actions": [{"type": "chat", "text": "done"}]}, on_message=messages.append) + result = agent.handle_response({"actions": [{"type": "invalid", "text": "done"}]}, on_message=messages.append) assert result.done is False assert agent.session.state.conversation == [] - assert messages == ["ActionType_Gate: invalid action type(s): chat."] + assert messages == ["Protocol_Gate: invalid action type(s): invalid."] def test_agent_plan_mode_stores_proposed_plan_completion(tmp_path): @@ -3090,7 +2735,7 @@ def __init__(self): self.user_prompts = [] self.responses = [ {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, - {"_format_error": "Invalid model output: plain answer", "actions": []}, + {"_format_error": "Invalid function-tool response: plain answer", "actions": []}, {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, {"actions": _final_actions("read sample")}, ] @@ -3151,7 +2796,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert len(session.state.tool_result_store) == 51 assert list(session.state.tool_result_store)[0] == "tr.1" - agent.model_client.responses = [{"actions": [{"type": "chat", "text": "ok"}]}] + agent.model_client.responses = [{"actions": [], "_assistant_text": "ok"}] agent.run("next task") assert len(session.state.tool_result_store) == 50 @@ -3235,7 +2880,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert [item.text for item in agent.blackboard.plan] == ["Read sample"] -def test_agent_run_requires_fresh_plan_when_goal_changes(tmp_path): +def test_agent_run_allows_readonly_discovery_when_goal_changes_before_plan(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") class FakeModelClient: @@ -3255,10 +2900,10 @@ def __init__(self): }, { "actions": [ + {"type": "goal", "text": "new goal", "complete": False}, { - "type": "start", - "goal": "new goal", - "plan": [{"id": "p1", "text": "Read sample", "status": "doing"}], + "type": "plan", + "items": [{"id": "p1", "text": "Read sample", "status": "doing"}], }, {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}, ] @@ -3288,7 +2933,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert "Retrying: new goal requires a fresh plan." not in messages assert agent.blackboard.goal == "new goal" assert [item.text for item in agent.blackboard.plan] == ["Read sample"] - assert len(session.state.tool_result_store) == 1 + assert len(session.state.tool_result_store) == 3 def test_agent_run_requires_task_alignment_before_work_with_old_context(tmp_path): @@ -3300,10 +2945,10 @@ def __init__(self): {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, { "actions": [ + {"type": "goal", "text": "run lint", "complete": False}, { - "type": "start", - "goal": "run lint", - "plan": [{"id": "p1", "text": "Read sample", "status": "doing"}], + "type": "plan", + "items": [{"id": "p1", "text": "Read sample", "status": "doing"}], }, {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}, ] @@ -3332,10 +2977,9 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.blackboard.goal == "run lint" assert [item.text for item in agent.blackboard.plan] == ["Read sample"] assert "previous task context is still present" in " ".join(agent.agent_feedback_errors) - assert not any("repeated start is invalid" in error for error in agent.agent_feedback_errors) -def test_agent_run_rejects_repeated_start_after_task_is_working(tmp_path): +def test_agent_run_rejects_goal_rewrite_after_task_is_working(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") class FakeModelClient: @@ -3344,27 +2988,19 @@ def __init__(self): self.responses = [ { "actions": [ + {"type": "goal", "text": "read sample", "complete": False}, { - "type": "start", - "goal": "read sample", - "plan": [{"id": "p1", "text": "Read sample", "status": "doing"}], - } + "type": "plan", + "items": [{"id": "p1", "text": "Read sample", "status": "doing"}], + }, ] }, + {"actions": [{"type": "goal", "text": "read sample again", "complete": False}]}, + {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, + {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, { "actions": [ - { - "type": "start", - "goal": "read sample again", - "plan": [{"id": "p1", "text": "Read sample again", "status": "doing"}], - } - ] - }, - {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, - {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, - { - "actions": [ - {"type": "plan", "items": [{"id": "p1", "text": "Read sample", "status": "done", "context": "read sample.txt"}]}, + {"type": "plan", "items": [{"id": "p1", "text": "Read sample", "status": "done", "context": "read sample.txt"}]}, *_final_actions("read sample"), ] }, @@ -3383,7 +3019,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.blackboard.goal == "read sample" assert [item.text for item in agent.blackboard.plan] == ["Read sample"] assert len(agent.tool_runner.latest_executions) == 1 - assert "ignored repeated start" in " ".join(agent.agent_feedback_errors) + assert "cannot rewrite Goal" in " ".join(agent.agent_feedback_errors) def test_agent_allows_plan_with_multiple_doing_items(tmp_path): @@ -3394,10 +3030,10 @@ def test_agent_allows_plan_with_multiple_doing_items(tmp_path): result = agent.handle_response( { "actions": [ + {"type": "goal", "text": "answer", "complete": False}, { - "type": "start", - "goal": "answer", - "plan": [ + "type": "plan", + "items": [ {"id": "p1", "text": "first", "status": "doing"}, {"id": "p2", "text": "second", "status": "doing"}, ], @@ -3453,14 +3089,14 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert not any(message.startswith("State Updated") for message in messages) -def test_agent_run_stops_after_chat_action(tmp_path): +def test_agent_run_stops_after_assistant_text(tmp_path): class FakeModelClient: def __init__(self): self.user_prompts = [] def request(self, system_prompt, user_prompt, *, activity="agent"): self.user_prompts.append(user_prompt) - return {"actions": [{"type": "chat", "text": "你好"}]} + return {"actions": [], "_assistant_text": "你好"} session = Session(cwd=str(tmp_path)) agent = Agent(session) @@ -3470,7 +3106,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): response = agent.run("你好", on_message=messages.append) - assert response["actions"] == [{"type": "chat", "text": "你好"}] + assert response == {"actions": [], "_assistant_text": "你好"} assert messages == ["你好"] assert len(agent.model_client.user_prompts) == 1 assert agent.blackboard.task_code == nanocode.TaskCode.DONE @@ -3499,6 +3135,28 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert "Continuing: goal is not complete yet." not in messages +def test_agent_run_rejects_no_effective_state_change(tmp_path): + class FakeModelClient: + def __init__(self): + self.responses = [ + {"actions": [{"type": "goal", "text": "answer", "complete": False}]}, + {"actions": _final_actions()}, + ] + + def request(self, system_prompt, user_prompt, *, activity="agent"): + return self.responses.pop(0) + + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + _seed_plan(agent, "answer") + agent.model_client = FakeModelClient() + + response = agent.run("answer") + + assert response["actions"][-1]["message_for_complete"] == "done" + assert any("response made no effective state change" in error for error in agent.agent_feedback_errors) + + def test_main_agent_accepts_memory_actions_during_act_turn(tmp_path): class FakeModelClient: def __init__(self): @@ -3822,10 +3480,10 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.blackboard.goal_reached is False -def test_agent_run_allows_chat_without_task_context(tmp_path): +def test_agent_run_allows_assistant_text_without_task_context(tmp_path): class FakeModelClient: def request(self, system_prompt, user_prompt, *, activity="agent"): - return {"actions": [{"type": "chat", "text": "hello"}]} + return {"actions": [], "_assistant_text": "hello"} session = Session(cwd=str(tmp_path)) agent = Agent(session) @@ -3834,17 +3492,17 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): response = agent.run("hi", on_message=messages.append) - assert response["actions"] == [{"type": "chat", "text": "hello"}] + assert response == {"actions": [], "_assistant_text": "hello"} assert messages == ["hello"] assert session.state.conversation[-1].content == "hello" -def test_agent_run_retries_chat_with_unfinished_task_context(tmp_path): +def test_agent_run_retries_assistant_text_with_unfinished_task_context(tmp_path): class FakeModelClient: def __init__(self): self.user_prompts = [] self.responses = [ - {"actions": [{"type": "chat", "text": "done too early"}]}, + {"actions": [], "_assistant_text": "done too early"}, { "actions": [ {"type": "plan", "mode": "patch", "items": [{"id": "p1", "status": "done", "context": "answered"}]}, @@ -3871,7 +3529,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert messages[-1] == "done" assert len(agent.model_client.user_prompts) == 2 assert "done too early" not in [item.content for item in session.state.conversation] - assert any("chat cannot finish an active task" in error for error in agent.agent_feedback_errors) + assert any("assistant text cannot finish an active task" in error for error in agent.agent_feedback_errors) def test_agent_run_retries_goal_complete_with_unfinished_plan(tmp_path): @@ -3950,7 +3608,7 @@ def test_investigate_completion_requires_root_cause_hypothesis(tmp_path): assert messages[-1] == "done" -def test_start_declares_investigate_work_mode(tmp_path): +def test_goal_declares_investigate_work_mode(tmp_path): class FakeModelClient: def __init__(self): self.user_prompts = [] @@ -3960,10 +3618,14 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): return { "actions": [ { - "type": "start", - "goal": "find bug", + "type": "goal", + "text": "find bug", "work_mode": "investigate", - "plan": [{"id": "p1", "text": "identify root cause", "status": "done", "context": "reasoned"}], + "complete": False, + }, + { + "type": "plan", + "items": [{"id": "p1", "text": "identify root cause", "status": "done", "context": "reasoned"}], }, {"type": "hypothesis", "items": [{"id": "h1", "text": "bad filter", "status": "confirmed", "source": ["tr.1"]}]}, _verify_passed_action(), @@ -4025,8 +3687,8 @@ class FakeModelClient: def __init__(self): self.user_prompts = [] self.responses = [ - {"_format_error": "Invalid model output: plain answer", "actions": []}, - {"_format_error": "Invalid model output: plain answer", "actions": []}, + {"_format_error": "Invalid function-tool response: plain answer", "actions": []}, + {"_format_error": "Invalid function-tool response: plain answer", "actions": []}, {"actions": _final_actions()}, ] @@ -4043,7 +3705,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert response["actions"][-1]["message_for_complete"] == "done" assert len(agent.model_client.user_prompts) == 3 - assert "Retrying: model returned invalid output: plain answer" not in messages + assert "Retrying: invalid function/tool response: plain answer" not in messages assert messages[-1] == "done" @@ -4052,7 +3714,7 @@ class FakeModelClient: def __init__(self): self.user_prompts = [] self.responses = [ - {"_format_error": "Invalid model output: plain answer", "actions": []}, + {"_format_error": "Invalid function-tool response: plain answer", "actions": []}, {"actions": [{"type": "goal", "text": "answer", "complete": False}]}, {"actions": _final_actions()}, ] @@ -4073,7 +3735,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): class ChatModelClient: def request(self, system_prompt, user_prompt, *, activity="agent"): - return {"actions": [{"type": "chat", "text": "ok"}]} + return {"actions": [], "_assistant_text": "ok"} agent.model_client = ChatModelClient() agent.run("next task") @@ -4087,7 +3749,20 @@ class FakeModelClient: def __init__(self): self.user_prompts = [] self.responses = [ - {"actions": [{"type": "progress", "text": "progress"}]}, + { + "actions": [ + { + "type": "verify", + "kind": "light", + "method": "check", + "criteria": ["progress can be emitted before completion"], + "status": "passed", + "blocker": None, + "context": "progress context", + } + ], + "_assistant_text": "progress", + }, {"actions": _final_actions()}, ] @@ -4104,7 +3779,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): response = agent.run("answer", on_message=messages.append) assert response["actions"][-1]["message_for_complete"] == "done" - assert messages[0] == "progress" + assert "progress" in messages assert messages[-1] == "done" assert "progress" not in [item.content for item in session.state.conversation] assert agent.agent_feedback_errors == [] @@ -4119,9 +3794,9 @@ def __init__(self): self.responses = [ { "actions": [ - {"type": "progress", "text": "reading sample"}, {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt"]}, - ] + ], + "_assistant_text": "reading sample", }, {"actions": [{"type": "forget", "source": ["tr.1"], "reason": "progress-only read result is not needed"}]}, {"actions": _final_actions()}, @@ -4147,7 +3822,7 @@ def test_agent_feedback_survives_keyboard_interrupt_until_next_run(tmp_path): class FakeModelClient: def __init__(self): self.responses = [ - {"_format_error": "Invalid model output: plain answer", "actions": []}, + {"_format_error": "Invalid function-tool response: plain answer", "actions": []}, KeyboardInterrupt(), ] @@ -4184,7 +3859,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): class ChatModelClient: def request(self, system_prompt, user_prompt, *, activity="agent"): - return {"actions": [{"type": "chat", "text": "ok"}]} + return {"actions": [], "_assistant_text": "ok"} agent.model_client = ChatModelClient() agent.run("next task") @@ -4215,45 +3890,11 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert len(agent.model_client.user_prompts) == 2 -def test_agent_run_only_shows_ignored_action_frame_errors_in_debug(tmp_path): - class FakeModelClient: - def __init__(self): - self.responses = [ - { - "actions": _final_actions(), - "_format_frame_errors": ["frame 1: expected JSON object action"], - } - ] - - def request(self, system_prompt, user_prompt, *, activity="agent"): - return self.responses.pop(0) - - session = Session(cwd=str(tmp_path)) - agent = Agent(session) - agent.model_client = FakeModelClient() - messages = [] - - agent.run("answer", on_message=messages.append) - - assert "Format_Warning:" not in "\n".join(messages) - assert messages[-1] == "done" - - debug_session = _session(tmp_path, debug=True) - debug_agent = Agent(debug_session) - debug_agent.model_client = FakeModelClient() - debug_messages = [] - - debug_agent.run("answer", on_message=debug_messages.append) - - assert debug_messages[0] == "Format_Warning: ignored invalid action frame(s).\n- frame 1: expected JSON object action" - assert debug_messages[-1] == "done" - - def test_agent_run_shows_debug_gate_details_when_debug_enabled(tmp_path): class FakeModelClient: def __init__(self): self.responses = [ - {"_format_error": "Invalid model output: plain answer", "_format_bad_output": "plain answer", "actions": []}, + {"_format_error": "Invalid function-tool response: plain answer", "_format_bad_output": "plain answer", "actions": []}, {"actions": _final_actions()}, ] @@ -4267,7 +3908,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): agent.run("answer", on_message=messages.append) - assert messages[0] == "Format_Gate: retrying model response. Invalid model output: plain answer\nFull bad output:\nplain answer" + assert messages[0] == "Format_Gate: retrying function/tool response. Invalid function-tool response: plain answer\nFull bad output:\nplain answer" def test_agent_run_stops_after_repeated_format_errors(tmp_path): @@ -4277,7 +3918,7 @@ def __init__(self): def request(self, system_prompt, user_prompt, *, activity="agent"): self.calls += 1 - return {"_format_error": "Invalid model output: missing content", "actions": []} + return {"_format_error": "Invalid function-tool response: missing content", "actions": []} session = Session(cwd=str(tmp_path)) agent = Agent(session) @@ -4292,8 +3933,8 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): raise AssertionError("expected LLMError") assert agent.model_client.calls == Agent.MAX_CONSECUTIVE_FORMAT_ERRORS - assert "model returned invalid output 3 times in a row" in message - assert messages[-1] == "Stopped: model returned invalid output 3 times in a row." + assert "invalid function/tool response 3 times in a row" in message + assert messages[-1] == "Stopped: invalid function/tool response 3 times in a row." def test_agent_run_no_retry_when_goal_complete_has_message_for_complete(tmp_path): @@ -4347,21 +3988,21 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.agent_feedback_errors -def test_agent_run_uses_message_for_complete_even_when_progress_actions_exist(tmp_path): +def test_agent_run_uses_message_for_complete_even_when_assistant_text_exists(tmp_path): class FakeModelClient: def __init__(self): self.user_prompts = [] self.responses = [ { "actions": [ - {"type": "progress", "text": "explicit progress"}, { "type": "goal", "text": "answer", "complete": True, "message_for_complete": "fallback message", }, - ] + ], + "_assistant_text": "explicit progress", }, {"actions": _final_actions()}, ] @@ -4377,8 +4018,8 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): response = agent.run("answer", on_message=messages.append) - assert response["actions"][1]["message_for_complete"] == "fallback message" - assert "explicit progress" in messages + assert response["actions"][0]["message_for_complete"] == "fallback message" + assert "explicit progress" not in messages assert messages[-1] == "fallback message" assert len(agent.model_client.user_prompts) == 1 assert "explicit progress" not in [item.content for item in session.state.conversation] @@ -4391,7 +4032,6 @@ def __init__(self): self.user_prompts = [] self.responses = [ {"actions": [{"type": "goal", "text": "answer", "complete": False, "message_for_complete": "should be ignored"}]}, - {"actions": [{"type": "progress", "text": "done without goal"}]}, {"actions": _final_actions()}, ] @@ -4407,6 +4047,6 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): response = agent.run("answer", on_message=messages.append) assert response["actions"][-1]["message_for_complete"] == "done" - assert len(agent.model_client.user_prompts) == 3 + assert len(agent.model_client.user_prompts) == 2 assert "should be ignored" not in messages - assert agent.agent_feedback_errors == [] + assert not agent.agent_feedback_errors diff --git a/tests/test_nanocode_context_tool.py b/tests/test_nanocode_context_tool.py index 251e7a6..6a17dfd 100644 --- a/tests/test_nanocode_context_tool.py +++ b/tests/test_nanocode_context_tool.py @@ -17,7 +17,7 @@ def test_tool_result_tool_gets_multiple_keys(tmp_path): ) } - assert ToolResultTool.name() == "Recall" + assert ToolResultTool.NAME == "Recall" result = ToolResultTool.make(session, ["tr.1", "missing"]).call() assert result.startswith("RecallToolResult:") diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 80d818b..c031c44 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -353,12 +353,11 @@ def __init__(self): self.session = make_session(tmp_path, model="model", yolo=True) class FakeTool: + EFFECT = nanocode.ToolEffect.EDIT + def preview(self): return "preview" - def effect(self): - return nanocode.ToolEffect.EDIT - outputs = [] loop = AgentLoop(FakeAgent(), output_fn=outputs.append) call = ParsedToolCall(name="Edit", intention="edit sample", args=["sample.txt", "old", "new"]) @@ -518,7 +517,7 @@ def run(self, user_input, *, confirm=None, on_auto_approve=None, on_message=None self.runs.append(user_input) if on_message is not None: on_message("assistant response") - return {"actions": [{"type": "chat", "text": "assistant response"}]} + return {"actions": [], "_assistant_text": "assistant response"} inputs = iter(["/status", "hello", "/exit"]) outputs = [] diff --git a/tests/test_nanocode_replace_range_tool.py b/tests/test_nanocode_replace_range_tool.py index eca8359..a991581 100644 --- a/tests/test_nanocode_replace_range_tool.py +++ b/tests/test_nanocode_replace_range_tool.py @@ -21,7 +21,7 @@ def test_replace_range_tool_replaces_range_when_fingerprint_matches(tmp_path): display = tool.preview() result = tool.call() - assert ReplaceRangeTool.name() == "ReplaceRange" + assert ReplaceRangeTool.NAME == "ReplaceRange" assert tool.requires_confirmation(session) is True assert display.startswith("--- ") assert "-beta\n" in display @@ -324,7 +324,7 @@ def test_replace_range_cache_survives_cancel_until_next_run(tmp_path): class FakeModelClient: def request(self, system_prompt, user_prompt, *, activity="agent"): - return {"actions": [{"type": "chat", "text": "done"}]} + return {"actions": [], "_assistant_text": "done"} agent.model_client = FakeModelClient() agent.run("next task") @@ -335,7 +335,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): def test_replace_range_cache_clears_when_new_main_run_starts(tmp_path): class FakeModelClient: def request(self, system_prompt, user_prompt, *, activity="agent"): - return {"actions": [{"type": "chat", "text": "done"}]} + return {"actions": [], "_assistant_text": "done"} path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") From 7fbb3d14ab59d7d040f8d86c0d0b97c319da80ef Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 19:50:36 -0700 Subject: [PATCH 011/144] fix openai tool loops and session cleanup Consolidate debug tracing, accept string plan and hypothesis tool items, keep stream requests valid, and make /clean remove inactive sessions. --- README.md | 2 +- nanocode.py | 631 ++++++++++++++++++++------------ tests/test_nanocode_agent.py | 147 +++----- tests/test_nanocode_commands.py | 141 +++---- tests/test_nanocode_loop.py | 2 +- 5 files changed, 507 insertions(+), 416 deletions(-) diff --git a/README.md b/README.md index b991281..3bf5b2b 100644 --- a/README.md +++ b/README.md @@ -103,7 +103,7 @@ Run `nanocode --init-config` to create `~/.nanocode/config.toml`. - Path config: `[paths] data_dir = "~/.nanocode"`. - Runtime config: `[runtime]`. - Session data: debug prompts and tool-result logs are stored under `~/.nanocode/sessions//`. -- Tool-result logs from inactive sessions are auto-cleaned after `runtime.auto_clean_recent` (default `3d`; use `off` to disable). `/clean` removes inactive session logs immediately. +- Old inactive session directories are auto-cleaned after `runtime.auto_clean_recent` (default `1d`; use `off` to disable). `/clean` removes inactive sessions immediately. - Project data: user rules are stored under `~/.nanocode/projects//`. ## Status diff --git a/nanocode.py b/nanocode.py index 7e3a913..8d14e4d 100644 --- a/nanocode.py +++ b/nanocode.py @@ -251,6 +251,9 @@ def format(self, indent: str = "") -> str: @classmethod def from_json(cls, value: JsonValue) -> "Hypothesis | None": + if isinstance(value, str): + text = value.strip() + return cls(text=text) if text else None item = _json_dict(value) text = _json_str(item.get("text")) or "" if not text: @@ -564,7 +567,7 @@ class RuntimeSettings: max_agent_steps: int = 100 plan_timeout: int = 360 plan_first_token_timeout: int = 180 - auto_clean_recent: str = "3d" + auto_clean_recent: str = "1d" yolo: bool = False plan_mode: bool = False debug: bool = False @@ -578,7 +581,7 @@ def from_dict(cls, data: Json, *, yolo: bool = False, plan_mode: bool = False, d max_agent_steps=max(1, Config.int(runtime, "max_agent_steps", 100) or 0), plan_timeout=max(1, Config.int(runtime, "plan_timeout", 360) or 0), plan_first_token_timeout=max(1, Config.int(runtime, "plan_first_token_timeout", 180) or 0), - auto_clean_recent=cls.clean_retention(Config.str(runtime, "auto_clean_recent", "3d")), + auto_clean_recent=cls.clean_retention(Config.str(runtime, "auto_clean_recent", "1d")), yolo=yolo or bool(Config.bool(runtime, "yolo", False)), plan_mode=plan_mode or bool(Config.bool(runtime, "plan_mode", False)), debug=debug, @@ -728,8 +731,8 @@ class ConfigFile: max_agent_steps = 100 plan_timeout = 360 plan_first_token_timeout = 180 -# Automatically delete tool-result logs older than this from inactive sessions. Use "off" to disable. -auto_clean_recent = "3d" +# Automatically delete inactive session directories older than this. Use "off" to disable. +auto_clean_recent = "1d" yolo = false plan_mode = false """ @@ -933,6 +936,7 @@ class RuntimeState: turn_tool_calls: int = 0 session_tool_calls: int = 0 turn_model_calls: int = 0 + debug_log_count: int = 0 @dataclass @@ -1027,6 +1031,188 @@ def missing_required_config(self) -> list[str]: return [key for key, value in (("provider.url", provider.url), ("provider.key", provider.key), ("provider.model", provider.model)) if not value] +class DebugTrace: + STRING_LIMIT: ClassVar[int] = 20_000 + + @classmethod + def value(cls, value: Any) -> JsonValue: + if isinstance(value, dict): + return {str(key): cls.value(item) for key, item in value.items()} + if isinstance(value, list | tuple): + return [cls.value(item) for item in value] + if isinstance(value, str): + return value if len(value) <= cls.STRING_LIMIT else value[: cls.STRING_LIMIT] + "..." + if value is None or isinstance(value, str | int | float | bool): + return value + return str(value) + + @classmethod + def write(cls, session: Session, *, activity: str, label: str, payload: JsonValue) -> str: + if not session.settings.debug: + return "" + session.state.debug_log_count += 1 + directory = session.debug_dir() + os.makedirs(directory, exist_ok=True) + timestamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f") + safe_activity = re.sub(r"[^A-Za-z0-9_.-]+", "-", activity or "debug") + safe_label = re.sub(r"[^A-Za-z0-9_.-]+", "-", label or "event") + filepath = os.path.join(directory, f"{timestamp}-{session.state.debug_log_count:04d}-{safe_activity}-{safe_label}.json") + with open(filepath, "w", encoding="utf-8") as f: + json.dump(cls.value(payload), f, ensure_ascii=False, indent=2) + f.write("\n") + return filepath + + @staticmethod + def response_summary(response: Json) -> Json: + actions = [_json_dict(action) for action in _json_list(response.get("actions"))] + return { + "actions_len": len(actions), + "action_types": [_json_str(action.get("type")) or "(missing)" for action in actions], + "tool_names": [_json_str(action.get("name")) or "" for action in actions if _json_str(action.get("type")) == "tool"], + "assistant_text_len": len(_json_str(response.get("_assistant_text")) or ""), + "format_error": _json_str(response.get("_format_error")) or "", + } + + @staticmethod + def tool_names(tool_schemas: list[Json] | None) -> list[str]: + names = [] + for schema in tool_schemas or []: + function = _json_dict(schema.get("function")) or schema + names.append(_json_str(function.get("name")) or "(unknown)") + return names + + @classmethod + def model_request( + cls, + session: Session, + *, + activity: str, + api: str, + model: str, + stream: bool, + params: Json, + tool_schemas: list[Json] | None, + ) -> None: + cls.write( + session, + activity=activity, + label="model-request", + payload={ + "api": api, + "model": model, + "stream": stream, + "tool_names": cls.tool_names(tool_schemas), + "param_keys": sorted(params), + "params": {key: value for key, value in params.items() if key not in {"messages", "instructions", "input", "tools"}}, + }, + ) + + @classmethod + def prompt(cls, session: Session, *, activity: str, messages: list[Json]) -> str: + if not session.settings.debug: + return "" + session.state.debug_prompt_count += 1 + directory = session.debug_dir() + os.makedirs(directory, exist_ok=True) + timestamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f") + filepath = os.path.join(directory, f"{timestamp}-{session.state.debug_prompt_count:04d}-{activity or 'request'}.txt") + with open(filepath, "w", encoding="utf-8") as f: + f.write(cls.format_prompt(messages)) + return filepath + + @staticmethod + def format_prompt(messages: list[Json]) -> str: + lines = [] + for index, message in enumerate(messages, start=1): + role = _json_str(message.get("role")) or "(unknown)" + content = message.get("content") + lines.append(f"--- {role} message {index} ---") + lines.append(content if isinstance(content, str) else json.dumps(content, ensure_ascii=False, indent=2)) + lines.append("") + return "\n".join(lines).rstrip() + "\n" + + @classmethod + def model_response(cls, session: Session, *, activity: str, api: str, stream: bool, raw: JsonValue, parsed: Json) -> None: + cls.write( + session, + activity=activity, + label="model-response", + payload={"api": api, "stream": stream, "parsed": cls.response_summary(parsed), "raw": raw}, + ) + + @classmethod + def stream_action(cls, session: Session, *, activity: str, action: Json) -> None: + cls.write( + session, + activity=activity, + label="stream-action", + payload={"action": cls.response_summary({"actions": [action]})}, + ) + + @classmethod + def loop_event( + cls, + agent: Any, + label: str, + *, + index: int, + response: Json, + result: Any | None = None, + committed: bool | None = None, + ) -> None: + payload: Json = cls._agent_payload(agent) + payload.update({"step": index, "response": cls.response_summary(response)}) + if result is not None: + payload["result"] = {"done": result.done, "value_type": type(result.value).__name__} + if committed is not None: + payload["committed"] = committed + cls.write(agent.session, activity="agent", label=label, payload=payload) + + @classmethod + def handle_event( + cls, + agent: Any, + label: str, + ctx: Any, + response: Json, + *, + result: Any | None = None, + extra: Json | None = None, + ) -> None: + payload = cls._agent_payload(agent) + payload.update( + { + "goal_reached": agent.blackboard.goal_reached, + "ctx": { + "actions": len(ctx.actions), + "tool_calls": len(ctx.tool_calls), + "assistant_text_len": len(ctx.assistant_text), + "completion_message": bool(ctx.completion_message), + "has_goal_action": ctx.has_goal_action, + "has_plan_action": ctx.has_plan_action, + "has_state_update_action": ctx.has_state_update_action, + "state_or_work_requested": ctx.state_or_work_requested, + }, + "response": cls.response_summary(response), + } + ) + if result is not None: + payload["result"] = {"done": result.done, "value_type": type(result.value).__name__} + if extra: + payload.update(extra) + cls.write(agent.session, activity="agent", label=label, payload=payload) + + @staticmethod + def _agent_payload(agent: Any) -> Json: + return { + "mode": agent.mode, + "task_code": agent.blackboard.task_code, + "goal": agent.blackboard.goal, + "plan_items": len(agent.blackboard.plan), + "feedback_tail": agent.agent_feedback_errors[-3:], + } + + ############################ # Tools ############################ @@ -1436,6 +1622,12 @@ def release(self) -> None: fcntl.flock(self.file.fileno(), fcntl.LOCK_UN) self.file.close() self.file = None + try: + os.remove(self.path) + except FileNotFoundError: + pass + except OSError: + pass def __enter__(self) -> Self: self.acquire() @@ -1467,7 +1659,7 @@ class CleanResult: skipped: int = 0 -class SessionLogCleaner: +class SessionCleaner: def __init__(self, session: Session): self.session = session @@ -1477,27 +1669,23 @@ def clean(self, *, older_than_seconds: int = 0) -> CleanResult: if not os.path.isdir(sessions_dir): return result cutoff = time.time() - older_than_seconds if older_than_seconds > 0 else 0.0 - for session_name in os.listdir(sessions_dir): + for session_name in sorted(os.listdir(sessions_dir)): session_dir = os.path.join(sessions_dir, session_name) if not os.path.isdir(session_dir): continue - if SessionLock.is_locked(os.path.join(session_dir, "session.lock")): + if cutoff and os.path.getmtime(session_dir) >= cutoff: + continue + if session_name == self.session.session_id: result.skipped += 1 continue - tool_results_dir = os.path.join(session_dir, "tool_results") - if not os.path.isdir(tool_results_dir): + if SessionLock.is_locked(os.path.join(session_dir, "session.lock")): + result.skipped += 1 continue - for name in os.listdir(tool_results_dir): - path = os.path.join(tool_results_dir, name) - if not name.endswith(".log") or not os.path.isfile(path): - continue - if cutoff and os.path.getmtime(path) >= cutoff: - continue - try: - os.remove(path) - result.cleaned += 1 - except OSError: - result.failed += 1 + try: + shutil.rmtree(session_dir) + result.cleaned += 1 + except OSError: + result.failed += 1 return result @@ -2898,6 +3086,32 @@ def _content(self, item: ToolResultItem) -> str: TOOL_NULLABLE_STRING_SCHEMA: Json = {"type": ["string", "null"]} TOOL_ITEMS_SCHEMA: Json = {"type": "array", "items": TOOL_JSON_VALUE_SCHEMA} TOOL_STRING_LIST_SCHEMA: Json = {"type": "array", "items": {"type": "string"}} +TOOL_PLAN_ITEMS_SCHEMA: Json = { + "type": "array", + "items": _tool_object_schema( + { + "op": {"type": ["string", "null"], "enum": ["add", "update", "remove", None]}, + "id": TOOL_NULLABLE_STRING_SCHEMA, + "text": TOOL_NULLABLE_STRING_SCHEMA, + "status": {"type": ["string", "null"], "enum": [*ALL_PLAN_STATUSES, None]}, + "context": TOOL_NULLABLE_STRING_SCHEMA, + }, + [], + ), +} +TOOL_HYPOTHESIS_ITEMS_SCHEMA: Json = { + "type": "array", + "items": _tool_object_schema( + { + "id": TOOL_NULLABLE_STRING_SCHEMA, + "text": TOOL_NULLABLE_STRING_SCHEMA, + "status": {"type": ["string", "null"], "enum": [*ALL_HYPOTHESIS_STATUSES, None]}, + "source": TOOL_STRING_LIST_SCHEMA, + "context": TOOL_NULLABLE_STRING_SCHEMA, + }, + [], + ), +} STATE_TOOL_PARAMS: dict[str, tuple[str, Json, list[str]]] = { @@ -2911,8 +3125,8 @@ def _content(self, item: ToolResultItem) -> str: }, ["text", "complete", "message_for_complete"], ), - "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_ITEMS_SCHEMA}, ["items"]), - "hypothesis": ("Update investigation hypotheses.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), + "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), + "hypothesis": ("Update investigation hypotheses.", {"items": TOOL_HYPOTHESIS_ITEMS_SCHEMA}, ["items"]), "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "stable_knowledge": ("Record rare reusable codebase facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "user_rule": ( @@ -3538,7 +3752,8 @@ def request( if api == "responses" else self._chat_completion_params(config, model=model, messages=messages, stream=stream, tool_schemas=tool_schemas, required_tool=required_tool) ) - self._write_debug_prompt(activity=activity, messages=messages) + DebugTrace.prompt(self.session, activity=activity, messages=messages) + DebugTrace.model_request(self.session, activity=activity, api=api, model=model, stream=stream, params=params, tool_schemas=tool_schemas) client = self._client(config, timeout=timeout) request_elapsed = 0.0 try: @@ -3562,6 +3777,7 @@ def request( timeout=timeout, request_deadline=request_deadline, first_token_timeout=first_token_timeout, + activity=activity, on_stream_action=on_stream_action, ) result = {"usage": usage, **response} @@ -3573,6 +3789,7 @@ def request( timeout=timeout, request_deadline=request_deadline, first_token_timeout=first_token_timeout, + activity=activity, on_stream_action=on_stream_action, ) result = {"usage": usage, **response} @@ -3640,12 +3857,18 @@ def request( self._record_usage(_json_dict(result.get("usage") if isinstance(result, dict) else None), config, elapsed=request_elapsed) if tool_schemas and isinstance(result.get("actions"), list): - return self._action_response(_json_list(result.get("actions")), _json_str(result.get("_assistant_text")) or "") + parsed = self._action_response(_json_list(result.get("actions")), _json_str(result.get("_assistant_text")) or "") + DebugTrace.model_response(self.session, activity=activity, api=api, stream=stream, raw=result, parsed=parsed) + return parsed if not stream: content = self._responses_content(result) if api == "responses" else self._message_content(result) if content is None: - return self._invalid_model_response(self._format_missing_message_content(result)) - return {"actions": [], "_assistant_text": content} + parsed = self._invalid_model_response(self._format_missing_message_content(result)) + DebugTrace.model_response(self.session, activity=activity, api=api, stream=stream, raw=result, parsed=parsed) + return parsed + parsed = {"actions": [], "_assistant_text": content} + DebugTrace.model_response(self.session, activity=activity, api=api, stream=stream, raw=result, parsed=parsed) + return parsed def _client(self, config: ProviderConfig, *, timeout: int) -> OpenAI: return OpenAI( @@ -3715,6 +3938,7 @@ def _read_chat_tool_stream( timeout: int, request_deadline: float, first_token_timeout: int | None, + activity: str, on_stream_action: Callable[[Json], bool] | None = None, ) -> tuple[Json, Json]: usage: Json = {} @@ -3723,57 +3947,76 @@ def _read_chat_tool_stream( first_output_seen = False stream_params = dict(params) - stream_params.pop("stream", None) self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) stopped = False - with client.beta.chat.completions.stream(**stream_params, timeout=timeout) as stream: - for event in stream: - data = self._sdk_json(event) - event_type = _json_str(data.get("type")) or str(getattr(event, "type", "") or "") - if event_type == "content.delta": - text = str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "") - first_output_seen = self._mark_stream_output( - len(text), - first_output_seen, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, - ) - if text: - text_parts.append(text) - continue - if event_type == "tool_calls.function.arguments.delta": + tool_calls: dict[int, Json] = {} + for event in client.chat.completions.create(**stream_params, timeout=timeout): + data = self._sdk_json(event) + event_usage = _json_dict(data.get("usage")) + if event_usage: + usage = event_usage + for choice in _json_list(data.get("choices")): + delta = _json_dict(_json_dict(choice).get("delta")) + content = delta.get("content") + output_chars = self._stream_output_chars(delta) + if output_chars > 0: first_output_seen = self._mark_stream_output( - len(str(getattr(event, "arguments_delta", "") or _json_str(data.get("arguments_delta")) or "")), + output_chars, first_output_seen, request_deadline=request_deadline, first_token_timeout=first_token_timeout, ) - continue - if event_type != "tool_calls.function.arguments.done": - continue - action = self._action_from_function_call( - str(getattr(event, "name", "") or _json_str(data.get("name")) or ""), - str(getattr(event, "arguments", "") or _json_str(data.get("arguments")) or "{}"), - ) - if text_parts and on_stream_action is not None: - action["_assistant_text"] = "".join(text_parts).strip() - text_parts.clear() - actions.append(action) - stopped, request_deadline = self._call_stream_action( - on_stream_action, - action, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, - ) - if stopped: - break - if not stopped: - final = self._sdk_json(stream.get_final_completion()) - usage = _json_dict(final.get("usage")) - if not actions: - return self._chat_tool_response(final), usage + if isinstance(content, str) and content: + text_parts.append(content) + self._accumulate_chat_tool_calls(tool_calls, delta) + for index in sorted(tool_calls): + item = tool_calls[index] + action = self._action_from_function_call(_json_str(item.get("name")) or "", _json_str(item.get("arguments")) or "{}") + DebugTrace.stream_action(self.session, activity=activity, action=action) + if text_parts and on_stream_action is not None: + action["_assistant_text"] = "".join(text_parts).strip() + text_parts.clear() + actions.append(action) + stopped, request_deadline = self._call_stream_action( + on_stream_action, + action, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + if stopped: + break return self._action_response(actions, "".join(text_parts)), usage + def _accumulate_chat_tool_calls(self, tool_calls: dict[int, Json], delta: Json) -> None: + for raw in _json_list(delta.get("tool_calls")): + call = _json_dict(raw) + index = self._stream_list_index(call.get("index"), len(tool_calls)) + function = _json_dict(call.get("function")) + item = tool_calls.setdefault(index, {"name": "", "arguments": ""}) + name = _json_str(function.get("name")) + arguments = _json_str(function.get("arguments")) + if name: + item["name"] = name + if arguments: + item["arguments"] = _json_str(item.get("arguments")) + arguments + function_call = _json_dict(delta.get("function_call")) + if function_call: + item = tool_calls.setdefault(0, {"name": "", "arguments": ""}) + name = _json_str(function_call.get("name")) + arguments = _json_str(function_call.get("arguments")) + if name: + item["name"] = name + if arguments: + item["arguments"] = _json_str(item.get("arguments")) + arguments + + @staticmethod + def _stream_list_index(value: JsonValue, fallback: int) -> int: + if isinstance(value, int): + return value + if isinstance(value, str) and value.isdigit(): + return int(value) + return fallback + def _read_responses_tool_stream( self, client: OpenAI, @@ -3782,6 +4025,7 @@ def _read_responses_tool_stream( timeout: int, request_deadline: float, first_token_timeout: int | None, + activity: str, on_stream_action: Callable[[Json], bool] | None = None, ) -> tuple[Json, Json]: usage: Json = {} @@ -3790,55 +4034,53 @@ def _read_responses_tool_stream( first_output_seen = False stream_params = dict(params) - stream_params.pop("stream", None) self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) stopped = False - with client.responses.stream(**stream_params, timeout=timeout) as stream: - for event in stream: - data = self._sdk_json(event) - event_type = _json_str(data.get("type")) or str(getattr(event, "type", "") or "") - if event_type in ("response.output_text.delta", "response.reasoning.delta"): - text = str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "") - first_output_seen = self._mark_stream_output( - len(text), - first_output_seen, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, - ) - if event_type == "response.output_text.delta" and text: - text_parts.append(text) - continue - if event_type == "response.function_call_arguments.delta": - first_output_seen = self._mark_stream_output( - len(str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "")), - first_output_seen, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, - ) - continue - if event_type != "response.function_call_arguments.done": - continue - action = self._action_from_function_call( - str(getattr(event, "name", "") or _json_str(data.get("name")) or ""), - str(getattr(event, "arguments", "") or _json_str(data.get("arguments")) or "{}"), - ) - if text_parts and on_stream_action is not None: - action["_assistant_text"] = "".join(text_parts).strip() - text_parts.clear() - actions.append(action) - stopped, request_deadline = self._call_stream_action( - on_stream_action, - action, + for event in client.responses.create(**stream_params, timeout=timeout): + data = self._sdk_json(event) + event_type = _json_str(data.get("type")) or str(getattr(event, "type", "") or "") + self._raise_responses_stream_error(data) + event_usage = _json_dict(data.get("usage")) + if event_usage: + usage = event_usage + if event_type == "response.completed": + response = _json_dict(data.get("response")) + usage = _json_dict(response.get("usage")) or usage + if not actions and not text_parts: + content = self._responses_content(response) + if content: + text_parts.append(content) + continue + if event_type in ("response.output_text.delta", "response.reasoning.delta", "response.function_call_arguments.delta"): + text = str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "") + first_output_seen = self._mark_stream_output( + len(text), + first_output_seen, request_deadline=request_deadline, first_token_timeout=first_token_timeout, ) - if stopped: - break - if not stopped: - final = self._sdk_json(stream.get_final_response()) - usage = _json_dict(final.get("usage")) - if not actions: - return self._responses_tool_response(final), usage + if event_type == "response.output_text.delta" and text: + text_parts.append(text) + continue + if event_type != "response.function_call_arguments.done": + continue + action = self._action_from_function_call( + str(getattr(event, "name", "") or _json_str(data.get("name")) or ""), + str(getattr(event, "arguments", "") or _json_str(data.get("arguments")) or "{}"), + ) + DebugTrace.stream_action(self.session, activity=activity, action=action) + if text_parts and on_stream_action is not None: + action["_assistant_text"] = "".join(text_parts).strip() + text_parts.clear() + actions.append(action) + stopped, request_deadline = self._call_stream_action( + on_stream_action, + action, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + if stopped: + break return self._action_response(actions, "".join(text_parts)), usage def _chat_tool_response(self, result: JsonValue) -> Json: @@ -4102,31 +4344,6 @@ def _arm_stream_timeout(self, *, request_deadline: float, first_output_seen: boo self._timeout_reason = "request first token timeout" signal.setitimer(signal.ITIMER_REAL, remaining) - def _write_debug_prompt(self, *, activity: str, messages: list[Json]) -> str: - if not self.session.settings.debug: - return "" - self.session.state.debug_prompt_count += 1 - directory = self.session.debug_dir() - os.makedirs(directory, exist_ok=True) - timestamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f") - filepath = os.path.join(directory, f"{timestamp}-{self.session.state.debug_prompt_count:04d}-{activity or 'request'}.txt") - with open(filepath, "w", encoding="utf-8") as f: - f.write(self._format_debug_prompt(messages=messages)) - return filepath - - def _format_debug_prompt(self, *, messages: list[Json]) -> str: - lines = [] - for index, message in enumerate(messages, start=1): - role = _json_str(message.get("role")) or "(unknown)" - content = message.get("content") - lines.append(f"--- {role} message {index} ---") - if isinstance(content, str): - lines.append(content) - else: - lines.append(json.dumps(content, ensure_ascii=False, indent=2)) - lines.append("") - return "\n".join(lines).rstrip() + "\n" - def _invalid_model_response(self, content: str, reason: str = "expected a function tool call") -> Json: return { "actions": [], @@ -4773,6 +4990,9 @@ def _apply_plan_patches(self, plan: list[PlanItem], value: JsonValue) -> bool: return changed def _plan_item_from_json(self, value: JsonValue) -> PlanItem | None: + if isinstance(value, str): + text = value.strip() + return PlanItem(text=text) if text else None item = _json_dict(value) text = _json_str(item.get("text")) if not text: @@ -5288,6 +5508,7 @@ def run_loop( if on_before_step is not None: on_before_step(index, max_steps) response = self.step(on_message=on_message) + DebugTrace.loop_event(self, "loop-step", index=index + 1, response=response) format_error = _json_str(response.get("_format_error")) if format_error: consecutive_format_errors += 1 @@ -5299,6 +5520,7 @@ def run_loop( continue consecutive_format_errors = 0 result = on_step(response) + DebugTrace.loop_event(self, "loop-result", index=index + 1, response=response, result=result) if result.done: return result.value return on_step_limit() @@ -5319,7 +5541,7 @@ def run_stream_loop( ) -> JsonValue: consecutive_format_errors = 0 try: - for _ in range(max_steps): + for index in range(max_steps): result, response, committed = self.stream_step( confirm=confirm, on_auto_approve=on_auto_approve, @@ -5327,6 +5549,7 @@ def run_stream_loop( on_live_done=on_live_done, on_message=on_message, ) + DebugTrace.loop_event(self, "stream-loop-step", index=index + 1, response=response, result=result, committed=committed) format_error = _json_str(response.get("_format_error")) if format_error: consecutive_format_errors += 1 @@ -5473,14 +5696,15 @@ def _format_observe_feedback(self) -> str: return "\n".join("- " + error for error in self.observe_feedback_errors) def _report_gate(self, on_message: MessageCallback | None, message: str, debug_message: str) -> None: + is_retry = message.startswith(("Retrying:", "Continuing:")) if on_message is None: return - if message.startswith(("Retrying:", "Continuing:")) and self.session.state.status_notice_until <= time.monotonic(): + if is_retry and self.session.state.status_notice_until <= time.monotonic(): self._set_status_notice("err:gate") if self.session.settings.debug: on_message(debug_message) return - if not message.startswith(("Retrying:", "Continuing:")): + if not is_retry: on_message(message) def _format_gate_user_message(self, prefix: str, format_error: str) -> str: @@ -5863,10 +6087,16 @@ def _incomplete_goal_update_from_actions(self, actions: list[Json]) -> str: def _has_fresh_plan_action(self, actions: list[Json]) -> bool: for action in actions: action_type = _json_str(action.get("type")) - if action_type == "plan" and action.get("mode") != "patch" and any(_json_str(_json_dict(raw).get("text")) for raw in _json_list(action.get("items"))): + if action_type == "plan" and action.get("mode") != "patch" and any(self._plan_item_has_text(raw) for raw in _json_list(action.get("items"))): return True return False + @staticmethod + def _plan_item_has_text(value: JsonValue) -> bool: + if isinstance(value, str): + return bool(value.strip()) + return bool(_json_str(_json_dict(value).get("text"))) + def _plan_is_complete(self) -> bool: return bool(self.blackboard.plan) and all( item.status in self.COMPLETED_PLAN_STATUSES and item.context.strip() for item in self.blackboard.plan @@ -6036,18 +6266,12 @@ def _build_response_context(self, response: Json) -> ResponseContext: def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: if ctx.actions or not ctx.assistant_text: return None - if ctx.state_or_work_requested or self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start: - return self._reject_result( - self._remember_agent_error, - on_message, - self._error("assistant text cannot finish an active task.", self.RULE_FINAL_ACTION), - "Retrying: active task is not complete.", - "Completion_Gate: assistant text before task completion.", - ) - self.blackboard.task_code = TaskCode.DONE self.session.append_conversation(AssistantMessage(content=ctx.assistant_text)) if on_message is not None: on_message(ctx.assistant_text) + if self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start: + return AgentRunResult() + self.blackboard.task_code = TaskCode.DONE return AgentRunResult(done=True, value=ctx.response) def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: @@ -6090,6 +6314,13 @@ def _gate_tool_actions(self, ctx: ResponseContext, on_message: MessageCallback | ) return False + def _drop_goal_rewrite_actions(self, ctx: ResponseContext) -> None: + def keep(action: Json) -> bool: + return not (_json_str(action.get("type")) == "goal" and action.get("complete") is not True) + + ctx.actions[:] = [action for action in ctx.actions if keep(action)] + ctx.response["actions"] = [action for action in _json_list(ctx.response.get("actions")) if not isinstance(action, dict) or keep(action)] + def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: if ( self.blackboard.task_code == TaskCode.NEW @@ -6099,28 +6330,13 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N and not ctx.has_plan_action and not ctx.has_user_rule_action ): - self._remember_agent_error( - self._error( - "previous task context is still present.", - "emit goal for a new task; otherwise update or confirm the current plan.", - ) - ) - self._report_gate( - on_message, - "Retrying: align this request with the task before work.", - "GoalPlan_Gate: work before task alignment with previous task context.", + self._warn_agent( + "previous task context is still present.", + "emit goal for a new task; otherwise update or confirm the current plan.", ) - return True if self.blackboard.task_code != TaskCode.NEW and ctx.goal_will_change and not ctx.has_fresh_plan_action: - self._remember_agent_error( - self._error("cannot rewrite Goal after the task is active.", "continue the existing Goal/Plan.") - ) - self._report_gate( - on_message, - "Retrying: current task is already active; continue without rewriting goal.", - "GoalPlan_Gate: goal rewrite while task code is " + self.blackboard.task_code + ".", - ) - return True + self._warn_agent("rewrote Goal after the task was active.", "replace Plan when the task scope changes.") + self._drop_goal_rewrite_actions(ctx) if ctx.pending_verify_requested: self._warn_agent('ignored verify status="pending".', self.RULE_VERIFY_DIRECTLY) if ( @@ -6129,20 +6345,10 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N and ctx.state_or_work_requested and (ctx.pending_verify_requested or self._has_non_readonly_tool_call(ctx.tool_calls)) ): - return self._reject_agent( - on_message, - self._error("Goal/Plan required before mutating work.", self.RULE_GOAL_PLAN_FIRST), - "Retrying: set goal and plan before tools.", - "GoalPlan_Gate: Goal is empty before task state/work.", - ) + self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or self._has_non_readonly_tool_call(ctx.tool_calls)): - self._remember_agent_error(self._error("changed Goal without replacing Plan.", "include a full plan action before mutating work.")) - self._report_gate( - on_message, - "Retrying: new goal requires a fresh plan.", - "GoalPlan_Gate: Goal changed without replacing Plan.", - ) - return True + self._warn_agent("changed Goal without replacing Plan.", "replace Plan when the task scope changes.") + self._drop_goal_rewrite_actions(ctx) return False def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback | None) -> None: @@ -6154,19 +6360,12 @@ def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback on_message(ctx.assistant_text) def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: - has_progress_text = bool(ctx.assistant_text and ctx.actions and not ctx.completion_message) if ( ctx.plan_was_empty and not self.blackboard.plan and (ctx.pending_verify_requested or self._has_non_readonly_tool_call(ctx.tool_calls)) ): - return self._reject_result( - self._remember_agent_error, - on_message, - self._error("Plan required before mutating work.", self.RULE_GOAL_PLAN_FIRST), - "Retrying: create a short plan before mutating tools.", - "GoalPlan_Gate: Plan is empty before mutating tool/verify.", - ) + self._warn_agent("mutating work before Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ( ctx.tool_calls @@ -6186,25 +6385,6 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | ) else: self._warn_agent("Plan and verification are complete; finish with goal.complete=true when no further work is needed.") - if ( - ctx.state_or_work_requested - and not ctx.tool_calls - and not ctx.pending_verify_requested - and not has_progress_text - and not ctx.completion_message - and not self.state_updater.changed - and not self.blackboard.goal_reached - ): - rule = "do not repeat unchanged state; call readonly discovery if context is missing, set plan if ready, verify, or finish." - if self.blackboard.goal and not self.blackboard.plan: - rule = "Goal is already set; do not repeat it. Call readonly discovery if context is missing, or set plan if ready." - return self._reject_result( - self._remember_agent_error, - on_message, - self._error("response made no effective state change.", rule), - "Retrying: move to the next workflow state.", - "Progress_Gate: no effective state change.", - ) if ( not self.session.settings.plan_mode and ctx.has_state_update_action @@ -6417,15 +6597,6 @@ def _finish_or_continue(self, ctx: ResponseContext, on_message: MessageCallback self._finish_current_goal() return AgentRunResult(done=True, value=ctx.response) self.blackboard.goal_reached = False - if not ctx.actions: - self._remember_agent_error( - self._error("no actions while goal is incomplete.", self.RULE_FINAL_ACTION) - ) - self._report_gate( - on_message, - "Continuing: assistant must set current task's goal.", - "GoalPlan_Gate: goal not reached; retrying next useful action.", - ) return AgentRunResult() def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: @@ -6567,6 +6738,7 @@ def handle_response( on_message: MessageCallback | None = None, ) -> AgentRunResult: ctx = self._build_response_context(response) + DebugTrace.handle_event(self, "handle-start", ctx, response) if self.mode == AgentMode.OBSERVE: return self._handle_observe_response( ctx, @@ -6575,13 +6747,16 @@ def handle_response( ) if self._gate_before_apply(ctx, on_message): + DebugTrace.handle_event(self, "handle-gated-before-apply", ctx, response) return AgentRunResult() text_result = self._handle_text_response(ctx, on_message) if text_result is not None: + DebugTrace.handle_event(self, "handle-text", ctx, response, result=text_result) return text_result forgotten_keys = self.apply_response(response) + DebugTrace.handle_event(self, "handle-applied", ctx, response, extra={"forgotten": forgotten_keys}) self._emit_state_and_text(ctx, on_message) self._emit_tool_context_update([], forgotten_keys, on_message) if ctx.has_user_rule_action and not ctx.tool_calls and not ctx.pending_verify_requested: @@ -6590,10 +6765,12 @@ def handle_response( if on_message is not None: on_message(message) self._finish_current_goal() + DebugTrace.handle_event(self, "handle-user-rule", ctx, response) return AgentRunResult(done=True, value=response) gate_result = self._gate_after_apply(ctx, on_message) if gate_result is not None: + DebugTrace.handle_event(self, "handle-gated-after-apply", ctx, response, result=gate_result) return gate_result self._promote_required_verification(ctx) @@ -6605,10 +6782,12 @@ def handle_response( on_live_done=on_live_done, on_message=on_message, ): + DebugTrace.handle_event(self, "handle-tools", ctx, response) return AgentRunResult() - self.runtime.consecutive_tool_turns = 0 - return self._finish_or_continue(ctx, on_message) + result = self._finish_or_continue(ctx, on_message) + DebugTrace.handle_event(self, "handle-finish-or-continue", ctx, response, result=result) + return result ############################ @@ -6649,7 +6828,7 @@ class CommandSpec: CommandSpec("/provider", "Show or switch provider", "Config", "/provider [name]"), CommandSpec("/plan", "Toggle plan mode or ask for a readonly plan", "Config", "/plan [on|off|question]"), CommandSpec("/yolo", "Toggle yolo mode (skip confirmations)", "Config", "/yolo"), - CommandSpec("/clean", "Clean all session tool result logs", "Maintenance", "/clean"), + CommandSpec("/clean", "Clean inactive session directories", "Maintenance", "/clean"), CommandSpec("/exit", "Exit nanocode", "Control", "/exit"), CommandSpec("/quit", "Exit nanocode", "Control", "/quit"), ) @@ -7106,9 +7285,9 @@ def _clean(self, args: str) -> str: return "Usage: /clean" sessions_dir = self.agent.session.data_path("sessions") if not os.path.isdir(sessions_dir): - return f"No session logs directory found at {sessions_dir}" - result = SessionLogCleaner(self.agent.session).clean() - msg = f"Cleaned {result.cleaned} log file(s) from {sessions_dir}" + return f"No sessions directory found at {sessions_dir}" + result = SessionCleaner(self.agent.session).clean() + msg = f"Cleaned {result.cleaned} session(s) from {sessions_dir}" if result.skipped: msg += f" ({result.skipped} active session(s) skipped)" if result.failed: @@ -7411,7 +7590,7 @@ def run(self) -> int: def _auto_clean_logs(self) -> None: seconds = RuntimeSettings.clean_retention_seconds(self.agent.session.settings.auto_clean_recent) if seconds > 0: - SessionLogCleaner(self.agent.session).clean(older_than_seconds=seconds) + SessionCleaner(self.agent.session).clean(older_than_seconds=seconds) def _prompt(self) -> str: labels = [] diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 3dbe541..b6d659d 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1217,6 +1217,29 @@ def test_agent_request_sends_function_tool_schema_and_parses_tool_call(tmp_path, assert session.state.last_total_tokens == 5 +def test_agent_accepts_string_plan_items_from_function_call(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + response = {"actions": [{"type": "plan", "mode": "replace", "items": ["Create demo", "Run smoke test"]}]} + + assert agent._build_response_context(response).has_fresh_plan_action is True + agent.apply_response(response) + + assert agent.blackboard.plan == [ + nanocode.PlanItem(text="Create demo"), + nanocode.PlanItem(text="Run smoke test"), + ] + + +def test_agent_accepts_string_hypothesis_items_from_function_call(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + + agent.apply_response({"actions": [{"type": "hypothesis", "items": ["Admin filter excludes history"]}]}) + + assert agent.blackboard.hypotheses == [ + nanocode.Hypothesis(text="Admin filter excludes history"), + ] + + def test_function_tool_schemas_define_items_for_every_array(): def walk(value, path="schema"): if isinstance(value, dict): @@ -1263,36 +1286,21 @@ def test_agent_request_responses_api_parses_function_call(tmp_path, monkeypatch) def test_agent_request_chat_stream_parses_function_tool_event(tmp_path, monkeypatch): calls = [] - class FakeStream: - def __enter__(self): - return self - - def __exit__(self, *_args): - return False - - def __iter__(self): + class FakeCompletions: + def create(self, **kwargs): + calls.append(kwargs) return iter( [ - {"type": "content.delta", "delta": "Reading."}, - { - "type": "tool_calls.function.arguments.done", - "name": "Read", - "arguments": '{"intention":"read sample","args":["sample.txt","0","1"]}', - }, + _stream_chunk({"content": "Reading."}), + _stream_chunk({"tool_calls": [{"index": "0", "function": {"name": "Read", "arguments": '{"intention":"read sample",'}}]}), + _stream_chunk({"tool_calls": [{"index": "0", "function": {"arguments": '"args":["sample.txt","0","1"]}'}}]}), + _stream_chunk(usage={"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, choices=False), ] ) - def get_final_completion(self): - return {"usage": {"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, "choices": [{"message": {}}]} - - class FakeStreamCompletions: - def stream(self, **kwargs): - calls.append(kwargs) - return FakeStream() - class FakeOpenAI: def __init__(self, **_kwargs): - self.beta = type("FakeBeta", (), {"chat": type("FakeChat", (), {"completions": FakeStreamCompletions()})()})() + self.chat = type("FakeChat", (), {"completions": FakeCompletions()})() monkeypatch.setattr(nanocode, "OpenAI", FakeOpenAI) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model") @@ -1300,6 +1308,7 @@ def __init__(self, **_kwargs): response = Agent(session).request("system", "user", tool_schemas=[nanocode.ReadTool.tool_schema()]) assert calls[0]["tools"][0]["function"]["name"] == "Read" + assert calls[0]["stream"] is True assert response == { "actions": [ { @@ -1317,14 +1326,9 @@ def __init__(self, **_kwargs): def test_agent_request_responses_stream_parses_function_tool_event(tmp_path, monkeypatch): response_calls = [] - class FakeStream: - def __enter__(self): - return self - - def __exit__(self, *_args): - return False - - def __iter__(self): + class FakeResponses: + def create(self, **kwargs): + response_calls.append(kwargs) return iter( [ {"type": "response.output_text.delta", "delta": "Recording."}, @@ -1333,17 +1337,10 @@ def __iter__(self): "name": "known", "arguments": '{"items":["Project uses pytest."]}', }, + {"type": "response.completed", "response": {"usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}}}, ] ) - def get_final_response(self): - return {"usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}, "output": []} - - class FakeResponses: - def stream(self, **kwargs): - response_calls.append(kwargs) - return FakeStream() - class FakeOpenAI: def __init__(self, **_kwargs): self.responses = FakeResponses() @@ -1354,6 +1351,7 @@ def __init__(self, **_kwargs): response = Agent(session).request("system", "user", tool_schemas=[nanocode._state_tool_schema("known")]) assert response_calls[0]["tools"][0]["name"] == "known" + assert response_calls[0]["stream"] is True assert response == {"actions": [{"type": "known", "items": ["Project uses pytest."]}], "_assistant_text": "Recording."} assert session.state.last_total_tokens == 5 @@ -2979,7 +2977,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert "previous task context is still present" in " ".join(agent.agent_feedback_errors) -def test_agent_run_rejects_goal_rewrite_after_task_is_working(tmp_path): +def test_agent_run_ignores_goal_rewrite_after_task_is_working(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") class FakeModelClient: @@ -3019,7 +3017,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.blackboard.goal == "read sample" assert [item.text for item in agent.blackboard.plan] == ["Read sample"] assert len(agent.tool_runner.latest_executions) == 1 - assert "cannot rewrite Goal" in " ".join(agent.agent_feedback_errors) + assert "rewrote Goal after the task was active" in " ".join(agent.agent_feedback_errors) def test_agent_allows_plan_with_multiple_doing_items(tmp_path): @@ -3048,7 +3046,7 @@ def test_agent_allows_plan_with_multiple_doing_items(tmp_path): assert agent.agent_feedback_errors == [] -def test_agent_rejects_goal_rewrite_after_task_is_working(tmp_path): +def test_agent_ignores_goal_rewrite_after_task_is_working(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.blackboard.task_code = nanocode.TaskCode.WORKING agent.blackboard.goal = "read sample" @@ -3059,7 +3057,7 @@ def test_agent_rejects_goal_rewrite_after_task_is_working(tmp_path): assert result.done is False assert agent.blackboard.goal == "read sample" assert [item.text for item in agent.blackboard.plan] == ["Read sample"] - assert "cannot rewrite Goal" in " ".join(agent.agent_feedback_errors) + assert "rewrote Goal after the task was active" in " ".join(agent.agent_feedback_errors) def test_agent_run_continues_when_no_tool_calls_and_goal_not_reached(tmp_path): @@ -3135,28 +3133,6 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert "Continuing: goal is not complete yet." not in messages -def test_agent_run_rejects_no_effective_state_change(tmp_path): - class FakeModelClient: - def __init__(self): - self.responses = [ - {"actions": [{"type": "goal", "text": "answer", "complete": False}]}, - {"actions": _final_actions()}, - ] - - def request(self, system_prompt, user_prompt, *, activity="agent"): - return self.responses.pop(0) - - session = Session(cwd=str(tmp_path)) - agent = Agent(session) - _seed_plan(agent, "answer") - agent.model_client = FakeModelClient() - - response = agent.run("answer") - - assert response["actions"][-1]["message_for_complete"] == "done" - assert any("response made no effective state change" in error for error in agent.agent_feedback_errors) - - def test_main_agent_accepts_memory_actions_during_act_turn(tmp_path): class FakeModelClient: def __init__(self): @@ -3282,40 +3258,6 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.blackboard.verification.status == VerificationStatus.DONE -def test_agent_run_retries_noop_state_only_response(tmp_path): - class FakeModelClient: - def __init__(self): - self.user_prompts = [] - self.responses = [ - {"actions": [{"type": "plan", "mode": "patch", "items": [{"id": "p1", "status": "doing"}]}]}, - {"actions": [{"type": "tool", "name": "Read", "intention": "inspect sample", "args": ["sample.txt", "0", "1"]}]}, - {"actions": [{"type": "forget", "source": ["tr.1"], "reason": "read result is not needed"}]}, - { - "actions": [ - {"type": "plan", "mode": "patch", "items": [{"id": "p1", "status": "done", "context": "sample inspected"}]}, - {"type": "verify", "status": "passed", "context": "no code change"}, - {"type": "goal", "text": "inspect sample", "complete": True, "message_for_complete": "done"}, - ] - }, - ] - - def request(self, system_prompt, user_prompt, *, activity="agent"): - self.user_prompts.append(user_prompt) - return self.responses.pop(0) - - (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - agent = Agent(session) - agent.blackboard.goal = "inspect sample" - agent.blackboard.plan = [nanocode.PlanItem(id="p1", text="inspect sample", status=nanocode.PlanStatus.DOING)] - agent.model_client = FakeModelClient() - - response = agent.run("inspect sample") - - assert response["actions"][-1]["message_for_complete"] == "done" - assert any("response made no effective state change" in error for error in agent.agent_feedback_errors) - - def test_agent_allows_tool_after_completed_plan_and_verification(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(_session(tmp_path, debug=True)) @@ -3497,7 +3439,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert session.state.conversation[-1].content == "hello" -def test_agent_run_retries_assistant_text_with_unfinished_task_context(tmp_path): +def test_agent_run_treats_assistant_text_as_progress_with_unfinished_task_context(tmp_path): class FakeModelClient: def __init__(self): self.user_prompts = [] @@ -3527,9 +3469,10 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert response["actions"][-1]["message_for_complete"] == "done" assert messages[-1] == "done" + assert "done too early" in messages assert len(agent.model_client.user_prompts) == 2 - assert "done too early" not in [item.content for item in session.state.conversation] - assert any("assistant text cannot finish an active task" in error for error in agent.agent_feedback_errors) + assert "done too early" in [item.content for item in session.state.conversation] + assert not any("assistant text cannot finish an active task" in error for error in agent.agent_feedback_errors) def test_agent_run_retries_goal_complete_with_unfinished_plan(tmp_path): diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 474e589..bb80ee5 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -3,7 +3,7 @@ import time import nanocode -from nanocode import Config, Agent, CommandDispatcher, CommandStatus, ModelUsage, RuntimeSettings, Session, SessionLock, SessionLogCleaner, UserMessage +from nanocode import Config, Agent, CommandDispatcher, CommandStatus, ModelUsage, RuntimeSettings, Session, SessionLock, SessionCleaner, UserMessage class FakeModelClient: @@ -153,7 +153,7 @@ def test_config_command_reports_resolved_provider_config(tmp_path): assert "runtime.max_agent_steps: 100" in result.message assert "runtime.plan_timeout: 360" in result.message assert "runtime.plan_first_token_timeout: 180" in result.message - assert "runtime.auto_clean_recent: 3d" in result.message + assert "runtime.auto_clean_recent: 1d" in result.message assert "runtime.plan_mode: off" in result.message @@ -555,90 +555,69 @@ def test_help_question_runs_agent_with_source_aware_prompt(tmp_path): assert len(prompts) == 1 -def test_clean_command_removes_all_session_log_files(tmp_path): +def test_clean_command_removes_inactive_session_directories(tmp_path): session = Session(cwd=str(tmp_path)) - tool_results_dir = session.tool_results_dir() - other_tool_results_dir = session.data_path("sessions", "other-session", "tool_results") - os.makedirs(tool_results_dir, exist_ok=True) - os.makedirs(other_tool_results_dir, exist_ok=True) - - # Create some log files and a non-log file - log1 = os.path.join(tool_results_dir, "test1.log") - log2 = os.path.join(tool_results_dir, "test2.log") - log3 = os.path.join(other_tool_results_dir, "test3.log") - other = os.path.join(tool_results_dir, "other.txt") - with open(log1, "w"): - pass - with open(log2, "w"): - pass - with open(log3, "w"): - pass - with open(other, "w"): - pass - + current_dir = session.session_dir() + old_dir = session.data_path("sessions", "old-session") + recent_dir = session.data_path("sessions", "recent-session") + for path in (current_dir, old_dir, recent_dir): + os.makedirs(path, exist_ok=True) dispatcher = CommandDispatcher(Agent(session)) result = dispatcher.dispatch("/clean") assert result.status == CommandStatus.HANDLED - assert "Cleaned 3 log file(s)" in result.message - assert not os.path.exists(log1) - assert not os.path.exists(log2) - assert not os.path.exists(log3) - assert os.path.exists(other) + assert "Cleaned 2 session(s)" in result.message + assert os.path.exists(current_dir) + assert not os.path.exists(old_dir) + assert not os.path.exists(recent_dir) def test_clean_command_skips_active_sessions(tmp_path): session = Session(cwd=str(tmp_path)) - active_tool_results_dir = session.tool_results_dir() - stale_tool_results_dir = session.data_path("sessions", "stale-session", "tool_results") - os.makedirs(active_tool_results_dir, exist_ok=True) - os.makedirs(stale_tool_results_dir, exist_ok=True) - - active_log = os.path.join(active_tool_results_dir, "active.log") - stale_log = os.path.join(stale_tool_results_dir, "stale.log") - with open(active_log, "w"): - pass - with open(stale_log, "w"): - pass + active_dir = session.data_path("sessions", "active-session") + stale_dir = session.data_path("sessions", "stale-session") + os.makedirs(active_dir, exist_ok=True) + os.makedirs(stale_dir, exist_ok=True) + old_time = time.time() - 2 * 86400 - with SessionLock(session.lock_path()): + with SessionLock(os.path.join(active_dir, "session.lock")): + os.utime(active_dir, (old_time, old_time)) + os.utime(stale_dir, (old_time, old_time)) dispatcher = CommandDispatcher(Agent(session)) result = dispatcher.dispatch("/clean") assert result.status == CommandStatus.HANDLED - assert "Cleaned 1 log file(s)" in result.message + assert "Cleaned 1 session(s)" in result.message assert "1 active session(s) skipped" in result.message - assert os.path.exists(active_log) - assert not os.path.exists(stale_log) + assert os.path.exists(active_dir) + assert not os.path.exists(stale_dir) -def test_session_log_cleaner_removes_only_old_logs_from_inactive_sessions(tmp_path): +def test_session_cleaner_removes_only_old_inactive_sessions(tmp_path): session = Session(cwd=str(tmp_path)) - old_dir = session.data_path("sessions", "old-session", "tool_results") - recent_dir = session.data_path("sessions", "recent-session", "tool_results") - active_dir = session.tool_results_dir() - os.makedirs(old_dir, exist_ok=True) - os.makedirs(recent_dir, exist_ok=True) - os.makedirs(active_dir, exist_ok=True) - - old_log = os.path.join(old_dir, "old.log") - recent_log = os.path.join(recent_dir, "recent.log") - active_old_log = os.path.join(active_dir, "active-old.log") - for path in (old_log, recent_log, active_old_log): - with open(path, "w"): - pass + old_dir = session.data_path("sessions", "old-session") + recent_dir = session.data_path("sessions", "recent-session") + current_dir = session.session_dir() + for path in (old_dir, recent_dir, current_dir): + os.makedirs(path, exist_ok=True) old_time = time.time() - 10 * 86400 - os.utime(old_log, (old_time, old_time)) - os.utime(active_old_log, (old_time, old_time)) + os.utime(old_dir, (old_time, old_time)) + os.utime(current_dir, (old_time, old_time)) with SessionLock(session.lock_path()): - result = SessionLogCleaner(session).clean(older_than_seconds=3 * 86400) + result = SessionCleaner(session).clean(older_than_seconds=3 * 86400) assert result.cleaned == 1 - assert result.skipped == 1 - assert not os.path.exists(old_log) - assert os.path.exists(recent_log) - assert os.path.exists(active_old_log) + assert not os.path.exists(old_dir) + assert os.path.exists(recent_dir) + assert os.path.exists(current_dir) + + +def test_session_lock_removes_lock_file_on_release(tmp_path): + session = Session(cwd=str(tmp_path)) + with SessionLock(session.lock_path()): + assert os.path.exists(session.lock_path()) + assert not os.path.exists(session.lock_path()) def test_clean_command_no_directory(tmp_path): @@ -651,25 +630,23 @@ def test_clean_command_no_directory(tmp_path): result = dispatcher.dispatch("/clean") assert result.status == CommandStatus.HANDLED - assert "No session logs directory found" in result.message + assert "No sessions directory found" in result.message def test_clean_command_empty_directory(tmp_path): session = Session(cwd=str(tmp_path)) - tool_results_dir = session.tool_results_dir() - os.makedirs(tool_results_dir, exist_ok=True) + os.makedirs(session.session_dir(), exist_ok=True) dispatcher = CommandDispatcher(Agent(session)) result = dispatcher.dispatch("/clean") assert result.status == CommandStatus.HANDLED - assert "Cleaned 0 log file(s)" in result.message + assert "Cleaned 0 session(s)" in result.message def test_clean_command_with_args_returns_usage(tmp_path): session = Session(cwd=str(tmp_path)) - tool_results_dir = session.tool_results_dir() - os.makedirs(tool_results_dir, exist_ok=True) + os.makedirs(session.session_dir(), exist_ok=True) dispatcher = CommandDispatcher(Agent(session)) result = dispatcher.dispatch("/clean extra-arg") @@ -680,32 +657,24 @@ def test_clean_command_with_args_returns_usage(tmp_path): def test_clean_command_reports_failed_deletions(tmp_path): session = Session(cwd=str(tmp_path)) - tool_results_dir = session.tool_results_dir() - os.makedirs(tool_results_dir, exist_ok=True) - - # Create two log files - log1 = os.path.join(tool_results_dir, "good.log") - log2 = os.path.join(tool_results_dir, "fail.log") - with open(log1, "w"): - pass - with open(log2, "w"): - pass - - # Mock os.remove to fail on the second file - original_remove = os.remove + good_dir = session.data_path("sessions", "good-session") + fail_dir = session.data_path("sessions", "fail-session") + os.makedirs(good_dir, exist_ok=True) + os.makedirs(fail_dir, exist_ok=True) + original_rmtree = shutil.rmtree call_count = [0] - def mock_remove(path): + def mock_rmtree(path): call_count[0] += 1 if call_count[0] == 2: raise OSError("Permission denied") - original_remove(path) + original_rmtree(path) import unittest.mock - with unittest.mock.patch("os.remove", side_effect=mock_remove): + with unittest.mock.patch("shutil.rmtree", side_effect=mock_rmtree): dispatcher = CommandDispatcher(Agent(session)) result = dispatcher.dispatch("/clean") assert result.status == CommandStatus.HANDLED - assert "Cleaned 1 log file(s)" in result.message + assert "Cleaned 1 session(s)" in result.message assert "1 failed" in result.message diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index c031c44..2bda508 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -85,7 +85,7 @@ def test_init_config_file_writes_default_toml(tmp_path): assert config["runtime"]["compact_at"] == 50 assert config["runtime"]["plan_timeout"] == 360 assert config["runtime"]["plan_first_token_timeout"] == 180 - assert config["runtime"]["auto_clean_recent"] == "3d" + assert config["runtime"]["auto_clean_recent"] == "1d" assert config["runtime"]["yolo"] is False assert config["runtime"]["plan_mode"] is False From e4ab75860182378fd6f1a3757bd7536b26e926f6 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 20:22:34 -0700 Subject: [PATCH 012/144] fix responses stream parsing and add api command --- README.md | 4 +- nanocode.py | 73 +++++++++++++++++++++++++++++++-- tests/test_nanocode_agent.py | 31 ++++++++++++++ tests/test_nanocode_commands.py | 18 ++++++++ tests/test_nanocode_loop.py | 3 ++ 5 files changed, 124 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 3bf5b2b..ae20cfe 100644 --- a/README.md +++ b/README.md @@ -87,11 +87,11 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Commands - Info: `/help [question]`, `/status`, `/rules`, `/knowledge`, `/compact`. -- Config: `/config`, `/set `, `/model [model_name]`, `/reason`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. +- Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. - Maintenance: `/clean`. - Exit: `/exit`, `/quit`. -Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model ` and `/reason` are direct shortcuts. +Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/api responses` switches the current provider to Responses format. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model ` and `/reason` are direct shortcuts. During a slow model request, press `Ctrl-G` to cancel that request and resend the same prompt. ## Configuration diff --git a/nanocode.py b/nanocode.py index 8d14e4d..ba75591 100644 --- a/nanocode.py +++ b/nanocode.py @@ -4032,6 +4032,7 @@ def _read_responses_tool_stream( actions: list[Json] = [] text_parts: list[str] = [] first_output_seen = False + function_calls: dict[str, Json] = {} stream_params = dict(params) self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) @@ -4051,7 +4052,10 @@ def _read_responses_tool_stream( if content: text_parts.append(content) continue - if event_type in ("response.output_text.delta", "response.reasoning.delta", "response.function_call_arguments.delta"): + if event_type in ("response.output_item.added", "response.output_item.done"): + self._remember_responses_function_call(function_calls, data) + continue + if event_type in ("response.output_text.delta", "response.reasoning.delta"): text = str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "") first_output_seen = self._mark_stream_output( len(text), @@ -4062,11 +4066,25 @@ def _read_responses_tool_stream( if event_type == "response.output_text.delta" and text: text_parts.append(text) continue + if event_type == "response.function_call_arguments.delta": + text = str(getattr(event, "delta", "") or _json_str(data.get("delta")) or "") + first_output_seen = self._mark_stream_output( + len(text), + first_output_seen, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + call = self._responses_function_call_for_event(function_calls, data) + call["arguments"] = _json_str(call.get("arguments")) + text + continue if event_type != "response.function_call_arguments.done": continue + call = self._responses_function_call_for_event(function_calls, data) + name = str(getattr(event, "name", "") or _json_str(data.get("name")) or _json_str(call.get("name")) or "") + arguments = str(getattr(event, "arguments", "") or _json_str(data.get("arguments")) or _json_str(call.get("arguments")) or "{}") action = self._action_from_function_call( - str(getattr(event, "name", "") or _json_str(data.get("name")) or ""), - str(getattr(event, "arguments", "") or _json_str(data.get("arguments")) or "{}"), + name, + arguments, ) DebugTrace.stream_action(self.session, activity=activity, action=action) if text_parts and on_stream_action is not None: @@ -4083,6 +4101,35 @@ def _read_responses_tool_stream( break return self._action_response(actions, "".join(text_parts)), usage + def _remember_responses_function_call(self, function_calls: dict[str, Json], event: Json) -> None: + item = _json_dict(event.get("item")) + if _json_str(item.get("type")) != "function_call": + return + call = function_calls.setdefault(self._responses_function_call_key(event, item, len(function_calls)), {"name": "", "arguments": ""}) + name = _json_str(item.get("name")) + arguments = _json_str(item.get("arguments")) + if name: + call["name"] = name + if arguments: + call["arguments"] = arguments + + def _responses_function_call_for_event(self, function_calls: dict[str, Json], event: Json) -> Json: + key = self._responses_function_call_key(event, {}, len(function_calls)) + if key.startswith("fallback:") and len(function_calls) == 1: + return next(iter(function_calls.values())) + return function_calls.setdefault(key, {"name": "", "arguments": ""}) + + def _responses_function_call_key(self, event: Json, item: Json, fallback: int) -> str: + item_id = _json_str(event.get("item_id")) or _json_str(item.get("id")) or _json_str(item.get("item_id")) + if item_id: + return "item:" + item_id + call_id = _json_str(event.get("call_id")) or _json_str(item.get("call_id")) + if call_id: + return "call:" + call_id + if "output_index" in event or "output_index" in item: + return "index:" + str(self._stream_list_index(event.get("output_index", item.get("output_index")), fallback)) + return "fallback:" + str(fallback) + def _chat_tool_response(self, result: JsonValue) -> Json: data = _json_dict(result) choices = _json_list(data.get("choices")) @@ -6823,6 +6870,7 @@ class CommandSpec: CommandSpec("/compact", "Compact conversation history", "Info", "/compact"), CommandSpec("/config", "Show resolved runtime config", "Config", "/config"), CommandSpec("/set", "Set a runtime config override", "Config", "/set "), + CommandSpec("/api", "Show or set provider API format", "Config", "/api [auto|chat|responses]"), CommandSpec("/model", "Show or set model and reasoning", "Config", "/model [model_name]"), CommandSpec("/reason", "Set reasoning effort", "Config", "/reason"), CommandSpec("/provider", "Show or switch provider", "Config", "/provider [name]"), @@ -6905,6 +6953,7 @@ def __init__( "/compact": self._compact, "/config": self._config, "/set": self._set, + "/api": self._api, "/clean": self._clean, "/model": self._model, "/reason": self._reason, @@ -6986,6 +7035,18 @@ def _model(self, args: str) -> str: return "Usage: /model [model_name]" return self._set_model(model) + def _api(self, args: str) -> str: + value = args.strip() + provider = self.agent.session.config.provider + if not value: + resolved = provider.resolved_api() + suffix = " (" + resolved + ")" if provider.api == "auto" else "" + return "provider.api: " + provider.api + suffix + "\nUsage: /api [auto|chat|responses]" + if value not in {"auto", "chat", "responses"}: + return "Usage: /api [auto|chat|responses]" + provider.api = value + return "Set provider.api = " + value + def _model_choices(self, provider: ProviderConfig) -> tuple[str, ...]: configured = provider.available_models remote = tuple(model for model in self._fetch_remote_models(provider) if model not in configured) @@ -8483,6 +8544,12 @@ def get_completions(self, document, complete_event): if value.startswith(text): yield Completion(value, start_position=-len(text)) return + if text.startswith("/api "): + text = text[len("/api ") :] + for value in ("auto", "chat", "responses"): + if value.startswith(text): + yield Completion(value, start_position=-len(text)) + return if text.startswith("/") and " " not in text: for spec in COMMANDS: if spec.name.startswith(text): diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index b6d659d..c91333c 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1356,6 +1356,37 @@ def __init__(self, **_kwargs): assert session.state.last_total_tokens == 5 +def test_agent_request_responses_stream_uses_output_item_function_name(tmp_path, monkeypatch): + class FakeResponses: + def create(self, **_kwargs): + return iter( + [ + { + "type": "response.output_item.added", + "output_index": 0, + "item": {"id": "fc_1", "type": "function_call", "name": "goal", "arguments": ""}, + }, + { + "type": "response.function_call_arguments.done", + "item_id": "fc_1", + "arguments": '{"text":"Greet the user.","complete":true,"message_for_complete":"Hi!"}', + }, + {"type": "response.completed", "response": {"usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}}}, + ] + ) + + class FakeOpenAI: + def __init__(self, **_kwargs): + self.responses = FakeResponses() + + monkeypatch.setattr(nanocode, "OpenAI", FakeOpenAI) + session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses") + + response = Agent(session).request("system", "user", tool_schemas=[nanocode._state_tool_schema("goal")]) + + assert response == {"actions": [{"type": "goal", "text": "Greet the user.", "complete": True, "message_for_complete": "Hi!"}]} + + def test_agent_request_responses_stream_error_event_raises_llm_error(tmp_path, monkeypatch): _patch_openai(monkeypatch, [{"code": "InvalidParameter", "message": "Unsupported model: 'deepseek-v4-flash'."}]) session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses") diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index bb80ee5..7fd9ee3 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -256,6 +256,24 @@ def test_model_command_can_select_reasoning_effort(tmp_path): assert session.config.provider.reasoning_effort == "high" +def test_api_command_shows_and_sets_provider_api(tmp_path): + session = make_session(tmp_path, model="model") + dispatcher = CommandDispatcher(Agent(session)) + + show_result = dispatcher.dispatch("/api") + responses_result = dispatcher.dispatch("/api responses") + chat_result = dispatcher.dispatch("/api chat") + auto_result = dispatcher.dispatch("/api auto") + bad_result = dispatcher.dispatch("/api invalid") + + assert show_result.message == "provider.api: auto (chat)\nUsage: /api [auto|chat|responses]" + assert responses_result.message == "Set provider.api = responses" + assert chat_result.message == "Set provider.api = chat" + assert auto_result.message == "Set provider.api = auto" + assert bad_result.message == "Usage: /api [auto|chat|responses]" + assert session.config.provider.api == "auto" + + def test_model_command_can_disable_reasoning(tmp_path): session = make_session(tmp_path, model="old") dispatcher = CommandDispatcher(Agent(session), select_reasoning=lambda: "off") diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 2bda508..a5d9410 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -381,8 +381,10 @@ def test_agent_loop_command_completer_matches_slash_commands(): set_plan_timeout_completions = list(completer.get_completions(Document("/set runtime.plan_"), CompleteEvent(completion_requested=True))) model_completions = list(nanocode.CommandCompleter(models=["qwen3", "deepseek"]).get_completions(Document("/model q"), CompleteEvent(completion_requested=True))) plan_completions = list(completer.get_completions(Document("/plan "), CompleteEvent(completion_requested=True))) + api_completions = list(completer.get_completions(Document("/api r"), CompleteEvent(completion_requested=True))) assert "/help" in [completion.text for completion in slash_completions] + assert "/api" in [completion.text for completion in slash_completions] assert "/plan" in [completion.text for completion in slash_completions] assert "/config" in [completion.text for completion in config_completions] assert "provider.reasoning" in [completion.text for completion in set_key_completions] @@ -391,6 +393,7 @@ def test_agent_loop_command_completer_matches_slash_commands(): assert {completion.text for completion in set_plan_timeout_completions} == {"runtime.plan_timeout", "runtime.plan_first_token_timeout"} assert [completion.text for completion in model_completions] == ["qwen3"] assert [completion.text for completion in plan_completions] == ["on", "off"] + assert [completion.text for completion in api_completions] == ["responses"] def test_command_lexer_highlights_known_command_prefix_only(): From d5174c232b327206588ed4d49f00d620298c5920 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 21:08:16 -0700 Subject: [PATCH 013/144] fix replace range insertion fingerprints --- nanocode.py | 4 +++- tests/test_nanocode_replace_range_tool.py | 10 ++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/nanocode.py b/nanocode.py index ba75591..d936d2c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -884,7 +884,9 @@ def _candidate_contents(self, *, filepath: str, start: int, end: int, fingerprin if entry.fingerprint != fingerprint or entry.filepath != filepath: continue if start == end: - if entry.start == start and entry.end == end and entry.content == "": + entry_lines = entry.content.splitlines(keepends=True) + cached_end = entry.start + len(entry_lines) + if entry.start <= start <= cached_end: contents.append("") continue entry_lines = entry.content.splitlines(keepends=True) diff --git a/tests/test_nanocode_replace_range_tool.py b/tests/test_nanocode_replace_range_tool.py index a991581..e01ac55 100644 --- a/tests/test_nanocode_replace_range_tool.py +++ b/tests/test_nanocode_replace_range_tool.py @@ -387,19 +387,17 @@ def test_replace_range_tool_requires_boundary_context_for_insert_range(tmp_path) assert path.read_text(encoding="utf-8") == "alpha\ngamma\n" -def test_replace_range_tool_rejects_wide_fingerprint_for_empty_insert_range(tmp_path): +def test_replace_range_tool_accepts_wide_fingerprint_for_empty_insert_range_with_context(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt"]).call()) - path.write_text("zero\nalpha\nbeta\ngamma\n", encoding="utf-8") tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 1, fingerprint, "alpha\n", "beta\n", "INSERT\n")) + result = tool.call() - assert "# preview unavailable: fingerprint mismatch" in tool.preview() - with pytest.raises(ToolCallError, match=r"call Read\(filepath, 1, 1\)"): - tool.call() - assert path.read_text(encoding="utf-8") == "zero\nalpha\nbeta\ngamma\n" + assert "* range: 1:1" in result + assert path.read_text(encoding="utf-8") == "alpha\nINSERT\nbeta\ngamma\n" def test_replace_range_tool_rejects_no_change(tmp_path): From 4e3dc4fddd31d806bdc0572ae9ca0fcd9b1762b0 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 21:14:17 -0700 Subject: [PATCH 014/144] require verification before text completion --- nanocode.py | 4 ++++ tests/test_nanocode_agent.py | 19 +++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/nanocode.py b/nanocode.py index d936d2c..58a5bb3 100644 --- a/nanocode.py +++ b/nanocode.py @@ -6320,6 +6320,10 @@ def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallbac on_message(ctx.assistant_text) if self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start: return AgentRunResult() + if self.blackboard.verification_required or self.blackboard.verification.status == VerificationStatus.REQUIRED: + self._warn_agent("assistant text cannot finish while verification is required.", self.RULE_VERIFY_DIRECTLY) + self.blackboard.task_code = TaskCode.VERIFYING + return AgentRunResult() self.blackboard.task_code = TaskCode.DONE return AgentRunResult(done=True, value=ctx.response) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index c91333c..d6f7019 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2756,6 +2756,25 @@ def test_agent_reports_edit_verification_gate_in_debug(tmp_path): assert messages == ["Verification_Gate: edit completion requires verification."] +def test_agent_plain_text_cannot_finish_when_verification_required(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.blackboard.verification_required = True + agent.blackboard.verification.status = VerificationStatus.REQUIRED + agent.blackboard.task_code = nanocode.TaskCode.NEW + ctx = agent._build_response_context({"actions": [], "_assistant_text": "Done."}) + messages = [] + + result = agent._handle_text_response(ctx, messages.append) + + assert result is not None + assert result.done is False + assert agent.blackboard.task_code == nanocode.TaskCode.VERIFYING + assert agent.agent_feedback_errors == [ + 'Warning: assistant text cannot finish while verification is required. Rule: run verification tools, then report verify status="passed"|"failed"|"blocked".' + ] + assert messages == ["Done."] + + def test_agent_run_keeps_tool_results_when_format_retry_happens(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") From e52a0ad6c7952227ef3fc7539655423aa72fc631 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 21:29:05 -0700 Subject: [PATCH 015/144] add chat reasoning payload command --- README.md | 6 +++--- nanocode.py | 29 ++++++++++++++++++++++++++++- tests/test_nanocode_agent.py | 31 +++++++++++++++++++++++++++++-- tests/test_nanocode_commands.py | 24 ++++++++++++++++++++++++ tests/test_nanocode_loop.py | 3 +++ 5 files changed, 87 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index ae20cfe..c2b1a9d 100644 --- a/README.md +++ b/README.md @@ -87,11 +87,11 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Commands - Info: `/help [question]`, `/status`, `/rules`, `/knowledge`, `/compact`. -- Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. +- Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/reason-payload [value]`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. - Maintenance: `/clean`. - Exit: `/exit`, `/quit`. -Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/api responses` switches the current provider to Responses format. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model ` and `/reason` are direct shortcuts. +Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/api responses` switches the current provider to Responses format. `/reason-payload off` disables Chat reasoning payloads when a provider/model rejects them. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model ` and `/reason` are direct shortcuts. During a slow model request, press `Ctrl-G` to cancel that request and resend the same prompt. ## Configuration @@ -99,7 +99,7 @@ During a slow model request, press `Ctrl-G` to cancel that request and resend th Run `nanocode --init-config` to create `~/.nanocode/config.toml`. - Provider config: `[provider] active = ""` plus `[provider.]` url, key, model, `available_models`, and model options. `api` selects `chat`, `responses`, or `auto`; auto uses exact-host profiles. Responses uses standard `reasoning.effort`; Chat reasoning is mapped by provider/model profile when known. -- Provider auto-detection covers common providers: OpenAI/OpenRouter prefer Responses API; DeepSeek, OpenRouter/OpenCode, and DashScope models use their matching Chat reasoning payload shapes. +- Provider auto-detection covers common providers: OpenAI/OpenRouter prefer Responses API; DeepSeek, selected OpenCode models, and DashScope models use their matching Chat reasoning payload shapes. - Path config: `[paths] data_dir = "~/.nanocode"`. - Runtime config: `[runtime]`. - Session data: debug prompts and tool-result logs are stored under `~/.nanocode/sessions//`. diff --git a/nanocode.py b/nanocode.py index 58a5bb3..f638bb3 100644 --- a/nanocode.py +++ b/nanocode.py @@ -441,7 +441,7 @@ class ProviderProfile: chat_reasoning_rules=(ChatReasoningRule("reasoning_effort", ("o1", "o3", "o4", "gpt-5")),), ), "openrouter.ai": ProviderProfile(api="responses", chat_reasoning_payload="reasoning"), - "opencode.ai": ProviderProfile(chat_reasoning_payload="reasoning"), + "opencode.ai": ProviderProfile(chat_reasoning_rules=(ChatReasoningRule("reasoning", ("deepseek-v4",)),)), "api.deepseek.com": ProviderProfile(chat_reasoning_payload="thinking"), "dashscope.aliyuncs.com": ALIYUN_CHAT_PROFILE, "dashscope-intl.aliyuncs.com": ALIYUN_CHAT_PROFILE, @@ -6879,6 +6879,7 @@ class CommandSpec: CommandSpec("/api", "Show or set provider API format", "Config", "/api [auto|chat|responses]"), CommandSpec("/model", "Show or set model and reasoning", "Config", "/model [model_name]"), CommandSpec("/reason", "Set reasoning effort", "Config", "/reason"), + CommandSpec("/reason-payload", "Show or set chat reasoning payload", "Config", "/reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]"), CommandSpec("/provider", "Show or switch provider", "Config", "/provider [name]"), CommandSpec("/plan", "Toggle plan mode or ask for a readonly plan", "Config", "/plan [on|off|question]"), CommandSpec("/yolo", "Toggle yolo mode (skip confirmations)", "Config", "/yolo"), @@ -6894,6 +6895,7 @@ class CommandSpec: CONFIG_EFFORTS: tuple[str, ...] = ("minimal", "low", "medium", "high", "xhigh") +CHAT_REASONING_PAYLOAD_CHOICES: tuple[str, ...] = ("auto", "off", "reasoning", "reasoning_effort", "thinking", "enable_thinking") CONFIG_PROVIDER_ATTRS: dict[str, str] = { "provider.model": "model", "provider.reasoning": "reasoning", @@ -6963,6 +6965,7 @@ def __init__( "/clean": self._clean, "/model": self._model, "/reason": self._reason, + "/reason-payload": self._reason_payload, "/provider": self._provider, "/plan": self._plan, "/yolo": self._yolo, @@ -7101,6 +7104,24 @@ def _reason(self, args: str) -> str: return "No change" return self._apply_reasoning_choice(choice) + def _reason_payload(self, args: str) -> str: + value = args.strip() + provider = self.agent.session.config.provider + if not value: + configured = provider.chat_reasoning_payload or "off" + resolved = provider.resolved_chat_reasoning_payload() or "off" + return ( + "provider.chat_reasoning_payload: " + + configured + + "\nprovider.resolved_chat_reasoning_payload: " + + resolved + + "\nUsage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" + ) + if value not in CHAT_REASONING_PAYLOAD_CHOICES: + return "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" + provider.chat_reasoning_payload = "" if value == "off" else value + return "Set provider.chat_reasoning_payload = " + value + def _apply_reasoning_choice(self, choice: str) -> str: provider = self.agent.session.config.provider if choice == "off": @@ -8556,6 +8577,12 @@ def get_completions(self, document, complete_event): if value.startswith(text): yield Completion(value, start_position=-len(text)) return + if text.startswith("/reason-payload "): + text = text[len("/reason-payload ") :] + for value in CHAT_REASONING_PAYLOAD_CHOICES: + if value.startswith(text): + yield Completion(value, start_position=-len(text)) + return if text.startswith("/") and " " not in text: for spec in COMMANDS: if spec.name.startswith(text): diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index d6f7019..35575d4 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1519,7 +1519,7 @@ def test_agent_request_uses_configured_thinking_disabled_payload(tmp_path, monke def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp_path, monkeypatch): - calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, tuple(_chat_response() for _ in range(8))) + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, tuple(_chat_response() for _ in range(10))) Agent( _session( @@ -1586,6 +1586,26 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp stream=False, ) ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://opencode.ai/zen/go/v1", + api_key="key", + model="deepseek-v4-flash", + reasoning_effort="high", + stream=False, + ) + ).request("system", "user") + Agent( + _session( + tmp_path, + api_url="https://opencode.ai/zen/go/v1", + api_key="key", + model="kimi-k2.6", + reasoning_effort="high", + stream=False, + ) + ).request("system", "user") Agent( _session( tmp_path, @@ -1615,7 +1635,8 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp assert payloads[3]["reasoning_effort"] == "max" assert payloads[4] == {"model": "glm-5.1", "messages": [{"role": "system", "content": "system"}, {"role": "user", "content": "user"}], "stream": False} assert payloads[5]["reasoning_effort"] == "medium" - for payload in payloads[6:]: + assert payloads[6]["reasoning"] == {"effort": "high"} + for payload in payloads[7:]: assert "reasoning" not in payload assert "reasoning_effort" not in payload assert "thinking" not in payload @@ -1626,6 +1647,8 @@ def test_provider_config_auto_resolves_api_and_chat_reasoning_payload_from_profi openai_provider = nanocode.ProviderConfig.from_dict({"url": "https://api.openai.com/v1", "api": "auto"}) openai_reasoning_provider = nanocode.ProviderConfig.from_dict({"url": "https://api.openai.com/v1", "api": "chat", "model": "gpt-5"}) openrouter_provider = nanocode.ProviderConfig.from_dict({"url": "https://openrouter.ai/api/v1", "api": "auto"}) + opencode_deepseek_provider = nanocode.ProviderConfig.from_dict({"url": "https://opencode.ai/zen/go/v1", "api": "auto", "model": "deepseek-v4-flash"}) + opencode_kimi_provider = nanocode.ProviderConfig.from_dict({"url": "https://opencode.ai/zen/go/v1", "api": "auto", "model": "kimi-k2.6"}) dashscope_provider = nanocode.ProviderConfig.from_dict({"url": "https://dashscope.aliyuncs.com/compatible-mode/v1", "api": "auto", "model": "qwen3.6-plus"}) dashscope_deepseek_provider = nanocode.ProviderConfig.from_dict({"url": "https://dashscope.aliyuncs.com/compatible-mode/v1", "api": "auto", "model": "deepseek-v4-flash"}) unknown_provider = nanocode.ProviderConfig.from_dict({"url": "https://example.test/v1", "api": "auto"}) @@ -1636,6 +1659,10 @@ def test_provider_config_auto_resolves_api_and_chat_reasoning_payload_from_profi assert openai_reasoning_provider.resolved_chat_reasoning_payload() == "reasoning_effort" assert openrouter_provider.resolved_api() == "responses" assert openrouter_provider.resolved_chat_reasoning_payload() == "reasoning" + assert opencode_deepseek_provider.resolved_api() == "chat" + assert opencode_deepseek_provider.resolved_chat_reasoning_payload() == "reasoning" + assert opencode_kimi_provider.resolved_api() == "chat" + assert opencode_kimi_provider.resolved_chat_reasoning_payload() == "" assert dashscope_provider.resolved_api() == "chat" assert dashscope_provider.resolved_chat_reasoning_payload() == "enable_thinking" assert dashscope_deepseek_provider.resolved_api() == "chat" diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 7fd9ee3..0f28462 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -338,6 +338,30 @@ def test_reason_command_back_keeps_current_reasoning(tmp_path): assert session.config.provider.reasoning_effort == "medium" +def test_reason_payload_command_shows_and_sets_chat_payload(tmp_path): + session = make_session(tmp_path, model="old") + dispatcher = CommandDispatcher(Agent(session)) + + show_result = dispatcher.dispatch("/reason-payload") + off_result = dispatcher.dispatch("/reason-payload off") + reasoning_result = dispatcher.dispatch("/reason-payload reasoning") + auto_result = dispatcher.dispatch("/reason-payload auto") + bad_result = dispatcher.dispatch("/reason-payload bad") + + assert show_result.message == "\n".join( + [ + "provider.chat_reasoning_payload: auto", + "provider.resolved_chat_reasoning_payload: off", + "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]", + ] + ) + assert off_result.message == "Set provider.chat_reasoning_payload = off" + assert reasoning_result.message == "Set provider.chat_reasoning_payload = reasoning" + assert auto_result.message == "Set provider.chat_reasoning_payload = auto" + assert bad_result.message == "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" + assert session.config.provider.chat_reasoning_payload == "auto" + + def test_model_command_selects_from_available_models(tmp_path): session = make_session(tmp_path, model="old") session.config.provider.available_models = ("old", "new-model") diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index a5d9410..1a92b52 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -382,9 +382,11 @@ def test_agent_loop_command_completer_matches_slash_commands(): model_completions = list(nanocode.CommandCompleter(models=["qwen3", "deepseek"]).get_completions(Document("/model q"), CompleteEvent(completion_requested=True))) plan_completions = list(completer.get_completions(Document("/plan "), CompleteEvent(completion_requested=True))) api_completions = list(completer.get_completions(Document("/api r"), CompleteEvent(completion_requested=True))) + reason_payload_completions = list(completer.get_completions(Document("/reason-payload rea"), CompleteEvent(completion_requested=True))) assert "/help" in [completion.text for completion in slash_completions] assert "/api" in [completion.text for completion in slash_completions] + assert "/reason-payload" in [completion.text for completion in slash_completions] assert "/plan" in [completion.text for completion in slash_completions] assert "/config" in [completion.text for completion in config_completions] assert "provider.reasoning" in [completion.text for completion in set_key_completions] @@ -394,6 +396,7 @@ def test_agent_loop_command_completer_matches_slash_commands(): assert [completion.text for completion in model_completions] == ["qwen3"] assert [completion.text for completion in plan_completions] == ["on", "off"] assert [completion.text for completion in api_completions] == ["responses"] + assert [completion.text for completion in reason_payload_completions] == ["reasoning", "reasoning_effort"] def test_command_lexer_highlights_known_command_prefix_only(): From f901a92111cf1f6ae89591a8986403ddad4bc4f1 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 21:34:33 -0700 Subject: [PATCH 016/144] fix nullable enum tool schemas --- nanocode.py | 10 +++++----- tests/test_nanocode_agent.py | 18 ++++++++++++++++++ 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/nanocode.py b/nanocode.py index f638bb3..606ef4e 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3092,10 +3092,10 @@ def _content(self, item: ToolResultItem) -> str: "type": "array", "items": _tool_object_schema( { - "op": {"type": ["string", "null"], "enum": ["add", "update", "remove", None]}, + "op": {"type": ["string", "null"], "enum": ["add", "update", "remove"]}, "id": TOOL_NULLABLE_STRING_SCHEMA, "text": TOOL_NULLABLE_STRING_SCHEMA, - "status": {"type": ["string", "null"], "enum": [*ALL_PLAN_STATUSES, None]}, + "status": {"type": ["string", "null"], "enum": [*ALL_PLAN_STATUSES]}, "context": TOOL_NULLABLE_STRING_SCHEMA, }, [], @@ -3107,7 +3107,7 @@ def _content(self, item: ToolResultItem) -> str: { "id": TOOL_NULLABLE_STRING_SCHEMA, "text": TOOL_NULLABLE_STRING_SCHEMA, - "status": {"type": ["string", "null"], "enum": [*ALL_HYPOTHESIS_STATUSES, None]}, + "status": {"type": ["string", "null"], "enum": [*ALL_HYPOTHESIS_STATUSES]}, "source": TOOL_STRING_LIST_SCHEMA, "context": TOOL_NULLABLE_STRING_SCHEMA, }, @@ -3121,7 +3121,7 @@ def _content(self, item: ToolResultItem) -> str: "Set, update, or complete the current goal. Use work_mode=investigate for root-cause/debug work; use message_for_complete for the final user message.", { "text": TOOL_STRING_SCHEMA, - "work_mode": {"type": ["string", "null"], "enum": ["normal", "investigate", None]}, + "work_mode": {"type": ["string", "null"], "enum": ["normal", "investigate"]}, "complete": {"type": "boolean"}, "message_for_complete": TOOL_NULLABLE_STRING_SCHEMA, }, @@ -3148,7 +3148,7 @@ def _content(self, item: ToolResultItem) -> str: "method": TOOL_NULLABLE_STRING_SCHEMA, "criteria": TOOL_STRING_LIST_SCHEMA, "status": {"type": "string", "enum": ["passed", "failed", "blocked"]}, - "blocker": {"type": ["string", "null"], "enum": ["user", "environment", "tool", "unknown", None]}, + "blocker": {"type": ["string", "null"], "enum": ["user", "environment", "tool", "unknown"]}, "context": TOOL_NULLABLE_STRING_SCHEMA, }, ["kind", "method", "criteria", "status", "blocker", "context"], diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 35575d4..7cedde4 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1258,6 +1258,24 @@ def walk(value, path="schema"): walk(schema) +def test_function_tool_schemas_do_not_emit_null_enum_values(): + def walk(value, path="schema"): + if isinstance(value, dict): + enum = value.get("enum") + if isinstance(enum, list): + assert None not in enum, path + for key, child in value.items(): + walk(child, path + "." + str(key)) + elif isinstance(value, list): + for index, child in enumerate(value): + walk(child, path + "[" + str(index) + "]") + + state_schemas = [nanocode._state_tool_schema(name) for name in nanocode.STATE_TOOL_PARAMS] + repo_schemas = [tool.tool_schema() for tool in nanocode.TOOL_REGISTRY.values()] + for schema in [*state_schemas, *repo_schemas, nanocode.COMPACT_TOOL_SCHEMA]: + walk(schema) + + def test_agent_request_responses_api_parses_function_call(tmp_path, monkeypatch): _calls, response_calls, _client_kwargs = _patch_openai( monkeypatch, From 25bb1d6fdbb3ca14fc03be814733ca2d788174d7 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sun, 17 May 2026 23:39:19 -0700 Subject: [PATCH 017/144] Simplify provider reasoning configuration --- README.md | 2 +- nanocode.py | 153 +++++++++++++++++--------------- tests/test_nanocode_agent.py | 74 +++++++-------- tests/test_nanocode_commands.py | 46 +++++----- tests/test_nanocode_loop.py | 22 +++-- 5 files changed, 149 insertions(+), 148 deletions(-) diff --git a/README.md b/README.md index c2b1a9d..6b16913 100644 --- a/README.md +++ b/README.md @@ -91,7 +91,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. - Maintenance: `/clean`. - Exit: `/exit`, `/quit`. -Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/api responses` switches the current provider to Responses format. `/reason-payload off` disables Chat reasoning payloads when a provider/model rejects them. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model ` and `/reason` are direct shortcuts. +Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/api responses` switches the current provider to Responses format. `/reason` sets `provider.reasoning` to `off` or an effort value; `/reason-payload` controls the Chat-only reasoning payload shape. `/model` lists configured models before discovered ones, then prompts for reasoning. During a slow model request, press `Ctrl-G` to cancel that request and resend the same prompt. ## Configuration diff --git a/nanocode.py b/nanocode.py index 606ef4e..53be727 100644 --- a/nanocode.py +++ b/nanocode.py @@ -420,10 +420,15 @@ class ChatReasoningRule: @dataclass(frozen=True) class ProviderProfile: api: str = "chat" - chat_reasoning_payload: str = "" + chat_reasoning: str = "off" chat_reasoning_rules: tuple[ChatReasoningRule, ...] = () +REASONING_LEVELS: tuple[str, ...] = ("minimal", "low", "medium", "high", "xhigh") +REASONING_CHOICES: tuple[str, ...] = ("off", *REASONING_LEVELS) +CHAT_REASONING_CHOICES: tuple[str, ...] = ("auto", "off", "reasoning", "reasoning_effort", "thinking", "enable_thinking") + + ALIYUN_CHAT_PROFILE = ProviderProfile( chat_reasoning_rules=( ChatReasoningRule("enable_thinking", ("qwen", "qwq", "qvq")), @@ -440,9 +445,9 @@ class ProviderProfile: api="responses", chat_reasoning_rules=(ChatReasoningRule("reasoning_effort", ("o1", "o3", "o4", "gpt-5")),), ), - "openrouter.ai": ProviderProfile(api="responses", chat_reasoning_payload="reasoning"), + "openrouter.ai": ProviderProfile(api="responses", chat_reasoning="reasoning"), "opencode.ai": ProviderProfile(chat_reasoning_rules=(ChatReasoningRule("reasoning", ("deepseek-v4",)),)), - "api.deepseek.com": ProviderProfile(chat_reasoning_payload="thinking"), + "api.deepseek.com": ProviderProfile(chat_reasoning="thinking"), "dashscope.aliyuncs.com": ALIYUN_CHAT_PROFILE, "dashscope-intl.aliyuncs.com": ALIYUN_CHAT_PROFILE, "dashscope-us.aliyuncs.com": ALIYUN_CHAT_PROFILE, @@ -476,9 +481,8 @@ class ProviderConfig: api: str = "auto" available_models: tuple[str, ...] = () temperature: float | None = None - reasoning: bool | None = True - reasoning_effort: str = "medium" - chat_reasoning_payload: str = "auto" + reasoning: str = "medium" + chat_reasoning: str = "auto" stream: bool | None = True timeout: int | None = 180 first_token_timeout: int | None = 90 @@ -493,9 +497,8 @@ def from_dict(cls, data: Json) -> "ProviderConfig": api=cls._api(data, defaults.api), available_models=Config.str_tuple(data, "available_models"), temperature=Config.float(data, "temperature", defaults.temperature), - reasoning=Config.bool(data, "reasoning", defaults.reasoning), - reasoning_effort=Config.str(data, "reasoning_effort", defaults.reasoning_effort), - chat_reasoning_payload=cls._chat_reasoning_payload(data, defaults.chat_reasoning_payload), + reasoning=cls._reasoning(data, defaults.reasoning), + chat_reasoning=cls._chat_reasoning(data, defaults.chat_reasoning), stream=Config.bool(data, "stream", defaults.stream), timeout=Config.int(data, "timeout", defaults.timeout), first_token_timeout=Config.int(data, "first_token_timeout", defaults.first_token_timeout), @@ -509,23 +512,30 @@ def _api(cls, data: Json, default: str) -> str: return value @classmethod - def _chat_reasoning_payload(cls, data: Json, default: str) -> str: - value = Config.str(data, "chat_reasoning_payload", default) - if value not in ("auto", "", "reasoning", "reasoning_effort", "thinking", "enable_thinking"): - raise ConfigError("config provider.chat_reasoning_payload must be one of: auto, reasoning, reasoning_effort, thinking, enable_thinking, empty") + def _reasoning(cls, data: Json, default: str) -> str: + value = Config.str(data, "reasoning", default) + if value not in REASONING_CHOICES: + raise ConfigError("config provider.reasoning must be one of: " + ", ".join(REASONING_CHOICES)) + return value + + @classmethod + def _chat_reasoning(cls, data: Json, default: str) -> str: + value = Config.str(data, "chat_reasoning", default) + if value not in CHAT_REASONING_CHOICES: + raise ConfigError("config provider.chat_reasoning must be one of: " + ", ".join(CHAT_REASONING_CHOICES)) return value - def resolved_chat_reasoning_payload(self) -> str: - if self.chat_reasoning_payload != "auto": - return self.chat_reasoning_payload + def resolved_chat_reasoning(self) -> str: + if self.chat_reasoning != "auto": + return self.chat_reasoning profile = PROVIDER_PROFILES.get(self.host()) if not profile: - return "" + return "off" model = self.model.lower() for rule in profile.chat_reasoning_rules: if any(model.startswith(prefix) for prefix in rule.model_prefixes): return rule.payload - return profile.chat_reasoning_payload + return profile.chat_reasoning def host(self) -> str: return (urlparse(self.url).hostname or "").lower() @@ -707,15 +717,14 @@ class ConfigFile: # /model choices above automatically discovered provider models. # Optional. Uncomment only for models/providers that support temperature. # temperature = 0.7 -reasoning = true -reasoning_effort = "medium" +reasoning = "medium" # Optional advanced override. Chat Completions reasoning shape is auto-detected # by provider/model profile where nanocode knows the provider. Responses API # always uses the standard reasoning.effort payload. -# chat_reasoning_payload = "reasoning" sends {"reasoning":{"effort":...}} -# chat_reasoning_payload = "reasoning_effort" sends a top-level effort. -# chat_reasoning_payload = "thinking" sends {"thinking":{"type":"enabled/disabled"}, "reasoning_effort":"high/max"}. -# chat_reasoning_payload = "enable_thinking" sends enable_thinking plus a budget mapped from effort. +# chat_reasoning = "reasoning" sends {"reasoning":{"effort":...}} +# chat_reasoning = "reasoning_effort" sends a top-level effort. +# chat_reasoning = "thinking" sends {"thinking":{"type":"enabled/disabled"}, "reasoning_effort":"high/max"}. +# chat_reasoning = "enable_thinking" sends enable_thinking plus a budget mapped from effort. stream = true timeout = 180 # Stream mode only: retry if no first content token arrives within this many seconds. @@ -3762,7 +3771,7 @@ def request( with ModelRetryShortcut(self.session): self.session.state.current_model_call_started_at = time.monotonic() self.session.state.current_model_call_label = model - self.session.state.current_model_call_reasoning_label = config.reasoning_effort if config.reasoning else "off" + self.session.state.current_model_call_reasoning_label = config.reasoning self.session.state.current_model_call_activity = activity self.session.state.current_model_call_has_content = False self.session.state.current_model_call_streaming_chars = 0 @@ -3883,7 +3892,7 @@ def _client(self, config: ProviderConfig, *, timeout: int) -> OpenAI: @staticmethod def _reasoning_effort(config: ProviderConfig) -> str: - return config.reasoning_effort or "medium" + return config.reasoning if config.reasoning in REASONING_LEVELS else "medium" def _chat_completion_params( self, @@ -3905,18 +3914,19 @@ def _chat_completion_params( params["tools"] = tool_schemas params["tool_choice"] = {"type": "function", "function": {"name": required_tool}} if required_tool else "auto" params["parallel_tool_calls"] = True - chat_reasoning_payload = config.resolved_chat_reasoning_payload() - if config.reasoning is not False and chat_reasoning_payload == "reasoning": + chat_reasoning = config.resolved_chat_reasoning() + reasoning_enabled = config.reasoning != "off" + if reasoning_enabled and chat_reasoning == "reasoning": extra_body["reasoning"] = {"effort": self._reasoning_effort(config)} - if config.reasoning is not False and chat_reasoning_payload == "reasoning_effort": + if reasoning_enabled and chat_reasoning == "reasoning_effort": params["reasoning_effort"] = self._reasoning_effort(config) - if chat_reasoning_payload == "thinking": - extra_body["thinking"] = {"type": "enabled" if config.reasoning is not False else "disabled"} - if config.reasoning is not False: + if chat_reasoning == "thinking": + extra_body["thinking"] = {"type": "enabled" if reasoning_enabled else "disabled"} + if reasoning_enabled: params["reasoning_effort"] = DEEPSEEK_REASONING_EFFORT_BY_EFFORT.get(self._reasoning_effort(config), "high") - if chat_reasoning_payload == "enable_thinking": - extra_body["enable_thinking"] = config.reasoning is not False - if config.reasoning is not False: + if chat_reasoning == "enable_thinking": + extra_body["enable_thinking"] = reasoning_enabled + if reasoning_enabled: extra_body["thinking_budget"] = ALIYUN_THINKING_BUDGET_BY_EFFORT.get(self._reasoning_effort(config), ALIYUN_THINKING_BUDGET_BY_EFFORT["medium"]) if extra_body: params["extra_body"] = extra_body @@ -4200,7 +4210,7 @@ def _responses_params( params["parallel_tool_calls"] = True if config.temperature is not None: params["temperature"] = config.temperature - if config.reasoning is not False: + if config.reasoning != "off": effort = self._reasoning_effort(config) params["reasoning"] = {"effort": "high" if effort in ("max", "xhigh") else effort} return params @@ -6894,12 +6904,10 @@ class CommandSpec: ############################ -CONFIG_EFFORTS: tuple[str, ...] = ("minimal", "low", "medium", "high", "xhigh") -CHAT_REASONING_PAYLOAD_CHOICES: tuple[str, ...] = ("auto", "off", "reasoning", "reasoning_effort", "thinking", "enable_thinking") CONFIG_PROVIDER_ATTRS: dict[str, str] = { "provider.model": "model", "provider.reasoning": "reasoning", - "provider.effort": "reasoning_effort", + "provider.chat_reasoning": "chat_reasoning", "provider.stream": "stream", "provider.temperature": "temperature", "provider.timeout": "timeout", @@ -6915,13 +6923,13 @@ class CommandSpec: } CONFIG_SET_KEYS: tuple[str, ...] = tuple(CONFIG_PROVIDER_ATTRS) + tuple(CONFIG_RUNTIME_ATTRS) CONFIG_VALUE_COMPLETIONS: dict[str, tuple[str, ...]] = { - "provider.reasoning": ("on", "off"), - "provider.effort": CONFIG_EFFORTS, + "provider.reasoning": REASONING_CHOICES, + "provider.chat_reasoning": CHAT_REASONING_CHOICES, "provider.stream": ("on", "off"), "provider.temperature": ("off",), "runtime.yolo": ("on", "off"), } -CONFIG_BOOL_KEYS: set[str] = {"provider.reasoning", "provider.stream", "runtime.yolo"} +CONFIG_BOOL_KEYS: set[str] = {"provider.stream", "runtime.yolo"} CONFIG_INT_KEYS: set[str] = { "provider.timeout", "provider.first_token_timeout", @@ -7108,30 +7116,26 @@ def _reason_payload(self, args: str) -> str: value = args.strip() provider = self.agent.session.config.provider if not value: - configured = provider.chat_reasoning_payload or "off" - resolved = provider.resolved_chat_reasoning_payload() or "off" + configured = provider.chat_reasoning or "off" + resolved = provider.resolved_chat_reasoning() or "off" return ( - "provider.chat_reasoning_payload: " + "provider.chat_reasoning: " + configured - + "\nprovider.resolved_chat_reasoning_payload: " + + "\nprovider.resolved_chat_reasoning: " + resolved + "\nUsage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" ) - if value not in CHAT_REASONING_PAYLOAD_CHOICES: + if value not in CHAT_REASONING_CHOICES: return "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" - provider.chat_reasoning_payload = "" if value == "off" else value - return "Set provider.chat_reasoning_payload = " + value + provider.chat_reasoning = value + return "Set provider.chat_reasoning = " + value def _apply_reasoning_choice(self, choice: str) -> str: provider = self.agent.session.config.provider - if choice == "off": - provider.reasoning = False - return "Set provider.reasoning = off" - if choice not in CONFIG_EFFORTS: - return "Invalid reasoning effort: " + choice - provider.reasoning = True - provider.reasoning_effort = choice - return "Set provider.reasoning = on\nSet provider.effort = " + choice + if choice not in REASONING_CHOICES: + return "Invalid reasoning: " + choice + provider.reasoning = choice + return "Set provider.reasoning = " + choice def _provider(self, args: str) -> str: name = args.strip() @@ -7257,10 +7261,9 @@ def _config(self, args: str) -> str: "provider.model: " + (provider_config.model or "(empty)"), "provider.api: " + provider_config.api, "provider.available_models: " + (", ".join(provider_config.available_models) or "(empty)"), - "provider.reasoning: " + self._format_bool(provider_config.reasoning), - "provider.effort: " + (provider_config.reasoning_effort or "(empty)"), - "provider.chat_reasoning_payload: " + (provider_config.chat_reasoning_payload or "(empty)"), - "provider.resolved_chat_reasoning_payload: " + (provider_config.resolved_chat_reasoning_payload() or "(empty)"), + "provider.reasoning: " + provider_config.reasoning, + "provider.chat_reasoning: " + (provider_config.chat_reasoning or "(empty)"), + "provider.resolved_chat_reasoning: " + (provider_config.resolved_chat_reasoning() or "(empty)"), "provider.stream: " + self._format_bool(provider_config.stream), "provider.temperature: " + self._format_optional(provider_config.temperature), "provider.timeout: " + self._format_optional(provider_config.timeout), @@ -7334,9 +7337,14 @@ def _apply_config_value(self, key: str, value: str) -> str: return "Usage: /set " + key + " [on|off]" setattr(target, attr, value == "on") return "" - if key == "provider.effort": - if value not in CONFIG_EFFORTS: - return "Usage: /set " + key + " [" + "|".join(CONFIG_EFFORTS) + "]" + if key == "provider.reasoning": + if value not in REASONING_CHOICES: + return "Usage: /set " + key + " [" + "|".join(REASONING_CHOICES) + "]" + setattr(target, attr, value) + return "" + if key == "provider.chat_reasoning": + if value not in CHAT_REASONING_CHOICES: + return "Usage: /set " + key + " [" + "|".join(CHAT_REASONING_CHOICES) + "]" setattr(target, attr, value) return "" if key == "provider.temperature": @@ -7386,12 +7394,11 @@ def _format_bool(self, value: bool | None) -> str: return "(fallback)" if value is None else ("on" if value else "off") def _format_provider_reasoning(self, provider: ProviderConfig) -> str: - if provider.reasoning is False: + if provider.reasoning == "off": return "off" - effort = provider.reasoning_effort or "medium" if provider.resolved_api() != "chat": - return effort - return effort + "(" + (provider.resolved_chat_reasoning_payload() or "no-payload") + ")" + return provider.reasoning + return provider.reasoning + "(" + provider.resolved_chat_reasoning() + ")" def _format_optional(self, value: object) -> str: return str(value) if value is not None else "(fallback)" @@ -7496,7 +7503,7 @@ def _format_line(self, turn_elapsed: float, *, now: float, show_elapsed: bool) - active_model = session.state.current_model_call_label or session.config.provider.model model = active_model.rsplit("/", 1)[-1] or active_model or "(no model)" reasoning = session.state.current_model_call_reasoning_label or ( - session.config.provider.reasoning_effort if session.config.provider.reasoning else "off" + session.config.provider.reasoning ) modes = "".join(" | " + label for label, enabled in (("yolo", session.settings.yolo), ("plan", session.settings.plan_mode)) if enabled) context = str(len(session.state.conversation)) + "/" + str(session.settings.compact_at) @@ -7997,13 +8004,13 @@ def _select_provider(self, providers: tuple[str, ...], current_provider: str) -> def _select_reasoning(self) -> SelectionResult: provider = self.agent.session.config.provider - current = provider.reasoning_effort if provider.reasoning else "off" + current = provider.reasoning labels = {"off": "off - disable reasoning"} if current == "off": labels["off"] = "off - disable reasoning (current)" - elif current in CONFIG_EFFORTS: + elif current in REASONING_LEVELS: labels[current] = current + " (current)" - return self._select_choice("Reasoning effort", ("off", *CONFIG_EFFORTS), labels, current=current) + return self._select_choice("Reasoning effort", REASONING_CHOICES, labels, current=current) def _discard_pending_tty_input(self) -> None: if not sys.stdin.isatty(): @@ -8579,7 +8586,7 @@ def get_completions(self, document, complete_event): return if text.startswith("/reason-payload "): text = text[len("/reason-payload ") :] - for value in CHAT_REASONING_PAYLOAD_CHOICES: + for value in CHAT_REASONING_CHOICES: if value.startswith(text): yield Completion(value, start_position=-len(text)) return diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 7cedde4..4e96ea5 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -34,8 +34,8 @@ def _session( timeout: int | None = None, first_token_timeout: int | None = None, temperature: float | None = None, - reasoning_effort: str = "", - chat_reasoning_payload: str = "", + reasoning: str = "", + chat_reasoning: str = "", yolo: bool = False, plan_mode: bool = False, debug: bool = False, @@ -52,10 +52,10 @@ def _session( provider["first_token_timeout"] = first_token_timeout if temperature is not None: provider["temperature"] = temperature - if reasoning_effort: - provider["reasoning_effort"] = reasoning_effort - if chat_reasoning_payload: - provider["chat_reasoning_payload"] = chat_reasoning_payload + if reasoning: + provider["reasoning"] = reasoning + if chat_reasoning: + provider["chat_reasoning"] = chat_reasoning data = {"provider": {"active": "default", "default": provider}, "paths": {"data_dir": str(tmp_path / ".nanocode")}} return Session( cwd=str(tmp_path), @@ -971,7 +971,7 @@ def model_dump(self, mode="json"): model="model", api="responses", stream=False, - reasoning_effort="high", + reasoning="high", ) response = Agent(session).request("system", "user") @@ -992,7 +992,7 @@ def model_dump(self, mode="json"): def test_agent_request_responses_api_omits_reasoning_when_disabled(tmp_path, monkeypatch): calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, _responses_response()) session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses", stream=False) - session.config.provider.reasoning = False + session.config.provider.reasoning = "off" Agent(session).request("system", "user") payload = _sdk_payload(response_calls[0]) @@ -1459,15 +1459,15 @@ def stream(): assert sleeps == [3, 10, 20, 30, 60, 120] -def test_agent_request_uses_configured_chat_reasoning_payload(tmp_path, monkeypatch): +def test_agent_request_uses_configured_chat_reasoning(tmp_path, monkeypatch): calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) session = _session( tmp_path, api_url="https://example.test/v1", api_key="key", model="model", - reasoning_effort="high", - chat_reasoning_payload="reasoning", + reasoning="high", + chat_reasoning="reasoning", stream=False, ) @@ -1485,8 +1485,8 @@ def test_agent_request_uses_configured_reasoning_effort_payload(tmp_path, monkey api_url="https://example.test/v1", api_key="key", model="model", - reasoning_effort="high", - chat_reasoning_payload="reasoning_effort", + reasoning="high", + chat_reasoning="reasoning_effort", stream=False, ) @@ -1504,8 +1504,8 @@ def test_agent_request_uses_configured_thinking_payload(tmp_path, monkeypatch): api_url="https://example.test/v1", api_key="key", model="model", - reasoning_effort="xhigh", - chat_reasoning_payload="thinking", + reasoning="xhigh", + chat_reasoning="thinking", stream=False, ) @@ -1524,10 +1524,10 @@ def test_agent_request_uses_configured_thinking_disabled_payload(tmp_path, monke api_url="https://example.test/v1", api_key="key", model="model", - chat_reasoning_payload="thinking", + chat_reasoning="thinking", stream=False, ) - session.config.provider.reasoning = False + session.config.provider.reasoning = "off" Agent(session).request("system", "user") payload = _sdk_payload(calls[0]) @@ -1536,7 +1536,7 @@ def test_agent_request_uses_configured_thinking_disabled_payload(tmp_path, monke assert "reasoning_effort" not in payload -def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp_path, monkeypatch): +def test_agent_request_auto_detects_chat_reasoning_from_provider_url(tmp_path, monkeypatch): calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, tuple(_chat_response() for _ in range(10))) Agent( @@ -1545,7 +1545,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp api_url="https://api.deepseek.com", api_key="key", model="model", - reasoning_effort="xhigh", + reasoning="xhigh", stream=False, ) ).request("system", "user") @@ -1556,7 +1556,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp api_key="key", model="model", api="chat", - reasoning_effort="high", + reasoning="high", stream=False, ) ).request("system", "user") @@ -1567,7 +1567,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp api_key="key", model="qwen3.6-plus", api="chat", - reasoning_effort="high", + reasoning="high", stream=False, ) ).request("system", "user") @@ -1578,7 +1578,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp api_key="key", model="deepseek-v4-flash", api="chat", - reasoning_effort="xhigh", + reasoning="xhigh", stream=False, ) ).request("system", "user") @@ -1589,7 +1589,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp api_key="key", model="glm-5.1", api="chat", - reasoning_effort="high", + reasoning="high", stream=False, ) ).request("system", "user") @@ -1600,7 +1600,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp api_key="key", model="gpt-5", api="chat", - reasoning_effort="medium", + reasoning="medium", stream=False, ) ).request("system", "user") @@ -1610,7 +1610,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp api_url="https://opencode.ai/zen/go/v1", api_key="key", model="deepseek-v4-flash", - reasoning_effort="high", + reasoning="high", stream=False, ) ).request("system", "user") @@ -1620,7 +1620,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp api_url="https://opencode.ai/zen/go/v1", api_key="key", model="kimi-k2.6", - reasoning_effort="high", + reasoning="high", stream=False, ) ).request("system", "user") @@ -1661,7 +1661,7 @@ def test_agent_request_auto_detects_chat_reasoning_payload_from_provider_url(tmp assert "enable_thinking" not in payload -def test_provider_config_auto_resolves_api_and_chat_reasoning_payload_from_profiles(): +def test_provider_config_auto_resolves_api_and_chat_reasoning_from_profiles(): openai_provider = nanocode.ProviderConfig.from_dict({"url": "https://api.openai.com/v1", "api": "auto"}) openai_reasoning_provider = nanocode.ProviderConfig.from_dict({"url": "https://api.openai.com/v1", "api": "chat", "model": "gpt-5"}) openrouter_provider = nanocode.ProviderConfig.from_dict({"url": "https://openrouter.ai/api/v1", "api": "auto"}) @@ -1672,24 +1672,24 @@ def test_provider_config_auto_resolves_api_and_chat_reasoning_payload_from_profi unknown_provider = nanocode.ProviderConfig.from_dict({"url": "https://example.test/v1", "api": "auto"}) assert openai_provider.resolved_api() == "responses" - assert openai_provider.resolved_chat_reasoning_payload() == "" + assert openai_provider.resolved_chat_reasoning() == "off" assert openai_reasoning_provider.resolved_api() == "chat" - assert openai_reasoning_provider.resolved_chat_reasoning_payload() == "reasoning_effort" + assert openai_reasoning_provider.resolved_chat_reasoning() == "reasoning_effort" assert openrouter_provider.resolved_api() == "responses" - assert openrouter_provider.resolved_chat_reasoning_payload() == "reasoning" + assert openrouter_provider.resolved_chat_reasoning() == "reasoning" assert opencode_deepseek_provider.resolved_api() == "chat" - assert opencode_deepseek_provider.resolved_chat_reasoning_payload() == "reasoning" + assert opencode_deepseek_provider.resolved_chat_reasoning() == "reasoning" assert opencode_kimi_provider.resolved_api() == "chat" - assert opencode_kimi_provider.resolved_chat_reasoning_payload() == "" + assert opencode_kimi_provider.resolved_chat_reasoning() == "off" assert dashscope_provider.resolved_api() == "chat" - assert dashscope_provider.resolved_chat_reasoning_payload() == "enable_thinking" + assert dashscope_provider.resolved_chat_reasoning() == "enable_thinking" assert dashscope_deepseek_provider.resolved_api() == "chat" - assert dashscope_deepseek_provider.resolved_chat_reasoning_payload() == "thinking" + assert dashscope_deepseek_provider.resolved_chat_reasoning() == "thinking" assert unknown_provider.resolved_api() == "chat" - assert unknown_provider.resolved_chat_reasoning_payload() == "" + assert unknown_provider.resolved_chat_reasoning() == "off" -def test_agent_request_empty_chat_reasoning_payload_disables_auto_detection(tmp_path, monkeypatch): +def test_agent_request_off_chat_reasoning_disables_auto_detection(tmp_path, monkeypatch): calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response()) session = _session( tmp_path, @@ -1698,7 +1698,7 @@ def test_agent_request_empty_chat_reasoning_payload_disables_auto_detection(tmp_ model="model", stream=False, ) - session.config.provider.chat_reasoning_payload = "" + session.config.provider.chat_reasoning = "off" Agent(session).request("system", "user") payload = _sdk_payload(calls[0]) diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 0f28462..d78ca81 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -56,8 +56,8 @@ def test_command_dispatcher_updates_config_and_auto_compacts(tmp_path): session.state.conversation = [UserMessage(content="one"), UserMessage(content="two"), UserMessage(content="three")] model_result = dispatcher.dispatch("/set provider.model new-model") - effort_result = dispatcher.dispatch("/set provider.effort high") - reason_result = dispatcher.dispatch("/set provider.reasoning off") + reason_result = dispatcher.dispatch("/set provider.reasoning high") + chat_reasoning_result = dispatcher.dispatch("/set provider.chat_reasoning reasoning") stream_result = dispatcher.dispatch("/set provider.stream off") first_token_result = dispatcher.dispatch("/set provider.first_token_timeout 6") yolo_result = dispatcher.dispatch("/set runtime.yolo on") @@ -66,10 +66,10 @@ def test_command_dispatcher_updates_config_and_auto_compacts(tmp_path): assert model_result.status == CommandStatus.HANDLED assert session.config.provider.model == "new-model" - assert effort_result.message == "Set provider.effort = high" - assert session.config.provider.reasoning_effort == "high" - assert reason_result.message == "Set provider.reasoning = off" - assert session.config.provider.reasoning is False + assert reason_result.message == "Set provider.reasoning = high" + assert session.config.provider.reasoning == "high" + assert chat_reasoning_result.message == "Set provider.chat_reasoning = reasoning" + assert session.config.provider.chat_reasoning == "reasoning" assert stream_result.message == "Set provider.stream = off" assert session.config.provider.stream is False assert first_token_result.message == "Set provider.first_token_timeout = 6" @@ -94,7 +94,7 @@ def test_status_reports_tokens_in_human_readable_format(tmp_path): assert result.status == CommandStatus.HANDLED assert "tokens: last=1k session=2m" in result.message - assert "model: model api=chat(auto) reasoning=medium(no-payload) stream=on" in result.message + assert "model: model api=chat(auto) reasoning=medium(off) stream=on" in result.message assert "session: " + session.session_id in result.message assert "runtime: yolo=off plan=off compact_at=50" in result.message assert "models:" in result.message @@ -250,10 +250,9 @@ def test_model_command_can_select_reasoning_effort(tmp_path): result = dispatcher.dispatch("/model new-model") - assert result.message == "Set provider.model = new-model\nSet provider.reasoning = on\nSet provider.effort = high" + assert result.message == "Set provider.model = new-model\nSet provider.reasoning = high" assert session.config.provider.model == "new-model" - assert session.config.provider.reasoning is True - assert session.config.provider.reasoning_effort == "high" + assert session.config.provider.reasoning == "high" def test_api_command_shows_and_sets_provider_api(tmp_path): @@ -282,7 +281,7 @@ def test_model_command_can_disable_reasoning(tmp_path): assert result.message == "Set provider.model = new-model\nSet provider.reasoning = off" assert session.config.provider.model == "new-model" - assert session.config.provider.reasoning is False + assert session.config.provider.reasoning == "off" def test_model_command_reasoning_back_cancels_direct_model_change(tmp_path): @@ -308,10 +307,9 @@ def test_model_command_reasoning_back_returns_to_model_selection(tmp_path): result = dispatcher.dispatch("/model") - assert result.message == "Set provider.model = second\nSet provider.reasoning = on\nSet provider.effort = high" + assert result.message == "Set provider.model = second\nSet provider.reasoning = high" assert session.config.provider.model == "second" - assert session.config.provider.reasoning is True - assert session.config.provider.reasoning_effort == "high" + assert session.config.provider.reasoning == "high" def test_reason_command_selects_reasoning_effort(tmp_path): @@ -321,10 +319,9 @@ def test_reason_command_selects_reasoning_effort(tmp_path): result = dispatcher.dispatch("/reason") usage_result = dispatcher.dispatch("/reason high") - assert result.message == "Set provider.reasoning = on\nSet provider.effort = high" + assert result.message == "Set provider.reasoning = high" assert usage_result.message == "Usage: /reason" - assert session.config.provider.reasoning is True - assert session.config.provider.reasoning_effort == "high" + assert session.config.provider.reasoning == "high" def test_reason_command_back_keeps_current_reasoning(tmp_path): @@ -334,8 +331,7 @@ def test_reason_command_back_keeps_current_reasoning(tmp_path): result = dispatcher.dispatch("/reason") assert result.message == "No change" - assert session.config.provider.reasoning is True - assert session.config.provider.reasoning_effort == "medium" + assert session.config.provider.reasoning == "medium" def test_reason_payload_command_shows_and_sets_chat_payload(tmp_path): @@ -350,16 +346,16 @@ def test_reason_payload_command_shows_and_sets_chat_payload(tmp_path): assert show_result.message == "\n".join( [ - "provider.chat_reasoning_payload: auto", - "provider.resolved_chat_reasoning_payload: off", + "provider.chat_reasoning: auto", + "provider.resolved_chat_reasoning: off", "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]", ] ) - assert off_result.message == "Set provider.chat_reasoning_payload = off" - assert reasoning_result.message == "Set provider.chat_reasoning_payload = reasoning" - assert auto_result.message == "Set provider.chat_reasoning_payload = auto" + assert off_result.message == "Set provider.chat_reasoning = off" + assert reasoning_result.message == "Set provider.chat_reasoning = reasoning" + assert auto_result.message == "Set provider.chat_reasoning = auto" assert bad_result.message == "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" - assert session.config.provider.chat_reasoning_payload == "auto" + assert session.config.provider.chat_reasoning == "auto" def test_model_command_selects_from_available_models(tmp_path): diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 1a92b52..322f6c0 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -79,7 +79,8 @@ def test_init_config_file_writes_default_toml(tmp_path): assert config["provider"]["default"]["url"] == "" assert "available_models" not in config["provider"]["default"] assert "temperature" not in config["provider"]["default"] - assert "chat_reasoning_payload" not in config["provider"]["default"] + assert config["provider"]["default"]["reasoning"] == "medium" + assert "chat_reasoning" not in config["provider"]["default"] assert config["provider"]["default"]["timeout"] == 180 assert config["provider"]["default"]["first_token_timeout"] == 90 assert config["runtime"]["compact_at"] == 50 @@ -376,8 +377,8 @@ def test_agent_loop_command_completer_matches_slash_commands(): slash_completions = list(completer.get_completions(Document("/"), CompleteEvent(completion_requested=True))) config_completions = list(completer.get_completions(Document("/con"), CompleteEvent(completion_requested=True))) set_key_completions = list(completer.get_completions(Document("/set provider."), CompleteEvent(completion_requested=True))) - set_bool_completions = list(completer.get_completions(Document("/set provider.reasoning "), CompleteEvent(completion_requested=True))) - set_effort_completions = list(completer.get_completions(Document("/set provider.effort h"), CompleteEvent(completion_requested=True))) + set_reasoning_completions = list(completer.get_completions(Document("/set provider.reasoning h"), CompleteEvent(completion_requested=True))) + set_chat_reasoning_completions = list(completer.get_completions(Document("/set provider.chat_reasoning rea"), CompleteEvent(completion_requested=True))) set_plan_timeout_completions = list(completer.get_completions(Document("/set runtime.plan_"), CompleteEvent(completion_requested=True))) model_completions = list(nanocode.CommandCompleter(models=["qwen3", "deepseek"]).get_completions(Document("/model q"), CompleteEvent(completion_requested=True))) plan_completions = list(completer.get_completions(Document("/plan "), CompleteEvent(completion_requested=True))) @@ -390,8 +391,8 @@ def test_agent_loop_command_completer_matches_slash_commands(): assert "/plan" in [completion.text for completion in slash_completions] assert "/config" in [completion.text for completion in config_completions] assert "provider.reasoning" in [completion.text for completion in set_key_completions] - assert [completion.text for completion in set_bool_completions] == ["on", "off"] - assert [completion.text for completion in set_effort_completions] == ["high"] + assert [completion.text for completion in set_reasoning_completions] == ["high"] + assert [completion.text for completion in set_chat_reasoning_completions] == ["reasoning", "reasoning_effort"] assert {completion.text for completion in set_plan_timeout_completions} == {"runtime.plan_timeout", "runtime.plan_first_token_timeout"} assert [completion.text for completion in model_completions] == ["qwen3"] assert [completion.text for completion in plan_completions] == ["on", "off"] @@ -533,7 +534,7 @@ def run(self, user_input, *, confirm=None, on_auto_approve=None, on_message=None assert result == 0 assert any("nanocode - AI coding assistant" in output for output in outputs) - assert any("model: model api=chat(auto) reasoning=medium(no-payload) stream=on" in output for output in outputs) + assert any("model: model api=chat(auto) reasoning=medium(off) stream=on" in output for output in outputs) assert "assistant response" in outputs assert loop.agent.runs == ["hello"] @@ -548,8 +549,7 @@ def __init__(self): assert loop.run() == 0 assert loop.agent.session.config.provider.model == "new-model" - assert loop.agent.session.config.provider.reasoning is True - assert loop.agent.session.config.provider.reasoning_effort == "high" + assert loop.agent.session.config.provider.reasoning == "high" def test_agent_loop_model_command_prompts_for_model_when_available(tmp_path): @@ -588,16 +588,14 @@ def test_agent_loop_model_command_can_keep_reasoning_effort(tmp_path): class FakeAgent: def __init__(self): self.session = make_session(tmp_path, model="old") - self.session.config.provider.reasoning = False - self.session.config.provider.reasoning_effort = "xhigh" + self.session.config.provider.reasoning = "xhigh" inputs = iter(["/model new-model", "", "/exit"]) loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: next(inputs), output_fn=lambda message: None) assert loop.run() == 0 assert loop.agent.session.config.provider.model == "new-model" - assert loop.agent.session.config.provider.reasoning is False - assert loop.agent.session.config.provider.reasoning_effort == "xhigh" + assert loop.agent.session.config.provider.reasoning == "xhigh" def test_agent_loop_choice_prompt_styles_selected_effort_and_erases_when_done(tmp_path, monkeypatch): From cbf3f249b463cf4bd03faf12229143ed7e75d00d Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 00:05:13 -0700 Subject: [PATCH 018/144] Clean up agent and toolcall compatibility code --- nanocode.py | 442 +++++++--------------- tests/test_nanocode_agent.py | 225 +++++------ tests/test_nanocode_commands.py | 2 +- tests/test_nanocode_compactor.py | 2 +- tests/test_nanocode_read_tool.py | 42 +- tests/test_nanocode_replace_range_tool.py | 72 ++-- 6 files changed, 257 insertions(+), 528 deletions(-) diff --git a/nanocode.py b/nanocode.py index 53be727..0d55707 100644 --- a/nanocode.py +++ b/nanocode.py @@ -788,7 +788,6 @@ class AgentMode(StrEnum): @dataclass class AgentRuntime: recent_edits: list[str] = field(default_factory=list) - consecutive_tool_turns: int = 0 @dataclass @@ -1337,12 +1336,6 @@ class ToolCallExecution: requires_verification: bool = False -@dataclass -class PreparedToolCall: - call: ParsedToolCall - tool: Tool - - @dataclass class BoundedToolOutput: value: str @@ -1747,7 +1740,6 @@ class ReadTool(Tool): start: int = 0 end: int = 0 ranges: list[tuple[int, int]] = field(default_factory=list) - filepaths: list[str] = field(default_factory=list) cwd: str = "" range_fingerprints: RangeFingerprintStore = field(default_factory=RangeFingerprintStore) @@ -1756,8 +1748,6 @@ def cli_args(cls, args: list[JsonValue]) -> list[str]: if not args: return [] tokens = [cls.cli_token(args[0])] - if len(args) == 3 and args[1].isdigit() and args[2].isdigit(): - return tokens + [args[1] + ":" + args[2]] return tokens + [str(arg) for arg in args[1:]] @staticmethod @@ -1778,21 +1768,6 @@ def make(cls, session: Session, args: list[str]) -> Self: ranges = [(0, 0)] elif all(re.fullmatch(r"\s*\d+\s*[-:,]\s*\d+\s*", arg) for arg in args[1:]): ranges = [cls._parse_line_range_token(arg) for arg in args[1:]] - elif len(args) == 3 and cls._is_integer_token(args[1]) and cls._is_integer_token(args[2]): - ranges = [_parse_line_range(args[1], args[2])] - elif cls._all_args_are_existing_files(session, args): - filepaths = [session.resolve_path(arg) for arg in args] - return cls( - filepath=filepaths[0], - start=0, - end=0, - ranges=[(0, 0)], - filepaths=filepaths, - cwd=session.cwd, - range_fingerprints=session.state.range_fingerprints, - ) - elif len(args) == 3: - ranges = [_parse_line_range(args[1], args[2])] elif len(args) == 2: raise ToolCallArgError('Read args error: invalid range token; expected ["filepath", "start,end"]. Example: Read("nanocode.py", "2065,2095").') else: @@ -1800,39 +1775,16 @@ def make(cls, session: Session, args: list[str]) -> Self: start, end = ranges[0] return cls(filepath=filepath, start=start, end=end, ranges=ranges, cwd=session.cwd, range_fingerprints=session.state.range_fingerprints) - @staticmethod - def _all_args_are_existing_files(session: Session, args: list[str]) -> bool: - if len(args) < 2: - return False - return all(os.path.isfile(session.resolve_path(arg)) for arg in args) - - @staticmethod - def _is_integer_token(value: str) -> bool: - return re.fullmatch(r"\s*-?\d+\s*", str(value)) is not None - def requires_confirmation(self, session: Session) -> bool: - return any(not session.is_path_in_cwd(filepath) for filepath in self._target_filepaths()) + return not session.is_path_in_cwd(self.filepath) def preview(self) -> str: - if self.filepaths: - return "Read(" + ", ".join(self.filepaths) + ")" if len(self.ranges) > 1: ranges = ", ".join(str(start) + ":" + str(end) for start, end in self.ranges) return f"Read({self.filepath}, {ranges})" return f"Read({self.filepath}, {self.start}, {self.end})" def call(self) -> str: - if self.filepaths: - lines = ["", " " + str(len(self.filepaths)) + ""] - for filepath in self.filepaths: - content, returned_end, fingerprint_end, fingerprint, truncated, total_lines = self._read_range(0, 0, filepath=filepath) - lines.append(" ") - lines.append(" " + filepath + "") - lines.extend(self._format_range_result(0, returned_end, fingerprint_end, fingerprint, truncated, total_lines, content, indent=" ")) - lines.append(" ") - lines.append("") - return "\n".join(lines) - if len(self.ranges) > 1: lines = ["", " " + str(len(self.ranges)) + ""] for start, end in self.ranges: @@ -1849,11 +1801,8 @@ def call(self) -> str: lines.append("") return "\n".join(lines) - def _target_filepaths(self) -> list[str]: - return self.filepaths or [self.filepath] - - def _read_range(self, start: int, end: int, *, filepath: str | None = None) -> tuple[str, int, int, str, bool, int]: - target_filepath = filepath or self.filepath + def _read_range(self, start: int, end: int) -> tuple[str, int, int, str, bool, int]: + target_filepath = self.filepath total_lines = 0 selected_lines = [] truncated = False @@ -2568,50 +2517,16 @@ def cli_args(cls, args: list[str]) -> list[str]: ranges = _json_list(args[1]) if ranges: return [cls.cli_token(args[0]), str(len(ranges)) + " ranges"] - if len(args) < 3: - return [cls.cli_token(arg) for arg in args] - return [cls.cli_token(args[0]), str(args[1]) + ":" + str(args[2])] - - @classmethod - def merge_key(cls, call: ParsedToolCall) -> tuple[str, ...] | None: - if len(call.args) != 7: - return None - return (str(call.args[0]),) - - @classmethod - def merge_calls(cls, session: Session, calls: list[ParsedToolCall]) -> PreparedToolCall | None: - if len(calls) < 2: - return None - filepath = calls[0].args[0] - edits = [] - intentions = [] - for call in calls: - try: - start, end = _parse_line_range(str(call.args[1]), str(call.args[2])) - except ToolCallArgError: - return None - fingerprint = str(call.args[3]) - if not fingerprint: - return None - edits.append( - ReplaceRangeEdit(start=start, end=end, fingerprint=fingerprint, before_context=str(call.args[4]), after_context=str(call.args[5]), content=str(call.args[6])) - ) - if call.intention: - intentions.append(call.intention) - tool = cls._from_edits(session, filepath=filepath, edits=edits) - call = ParsedToolCall(name=cls.NAME, intention="; ".join(intentions), args=list(calls[0].args)) - return PreparedToolCall(call=call, tool=tool) + return [cls.cli_token(arg) for arg in args] @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: - if len(args) == 2: - ranges = _json_list(args[1]) - if not ranges: - raise ToolCallArgError("ranges cannot be empty") - return cls._from_edits(session, filepath=str(args[0]), edits=[cls._edit_from_args(_json_list(item)) for item in ranges]) - if len(args) != 7: - raise ToolCallArgError("requires args: filepath, ranges where each range is [start,end,fingerprint,before_context,after_context,content]") - return cls._from_edits(session, filepath=str(args[0]), edits=[cls._edit_from_args(args[1:])]) + if len(args) != 2: + raise ToolCallArgError("requires args: filepath, ranges") + ranges = _json_list(args[1]) + if not ranges: + raise ToolCallArgError("ranges cannot be empty") + return cls._from_edits(session, filepath=str(args[0]), edits=[cls._edit_from_args(_json_list(item)) for item in ranges]) @staticmethod def _edit_from_args(args: list[JsonValue]) -> ReplaceRangeEdit: @@ -3604,110 +3519,6 @@ def _state_tool_schema(name: str) -> Json: """ -class PromptBuilder: - def __init__( - self, - session: Session, - *, - system_prompt_template: str = AGENT_SYSTEM_PROMPT, - user_prompt_template: str = AGENT_USER_PROMPT_TEMPLATE, - blackboard: Blackboard | None = None, - runtime: AgentRuntime | None = None, - tool_context: ToolResultContext | None = None, - ): - self.session = session - self.system_prompt_template = system_prompt_template - self.user_prompt_template = user_prompt_template - self.blackboard = blackboard or Blackboard() - self.runtime = runtime or AgentRuntime() - self.tool_context = tool_context or ToolResultContext() - - def system_prompt(self, template: str | None = None, *, tools: Iterable[ToolClass] | None = None) -> str: - tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) - return ( - (template or self.system_prompt_template) - .replace("{ __tool_names__ }", "|".join(tool.NAME for tool in tool_classes)) - .replace("{ __hypothesis_status_text__ }", HYPOTHESIS_STATUS_TEXT) - .strip() - ) - - def user_prompt( - self, - *, - tool_result_index: str, - unreduced_tool_results: str, - latest_tool_results: str, - errors: str, - ) -> str: - current = self.blackboard - conversation = self.session.state.conversation - return self.user_prompt_template.format( - environment="\n".join(["- system: " + self.session.system, "- arch: " + self.session.arch, "- cwd: " + self.session.cwd]), - conversation_history="\n\n".join(item.format() for item in conversation) if conversation else "(empty)", - user_rules=self.session.state.user_rules.format(), - known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", - kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", - stable_knowledge=self._format_stable_knowledge(), - tool_result_index=tool_result_index or "(empty)", - unreduced_tool_results=unreduced_tool_results or "(empty)", - latest_tool_results=latest_tool_results or "(empty)", - task_code=self.blackboard.task_code, - work_mode=self.blackboard.work_mode, - goal=current.goal or "(empty)", - plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", - hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", - verification_state=current.verification.format(), - errors=errors or "(empty)", - recent_edits="\n".join(self.runtime.recent_edits) if self.runtime.recent_edits else "(empty)", - user_request=self._format_user_request(), - ).strip() - - def observe_user_prompt(self, unreduced_tool_results: str, errors: str) -> str: - current = self.blackboard - return AGENT_OBSERVE_USER_PROMPT_TEMPLATE.format( - user_rules=self.session.state.user_rules.format(), - goal=current.goal or "(empty)", - plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", - hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", - known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", - stable_knowledge=self._format_stable_knowledge(), - kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", - errors=errors or "(empty)", - unreduced_tool_results=unreduced_tool_results or "(empty)", - user_request=self._format_user_request(), - ).strip() - - def _format_user_request(self) -> str: - user_request = self.blackboard.user_input or "(empty)" - fence = "`" * max(3, max((len(match.group(0)) for match in re.finditer(r"`{3,}", user_request)), default=0) + 1) - return fence + "text\n" + user_request + "\n" + fence - - def _format_stable_knowledge(self) -> str: - knowledge = self.blackboard.stable_knowledge - if not any(knowledge.values()): - return "(empty)" - lines = [] - for category in STABLE_KNOWLEDGE_CATEGORIES: - items = [item for item in knowledge.get(category, []) if item] - if not items: - continue - lines.append(category + ":") - lines.extend("- " + item for item in items) - lines.append("") - return "\n".join(lines).rstrip() - - def format_archived_tool_result_index(self, visible_result_keys: set[str] | None = None, *, limit: int = 0) -> list[str]: - if not self.session.state.tool_result_store: - return [] - hidden_keys = visible_result_keys or set() - lines = [] - for key, item in self.session.state.tool_result_store.items(): - if key in hidden_keys: - continue - lines.append(item.format(result_key=key)) - return lines[-limit:] if limit > 0 else lines - - ############################ # LLM Request (ModelClient) ############################ @@ -3984,14 +3795,12 @@ def _read_chat_tool_stream( for index in sorted(tool_calls): item = tool_calls[index] action = self._action_from_function_call(_json_str(item.get("name")) or "", _json_str(item.get("arguments")) or "{}") - DebugTrace.stream_action(self.session, activity=activity, action=action) - if text_parts and on_stream_action is not None: - action["_assistant_text"] = "".join(text_parts).strip() - text_parts.clear() - actions.append(action) - stopped, request_deadline = self._call_stream_action( - on_stream_action, + stopped, request_deadline = self._consume_stream_action( + actions, + text_parts, action, + activity=activity, + on_stream_action=on_stream_action, request_deadline=request_deadline, first_token_timeout=first_token_timeout, ) @@ -3999,6 +3808,29 @@ def _read_chat_tool_stream( break return self._action_response(actions, "".join(text_parts)), usage + def _consume_stream_action( + self, + actions: list[Json], + text_parts: list[str], + action: Json, + *, + activity: str, + on_stream_action: Callable[[Json], bool] | None, + request_deadline: float, + first_token_timeout: int | None, + ) -> tuple[bool, float]: + DebugTrace.stream_action(self.session, activity=activity, action=action) + if text_parts and on_stream_action is not None: + action["_assistant_text"] = "".join(text_parts).strip() + text_parts.clear() + actions.append(action) + return self._call_stream_action( + on_stream_action, + action, + request_deadline=request_deadline, + first_token_timeout=first_token_timeout, + ) + def _accumulate_chat_tool_calls(self, tool_calls: dict[int, Json], delta: Json) -> None: for raw in _json_list(delta.get("tool_calls")): call = _json_dict(raw) @@ -4098,14 +3930,12 @@ def _read_responses_tool_stream( name, arguments, ) - DebugTrace.stream_action(self.session, activity=activity, action=action) - if text_parts and on_stream_action is not None: - action["_assistant_text"] = "".join(text_parts).strip() - text_parts.clear() - actions.append(action) - stopped, request_deadline = self._call_stream_action( - on_stream_action, + stopped, request_deadline = self._consume_stream_action( + actions, + text_parts, action, + activity=activity, + on_stream_action=on_stream_action, request_deadline=request_deadline, first_token_timeout=first_token_timeout, ) @@ -4551,7 +4381,7 @@ def execute( executions = [] self.skipped_after_failure_count = 0 self.skipped_after_failure_key = "" - items = self._merge_adjacent_tool_calls(self._dedupe_readonly_tool_calls(tool_calls)) + items = self._dedupe_readonly_tool_calls(tool_calls) for index, item in enumerate(items): call: ParsedToolCall | None = None outcome = "success" @@ -4560,12 +4390,8 @@ def execute( requires_confirmation = False requires_verification = False try: - if isinstance(item, PreparedToolCall): - call = item.call - tool = item.tool - else: - call = item if isinstance(item, ParsedToolCall) else self.parse_tool_call(item) - tool = self._make_tool(call) + call = item if isinstance(item, ParsedToolCall) else self.parse_tool_call(item) + tool = self._make_tool(call) requires_verification = tool.EFFECT == ToolEffect.EDIT preview_error = getattr(tool, "preview_error", None) if callable(preview_error): @@ -4677,53 +4503,6 @@ def _dedupe_readonly_tool_calls(self, tool_calls: list[JsonValue]) -> list[JsonV filtered.append(call) return filtered - def _merge_adjacent_tool_calls(self, tool_calls: list[JsonValue | ParsedToolCall]) -> list[JsonValue | ParsedToolCall | PreparedToolCall]: - merged: list[JsonValue | ParsedToolCall | PreparedToolCall] = [] - index = 0 - while index < len(tool_calls): - item = tool_calls[index] - merge_key = self._merge_key(item) - if merge_key is None: - merged.append(item) - index += 1 - continue - - group = [item] - index += 1 - while index < len(tool_calls): - next_item = tool_calls[index] - if self._merge_key(next_item) != merge_key: - break - group.append(next_item) - index += 1 - - if len(group) == 1: - merged.append(item) - continue - - prepared = self._merge_calls(group) - if prepared is None: - merged.extend(group) - else: - merged.append(prepared) - return merged - - def _merge_key(self, item: JsonValue | ParsedToolCall) -> tuple[str, tuple[str, ...]] | None: - if not isinstance(item, ParsedToolCall) or item.name != ReplaceRangeTool.NAME: - return None - key = ReplaceRangeTool.merge_key(item) - if key is None: - return None - return (item.name, key) - - def _merge_calls(self, group: list[JsonValue | ParsedToolCall]) -> PreparedToolCall | None: - parsed_group = [item for item in group if isinstance(item, ParsedToolCall)] - if len(parsed_group) != len(group): - return None - if parsed_group[0].name != ReplaceRangeTool.NAME: - return None - return ReplaceRangeTool.merge_calls(self.session, parsed_group) - def _store_tool_result(self, call: ParsedToolCall, outcome: str, output: str) -> str: self.session.state.tool_result_counter += 1 key = "tr." + str(self.session.state.tool_result_counter) @@ -4773,8 +4552,6 @@ def parse_tool_call(self, value: JsonValue) -> ParsedToolCall: name = _json_str(item.get("name")) if not name: raise ToolCallArgError('tool action missing required field: name. Use {"type":"tool","name":"Read","intention":"...","args":["path"]}.') - if name not in TOOL_REGISTRY and name == name.lower(): - name = next((registered_name for registered_name in TOOL_REGISTRY if registered_name.lower() == name), name) intention = _json_str(item.get("intention")) or "" raw_args = _json_list(item.get("args")) args: list[JsonValue] = list(raw_args) if name == ReplaceRangeTool.NAME else [_json_str(arg) or "" for arg in raw_args] @@ -5356,8 +5133,7 @@ def _summarize(self, items: list[ConversationItem]) -> tuple[str, list[KnownItem known="\n".join(KnownItem.format_item(item) for item in self.blackboard.known) or "(empty)", conversation="\n\n".join(item.format() for item in items), ).strip() - kwargs = {"tool_schemas": [COMPACT_TOOL_SCHEMA], "required_tool": "compact"} if isinstance(self.model_client, ModelClient) else {} - response = self.model_client.request(COMPACTOR_PROMPT.strip(), user_prompt, activity="compact", **kwargs) + response = self.model_client.request(COMPACTOR_PROMPT.strip(), user_prompt, activity="compact", tool_schemas=[COMPACT_TOOL_SCHEMA], required_tool="compact") if "actions" in response: response = next( (_json_dict(action) for action in _json_list(response.get("actions")) if _json_str(_json_dict(action).get("type")) == "compact"), @@ -5460,12 +5236,6 @@ def __init__(self, session: Session): self.blackboard = Blackboard() self.runtime = AgentRuntime() self.tool_context = ToolResultContext() - self.prompt_builder = PromptBuilder( - session, - blackboard=self.blackboard, - runtime=self.runtime, - tool_context=self.tool_context, - ) self.model_client = ModelClient(session) self.tool_runner = ToolCallRunner(session, self._protected_tool_result_keys) self.state_updater = AgentStateUpdater(session, self.blackboard) @@ -5481,19 +5251,72 @@ def __init__(self, session: Session): def build_user_prompt(self) -> str: tool_result_index, unreduced_tool_results, latest_tool_results = self._format_act_tool_result_context() - return self.prompt_builder.user_prompt( - tool_result_index=tool_result_index, - unreduced_tool_results=unreduced_tool_results, - latest_tool_results=latest_tool_results, - errors=self._format_agent_feedback(), - ) + current = self.blackboard + conversation = self.session.state.conversation + return AGENT_USER_PROMPT_TEMPLATE.format( + environment="\n".join(["- system: " + self.session.system, "- arch: " + self.session.arch, "- cwd: " + self.session.cwd]), + conversation_history="\n\n".join(item.format() for item in conversation) if conversation else "(empty)", + user_rules=self.session.state.user_rules.format(), + known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", + kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", + stable_knowledge=self._format_stable_knowledge(), + tool_result_index=tool_result_index or "(empty)", + unreduced_tool_results=unreduced_tool_results or "(empty)", + latest_tool_results=latest_tool_results or "(empty)", + task_code=current.task_code, + work_mode=current.work_mode, + goal=current.goal or "(empty)", + plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", + hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", + verification_state=current.verification.format(), + errors=self._format_agent_feedback() or "(empty)", + recent_edits="\n".join(self.runtime.recent_edits) if self.runtime.recent_edits else "(empty)", + user_request=self._format_user_request(), + ).strip() def build_observe_prompt(self) -> str: - return self.prompt_builder.observe_user_prompt( - self._format_observe_tool_result_context(), - self._format_observe_feedback(), + current = self.blackboard + return AGENT_OBSERVE_USER_PROMPT_TEMPLATE.format( + user_rules=self.session.state.user_rules.format(), + goal=current.goal or "(empty)", + plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", + hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", + known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", + stable_knowledge=self._format_stable_knowledge(), + kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", + errors=self._format_observe_feedback() or "(empty)", + unreduced_tool_results=self._format_observe_tool_result_context() or "(empty)", + user_request=self._format_user_request(), + ).strip() + + def _system_prompt(self, template: str | None = None, *, tools: Iterable[ToolClass] | None = None) -> str: + tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) + return ( + (template or AGENT_SYSTEM_PROMPT) + .replace("{ __tool_names__ }", "|".join(tool.NAME for tool in tool_classes)) + .replace("{ __hypothesis_status_text__ }", HYPOTHESIS_STATUS_TEXT) + .strip() ) + def _format_user_request(self) -> str: + user_request = self.blackboard.user_input or "(empty)" + fence = "`" * max(3, max((len(match.group(0)) for match in re.finditer(r"`{3,}", user_request)), default=0) + 1) + return fence + "text\n" + user_request + "\n" + fence + + def _format_stable_knowledge(self) -> str: + knowledge = self.blackboard.stable_knowledge + if not any(knowledge.values()): + return "(empty)" + lines = [] + for category in STABLE_KNOWLEDGE_CATEGORIES: + items = [item for item in knowledge.get(category, []) if item] + if not items: + continue + lines.append(category + ":") + lines.extend("- " + item for item in items) + lines.append("") + return "\n".join(lines).rstrip() + def request( self, system_prompt: str, @@ -5508,15 +5331,13 @@ def request( while attempt <= len(self.MODEL_TIMEOUT_RETRY_DELAYS): try: self.session.state.turn_model_calls += 1 - if isinstance(self.model_client, ModelClient): - return self.model_client.request( - system_prompt, - user_prompt, - activity=activity, - on_stream_action=on_stream_action, - tool_schemas=tool_schemas, - ) - return self.model_client.request(system_prompt, user_prompt, activity=activity) + return self.model_client.request( + system_prompt, + user_prompt, + activity=activity, + on_stream_action=on_stream_action, + tool_schemas=tool_schemas, + ) except ModelRequestRetry: if on_message is not None and self.session.settings.debug: on_message("Retrying: manual model retry requested.") @@ -5660,13 +5481,21 @@ def _format_act_tool_result_context(self) -> tuple[str, str, str]: ToolResultContext.blocks_by_key(timeline + unreduced + latest + self.tool_context.kept_results) ) archived_limit = max(0, self.TOOL_RESULT_INDEX_ITEMS - len(timeline)) - archived = self.prompt_builder.format_archived_tool_result_index(visible_keys, limit=archived_limit) + archived = self._format_archived_tool_result_index(visible_keys, limit=archived_limit) index = self._format_tool_result_index(archived, timeline) return index, "\n\n".join(unreduced), "\n\n".join(latest) def _format_observe_tool_result_context(self) -> str: return "\n\n".join(self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter)) + def _format_archived_tool_result_index(self, visible_result_keys: set[str], *, limit: int) -> list[str]: + lines = [ + item.format(result_key=key) + for key, item in self.session.state.tool_result_store.items() + if key not in visible_result_keys + ] + return lines[-limit:] if limit > 0 else lines + @staticmethod def _format_tool_result_index(archived: list[str], timeline: list[str]) -> str: sections = [] @@ -5785,11 +5614,11 @@ def _format_gate_debug_details(self, response: Json, format_error: str) -> str: def _step_prompts(self) -> tuple[str, str, str]: if self.mode == AgentMode.OBSERVE: - system_prompt = self.prompt_builder.system_prompt(AGENT_OBSERVE_SYSTEM_PROMPT) + system_prompt = self._system_prompt(AGENT_OBSERVE_SYSTEM_PROMPT) user_prompt = self.build_observe_prompt() activity = "observe" else: - system_prompt = self.prompt_builder.system_prompt( + system_prompt = self._system_prompt( AGENT_PLAN_SYSTEM_PROMPT if self.session.settings.plan_mode else None, tools=PLAN_MODE_TOOLS if self.session.settings.plan_mode else None, ) @@ -5975,7 +5804,6 @@ def execute_tool_calls( self.session.state.session_tool_calls += len(self.tool_runner.latest_executions) for execution in self.tool_runner.latest_executions: self._after_tool_execution(execution) - self.runtime.consecutive_tool_turns += 1 if self._should_observe_after_tools(): self.mode = AgentMode.OBSERVE return "\n\n".join(self.tool_context.latest) @@ -6094,18 +5922,7 @@ def _validate_action_response(self, response: Json) -> Json | None: return None def _response_actions(self, response: Json) -> list[Json]: - actions = [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action] - for action in actions: - self._normalize_response_action(action) - return actions - - def _normalize_response_action(self, action: Json) -> None: - action_type = _json_str(action.get("type")) - if not action_type: - return - lowered = action_type.lower() - if lowered in (self.ACT_ACTION_TYPES | self.OBSERVE_ACTION_TYPES): - action["type"] = lowered + return [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action] def _gate_action_types( self, @@ -6585,7 +6402,6 @@ def _handle_observe_response( kept_keys: list[str] = [] if any(_json_str(action.get("type")) in {"keep", "forget", "known", "stable_knowledge"} for action in ctx.actions): self.mode = AgentMode.ACT - self.runtime.consecutive_tool_turns = 0 kept_keys = self.tool_context.keep_results(ctx.actions, observed_blocks, max_chars=self.KEPT_TOOL_RESULT_CHARS) self.tool_context.compact_observed(observed_blocks) self._mark_memory_checkpoint(observed_counter) @@ -6732,7 +6548,6 @@ def run( self.agent_feedback_errors = [] self.failed_tool_call_key = None self.failed_tool_call_count = 0 - self.runtime.consecutive_tool_turns = 0 self.tool_context.prune_recent( max_index_items=self.TOOL_RESULT_INDEX_ITEMS, checkpoint=self.blackboard.memory_checkpoint_tool_result_counter, @@ -6847,7 +6662,6 @@ def handle_response( ): DebugTrace.handle_event(self, "handle-tools", ctx, response) return AgentRunResult() - self.runtime.consecutive_tool_turns = 0 result = self._finish_or_continue(ctx, on_message) DebugTrace.handle_event(self, "handle-finish-or-continue", ctx, response, result=result) return result diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 4e96ea5..aea5c4e 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -138,13 +138,13 @@ def test_agent_tool_results_go_to_latest_tool_results_and_store(tmp_path): { "name": "Read", "intention": "read sample", - "args": ["sample.txt", "0", "1"], + "args": ["sample.txt", "0,1"], } ] ) assert "alpha" in latest - assert '- ok tool=Read args=["sample.txt","0","1"] key=tr.1' in latest + assert '- ok tool=Read args=["sample.txt","0,1"] key=tr.1' in latest assert "why: read sample" in latest assert "output:\n" in latest assert session.state.tool_result_store["tr.1"].value.startswith("") @@ -158,27 +158,6 @@ def test_agent_tool_results_go_to_latest_tool_results_and_store(tmp_path): assert os.path.isdir(session.tool_results_dir()) -def test_agent_accepts_lowercase_tool_name_without_prompting_it(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - agent = Agent(session) - - latest = agent.execute_tool_calls( - [ - { - "name": "read", - "intention": "read sample", - "args": ["sample.txt", "0", "1"], - } - ] - ) - - assert "alpha" in latest - assert '- ok tool=Read args=["sample.txt","0","1"] key=tr.1' in latest - assert agent.tool_runner.latest_executions[0].call.name == "Read" - - def test_agent_dedupes_same_batch_readonly_tool_calls_keeping_latest(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\n", encoding="utf-8") @@ -261,7 +240,7 @@ def test_agent_tool_results_are_bounded_and_logged(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) - latest = agent.execute_tool_calls([{"name": "Read", "intention": "read large sample", "args": ["sample.txt", "0", "1"]}]) + latest = agent.execute_tool_calls([{"name": "Read", "intention": "read large sample", "args": ["sample.txt", "0,1"]}]) item = session.state.tool_result_store["tr.1"] assert item.excerpted is True @@ -286,7 +265,7 @@ def test_agent_keeps_latest_batch_and_unreduced_tool_results(tmp_path): agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 4 for name in ["one.txt", "two.txt", "three.txt", "four.txt"]: - agent.execute_tool_calls([{"name": "Read", "intention": "read " + name, "args": [name, "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read " + name, "args": [name, "0,1"]}]) latest = _blocks_text(agent.tool_context.latest) recent = _blocks_text(agent.tool_context.recent) @@ -315,8 +294,8 @@ def test_agent_observes_full_latest_result_when_it_becomes_recent(tmp_path): agent.TOOL_RESULT_RAW_CHARS = 10_000 agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 2 - agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0", "1"]}]) - agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}]) context = agent._format_observe_tool_result_context() assert agent.mode == nanocode.AgentMode.OBSERVE @@ -352,8 +331,8 @@ def test_agent_act_context_keeps_pending_raw_after_latest_rotates(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.TOOL_RESULT_RAW_CHARS = 10_000 - agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0", "1"]}]) - agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}]) assert agent.mode == nanocode.AgentMode.ACT assert "key=tr.1" in _blocks_text(agent.tool_context.recent) @@ -374,8 +353,8 @@ def test_observe_text_does_not_checkpoint_tool_results(tmp_path): agent.TOOL_RESULT_RAW_CHARS = 300 agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 2 - agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0", "1"]}]) - agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}]) agent.handle_response({"actions": [], "_assistant_text": "checking result"}) @@ -389,7 +368,7 @@ def test_observe_text_does_not_checkpoint_tool_results(tmp_path): def test_assistant_text_does_not_mark_memory_checkpoint(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) agent.apply_response({"actions": [], "_assistant_text": "reading sample"}) @@ -457,8 +436,8 @@ def test_act_prompt_includes_kept_tool_results(tmp_path): agent.execute_tool_calls( [ - {"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}, - {"name": "Read", "intention": "read other", "args": ["other.txt", "0", "1"]}, + {"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}, + {"name": "Read", "intention": "read other", "args": ["other.txt", "0,1"]}, ] ) agent.mode = nanocode.AgentMode.OBSERVE @@ -482,7 +461,7 @@ def test_kept_tool_results_deduplicate_by_tool_key(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) agent.mode = nanocode.AgentMode.OBSERVE agent.handle_response( { @@ -500,7 +479,7 @@ def test_kept_tool_results_deduplicate_by_tool_key(tmp_path): def test_observe_reports_kept_tool_result_keys(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) agent.mode = nanocode.AgentMode.OBSERVE messages = [] @@ -697,7 +676,7 @@ def test_keep_tool_results_ignore_non_tool_sources(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) agent.mode = nanocode.AgentMode.OBSERVE agent.handle_response( { @@ -725,7 +704,7 @@ def test_keep_action_is_observe_only(tmp_path): def test_observe_rejects_invalid_action_and_empty_actions(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) agent.mode = nanocode.AgentMode.OBSERVE agent.handle_response({"actions": [{"type": "goal", "text": "answer", "complete": False}]}) @@ -807,7 +786,7 @@ def test_kept_tool_results_respect_char_budget(tmp_path): def test_observe_checkpoint_clears_observe_errors(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) agent.mode = nanocode.AgentMode.OBSERVE agent.observe_feedback_errors = ["old observe error"] @@ -825,7 +804,7 @@ def test_agent_tool_result_raw_budget_triggers_observe(tmp_path): path = tmp_path / "sample.txt" path.write_text("x" * 400 + "\n", encoding="utf-8") - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) assert agent.mode == nanocode.AgentMode.OBSERVE assert agent.tool_context.raw_context_chars(agent.blackboard.memory_checkpoint_tool_result_counter) >= agent.TOOL_RESULT_RAW_CHARS @@ -931,7 +910,7 @@ class FakeModelClient: def __init__(self): self.calls = 0 - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.calls += 1 if self.calls == 1: raise nanocode.ModelRequestRetry() @@ -1016,7 +995,7 @@ class FakeModelClient: def __init__(self): self.calls = 0 - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.calls += 1 if self.calls <= 3: raise LLMError("request model timeout") @@ -1040,7 +1019,7 @@ class FakeModelClient: def __init__(self): self.calls = 0 - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.calls += 1 if self.calls == 1: raise LLMError("request first token timeout") @@ -1063,7 +1042,7 @@ class FakeModelClient: def __init__(self): self.calls = 0 - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.calls += 1 if self.calls <= 2: raise LLMError("request model timeout") @@ -1133,7 +1112,7 @@ class FakeModelClient: def __init__(self): self.calls = 0 - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.calls += 1 raise LLMError("request model timeout") @@ -1159,7 +1138,7 @@ class FakeModelClient: def __init__(self): self.calls = 0 - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.calls += 1 raise LLMError("API request failed") @@ -1708,24 +1687,6 @@ def test_agent_request_off_chat_reasoning_disables_auto_detection(tmp_path, monk assert "thinking" not in payload -def test_agent_normalizes_harmless_action_type_aliases(tmp_path): - agent = Agent(Session(cwd=str(tmp_path))) - - actions = agent._response_actions( - { - "actions": [ - {"type": "Plan", "items": []}, - {"type": "Known", "items": []}, - ] - } - ) - - assert actions == [ - {"type": "plan", "items": []}, - {"type": "known", "items": []}, - ] - - def test_agent_request_wraps_non_json_model_content_as_format_error(tmp_path, monkeypatch): _patch_openai(monkeypatch, _chat_response("plain answer")) session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) @@ -1916,7 +1877,7 @@ class FakeModelClient: def __init__(self): self.calls = 0 - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.calls += 1 return { "actions": [ @@ -1945,7 +1906,7 @@ def test_main_agent_state_updates_show_in_debug(tmp_path): agent = Agent(_session(tmp_path, debug=True)) class FakeModelClient: - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return {"actions": [{"type": "user_rule", "text": "Prompt-only changes do not need tests.", "message": "记住了。"}]} agent.model_client = FakeModelClient() @@ -2425,7 +2386,7 @@ def test_agent_execute_tool_calls_rejects_failed_preview_before_confirmation(tmp confirmations = [] latest = agent.execute_tool_calls( - [{"name": "ReplaceRange", "intention": "edit stale range", "args": ["sample.txt", "0", "1", "bad", "", "", "new"]}], + [{"name": "ReplaceRange", "intention": "edit stale range", "args": ["sample.txt", [["0", "1", "bad", "", "", "new"]]]}], confirm=lambda call, tool: confirmations.append((call.executed, tool.preview())) or True, ) @@ -2452,12 +2413,12 @@ def test_agent_execute_tool_calls_records_arg_errors_in_feedback(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) - latest = agent.execute_tool_calls([{"name": "Read", "intention": "bad range", "args": ["sample.txt", "bad", "1"]}]) + latest = agent.execute_tool_calls([{"name": "Read", "intention": "bad range", "args": ["sample.txt", "bad,1"]}]) - assert "ToolCallError: invalid start: should be an integer" in latest - assert agent.agent_feedback_errors == [ - 'Error: tool call args invalid: tool=Read args=["sample.txt","bad","1"] -> ToolCallError: invalid start: should be an integer. Rule: use the tool signature exactly.' - ] + assert "ToolCallError: Read args error: invalid range token" in latest + assert len(agent.agent_feedback_errors) == 1 + assert 'tool=Read args=["sample.txt","bad,1"]' in agent.agent_feedback_errors[0] + assert "invalid range token" in agent.agent_feedback_errors[0] def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): @@ -2466,7 +2427,7 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): latest = agent.execute_tool_calls([{"name": "ReplaceRange", "intention": "bad edit", "args": ["sample.txt", "0", "1", "abc", "", ""]}]) - assert "ToolCallError: requires args: filepath, ranges where each range is [start,end,fingerprint,before_context,after_context,content]" in latest + assert "ToolCallError: requires args: filepath, ranges" in latest assert "got 6 args, expected 2, extra: 4" in agent.agent_feedback_errors[0] assert "use ReplaceRange for read ranges" in agent.agent_feedback_errors[0] @@ -2475,7 +2436,7 @@ def test_tool_arg_error_does_not_force_observe(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) - agent.execute_tool_calls([{"name": "Read", "intention": "bad range", "args": ["sample.txt", "bad", "1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "bad range", "args": ["sample.txt", "bad,1"]}]) assert agent.mode == nanocode.AgentMode.ACT assert agent.agent_feedback_errors @@ -2498,7 +2459,7 @@ def test_agent_blocks_repeated_identical_failed_tool_call(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) _seed_plan(agent, "read sample") - action = {"type": "tool", "name": "Read", "intention": "bad range", "args": ["sample.txt", "bad", "1"]} + action = {"type": "tool", "name": "Read", "intention": "bad range", "args": ["sample.txt", "bad,1"]} agent.handle_response({"actions": [action]}) agent.handle_response({"actions": [{"type": "forget", "source": ["tr.1"], "reason": "failed read has no useful result"}]}) @@ -2534,7 +2495,7 @@ def test_agent_execute_tool_calls_does_not_record_runtime_errors_in_feedback(tmp session = Session(cwd=str(tmp_path)) agent = Agent(session) - latest = agent.execute_tool_calls([{"name": "Read", "intention": "missing file", "args": ["missing.txt", "0", "1"]}]) + latest = agent.execute_tool_calls([{"name": "Read", "intention": "missing file", "args": ["missing.txt", "0,1"]}]) assert "ToolCallError: " in latest assert agent.agent_feedback_errors == [] @@ -2585,7 +2546,7 @@ def __init__(self): self.user_prompts = [] self.responses = [ { - "actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}] + "actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}] }, {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, { @@ -2602,7 +2563,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -2616,7 +2577,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): response = agent.run("read sample", on_message=messages.append) assert response["actions"][-1]["message_for_complete"] == "done" - assert messages[0].startswith("[success] Read sample.txt 0:1 -> tr.1") + assert messages[0].startswith("[success] Read sample.txt 0,1 -> tr.1") assert "why:" not in messages[0] assert "log: .nanocode/sessions/" not in messages[0] assert messages[-1] == "done" @@ -2625,7 +2586,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert "alpha" in fake_client.user_prompts[2] assert "Kept Tool Results:" in fake_client.user_prompts[2] assert "" in fake_client.user_prompts[2] - assert 'tool=Read args=["sample.txt","0","1"]' in _blocks_text(agent.tool_context.latest) + assert 'tool=Read args=["sample.txt","0,1"]' in _blocks_text(agent.tool_context.latest) assert agent.tool_context.recent == [] assert agent.blackboard.known == ["Read sample.txt and found alpha."] assert agent.blackboard.user_input == "read sample" @@ -2711,7 +2672,7 @@ class FakeModelClient: def __init__(self): self.user_prompts = [] self.responses = [ - {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, + {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]}, { "actions": [ {"type": "goal", "text": "answer sample", "complete": True, "message_for_complete": "sample contains alpha"}, @@ -2719,7 +2680,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -2754,7 +2715,7 @@ def __init__(self): }, {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, {"actions": [{"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}]}, - {"actions": [{"type": "tool", "name": "Read", "intention": "inspect changed sample", "args": ["sample.txt", "0", "1"]}]}, + {"actions": [{"type": "tool", "name": "Read", "intention": "inspect changed sample", "args": ["sample.txt", "0,1"]}]}, {"actions": [{"type": "keep", "source": ["tr.2"], "reason": "keep useful result"}]}, { "actions": [ @@ -2764,7 +2725,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -2827,13 +2788,13 @@ class FakeModelClient: def __init__(self): self.user_prompts = [] self.responses = [ - {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, + {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]}, {"_format_error": "Invalid function-tool response: plain answer", "actions": []}, {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, {"actions": _final_actions("read sample")}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -2851,7 +2812,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert "" in agent.model_client.user_prompts[2] assert "Kept Tool Results:" in agent.model_client.user_prompts[3] assert "" in agent.model_client.user_prompts[3] - assert 'tool=Read args=["sample.txt","0","1"]' in _blocks_text(agent.tool_context.latest) + assert 'tool=Read args=["sample.txt","0,1"]' in _blocks_text(agent.tool_context.latest) assert agent.tool_context.recent == [] @@ -2864,7 +2825,7 @@ def __init__(self): self.responses = [ { "actions": [ - {"type": "tool", "name": "Read", "intention": f"read {index}", "args": [f"sample-{index}.txt", "0", "1"]} + {"type": "tool", "name": "Read", "intention": f"read {index}", "args": [f"sample-{index}.txt", "0,1"]} for index in range(51) ] }, @@ -2872,7 +2833,7 @@ def __init__(self): {"actions": _final_actions("read samples")}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = Session(cwd=str(tmp_path)) @@ -2911,12 +2872,12 @@ class FakeModelClient: def __init__(self): self.user_prompts = [] self.responses = [ - {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, + {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]}, {"actions": [{"type": "forget", "source": ["tr.1"], "reason": "sample content is not needed"}]}, {"actions": _final_actions("read sample", "done too early")}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -2945,7 +2906,7 @@ def __init__(self): { "actions": [ {"type": "goal", "text": "read sample", "complete": False}, - {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}, + {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}, ] }, { @@ -2956,7 +2917,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -2982,13 +2943,13 @@ def __init__(self): { "actions": [ {"type": "goal", "text": "new goal", "complete": False}, - {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}, + {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}, ] }, { "actions": [ {"type": "goal", "text": "new goal", "complete": False}, - {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}, + {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}, ] }, { @@ -2998,7 +2959,7 @@ def __init__(self): "type": "plan", "items": [{"id": "p1", "text": "Read sample", "status": "doing"}], }, - {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}, + {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}, ] }, {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, @@ -3010,7 +2971,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = Session(cwd=str(tmp_path)) @@ -3035,7 +2996,7 @@ def test_agent_run_requires_task_alignment_before_work_with_old_context(tmp_path class FakeModelClient: def __init__(self): self.responses = [ - {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, + {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]}, { "actions": [ {"type": "goal", "text": "run lint", "complete": False}, @@ -3043,7 +3004,7 @@ def __init__(self): "type": "plan", "items": [{"id": "p1", "text": "Read sample", "status": "doing"}], }, - {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}, + {"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}, ] }, { @@ -3054,7 +3015,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = Session(cwd=str(tmp_path)) @@ -3089,7 +3050,7 @@ def __init__(self): ] }, {"actions": [{"type": "goal", "text": "read sample again", "complete": False}]}, - {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0", "1"]}]}, + {"actions": [{"type": "tool", "name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]}, {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, { "actions": [ @@ -3099,7 +3060,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3164,7 +3125,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3187,7 +3148,7 @@ class FakeModelClient: def __init__(self): self.user_prompts = [] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return {"actions": [], "_assistant_text": "你好"} @@ -3213,7 +3174,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = Session(cwd=str(tmp_path)) @@ -3236,7 +3197,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = Session(cwd=str(tmp_path)) @@ -3259,7 +3220,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = Session(cwd=str(tmp_path)) @@ -3289,7 +3250,7 @@ def __init__(self): {"actions": _final_actions("change file")}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3335,7 +3296,7 @@ def __init__(self): {"actions": _final_actions("change file")}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3364,7 +3325,7 @@ def test_agent_allows_tool_after_completed_plan_and_verification(tmp_path): result = agent.handle_response( { "actions": [ - {"type": "tool", "name": "Read", "intention": "inspect again", "args": ["sample.txt", "0", "1"]} + {"type": "tool", "name": "Read", "intention": "inspect again", "args": ["sample.txt", "0,1"]} ] }, on_message=messages.append, @@ -3399,7 +3360,7 @@ def test_agent_allows_tool_after_reopening_completed_plan_with_context(tmp_path) } ], }, - {"type": "tool", "name": "Read", "intention": "inspect sample", "args": ["sample.txt", "0", "1"]}, + {"type": "tool", "name": "Read", "intention": "inspect sample", "args": ["sample.txt", "0,1"]}, ] } ) @@ -3431,7 +3392,7 @@ def test_agent_allows_tool_after_reopening_completed_plan_without_context(tmp_pa "mode": "patch", "items": [{"id": "p2", "text": "Inspect the remaining issue", "status": "doing"}], }, - {"type": "tool", "name": "Read", "intention": "inspect sample", "args": ["sample.txt", "0", "1"]}, + {"type": "tool", "name": "Read", "intention": "inspect sample", "args": ["sample.txt", "0,1"]}, ] }, on_message=messages.append, @@ -3497,7 +3458,7 @@ def __init__(self): {"actions": [{"type": "goal", "text": "answer", "complete": True}]}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3519,7 +3480,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): def test_agent_run_allows_assistant_text_without_task_context(tmp_path): class FakeModelClient: - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return {"actions": [], "_assistant_text": "hello"} session = Session(cwd=str(tmp_path)) @@ -3548,7 +3509,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3587,7 +3548,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3651,7 +3612,7 @@ class FakeModelClient: def __init__(self): self.user_prompts = [] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return { "actions": [ @@ -3702,7 +3663,7 @@ def __init__(self): }, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = Session(cwd=str(tmp_path)) @@ -3730,7 +3691,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3757,7 +3718,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3772,7 +3733,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.agent_feedback_errors class ChatModelClient: - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return {"actions": [], "_assistant_text": "ok"} agent.model_client = ChatModelClient() @@ -3804,7 +3765,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3840,7 +3801,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = Session(cwd=str(tmp_path)) @@ -3864,7 +3825,7 @@ def __init__(self): KeyboardInterrupt(), ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): response = self.responses.pop(0) if isinstance(response, KeyboardInterrupt): raise response @@ -3896,7 +3857,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): assert agent.blackboard.goal_reached is False class ChatModelClient: - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return {"actions": [], "_assistant_text": "ok"} agent.model_client = ChatModelClient() @@ -3914,7 +3875,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -3936,7 +3897,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return self.responses.pop(0) session = _session(tmp_path, debug=True) @@ -3954,7 +3915,7 @@ class FakeModelClient: def __init__(self): self.calls = 0 - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.calls += 1 return {"_format_error": "Invalid function-tool response: missing content", "actions": []} @@ -3984,7 +3945,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -4008,7 +3969,7 @@ def __init__(self): {"actions": [{"type": "goal", "text": "answer", "complete": True, "message_for_complete": ""}]}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -4045,7 +4006,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) @@ -4073,7 +4034,7 @@ def __init__(self): {"actions": _final_actions()}, ] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index d78ca81..7bc1271 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -11,7 +11,7 @@ def __init__(self, summary="LLM compact summary"): self.summary = summary self.requests = [] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.requests.append((system_prompt, user_prompt, activity)) return {"summary": self.summary} diff --git a/tests/test_nanocode_compactor.py b/tests/test_nanocode_compactor.py index 9c32cf8..02cbcbe 100644 --- a/tests/test_nanocode_compactor.py +++ b/tests/test_nanocode_compactor.py @@ -8,7 +8,7 @@ def __init__(self, summary="LLM compact summary", known=None): self.known = known self.requests = [] - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.requests.append((system_prompt, user_prompt, activity)) response = {"summary": self.summary} if self.known is not None: diff --git a/tests/test_nanocode_read_tool.py b/tests/test_nanocode_read_tool.py index 5e4e2de..3795782 100644 --- a/tests/test_nanocode_read_tool.py +++ b/tests/test_nanocode_read_tool.py @@ -9,7 +9,7 @@ def test_read_tool_reads_requested_line_range(tmp_path): path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = ReadTool.make(session, ["sample.txt", "1", "3"]) + tool = ReadTool.make(session, ["sample.txt", "1,3"]) result = tool.call() assert tool.requires_confirmation(session) is False @@ -77,7 +77,7 @@ def test_read_tool_reads_to_eof_when_end_is_zero(tmp_path): path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - result = ReadTool.make(session, ["sample.txt", "1", "0"]).call() + result = ReadTool.make(session, ["sample.txt", "1,0"]).call() assert "beta\ngamma\n" in result assert "alpha" not in result @@ -97,38 +97,16 @@ def test_read_tool_allows_omitted_range_for_full_file_read(tmp_path): assert "alpha\nbeta\n" in result -def test_read_tool_accepts_multiple_existing_file_args_for_compatibility(tmp_path): - for name, content in { - "one.txt": "one\n", - "two.txt": "two\n", - "three.txt": "three\n", - }.items(): - (tmp_path / name).write_text(content, encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = ReadTool.make(session, ["one.txt", "two.txt", "three.txt"]) - result = tool.call() - - assert tool.filepaths == [str(tmp_path / "one.txt"), str(tmp_path / "two.txt"), str(tmp_path / "three.txt")] - assert "3" in result - assert "" + str(tmp_path / "one.txt") + "" in result - assert "" + str(tmp_path / "two.txt") + "" in result - assert "" + str(tmp_path / "three.txt") + "" in result - assert "one\n" in result - assert "two\n" in result - assert "three\n" in result - - -def test_read_tool_keeps_start_end_args_preferred_over_existing_numeric_filenames(tmp_path): +def test_read_tool_reads_range_token_when_numeric_filenames_exist(tmp_path): (tmp_path / "sample.txt").write_text("zero\none\ntwo\nthree\n", encoding="utf-8") (tmp_path / "1").write_text("numeric filename one\n", encoding="utf-8") (tmp_path / "3").write_text("numeric filename three\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = ReadTool.make(session, ["sample.txt", "1", "3"]) + tool = ReadTool.make(session, ["sample.txt", "1,3"]) result = tool.call() - assert tool.filepaths == [] + assert tool.ranges == [(1, 3)] assert "1:3" in result assert "one\ntwo\n" in result assert "numeric filename" not in result @@ -155,7 +133,7 @@ def test_read_tool_truncates_large_bounded_ranges_after_600_lines(tmp_path): path.write_text("".join(f"line-{index:04d}\n" for index in range(700)), encoding="utf-8") session = Session(cwd=str(tmp_path)) - result = ReadTool.make(session, ["sample.txt", "10", "650"]).call() + result = ReadTool.make(session, ["sample.txt", "10,650"]).call() assert "10:610" in result assert "true" in result @@ -193,7 +171,7 @@ def tracking_open(*args, **kwargs): monkeypatch.setattr(nanocode, "open", tracking_open, raising=False) - result = ReadTool.make(session, ["sample.txt", "1", "3"]).call() + result = ReadTool.make(session, ["sample.txt", "1,3"]).call() assert "one\ntwo\n" in result assert "three" not in result @@ -205,7 +183,7 @@ def test_read_tool_clamps_out_of_bounds_range(tmp_path): path.write_text("alpha\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - result = ReadTool.make(session, ["sample.txt", "10", "20"]).call() + result = ReadTool.make(session, ["sample.txt", "10,20"]).call() assert "alpha" not in result assert " \n\n " in result @@ -216,8 +194,8 @@ def test_read_tool_rejects_non_integer_range(tmp_path): path.write_text("alpha\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - with pytest.raises(ToolCallError, match="invalid start"): - ReadTool.make(session, ["sample.txt", "bad", "1"]) + with pytest.raises(ToolCallError, match="invalid range"): + ReadTool.make(session, ["sample.txt", "bad,1"]) def test_read_tool_rejects_partial_range(tmp_path): diff --git a/tests/test_nanocode_replace_range_tool.py b/tests/test_nanocode_replace_range_tool.py index e01ac55..3d8b159 100644 --- a/tests/test_nanocode_replace_range_tool.py +++ b/tests/test_nanocode_replace_range_tool.py @@ -7,15 +7,15 @@ def _fingerprint(read_result: str) -> str: return read_result.split("", 1)[1].split("", 1)[0] -def _replace_args(filepath: str, start: int, end: int, fingerprint: str, before: str, after: str, content: str) -> list[str]: - return [filepath, str(start), str(end), fingerprint, before, after, content] +def _replace_args(filepath: str, start: int, end: int, fingerprint: str, before: str, after: str, content: str) -> list[object]: + return [filepath, [[str(start), str(end), fingerprint, before, after, content]]] def test_replace_range_tool_replaces_range_when_fingerprint_matches(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\n")) display = tool.preview() @@ -42,7 +42,7 @@ def test_replace_range_tool_rejects_before_context_mismatch(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "wrong\n", "gamma\n", "BETA\n")) @@ -56,7 +56,7 @@ def test_replace_range_tool_rejects_after_context_mismatch(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "wrong\n", "BETA\n")) @@ -70,7 +70,7 @@ def test_replace_range_tool_allows_empty_boundary_context_for_non_empty_range(tm path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "", "", "BETA\n")).call() @@ -81,7 +81,7 @@ def test_replace_range_tool_rejects_content_that_repeats_boundary_context(tmp_pa path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) before_tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "alpha\nBETA\n")) after_tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\ngamma\n")) @@ -127,8 +127,8 @@ def test_replace_range_tool_accepts_public_batch_ranges(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\ndelta\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - beta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) - delta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "3", "4"]).call()) + beta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) + delta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "3,4"]).call()) result = ReplaceRangeTool.make( session, @@ -149,8 +149,8 @@ def test_agent_executes_replace_range_batch_args(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\ndelta\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - beta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) - delta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "3", "4"]).call()) + beta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) + delta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "3,4"]).call()) agent = Agent(session) latest = agent.execute_tool_calls( @@ -174,35 +174,11 @@ def test_agent_executes_replace_range_batch_args(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\nDELTA\n" -def test_agent_merges_consecutive_same_file_replace_range_calls(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\ndelta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - beta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) - delta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "3", "4"]).call()) - agent = Agent(session) - confirmations = [] - - latest = agent.execute_tool_calls( - [ - {"name": "ReplaceRange", "intention": "replace beta", "args": _replace_args("sample.txt", 1, 2, beta_fingerprint, "alpha\n", "gamma\n", "BETA\n")}, - {"name": "ReplaceRange", "intention": "replace delta", "args": _replace_args("sample.txt", 3, 4, delta_fingerprint, "gamma\n", "", "DELTA\n")}, - ], - confirm=lambda call, tool: confirmations.append(call.executed) or True, - ) - - assert len(agent.tool_runner.latest_executions) == 1 - assert confirmations[0].startswith('ReplaceRange("sample.txt", "1", "2"') - assert "replace beta; replace delta" in session.state.tool_result_store["tr.1"].description - assert "* replacements: 2" in latest - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\nDELTA\n" - - def test_replace_range_tool_adds_line_break_before_following_content(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA")).call() @@ -213,7 +189,7 @@ def test_replace_range_tool_relocates_cached_fingerprint_after_line_shift(tmp_pa path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "2", "3"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "2,3"]).call()) path.write_text("zero\nalpha\nbeta\ngamma\n", encoding="utf-8") result = ReplaceRangeTool.make(session, _replace_args("sample.txt", 2, 3, fingerprint, "beta\n", "", "GAMMA\n")).call() @@ -227,7 +203,7 @@ def test_replace_range_tool_rejects_ambiguous_cached_relocation(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) path.write_text("zero\nalpha\nbeta\nbeta\ngamma\n", encoding="utf-8") tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\n")) @@ -259,7 +235,7 @@ def test_replace_range_tool_reports_fingerprint_cached_range(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "0", "3"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "0,3"]).call()) path.write_text("alpha\nBETA\ngamma\n", encoding="utf-8") tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\n")) @@ -302,7 +278,7 @@ def test_replace_range_cache_survives_goal_rewording(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) Agent(session).apply_response({"actions": [{"type": "goal", "text": "new goal"}]}) @@ -315,7 +291,7 @@ def test_replace_range_cache_survives_cancel_until_next_run(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) agent = Agent(session) agent.cancel_current_goal() @@ -323,7 +299,7 @@ def test_replace_range_cache_survives_cancel_until_next_run(tmp_path): assert len(session.state.range_fingerprints) == 1 class FakeModelClient: - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return {"actions": [], "_assistant_text": "done"} agent.model_client = FakeModelClient() @@ -334,13 +310,13 @@ def request(self, system_prompt, user_prompt, *, activity="agent"): def test_replace_range_cache_clears_when_new_main_run_starts(tmp_path): class FakeModelClient: - def request(self, system_prompt, user_prompt, *, activity="agent"): + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): return {"actions": [], "_assistant_text": "done"} path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) agent = Agent(session) agent.model_client = FakeModelClient() @@ -353,7 +329,7 @@ def test_replace_range_tool_replaces_to_eof_when_end_is_zero(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "0"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,0"]).call()) tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 0, fingerprint, "alpha\n", "", "tail\n")) result = tool.call() @@ -366,7 +342,7 @@ def test_replace_range_tool_inserts_when_start_equals_end(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "1"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,1"]).call()) ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 1, fingerprint, "alpha\n", "gamma\n", "beta\n")).call() @@ -377,7 +353,7 @@ def test_replace_range_tool_requires_boundary_context_for_insert_range(tmp_path) path = tmp_path / "sample.txt" path.write_text("alpha\ngamma\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "1"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,1"]).call()) tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 1, fingerprint, "", "", "beta\n")) @@ -404,7 +380,7 @@ def test_replace_range_tool_rejects_no_change(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1", "2"]).call()) + fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "", "beta\n")) From f1e7bb5c5bb1c2a091bd76eb4ce482d125d63a28 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 00:13:56 -0700 Subject: [PATCH 019/144] Simplify agent runtime and state formatting --- nanocode.py | 97 ++++++++++++------------------------ tests/test_nanocode_agent.py | 4 +- 2 files changed, 34 insertions(+), 67 deletions(-) diff --git a/nanocode.py b/nanocode.py index 0d55707..fb1afd7 100644 --- a/nanocode.py +++ b/nanocode.py @@ -785,11 +785,6 @@ class AgentMode(StrEnum): OBSERVE = "observe" -@dataclass -class AgentRuntime: - recent_edits: list[str] = field(default_factory=list) - - @dataclass class AgentRunResult: done: bool = False @@ -1397,30 +1392,21 @@ def forget_results(self, keys: list[str]) -> list[str]: return [] removed = [] - def remove_blocks(blocks: list[str]) -> list[str]: - kept = [] - for block in blocks: - key = self.result_key(block) - if key in wanted: - removed.append(key) - else: - kept.append(block) - return kept - - def compact_blocks(blocks: list[str]) -> list[str]: - compacted = [] + def update(blocks: list[str], *, compact: bool) -> list[str]: + updated = [] for block in blocks: key = self.result_key(block) if key in wanted: removed.append(key) - compacted.append(self.compact_block(block)) + if compact: + updated.append(self.compact_block(block)) else: - compacted.append(block) - return compacted + updated.append(block) + return updated - self.kept_results = remove_blocks(self.kept_results) - self.latest = compact_blocks(self.latest) - self.recent = compact_blocks(self.recent) + self.kept_results = update(self.kept_results, compact=False) + self.latest = update(self.latest, compact=True) + self.recent = update(self.recent, compact=True) return list(dict.fromkeys(removed)) def keep_results(self, actions: list[Json], observed_blocks: list[str], *, max_chars: int) -> list[str]: @@ -4602,7 +4588,7 @@ def __init__( self.changed = False def apply(self, response: Json) -> None: - actions = self._actions(response) + actions = [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action] before_goal = self.blackboard.goal before_plan = [item.format() for item in self.blackboard.plan] before_hypotheses = [item.format() for item in self.blackboard.hypotheses] @@ -4629,9 +4615,6 @@ def apply(self, response: Json) -> None: ) self.changed = bool(self.latest_report) - def _actions(self, response: Json) -> list[Json]: - return [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action] - def _format_state_report( self, before_goal: str, @@ -4663,35 +4646,28 @@ def _format_state_report( return "\n".join(lines) def _format_plan_rows(self) -> list[str]: - items = self.blackboard.plan - if not items: - return [" (empty)"] - offset = max(0, len(items) - self.DISPLAY_LIMIT) - rows = [" ... " + str(offset) + " older"] if offset else [] - for index, item in enumerate(items[offset:], start=offset + 1): - rows.append(" " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text)) + def render(index: int, item: PlanItem) -> list[str]: + rows = [" " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text)] if item.context: rows.append(" context: " + self._compact(item.context)) - return rows + return rows + + return self._format_rows(self.blackboard.plan, render) def _format_known_rows(self) -> list[str]: - items = self.blackboard.known - if not items: - return [" (empty)"] - offset = max(0, len(items) - self.DISPLAY_LIMIT) - rows = [" ... " + str(offset) + " older"] if offset else [] - for index, item in enumerate(items[offset:], start=offset + 1): - rows.append(" " + str(index) + ". " + self._compact(KnownItem.format_item(item))) - return rows + return self._format_rows(self.blackboard.known, lambda index, item: " " + str(index) + ". " + self._compact(KnownItem.format_item(item))) def _format_hypothesis_rows(self) -> list[str]: - items = self.blackboard.hypotheses + return self._format_rows(self.blackboard.hypotheses, lambda index, item: " " + str(index) + ". " + self._compact(item.format())) + + def _format_rows(self, items: list[Any], render: Callable[[int, Any], str | list[str]]) -> list[str]: if not items: return [" (empty)"] offset = max(0, len(items) - self.DISPLAY_LIMIT) rows = [" ... " + str(offset) + " older"] if offset else [] for index, item in enumerate(items[offset:], start=offset + 1): - rows.append(" " + str(index) + ". " + self._compact(item.format())) + rendered = render(index, item) + rows.extend(rendered if isinstance(rendered, list) else [rendered]) return rows def compact_report(self) -> str: @@ -4721,11 +4697,7 @@ def compact_report(self) -> str: return "\n".join(lines) def _compact_plan_rows(self) -> list[str]: - items = self.blackboard.plan - offset = max(0, len(items) - self.COMPACT_DISPLAY_LIMIT) - rows = [" ... " + str(offset) + " older"] if offset else [] - rows.extend(self._compact_plan_row(index, item) for index, item in enumerate(items[offset:], start=offset + 1)) - return rows + return self._compact_rows(self.blackboard.plan, lambda item: "[" + str(item.status) + "] " + self._compact(item.text, 90)) def _compact_changed_plan_rows(self, before_plan: list[str], plan: list[str]) -> list[str]: if not before_plan: @@ -4746,17 +4718,15 @@ def _compact_plan_row(self, index: int, item: PlanItem) -> str: return " " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text, 90) def _compact_known_rows(self) -> list[str]: - items = self.blackboard.known - offset = max(0, len(items) - self.COMPACT_DISPLAY_LIMIT) - rows = [" ... " + str(offset) + " older"] if offset else [] - rows.extend(" " + str(index) + ". " + self._compact(KnownItem.format_item(item), 100) for index, item in enumerate(items[offset:], start=offset + 1)) - return rows + return self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100)) def _compact_hypothesis_rows(self) -> list[str]: - items = self.blackboard.hypotheses + return self._compact_rows(self.blackboard.hypotheses, lambda item: self._compact(item.format(), 100)) + + def _compact_rows(self, items: list[Any], render: Callable[[Any], str]) -> list[str]: offset = max(0, len(items) - self.COMPACT_DISPLAY_LIMIT) rows = [" ... " + str(offset) + " older"] if offset else [] - rows.extend(" " + str(index) + ". " + self._compact(item.format(), 100) for index, item in enumerate(items[offset:], start=offset + 1)) + rows.extend(" " + str(index) + ". " + render(item) for index, item in enumerate(items[offset:], start=offset + 1)) return rows def _compact(self, text: str, limit: int = 140) -> str: @@ -5234,7 +5204,7 @@ class Agent: def __init__(self, session: Session): self.session = session self.blackboard = Blackboard() - self.runtime = AgentRuntime() + self.recent_edits: list[str] = [] self.tool_context = ToolResultContext() self.model_client = ModelClient(session) self.tool_runner = ToolCallRunner(session, self._protected_tool_result_keys) @@ -5270,7 +5240,7 @@ def build_user_prompt(self) -> str: hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", verification_state=current.verification.format(), errors=self._format_agent_feedback() or "(empty)", - recent_edits="\n".join(self.runtime.recent_edits) if self.runtime.recent_edits else "(empty)", + recent_edits="\n".join(self.recent_edits) if self.recent_edits else "(empty)", user_request=self._format_user_request(), ).strip() @@ -5547,9 +5517,6 @@ def _warning(self, text: str, rule: str = "") -> str: def _warn_agent(self, text: str, rule: str = "") -> None: self._remember_agent_error(self._warning(text, rule)) - def _warn_observe(self, text: str, rule: str = "") -> None: - self._remember_observe_error(self._warning(text, rule)) - def _reject_agent(self, on_message: MessageCallback | None, feedback: str, retry: str, debug: str) -> bool: self.stream_stop_requested = True self._remember_agent_error(feedback) @@ -5901,8 +5868,8 @@ def _remember_recent_edit(self, execution: ToolCallExecution) -> None: except ValueError: path = filepath intention = " ".join(execution.call.intention.split()) or execution.call.name - self.runtime.recent_edits.append("- " + path + ": " + _shorten(intention, 160)) - self.runtime.recent_edits = self.runtime.recent_edits[-self.RECENT_EDITS :] + self.recent_edits.append("- " + path + ": " + _shorten(intention, 160)) + self.recent_edits = self.recent_edits[-self.RECENT_EDITS :] def _invalid_action_response(self, response: Json, reason: str) -> Json: return { @@ -6346,7 +6313,7 @@ def _handle_observe_response( on_message: MessageCallback | None, ) -> AgentRunResult: if ctx.pending_verify_requested: - self._warn_observe('ignored verify status="pending".', "observe must keep or forget latest results first.") + self._remember_observe_error(self._warning('ignored verify status="pending".', "observe must keep or forget latest results first.")) repeated_tool_retry_error = self._repeated_tool_retry_error(ctx.tool_calls) if repeated_tool_retry_error: return self._reject_result( diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index aea5c4e..545212b 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -400,7 +400,7 @@ def test_observe_prompt_uses_narrow_context(tmp_path): agent.blackboard.known = ["known fact"] agent.blackboard.stable_knowledge = {"workflow": ["use pytest"]} agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] - agent.runtime.recent_edits = ["- sample.py: old edit"] + agent.recent_edits = ["- sample.py: old edit"] agent.agent_feedback_errors = ["act error"] agent.observe_feedback_errors = ["observe error"] agent.tool_context.latest = ['- ok tool=Read args=["sample.py"] key=tr.2\n output:\nraw alpha'] @@ -2535,7 +2535,7 @@ def test_agent_execute_tool_calls_shows_auto_approval_in_yolo_mode(tmp_path): assert path.read_text(encoding="utf-8") == "new\n" assert agent.blackboard.verification_required is True assert agent.blackboard.task_code == nanocode.TaskCode.VERIFYING - assert agent.runtime.recent_edits == ["- sample.txt: edit sample"] + assert agent.recent_edits == ["- sample.txt: edit sample"] def test_agent_run_loops_tool_results_into_next_model_prompt(tmp_path): From 217649e819da30586e15277d94ec20c37cb8b284 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 00:53:47 -0700 Subject: [PATCH 020/144] Relax observe coverage and lower pending result threshold --- nanocode.py | 48 +++++++----------------------------- tests/test_nanocode_agent.py | 47 ++++++++++++++++++----------------- 2 files changed, 33 insertions(+), 62 deletions(-) diff --git a/nanocode.py b/nanocode.py index fb1afd7..253c563 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3438,7 +3438,7 @@ def _state_tool_schema(name: str) -> Json: --- Output --- Use function tools only. -Keep or forget Unreduced Raw Tool Results. +Prefer explicit keep/forget decisions. Omitted results are compacted by default. YOUR OUTPUT: """ @@ -3449,12 +3449,12 @@ def _state_tool_schema(name: str) -> Json: Job: - Reduce Unreduced Raw Tool Results before ACT continues. -- Cover every unreduced tr.N key with keep or forget. +- Prefer declaring keep or forget for each result you reviewed. - keep only raw results that affect the next ACT frontier: target selection, edit choice, verification, error repair, or completion. - forget routine success, duplicate listings, no-match searches, superseded results, and ruled-out branches. Forget preserves logs and Recall. +- If you omit a tr.N key, nanocode compacts it by default; use omission only for unimportant results. - Before forgetting an important conclusion, preserve it with known, hypothesis, or stable_knowledge. - Do not update Plan, Verify, or Goal. -- Do not return {"actions":[]}. Allowed tools: keep, forget, known, hypothesis, stable_knowledge. """ @@ -5187,7 +5187,7 @@ class Agent: # Compact recall/timeline entries shown in Tool Result Index; current-task timeline has priority over archived entries. TOOL_RESULT_INDEX_ITEMS: ClassVar[int] = 40 # Trigger observe after this many unresolved raw result blocks accumulate; raw-size pressure can still trigger earlier. - OBSERVE_AFTER_PENDING_RESULT_COUNT: ClassVar[int] = 12 + OBSERVE_AFTER_PENDING_RESULT_COUNT: ClassVar[int] = 10 PLAN_MODE_GIT_READONLY: ClassVar[frozenset[str]] = GIT_READONLY_COMMANDS RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." RULE_CLOSE_SOURCE: ClassVar[str] = "close the hypothesis before forgetting its source." @@ -6336,45 +6336,15 @@ def _handle_observe_response( forget_gate = self._gate_forget_actions(ctx.actions, on_message, self._remember_observe_error) if forget_gate is not None: return forget_gate - if not ctx.actions: - return self._reject_result( - self._remember_observe_error, - on_message, - self._error("observe returned no actions.", "keep useful results or forget latest results with a reason."), - "Retrying: keep or forget latest results.", - "Observe_Gate: empty actions are not a checkpoint; return keep or forget.", - ) observed_blocks = self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter) observed_counter = ToolResultContext.max_counter(observed_blocks) - covered = { - key - for action in ctx.actions - if _json_str(action.get("type")) in {"keep", "forget"} - for key in _source_from_json(action) - if key.startswith("tr.") - } - missing_observe_keys = [key for key in ToolResultContext.blocks_by_key(observed_blocks) if key not in covered] - if missing_observe_keys: - self._remember_observe_error( - self._error("observe missed result key(s): " + ", ".join(missing_observe_keys) + ".", "cover each latest result with keep or forget.") - ) - self._report_gate( - on_message, - "Retrying: cover every latest result key with keep or forget.", - "Observe_Gate: missing coverage for result keys: " + ", ".join(missing_observe_keys) + ".", - ) - return AgentRunResult() forgotten_keys = self.apply_response(response) self._emit_state_and_text(ctx, on_message) - kept_keys: list[str] = [] - if any(_json_str(action.get("type")) in {"keep", "forget", "known", "stable_knowledge"} for action in ctx.actions): - self.mode = AgentMode.ACT - kept_keys = self.tool_context.keep_results(ctx.actions, observed_blocks, max_chars=self.KEPT_TOOL_RESULT_CHARS) - self.tool_context.compact_observed(observed_blocks) - self._mark_memory_checkpoint(observed_counter) - self.observe_feedback_errors = [] - else: - self.mode = AgentMode.OBSERVE + self.mode = AgentMode.ACT + kept_keys = self.tool_context.keep_results(ctx.actions, observed_blocks, max_chars=self.KEPT_TOOL_RESULT_CHARS) + self.tool_context.compact_observed(observed_blocks) + self._mark_memory_checkpoint(observed_counter) + self.observe_feedback_errors = [] self._emit_tool_context_update(kept_keys, forgotten_keys, on_message) self._promote_required_verification(ctx) return AgentRunResult() diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 545212b..e79162c 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -346,7 +346,7 @@ def test_agent_act_context_keeps_pending_raw_after_latest_rotates(tmp_path): assert "output:\n" not in index -def test_observe_text_does_not_checkpoint_tool_results(tmp_path): +def test_empty_observe_compacts_unreduced_tool_results(tmp_path): (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) @@ -358,11 +358,9 @@ def test_observe_text_does_not_checkpoint_tool_results(tmp_path): agent.handle_response({"actions": [], "_assistant_text": "checking result"}) - assert agent.blackboard.memory_checkpoint_tool_result_counter == 0 - assert agent.mode == nanocode.AgentMode.OBSERVE - unreduced = _blocks_text(agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter)) - assert "one.txt" in unreduced - assert "two.txt" in unreduced + assert agent.blackboard.memory_checkpoint_tool_result_counter == 2 + assert agent.mode == nanocode.AgentMode.ACT + assert agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter) == [] def test_assistant_text_does_not_mark_memory_checkpoint(tmp_path): @@ -642,10 +640,10 @@ def test_observe_forget_does_not_cover_latest_result_key(tmp_path): result = agent.handle_response({"actions": [{"type": "forget", "source": ["tr.1"], "reason": "old branch ruled out"}]}, on_message=messages.append) assert result.done is False - assert agent.mode == nanocode.AgentMode.OBSERVE - assert "tr.1" in _blocks_text(agent.tool_context.kept_results) - assert any("tr.2" in error for error in agent.observe_feedback_errors) - assert messages == ["Observe_Gate: missing coverage for result keys: tr.2."] + assert agent.mode == nanocode.AgentMode.ACT + assert "tr.1" not in _blocks_text(agent.tool_context.kept_results) + assert agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter) == [] + assert messages == ["Tool Result Context: -tr.1"] def test_observe_can_forget_old_kept_result_while_forgetting_latest(tmp_path): @@ -701,21 +699,24 @@ def test_keep_action_is_observe_only(tmp_path): assert any("Invalid action(s): keep" in error for error in agent.agent_feedback_errors) -def test_observe_rejects_invalid_action_and_empty_actions(tmp_path): +def test_observe_rejects_invalid_action_and_allows_empty_actions(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) agent.mode = nanocode.AgentMode.OBSERVE agent.handle_response({"actions": [{"type": "goal", "text": "answer", "complete": False}]}) - agent.handle_response({"actions": []}) - assert any("latest results must be observed" in error for error in agent.observe_feedback_errors) - assert any("observe returned no actions" in error for error in agent.observe_feedback_errors) assert agent.mode == nanocode.AgentMode.OBSERVE + agent.handle_response({"actions": []}) -def test_observe_requires_every_result_key_to_be_covered(tmp_path): + assert agent.mode == nanocode.AgentMode.ACT + assert agent.observe_feedback_errors == [] + assert agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter) == [] + + +def test_observe_compacts_unmentioned_result_keys_by_default(tmp_path): agent = Agent(_session(tmp_path, debug=True)) agent.mode = nanocode.AgentMode.OBSERVE agent.tool_context.latest = [ @@ -730,10 +731,10 @@ def test_observe_requires_every_result_key_to_be_covered(tmp_path): ) assert result.done is False - assert agent.mode == nanocode.AgentMode.OBSERVE - assert "tr.2" in _blocks_text(agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter)) - assert any("tr.2" in error for error in agent.observe_feedback_errors) - assert messages == ["Observe_Gate: missing coverage for result keys: tr.2."] + assert agent.mode == nanocode.AgentMode.ACT + assert "tr.1" in _blocks_text(agent.tool_context.kept_results) + assert agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter) == [] + assert messages == ["Tool Result Context: +tr.1"] def test_observe_forget_source_covers_result_key(tmp_path): @@ -749,16 +750,16 @@ def test_observe_forget_source_covers_result_key(tmp_path): assert agent.tool_context.kept_results == [] -def test_observe_known_source_does_not_cover_result_key(tmp_path): +def test_observe_known_source_compacts_result_key_by_default(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.mode = nanocode.AgentMode.OBSERVE agent.tool_context.latest = ['- ok tool=Read args=["a"] key=tr.1\n output:\na'] agent.handle_response({"actions": [{"type": "known", "items": [{"source": ["tr.1"], "text": "a exists"}]}]}) - assert agent.mode == nanocode.AgentMode.OBSERVE - assert agent.blackboard.known == [] - assert any("tr.1" in error for error in agent.observe_feedback_errors) + assert agent.mode == nanocode.AgentMode.ACT + assert [nanocode.KnownItem.format_item(item) for item in agent.blackboard.known] == ["[tr.1] a exists"] + assert agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter) == [] def test_kept_tool_results_respect_char_budget(tmp_path): From 39c7606275e2cfae0c0648b63fa1a4b754e9f606 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 01:25:50 -0700 Subject: [PATCH 021/144] Show current plan focus in act prompt --- nanocode.py | 12 ++++++++++++ tests/test_nanocode_agent.py | 26 ++++++++++++++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/nanocode.py b/nanocode.py index 253c563..403ee53 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3378,6 +3378,9 @@ def _state_tool_schema(name: str) -> Json: Plan: {plan} +Current Focus: +{current_focus} + Hypotheses: {hypotheses} @@ -5237,6 +5240,7 @@ def build_user_prompt(self) -> str: work_mode=current.work_mode, goal=current.goal or "(empty)", plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", + current_focus=self._format_current_focus(), hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", verification_state=current.verification.format(), errors=self._format_agent_feedback() or "(empty)", @@ -5244,6 +5248,14 @@ def build_user_prompt(self) -> str: user_request=self._format_user_request(), ).strip() + def _format_current_focus(self) -> str: + plan = self.blackboard.plan + item = next((item for item in plan if item.status == PlanStatus.DOING), None) or next( + (item for item in plan if item.status == PlanStatus.TODO), + None, + ) + return item.format() if item else "(empty)" + def build_observe_prompt(self) -> str: current = self.blackboard return AGENT_OBSERVE_USER_PROMPT_TEMPLATE.format( diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index e79162c..274b3e1 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -427,6 +427,32 @@ def test_observe_prompt_uses_narrow_context(tmp_path): assert "old edit" not in prompt +def test_act_prompt_includes_current_focus_from_doing_plan_item(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.blackboard.plan = [ + nanocode.PlanItem(id="p1", text="inspect config", status=nanocode.PlanStatus.DONE), + nanocode.PlanItem(id="p2", text="edit command handler", status=nanocode.PlanStatus.DOING, context="next change"), + nanocode.PlanItem(id="p3", text="run tests", status=nanocode.PlanStatus.TODO), + ] + + prompt = agent.build_user_prompt() + + assert "Current Focus:\n- [◔ doing] edit command handler (id=p2)\n context: next change" in prompt + + +def test_act_prompt_uses_first_todo_as_current_focus(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.blackboard.plan = [ + nanocode.PlanItem(id="p1", text="inspect config", status=nanocode.PlanStatus.DONE), + nanocode.PlanItem(id="p2", text="edit command handler", status=nanocode.PlanStatus.TODO), + nanocode.PlanItem(id="p3", text="run tests", status=nanocode.PlanStatus.TODO), + ] + + prompt = agent.build_user_prompt() + + assert "Current Focus:\n- [○ todo] edit command handler (id=p2)" in prompt + + def test_act_prompt_includes_kept_tool_results(tmp_path): (tmp_path / "sample.txt").write_text("alpha unique\n", encoding="utf-8") (tmp_path / "other.txt").write_text("beta unique\n", encoding="utf-8") From e39f37abea157ebcc8274f7064442ce4ccf41ec4 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 03:12:38 -0700 Subject: [PATCH 022/144] Add context budget profiles --- README.md | 1 + nanocode.py | 149 ++++++++++++++++++++++++++++---- tests/test_nanocode_agent.py | 27 ++++++ tests/test_nanocode_commands.py | 24 +++++ tests/test_nanocode_loop.py | 1 + 5 files changed, 187 insertions(+), 15 deletions(-) diff --git a/README.md b/README.md index 6b16913..c4edd50 100644 --- a/README.md +++ b/README.md @@ -102,6 +102,7 @@ Run `nanocode --init-config` to create `~/.nanocode/config.toml`. - Provider auto-detection covers common providers: OpenAI/OpenRouter prefer Responses API; DeepSeek, selected OpenCode models, and DashScope models use their matching Chat reasoning payload shapes. - Path config: `[paths] data_dir = "~/.nanocode"`. - Runtime config: `[runtime]`. +- `/context [low|medium|high]` shows or switches tool-result context budgets; lower budgets reduce token usage and observe overhead. - Session data: debug prompts and tool-result logs are stored under `~/.nanocode/sessions//`. - Old inactive session directories are auto-cleaned after `runtime.auto_clean_recent` (default `1d`; use `off` to disable). `/clean` removes inactive sessions immediately. - Project data: user rules are stored under `~/.nanocode/projects//`. diff --git a/nanocode.py b/nanocode.py index 403ee53..0a6ee6a 100644 --- a/nanocode.py +++ b/nanocode.py @@ -565,6 +565,25 @@ def add(self, *, prompt_tokens: int, completion_tokens: int, total_tokens: int) self.total_tokens += total_tokens +CONTEXT_BUDGET_CHOICES: tuple[str, ...] = ("low", "medium", "high") + + +@dataclass(frozen=True) +class ContextBudget: + raw_chars: int + kept_chars: int + kept_block_chars: int + index_items: int + observe_after_results: int + planless_discovery_tool_calls: int + + +CONTEXT_BUDGETS: dict[str, ContextBudget] = { + "low": ContextBudget(36_000, 16_000, 4_000, 20, 6, 6), + "high": ContextBudget(120_000, 64_000, 8_000, 60, 16, 12), +} + + ############################ # Config ############################ @@ -578,6 +597,7 @@ class RuntimeSettings: plan_timeout: int = 360 plan_first_token_timeout: int = 180 auto_clean_recent: str = "1d" + context_budget: str = "medium" yolo: bool = False plan_mode: bool = False debug: bool = False @@ -592,6 +612,7 @@ def from_dict(cls, data: Json, *, yolo: bool = False, plan_mode: bool = False, d plan_timeout=max(1, Config.int(runtime, "plan_timeout", 360) or 0), plan_first_token_timeout=max(1, Config.int(runtime, "plan_first_token_timeout", 180) or 0), auto_clean_recent=cls.clean_retention(Config.str(runtime, "auto_clean_recent", "1d")), + context_budget=cls.clean_context_budget(Config.str(runtime, "context_budget", "medium")), yolo=yolo or bool(Config.bool(runtime, "yolo", False)), plan_mode=plan_mode or bool(Config.bool(runtime, "plan_mode", False)), debug=debug, @@ -614,6 +635,13 @@ def clean_retention_seconds(value: str) -> int: units = {"m": 60, "h": 3600, "d": 86400} return int(value[:-1]) * units[value[-1]] + @staticmethod + def clean_context_budget(value: str) -> str: + value = value.strip().lower() + if value not in CONTEXT_BUDGET_CHOICES: + raise ConfigError("runtime.context_budget must be one of: " + ", ".join(CONTEXT_BUDGET_CHOICES)) + return value + @dataclass class Config: @@ -740,6 +768,7 @@ class ConfigFile: max_agent_steps = 100 plan_timeout = 360 plan_first_token_timeout = 180 +context_budget = "medium" # Automatically delete inactive session directories older than this. Use "off" to disable. auto_clean_recent = "1d" yolo = false @@ -1382,6 +1411,7 @@ def _tool_call_args_key(args: list[JsonValue]) -> tuple[str, ...]: @dataclass class ToolResultContext: + COMPACT_OUTPUT_SUMMARY_CHARS: ClassVar[int] = 120 latest: list[str] = field(default_factory=list) recent: list[str] = field(default_factory=list) kept_results: list[str] = field(default_factory=list) @@ -1409,7 +1439,7 @@ def update(blocks: list[str], *, compact: bool) -> list[str]: self.recent = update(self.recent, compact=True) return list(dict.fromkeys(removed)) - def keep_results(self, actions: list[Json], observed_blocks: list[str], *, max_chars: int) -> list[str]: + def keep_results(self, actions: list[Json], observed_blocks: list[str], *, max_chars: int, max_block_chars: int) -> list[str]: wanted = [] for action in actions: if _json_str(action.get("type")) == "keep": @@ -1418,16 +1448,20 @@ def keep_results(self, actions: list[Json], observed_blocks: list[str], *, max_c if not wanted: return [] by_key = self.blocks_by_key(observed_blocks) - selected = {key: by_key[key] for key in wanted if key in by_key} + selected = {key: self.bound_block(by_key[key], max_chars=max_block_chars) for key in wanted if key in by_key} if not selected: return [] existing = self.blocks_by_key(self.kept_results) self.kept_results = [block for key, block in existing.items() if key not in selected] + [selected[key] for key in wanted if key in selected] - while self.kept_results and len("\n\n".join(self.kept_results)) > max_chars: - del self.kept_results[0] + self.bound_kept(max_chars=max_chars, max_block_chars=max_block_chars) retained = self.blocks_by_key(self.kept_results) return [key for key in wanted if key in selected and key in retained] + def bound_kept(self, *, max_chars: int, max_block_chars: int) -> None: + self.kept_results = [self.bound_block(block, max_chars=max_block_chars) for block in self.kept_results] + while self.kept_results and len("\n\n".join(self.kept_results)) > max_chars: + del self.kept_results[0] + def append_latest(self, executions: list[ToolCallExecution], *, max_index_items: int, checkpoint: int) -> None: if not executions: return @@ -1540,9 +1574,22 @@ def compact_block(cls, block: str) -> str: if match: parts.append("recall=" + match.group(1)) elif output: - parts.append(_shorten(" ".join(output.split()), 220)) + parts.append(_shorten(" ".join(output.split()), cls.COMPACT_OUTPUT_SUMMARY_CHARS)) return header + "\n out: " + ("; ".join(parts) if parts else "ok") + @classmethod + def bound_block(cls, block: str, *, max_chars: int) -> str: + if len(block) <= max_chars: + return block + if not cls.is_full_block(block): + return _shorten(block, max_chars) + header, output = block.split("\n output:\n", 1) + separator = "\n output:\n" + output_budget = max_chars - len(header) - len(separator) + if output_budget <= 0: + return _shorten(cls.compact_block(block), max_chars) + return header + separator + _bound_tool_output(output, max_chars=output_budget).value + @classmethod def result_key(cls, block: str) -> str: match = RESULT_KEY_PATTERN.search(block) @@ -5186,11 +5233,13 @@ class Agent: # Reducer trigger, not a pre-observe truncation limit: unreduced raw must stay visible until OBSERVE can keep or forget it. TOOL_RESULT_RAW_CHARS: ClassVar[int] = 72_000 # Raw results explicitly kept by OBSERVE are bounded separately from latest/unreduced raw. - KEPT_TOOL_RESULT_CHARS: ClassVar[int] = 96_000 + KEPT_TOOL_RESULT_CHARS: ClassVar[int] = 32_000 + KEPT_TOOL_RESULT_BLOCK_CHARS: ClassVar[int] = 6_000 # Compact recall/timeline entries shown in Tool Result Index; current-task timeline has priority over archived entries. - TOOL_RESULT_INDEX_ITEMS: ClassVar[int] = 40 + TOOL_RESULT_INDEX_ITEMS: ClassVar[int] = 30 # Trigger observe after this many unresolved raw result blocks accumulate; raw-size pressure can still trigger earlier. OBSERVE_AFTER_PENDING_RESULT_COUNT: ClassVar[int] = 10 + PLANLESS_DISCOVERY_TOOL_CALLS: ClassVar[int] = 8 PLAN_MODE_GIT_READONLY: ClassVar[frozenset[str]] = GIT_READONLY_COMMANDS RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." RULE_CLOSE_SOURCE: ClassVar[str] = "close the hypothesis before forgetting its source." @@ -5222,6 +5271,24 @@ def __init__(self, session: Session): self.stream_stop_requested = False self.mode = AgentMode.ACT + def context_budget(self) -> ContextBudget: + if self.session.settings.context_budget == "medium": + return ContextBudget( + self.TOOL_RESULT_RAW_CHARS, + self.KEPT_TOOL_RESULT_CHARS, + self.KEPT_TOOL_RESULT_BLOCK_CHARS, + self.TOOL_RESULT_INDEX_ITEMS, + self.OBSERVE_AFTER_PENDING_RESULT_COUNT, + self.PLANLESS_DISCOVERY_TOOL_CALLS, + ) + return CONTEXT_BUDGETS[self.session.settings.context_budget] + + def apply_context_budget(self) -> None: + budget = self.context_budget() + checkpoint = self.blackboard.memory_checkpoint_tool_result_counter + self.tool_context.bound_kept(max_chars=budget.kept_chars, max_block_chars=budget.kept_block_chars) + self.tool_context.prune_recent(max_index_items=budget.index_items, checkpoint=checkpoint) + def build_user_prompt(self) -> str: tool_result_index, unreduced_tool_results, latest_tool_results = self._format_act_tool_result_context() current = self.blackboard @@ -5456,13 +5523,14 @@ def _finish_current_goal(self) -> None: def _format_act_tool_result_context(self) -> tuple[str, str, str]: checkpoint = self.blackboard.memory_checkpoint_tool_result_counter - timeline = self.tool_context.current_timeline_blocks()[-self.TOOL_RESULT_INDEX_ITEMS :] + budget = self.context_budget() + timeline = self.tool_context.current_timeline_blocks()[-budget.index_items :] unreduced = self.tool_context.unreduced_recent_blocks(checkpoint) latest = self.tool_context.latest_raw_blocks() visible_keys = set( ToolResultContext.blocks_by_key(timeline + unreduced + latest + self.tool_context.kept_results) ) - archived_limit = max(0, self.TOOL_RESULT_INDEX_ITEMS - len(timeline)) + archived_limit = max(0, budget.index_items - len(timeline)) archived = self._format_archived_tool_result_index(visible_keys, limit=archived_limit) index = self._format_tool_result_index(archived, timeline) return index, "\n\n".join(unreduced), "\n\n".join(latest) @@ -5776,7 +5844,7 @@ def execute_tool_calls( ) self.tool_context.append_latest( self.tool_runner.latest_executions, - max_index_items=self.TOOL_RESULT_INDEX_ITEMS, + max_index_items=self.context_budget().index_items, checkpoint=self.blackboard.memory_checkpoint_tool_result_counter, ) self.session.state.turn_tool_calls += len(self.tool_runner.latest_executions) @@ -5791,11 +5859,12 @@ def _should_observe_after_tools(self) -> bool: pending = self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter) if not pending: return False + budget = self.context_budget() # Tool failures stay visible to ACT as Latest Tool Results plus feedback. # Very large failures still trigger observe through raw-context pressure. - return len(pending) >= self.OBSERVE_AFTER_PENDING_RESULT_COUNT or self.tool_context.raw_context_chars( + return len(pending) >= budget.observe_after_results or self.tool_context.raw_context_chars( self.blackboard.memory_checkpoint_tool_result_counter - ) >= self.TOOL_RESULT_RAW_CHARS + ) >= budget.raw_chars def _after_tool_execution(self, execution: ToolCallExecution) -> None: self._remember_tool_failure(execution) @@ -6225,6 +6294,13 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | and (ctx.pending_verify_requested or self._has_non_readonly_tool_call(ctx.tool_calls)) ): self._warn_agent("mutating work before Plan was set.", self.RULE_GOAL_PLAN_FIRST) + if ( + ctx.plan_was_empty + and not self.blackboard.plan + and ctx.tool_calls + and self.session.state.turn_tool_calls + len(ctx.tool_calls) >= self.context_budget().planless_discovery_tool_calls + ): + self._warn_agent("Plan is empty after discovery.", "set a short Plan before more broad exploration.") if ( ctx.tool_calls @@ -6353,7 +6429,12 @@ def _handle_observe_response( forgotten_keys = self.apply_response(response) self._emit_state_and_text(ctx, on_message) self.mode = AgentMode.ACT - kept_keys = self.tool_context.keep_results(ctx.actions, observed_blocks, max_chars=self.KEPT_TOOL_RESULT_CHARS) + kept_keys = self.tool_context.keep_results( + ctx.actions, + observed_blocks, + max_chars=self.context_budget().kept_chars, + max_block_chars=self.context_budget().kept_block_chars, + ) self.tool_context.compact_observed(observed_blocks) self._mark_memory_checkpoint(observed_counter) self.observe_feedback_errors = [] @@ -6498,7 +6579,7 @@ def run( self.failed_tool_call_key = None self.failed_tool_call_count = 0 self.tool_context.prune_recent( - max_index_items=self.TOOL_RESULT_INDEX_ITEMS, + max_index_items=self.context_budget().index_items, checkpoint=self.blackboard.memory_checkpoint_tool_result_counter, ) self._prune_tool_result_store() @@ -6648,6 +6729,7 @@ class CommandSpec: CommandSpec("/knowledge", "Show stable knowledge", "Info", "/knowledge"), CommandSpec("/compact", "Compact conversation history", "Info", "/compact"), CommandSpec("/config", "Show resolved runtime config", "Config", "/config"), + CommandSpec("/context", "Show or set context budget", "Config", "/context [low|medium|high]"), CommandSpec("/set", "Set a runtime config override", "Config", "/set "), CommandSpec("/api", "Show or set provider API format", "Config", "/api [auto|chat|responses]"), CommandSpec("/model", "Show or set model and reasoning", "Config", "/model [model_name]"), @@ -6682,6 +6764,7 @@ class CommandSpec: "runtime.max_agent_steps": "max_agent_steps", "runtime.plan_timeout": "plan_timeout", "runtime.plan_first_token_timeout": "plan_first_token_timeout", + "runtime.context_budget": "context_budget", "runtime.yolo": "yolo", } CONFIG_SET_KEYS: tuple[str, ...] = tuple(CONFIG_PROVIDER_ATTRS) + tuple(CONFIG_RUNTIME_ATTRS) @@ -6690,6 +6773,7 @@ class CommandSpec: "provider.chat_reasoning": CHAT_REASONING_CHOICES, "provider.stream": ("on", "off"), "provider.temperature": ("off",), + "runtime.context_budget": CONTEXT_BUDGET_CHOICES, "runtime.yolo": ("on", "off"), } CONFIG_BOOL_KEYS: set[str] = {"provider.stream", "runtime.yolo"} @@ -6731,6 +6815,9 @@ def __init__( "/rules": self._rules, "/compact": self._compact, "/config": self._config, + "/context": self._context, + "/context-budget": self._context, + "/context_budget": self._context, "/set": self._set, "/api": self._api, "/clean": self._clean, @@ -6981,7 +7068,9 @@ def _status(self, args: str) -> str: + " plan=" + self._format_bool(session.settings.plan_mode) + " compact_at=" - + str(session.settings.compact_at), + + str(session.settings.compact_at) + + " context_budget=" + + session.settings.context_budget, "conversation: " + str(len(session.state.conversation)) + "/" + str(session.settings.compact_at), "tool_calls: turn=" + str(session.state.turn_tool_calls) + " session=" + str(session.state.session_tool_calls), "tokens: last=" + _format_count(session.state.last_total_tokens) + " session=" + _format_count(session.state.session_total_tokens), @@ -6998,6 +7087,29 @@ def _compact(self, args: str) -> str: return "Usage: /compact" return self._with_status(self._compact_history) + def _context(self, args: str) -> str: + value = args.strip() + if value: + if value not in CONTEXT_BUDGET_CHOICES: + return "Usage: /context [low|medium|high]" + self.agent.session.settings.context_budget = value + self.agent.apply_context_budget() + return "Set runtime.context_budget = " + value + "\n" + self._format_context_budget() + return self._format_context_budget() + + def _format_context_budget(self) -> str: + budget = self.agent.context_budget() + return "\n".join( + [ + "context_budget: " + self.agent.session.settings.context_budget, + "raw_chars: " + str(budget.raw_chars), + "kept_chars: " + str(budget.kept_chars), + "kept_block_chars: " + str(budget.kept_block_chars), + "index_items: " + str(budget.index_items), + "observe_after_results: " + str(budget.observe_after_results), + ] + ) + def _compact_history(self) -> str: before = len(self.agent.session.state.conversation) count = self.agent.compact_history() @@ -7040,6 +7152,7 @@ def _config(self, args: str) -> str: "runtime.max_agent_steps: " + str(session.settings.max_agent_steps), "runtime.plan_timeout: " + str(session.settings.plan_timeout), "runtime.plan_first_token_timeout: " + str(session.settings.plan_first_token_timeout), + "runtime.context_budget: " + session.settings.context_budget, "runtime.auto_clean_recent: " + session.settings.auto_clean_recent, "runtime.yolo: " + self._format_bool(session.settings.yolo), "runtime.plan_mode: " + self._format_bool(session.settings.plan_mode), @@ -7110,6 +7223,12 @@ def _apply_config_value(self, key: str, value: str) -> str: return "Usage: /set " + key + " [" + "|".join(CHAT_REASONING_CHOICES) + "]" setattr(target, attr, value) return "" + if key == "runtime.context_budget": + if value not in CONTEXT_BUDGET_CHOICES: + return "Usage: /set " + key + " [" + "|".join(CONTEXT_BUDGET_CHOICES) + "]" + setattr(target, attr, value) + self.agent.apply_context_budget() + return "" if key == "provider.temperature": if value == "off": setattr(target, attr, None) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 274b3e1..6942efd 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -810,6 +810,22 @@ def test_kept_tool_results_respect_char_budget(tmp_path): assert "key=tr.2" in context +def test_kept_tool_results_respect_per_block_char_budget(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.mode = nanocode.AgentMode.OBSERVE + agent.KEPT_TOOL_RESULT_CHARS = 10_000 + agent.KEPT_TOOL_RESULT_BLOCK_CHARS = 300 + agent.tool_context.latest = [ + '- ok tool=Read args=["large.py"] key=tr.1\n output:\n' + ("head\n" + ("x" * 2000) + "\ntail") + ] + + agent.handle_response({"actions": [{"type": "keep", "source": ["tr.1"], "reason": "large output matters"}]}) + + assert len(agent.tool_context.kept_results[0]) <= 300 + assert "key=tr.1" in agent.tool_context.kept_results[0] + assert "[tool result excerpt]" in agent.tool_context.kept_results[0] + + def test_observe_checkpoint_clears_observe_errors(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) @@ -3239,6 +3255,17 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert any("state update-only turn" in error for error in agent.agent_feedback_errors) +def test_agent_warns_when_discovery_runs_long_without_plan(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.blackboard.goal = "investigate" + agent.PLANLESS_DISCOVERY_TOOL_CALLS = 2 + + agent.handle_response({"actions": [{"type": "tool", "name": "ListDir", "intention": "inspect root", "args": ["."]}]}) + agent.handle_response({"actions": [{"type": "tool", "name": "ListDir", "intention": "inspect root again", "args": ["."]}]}) + + assert any("Plan is empty after discovery" in error for error in agent.agent_feedback_errors) + + def test_agent_run_reports_continuation_only_when_no_actions(tmp_path): class FakeModelClient: def __init__(self): diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 7bc1271..95ef802 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -62,6 +62,7 @@ def test_command_dispatcher_updates_config_and_auto_compacts(tmp_path): first_token_result = dispatcher.dispatch("/set provider.first_token_timeout 6") yolo_result = dispatcher.dispatch("/set runtime.yolo on") compact_result = dispatcher.dispatch("/set runtime.compact_at 2") + context_result = dispatcher.dispatch("/set runtime.context_budget low") exit_result = dispatcher.dispatch("/exit") assert model_result.status == CommandStatus.HANDLED @@ -78,6 +79,8 @@ def test_command_dispatcher_updates_config_and_auto_compacts(tmp_path): assert session.settings.yolo is True assert compact_result.message == "Set runtime.compact_at = 2" assert session.settings.compact_at == 2 + assert context_result.message == "Set runtime.context_budget = low" + assert session.settings.context_budget == "low" assert len(session.state.conversation) == 3 assert fake_client.requests == [] assert exit_result.status == CommandStatus.EXIT @@ -153,6 +156,7 @@ def test_config_command_reports_resolved_provider_config(tmp_path): assert "runtime.max_agent_steps: 100" in result.message assert "runtime.plan_timeout: 360" in result.message assert "runtime.plan_first_token_timeout: 180" in result.message + assert "runtime.context_budget: medium" in result.message assert "runtime.auto_clean_recent: 1d" in result.message assert "runtime.plan_mode: off" in result.message @@ -170,6 +174,26 @@ def test_set_command_updates_plan_timeouts(tmp_path): assert session.settings.plan_first_token_timeout == 80 +def test_context_command_shows_and_sets_budget(tmp_path): + session = make_session(tmp_path) + agent = Agent(session) + agent.tool_context.kept_results = ['- ok tool=Read args=["large.py"] key=tr.1\n output:\n' + ("x" * 10_000)] + dispatcher = CommandDispatcher(agent) + + show_result = dispatcher.dispatch("/context") + set_result = dispatcher.dispatch("/context low") + alias_result = dispatcher.dispatch("/context_budget high") + invalid_result = dispatcher.dispatch("/context tiny") + + assert "context_budget: medium" in show_result.message + assert "observe_after_results: 10" in show_result.message + assert set_result.message.startswith("Set runtime.context_budget = low\ncontext_budget: low") + assert session.settings.context_budget == "high" + assert len(agent.tool_context.kept_results[0]) <= agent.context_budget().kept_block_chars + assert alias_result.message.startswith("Set runtime.context_budget = high\ncontext_budget: high") + assert invalid_result.message == "Usage: /context [low|medium|high]" + + def test_plan_command_toggles_plan_mode(tmp_path): session = make_session(tmp_path) dispatcher = CommandDispatcher(Agent(session)) diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 322f6c0..d12cd2d 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -86,6 +86,7 @@ def test_init_config_file_writes_default_toml(tmp_path): assert config["runtime"]["compact_at"] == 50 assert config["runtime"]["plan_timeout"] == 360 assert config["runtime"]["plan_first_token_timeout"] == 180 + assert config["runtime"]["context_budget"] == "medium" assert config["runtime"]["auto_clean_recent"] == "1d" assert config["runtime"]["yolo"] is False assert config["runtime"]["plan_mode"] is False From 140b704a22fac3576d7353bd5c35a287fa09b7c0 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 03:58:54 -0700 Subject: [PATCH 023/144] Simplify agent context and gate helpers --- nanocode.py | 172 +++++++++++------------------------ tests/test_nanocode_agent.py | 67 +++++++------- 2 files changed, 91 insertions(+), 148 deletions(-) diff --git a/nanocode.py b/nanocode.py index 0a6ee6a..5f9ab9a 100644 --- a/nanocode.py +++ b/nanocode.py @@ -580,6 +580,7 @@ class ContextBudget: CONTEXT_BUDGETS: dict[str, ContextBudget] = { "low": ContextBudget(36_000, 16_000, 4_000, 20, 6, 6), + "medium": ContextBudget(72_000, 32_000, 6_000, 30, 10, 8), "high": ContextBudget(120_000, 64_000, 8_000, 60, 16, 12), } @@ -5199,6 +5200,7 @@ class ResponseContext: has_plan_action: bool has_fresh_plan_action: bool has_user_rule_action: bool + has_non_readonly_tool_call: bool has_state_update_action: bool state_or_work_requested: bool @@ -5230,16 +5232,6 @@ class Agent: COMPLETED_PLAN_STATUSES: ClassVar[set[PlanStatus]] = {PlanStatus.DONE, PlanStatus.BLOCKED} MAX_COMPLETED_GOAL_TOOL_RESULTS: ClassVar[int] = 50 RECENT_EDITS: ClassVar[int] = 20 - # Reducer trigger, not a pre-observe truncation limit: unreduced raw must stay visible until OBSERVE can keep or forget it. - TOOL_RESULT_RAW_CHARS: ClassVar[int] = 72_000 - # Raw results explicitly kept by OBSERVE are bounded separately from latest/unreduced raw. - KEPT_TOOL_RESULT_CHARS: ClassVar[int] = 32_000 - KEPT_TOOL_RESULT_BLOCK_CHARS: ClassVar[int] = 6_000 - # Compact recall/timeline entries shown in Tool Result Index; current-task timeline has priority over archived entries. - TOOL_RESULT_INDEX_ITEMS: ClassVar[int] = 30 - # Trigger observe after this many unresolved raw result blocks accumulate; raw-size pressure can still trigger earlier. - OBSERVE_AFTER_PENDING_RESULT_COUNT: ClassVar[int] = 10 - PLANLESS_DISCOVERY_TOOL_CALLS: ClassVar[int] = 8 PLAN_MODE_GIT_READONLY: ClassVar[frozenset[str]] = GIT_READONLY_COMMANDS RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." RULE_CLOSE_SOURCE: ClassVar[str] = "close the hypothesis before forgetting its source." @@ -5272,15 +5264,6 @@ def __init__(self, session: Session): self.mode = AgentMode.ACT def context_budget(self) -> ContextBudget: - if self.session.settings.context_budget == "medium": - return ContextBudget( - self.TOOL_RESULT_RAW_CHARS, - self.KEPT_TOOL_RESULT_CHARS, - self.KEPT_TOOL_RESULT_BLOCK_CHARS, - self.TOOL_RESULT_INDEX_ITEMS, - self.OBSERVE_AFTER_PENDING_RESULT_COUNT, - self.PLANLESS_DISCOVERY_TOOL_CALLS, - ) return CONTEXT_BUDGETS[self.session.settings.context_budget] def apply_context_budget(self) -> None: @@ -5310,7 +5293,7 @@ def build_user_prompt(self) -> str: current_focus=self._format_current_focus(), hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", verification_state=current.verification.format(), - errors=self._format_agent_feedback() or "(empty)", + errors="\n".join("- " + error for error in self.agent_feedback_errors) or "(empty)", recent_edits="\n".join(self.recent_edits) if self.recent_edits else "(empty)", user_request=self._format_user_request(), ).strip() @@ -5325,6 +5308,7 @@ def _format_current_focus(self) -> str: def build_observe_prompt(self) -> str: current = self.blackboard + unreduced = "\n\n".join(self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter)) return AGENT_OBSERVE_USER_PROMPT_TEMPLATE.format( user_rules=self.session.state.user_rules.format(), goal=current.goal or "(empty)", @@ -5333,8 +5317,8 @@ def build_observe_prompt(self) -> str: known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", stable_knowledge=self._format_stable_knowledge(), kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", - errors=self._format_observe_feedback() or "(empty)", - unreduced_tool_results=self._format_observe_tool_result_context() or "(empty)", + errors="\n".join("- " + error for error in self.observe_feedback_errors) or "(empty)", + unreduced_tool_results=unreduced or "(empty)", user_request=self._format_user_request(), ).strip() @@ -5531,29 +5515,18 @@ def _format_act_tool_result_context(self) -> tuple[str, str, str]: ToolResultContext.blocks_by_key(timeline + unreduced + latest + self.tool_context.kept_results) ) archived_limit = max(0, budget.index_items - len(timeline)) - archived = self._format_archived_tool_result_index(visible_keys, limit=archived_limit) - index = self._format_tool_result_index(archived, timeline) - return index, "\n\n".join(unreduced), "\n\n".join(latest) - - def _format_observe_tool_result_context(self) -> str: - return "\n\n".join(self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter)) - - def _format_archived_tool_result_index(self, visible_result_keys: set[str], *, limit: int) -> list[str]: - lines = [ + archived = [ item.format(result_key=key) for key, item in self.session.state.tool_result_store.items() - if key not in visible_result_keys + if key not in visible_keys ] - return lines[-limit:] if limit > 0 else lines - - @staticmethod - def _format_tool_result_index(archived: list[str], timeline: list[str]) -> str: + archived = archived[-archived_limit:] if archived_limit > 0 else archived sections = [] if archived: sections.append("Archived Recall Index:\n" + "\n".join(archived)) if timeline: sections.append("Current Task Timeline:\n" + "\n".join(timeline)) - return "\n\n".join(sections) + return "\n\n".join(sections), "\n\n".join(unreduced), "\n\n".join(latest) def _prune_tool_result_store(self) -> None: keep = self._protected_tool_result_keys() @@ -5620,16 +5593,6 @@ def _reject_completion(self, on_message: MessageCallback | None, feedback: str, self.blackboard.goal_reached = False return self._reject_result(self._remember_agent_error, on_message, feedback, retry, debug) - def _format_agent_feedback(self) -> str: - if not self.agent_feedback_errors: - return "" - return "\n".join("- " + error for error in self.agent_feedback_errors) - - def _format_observe_feedback(self) -> str: - if not self.observe_feedback_errors: - return "" - return "\n".join("- " + error for error in self.observe_feedback_errors) - def _report_gate(self, on_message: MessageCallback | None, message: str, debug_message: str) -> None: is_retry = message.startswith(("Retrying:", "Continuing:")) if on_message is None: @@ -5921,7 +5884,11 @@ def _format_tool_arg_error(self, execution: ToolCallExecution) -> str: tool_class = TOOL_REGISTRY.get(call.name) if tool_class is None: return execution.output - params = ["filepath", "ranges"] if call.name == ReplaceRangeTool.NAME else self._exact_signature_params(tool_class.SIGNATURE) + match = re.search(r"\(([^)]*)\)", tool_class.SIGNATURE) + value = match.group(1) if match else "" + params = ["filepath", "ranges"] if call.name == ReplaceRangeTool.NAME else [] + if not params and value and not any(token in value for token in "[]*") and "..." not in value: + params = [part.strip().split("=", 1)[0].strip() for part in value.split(",") if part.strip()] if not params or len(call.args) == len(params): return execution.output detail = "got " + str(len(call.args)) + " args, expected " + str(len(params)) @@ -5931,15 +5898,6 @@ def _format_tool_arg_error(self, execution: ToolCallExecution) -> str: detail += ", extra: " + str(len(call.args) - len(params)) return detail - def _exact_signature_params(self, signature: str) -> list[str]: - match = re.search(r"\(([^)]*)\)", signature) - if not match: - return [] - value = match.group(1) - if "[" in value or "]" in value or "*" in value or "..." in value: - return [] - return [part.strip().split("=", 1)[0].strip() for part in value.split(",") if part.strip()] - def _remember_recent_edit(self, execution: ToolCallExecution) -> None: if not execution.call.args: return @@ -5993,34 +5951,6 @@ def _gate_action_types( ) return AgentRunResult() - def _completion_fallback_message(self, ctx: ResponseContext) -> str: - if ctx.completion_message: - return ctx.completion_message - if ctx.assistant_text: - return ctx.assistant_text - return "Done." - - def _incomplete_goal_update_from_actions(self, actions: list[Json]) -> str: - update = "" - for action in actions: - action_type = _json_str(action.get("type")) - if action_type == "goal" and action.get("complete") is not True: - update = _json_str(action.get("text")) or update - return update - - def _has_fresh_plan_action(self, actions: list[Json]) -> bool: - for action in actions: - action_type = _json_str(action.get("type")) - if action_type == "plan" and action.get("mode") != "patch" and any(self._plan_item_has_text(raw) for raw in _json_list(action.get("items"))): - return True - return False - - @staticmethod - def _plan_item_has_text(value: JsonValue) -> bool: - if isinstance(value, str): - return bool(value.strip()) - return bool(_json_str(_json_dict(value).get("text"))) - def _plan_is_complete(self) -> bool: return bool(self.blackboard.plan) and all( item.status in self.COMPLETED_PLAN_STATUSES and item.context.strip() for item in self.blackboard.plan @@ -6126,29 +6056,40 @@ def _plan_mode_tool_error(self, tool_calls: list[JsonValue]) -> str: return "plan mode allows readonly discovery only; blocked " + _format_tool_call_summary(call) return "" - def _has_non_readonly_tool_call(self, tool_calls: list[JsonValue]) -> bool: - for value in tool_calls: - try: - call = self.tool_runner.parse_tool_call(value) - except ToolCallArgError: - return True - tool_class = TOOL_REGISTRY.get(call.name) - if tool_class is None or tool_class.EFFECT != ToolEffect.READONLY: - return True - return False - def _build_response_context(self, response: Json) -> ResponseContext: raw_actions = self._response_actions(response) assistant_text = _json_str(response.get("_assistant_text")) or "" pending_verify_requested = any(self._is_pending_verify_action(action) for action in raw_actions) actions = [action for action in raw_actions if not self._is_pending_verify_action(action)] tool_calls = [action for action in actions if _json_str(action.get("type")) == "tool"] - has_goal_action = any(_json_str(action.get("type")) == "goal" for action in actions) - has_plan_action = any(_json_str(action.get("type")) == "plan" for action in actions) - has_forget_action = any(_json_str(action.get("type")) == "forget" for action in actions) - has_hypothesis_action = any(_json_str(action.get("type")) == "hypothesis" for action in actions) - has_state_update_action = any(_json_str(action.get("type")) in {"goal", "plan", "known", "hypothesis", "stable_knowledge"} for action in actions) - goal_update = self._incomplete_goal_update_from_actions(actions) + action_types = {_json_str(action.get("type")) for action in actions} + has_non_readonly_tool_call = False + for value in tool_calls: + try: + call = self.tool_runner.parse_tool_call(value) + except ToolCallArgError: + has_non_readonly_tool_call = True + break + tool_class = TOOL_REGISTRY.get(call.name) + if tool_class is None or tool_class.EFFECT != ToolEffect.READONLY: + has_non_readonly_tool_call = True + break + goal_update = next( + ( + text + for action in reversed(actions) + if _json_str(action.get("type")) == "goal" and action.get("complete") is not True + for text in [_json_str(action.get("text"))] + if text + ), + "", + ) + has_fresh_plan_action = any( + _json_str(action.get("type")) == "plan" + and action.get("mode") != "patch" + and any((raw.strip() if isinstance(raw, str) else _json_str(_json_dict(raw).get("text"))) for raw in _json_list(action.get("items"))) + for action in actions + ) completion_message = next( ( _json_str(action.get("message_for_complete")) or "" @@ -6170,20 +6111,17 @@ def _build_response_context(self, response: Json) -> ResponseContext: pending_verify_requested=pending_verify_requested, user_rule_message=self._user_rule_message_from_actions(actions), completion_message=completion_message, - has_goal_action=has_goal_action, - has_plan_action=has_plan_action, - has_fresh_plan_action=self._has_fresh_plan_action(actions), - has_user_rule_action=any(_json_str(action.get("type")) == "user_rule" for action in actions), - has_state_update_action=has_state_update_action, + has_goal_action="goal" in action_types, + has_plan_action="plan" in action_types, + has_fresh_plan_action=has_fresh_plan_action, + has_user_rule_action="user_rule" in action_types, + has_non_readonly_tool_call=has_non_readonly_tool_call, + has_state_update_action=bool(action_types & {"goal", "plan", "known", "hypothesis", "stable_knowledge"}), state_or_work_requested=bool( tool_calls or pending_verify_requested or (assistant_text and actions and not completion_message) - or has_goal_action - or has_plan_action - or has_forget_action - or has_hypothesis_action - or has_state_update_action + or action_types & {"goal", "plan", "forget", "hypothesis", "known", "stable_knowledge"} ), ) @@ -6271,10 +6209,10 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested - and (ctx.pending_verify_requested or self._has_non_readonly_tool_call(ctx.tool_calls)) + and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call) ): self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) - if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or self._has_non_readonly_tool_call(ctx.tool_calls)): + if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): self._warn_agent("changed Goal without replacing Plan.", "replace Plan when the task scope changes.") self._drop_goal_rewrite_actions(ctx) return False @@ -6291,7 +6229,7 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | if ( ctx.plan_was_empty and not self.blackboard.plan - and (ctx.pending_verify_requested or self._has_non_readonly_tool_call(ctx.tool_calls)) + and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call) ): self._warn_agent("mutating work before Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ( @@ -6498,7 +6436,7 @@ def _finish_or_continue(self, ctx: ResponseContext, on_message: MessageCallback return completion_gate if self.blackboard.goal_reached and not ctx.completion_message: self._warn_agent("filled missing message_for_complete with a fallback completion message.") - completion_message = self._completion_fallback_message(ctx) if self.blackboard.goal_reached else "" + completion_message = (ctx.completion_message or ctx.assistant_text or "Done.") if self.blackboard.goal_reached else "" if self.blackboard.goal_reached: self.session.append_conversation(AssistantMessage(content=completion_message)) if on_message is not None: @@ -6554,7 +6492,7 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N "Retrying: confirm a hypothesis before completing.", "Completion_Gate: " + investigate_completion_error + ".", ) - completion_message = self._completion_fallback_message(ctx) if self.blackboard.goal_reached else "" + completion_message = (ctx.completion_message or ctx.assistant_text or "Done.") if self.blackboard.goal_reached else "" plan_mode_completion_error = self._plan_mode_completion_error(completion_message) if self.blackboard.goal_reached else "" if plan_mode_completion_error: return self._reject_completion( diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 6942efd..5fa4a44 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1,4 +1,5 @@ import os +from dataclasses import replace import nanocode from nanocode import Agent, LLMError, ParsedToolCall, Session, VerificationStatus @@ -24,6 +25,15 @@ def _blocks_text(blocks): return "\n".join(blocks) +def _observe_tool_result_context(agent): + return "\n\n".join(agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter)) + + +def _set_context_budget(monkeypatch, agent, **overrides): + agent.session.settings.context_budget = "medium" + monkeypatch.setitem(nanocode.CONTEXT_BUDGETS, "medium", replace(nanocode.CONTEXT_BUDGETS["medium"], **overrides)) + + def _session( tmp_path, *, @@ -256,13 +266,12 @@ def test_agent_tool_results_are_bounded_and_logged(tmp_path): assert (tmp_path / item.log_path).read_text(encoding="utf-8").startswith("") -def test_agent_keeps_latest_batch_and_unreduced_tool_results(tmp_path): +def test_agent_keeps_latest_batch_and_unreduced_tool_results(tmp_path, monkeypatch): for name in ["one.txt", "two.txt", "three.txt", "four.txt"]: (tmp_path / name).write_text(name + "\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) agent = Agent(session) - agent.TOOL_RESULT_INDEX_ITEMS = 2 - agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 4 + _set_context_budget(monkeypatch, agent, index_items=2, observe_after_results=4) for name in ["one.txt", "two.txt", "three.txt", "four.txt"]: agent.execute_tool_calls([{"name": "Read", "intention": "read " + name, "args": [name, "0,1"]}]) @@ -278,7 +287,7 @@ def test_agent_keeps_latest_batch_and_unreduced_tool_results(tmp_path): assert "" in recent assert len(agent.tool_context.recent) == 3 assert agent.mode == nanocode.AgentMode.OBSERVE - context = agent._format_observe_tool_result_context() + context = _observe_tool_result_context(agent) assert "one.txt" in context assert "two.txt" in context assert "three.txt" in context @@ -287,17 +296,16 @@ def test_agent_keeps_latest_batch_and_unreduced_tool_results(tmp_path): assert len(agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter)) == 4 -def test_agent_observes_full_latest_result_when_it_becomes_recent(tmp_path): +def test_agent_observes_full_latest_result_when_it_becomes_recent(tmp_path, monkeypatch): (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.TOOL_RESULT_RAW_CHARS = 10_000 - agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 2 + _set_context_budget(monkeypatch, agent, raw_chars=10_000, observe_after_results=2) agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}]) - context = agent._format_observe_tool_result_context() + context = _observe_tool_result_context(agent) assert agent.mode == nanocode.AgentMode.OBSERVE assert "one.txt" in context assert "" in context @@ -325,11 +333,11 @@ def test_agent_observes_full_latest_result_when_it_becomes_recent(tmp_path): assert "recall=tr.2" in _blocks_text(agent.tool_context.latest) -def test_agent_act_context_keeps_pending_raw_after_latest_rotates(tmp_path): +def test_agent_act_context_keeps_pending_raw_after_latest_rotates(tmp_path, monkeypatch): (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.TOOL_RESULT_RAW_CHARS = 10_000 + _set_context_budget(monkeypatch, agent, raw_chars=10_000) agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}]) @@ -346,12 +354,11 @@ def test_agent_act_context_keeps_pending_raw_after_latest_rotates(tmp_path): assert "output:\n" not in index -def test_empty_observe_compacts_unreduced_tool_results(tmp_path): +def test_empty_observe_compacts_unreduced_tool_results(tmp_path, monkeypatch): (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) - agent.TOOL_RESULT_RAW_CHARS = 300 - agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 2 + _set_context_budget(monkeypatch, agent, raw_chars=300, observe_after_results=2) agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}]) @@ -788,10 +795,10 @@ def test_observe_known_source_compacts_result_key_by_default(tmp_path): assert agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter) == [] -def test_kept_tool_results_respect_char_budget(tmp_path): +def test_kept_tool_results_respect_char_budget(tmp_path, monkeypatch): agent = Agent(Session(cwd=str(tmp_path))) agent.mode = nanocode.AgentMode.OBSERVE - agent.KEPT_TOOL_RESULT_CHARS = 100 + _set_context_budget(monkeypatch, agent, kept_chars=100) agent.tool_context.latest = [ '- ok tool=Read args=["a"] key=tr.1\n output:\n' + ("a" * 30), '- ok tool=Read args=["b"] key=tr.2\n output:\n' + ("b" * 30), @@ -810,18 +817,17 @@ def test_kept_tool_results_respect_char_budget(tmp_path): assert "key=tr.2" in context -def test_kept_tool_results_respect_per_block_char_budget(tmp_path): +def test_kept_tool_results_respect_per_block_char_budget(tmp_path, monkeypatch): agent = Agent(Session(cwd=str(tmp_path))) agent.mode = nanocode.AgentMode.OBSERVE - agent.KEPT_TOOL_RESULT_CHARS = 10_000 - agent.KEPT_TOOL_RESULT_BLOCK_CHARS = 300 + _set_context_budget(monkeypatch, agent, kept_chars=10_000, kept_block_chars=300) agent.tool_context.latest = [ '- ok tool=Read args=["large.py"] key=tr.1\n output:\n' + ("head\n" + ("x" * 2000) + "\ntail") ] agent.handle_response({"actions": [{"type": "keep", "source": ["tr.1"], "reason": "large output matters"}]}) - assert len(agent.tool_context.kept_results[0]) <= 300 + assert len(agent.tool_context.kept_results[0]) <= agent.context_budget().kept_block_chars assert "key=tr.1" in agent.tool_context.kept_results[0] assert "[tool result excerpt]" in agent.tool_context.kept_results[0] @@ -839,32 +845,31 @@ def test_observe_checkpoint_clears_observe_errors(tmp_path): assert agent.observe_feedback_errors == [] -def test_agent_tool_result_raw_budget_triggers_observe(tmp_path): +def test_agent_tool_result_raw_budget_triggers_observe(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path)) agent = Agent(session) - agent.TOOL_RESULT_RAW_CHARS = 180 - agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 99 + _set_context_budget(monkeypatch, agent, raw_chars=180, observe_after_results=99) path = tmp_path / "sample.txt" path.write_text("x" * 400 + "\n", encoding="utf-8") agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) assert agent.mode == nanocode.AgentMode.OBSERVE - assert agent.tool_context.raw_context_chars(agent.blackboard.memory_checkpoint_tool_result_counter) >= agent.TOOL_RESULT_RAW_CHARS - observe_context = agent._format_observe_tool_result_context() + assert agent.tool_context.raw_context_chars(agent.blackboard.memory_checkpoint_tool_result_counter) >= agent.context_budget().raw_chars + observe_context = _observe_tool_result_context(agent) assert "sample.txt" in observe_context assert "x" * 50 in observe_context -def test_agent_tool_result_index_has_count_limit(tmp_path): +def test_agent_tool_result_index_has_count_limit(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path)) agent = Agent(session) - agent.TOOL_RESULT_INDEX_ITEMS = 2 + _set_context_budget(monkeypatch, agent, index_items=2) for index in range(4): agent.tool_context.append_recent( ['- ok tool=Read args=["' + str(index) + '"] key=tr.' + str(index + 1) + "\n output:\n" + ("x" * 20)], - max_index_items=agent.TOOL_RESULT_INDEX_ITEMS, + max_index_items=agent.context_budget().index_items, checkpoint=999, ) @@ -2824,7 +2829,7 @@ def test_agent_plain_text_cannot_finish_when_verification_required(tmp_path): assert messages == ["Done."] -def test_agent_run_keeps_tool_results_when_format_retry_happens(tmp_path): +def test_agent_run_keeps_tool_results_when_format_retry_happens(tmp_path, monkeypatch): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") class FakeModelClient: @@ -2843,7 +2848,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): session = Session(cwd=str(tmp_path)) agent = Agent(session) - agent.OBSERVE_AFTER_PENDING_RESULT_COUNT = 1 + _set_context_budget(monkeypatch, agent, observe_after_results=1) _seed_plan(agent, "read sample") agent.model_client = FakeModelClient() @@ -3255,10 +3260,10 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert any("state update-only turn" in error for error in agent.agent_feedback_errors) -def test_agent_warns_when_discovery_runs_long_without_plan(tmp_path): +def test_agent_warns_when_discovery_runs_long_without_plan(tmp_path, monkeypatch): agent = Agent(Session(cwd=str(tmp_path))) agent.blackboard.goal = "investigate" - agent.PLANLESS_DISCOVERY_TOOL_CALLS = 2 + _set_context_budget(monkeypatch, agent, planless_discovery_tool_calls=2) agent.handle_response({"actions": [{"type": "tool", "name": "ListDir", "intention": "inspect root", "args": ["."]}]}) agent.handle_response({"actions": [{"type": "tool", "name": "ListDir", "intention": "inspect root again", "args": ["."]}]}) From 49208fe124411edddde1ee1c4d09e585e8599afe Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 04:13:29 -0700 Subject: [PATCH 024/144] Remove knowledge command --- CHANGELOG.md | 2 +- README.md | 2 +- nanocode.py | 17 ----------------- tests/test_nanocode_commands.py | 25 ------------------------- 4 files changed, 2 insertions(+), 44 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1be6ff7..457f767 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -115,7 +115,7 @@ ### Changed - Tightened completion gates, verification blockers, and compact state update grouping. -- Simplified Search argument parsing and removed legacy `/knowledge update` behavior. +- Simplified Search argument parsing and removed legacy knowledge-update behavior. - Made provider reasoning payload shape configurable. ## 0.3.20 - 2026-05-15 diff --git a/README.md b/README.md index c4edd50..747d683 100644 --- a/README.md +++ b/README.md @@ -86,7 +86,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Commands -- Info: `/help [question]`, `/status`, `/rules`, `/knowledge`, `/compact`. +- Info: `/help [question]`, `/status`, `/rules`, `/compact`. - Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/reason-payload [value]`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. - Maintenance: `/clean`. - Exit: `/exit`, `/quit`. diff --git a/nanocode.py b/nanocode.py index 5f9ab9a..6de2678 100644 --- a/nanocode.py +++ b/nanocode.py @@ -6664,7 +6664,6 @@ class CommandSpec: CommandSpec("/help", "Show commands or ask about nanocode", "Info", "/help [question]"), CommandSpec("/status", "Show session status", "Info", "/status"), CommandSpec("/rules", "Show long-term user rules", "Info", "/rules"), - CommandSpec("/knowledge", "Show stable knowledge", "Info", "/knowledge"), CommandSpec("/compact", "Compact conversation history", "Info", "/compact"), CommandSpec("/config", "Show resolved runtime config", "Config", "/config"), CommandSpec("/context", "Show or set context budget", "Config", "/context [low|medium|high]"), @@ -6765,7 +6764,6 @@ def __init__( "/provider": self._provider, "/plan": self._plan, "/yolo": self._yolo, - "/knowledge": self._knowledge, } def dispatch(self, user_input: str) -> CommandResult: @@ -7097,21 +7095,6 @@ def _config(self, args: str) -> str: ] ) - def _knowledge(self, args: str) -> str: - if args: - return "Usage: /knowledge" - knowledge = self.agent.blackboard.stable_knowledge - if not any(knowledge.values()): - return "No stable knowledge stored." - lines = ["Stable knowledge:"] - for category in STABLE_KNOWLEDGE_CATEGORIES: - items = knowledge.get(category, []) - if not items: - continue - lines.append(category + ":") - lines.extend("- " + item for item in items) - return "\n".join(lines) - def _set(self, args: str) -> str: key, value = self._parse_set_args(args) if not key: diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 95ef802..0ecc6f8 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -472,31 +472,6 @@ def test_rules_command_shows_rules_content(tmp_path): assert result.message == "# User Rules\n\n- Prompt-only changes do not need tests." -def test_knowledge_command_shows_stable_knowledge(tmp_path): - agent = Agent(Session(cwd=str(tmp_path))) - dispatcher = CommandDispatcher(agent) - - empty_result = dispatcher.dispatch("/knowledge") - usage_result = dispatcher.dispatch("/knowledge extra") - agent.blackboard.stable_knowledge = { - "workflow": ["Project test command is make test."], - "structure": ["Main runtime lives in nanocode.py."], - } - result = dispatcher.dispatch("/knowledge") - - assert empty_result.message == "No stable knowledge stored." - assert usage_result.message == "Usage: /knowledge" - assert result.status == CommandStatus.HANDLED - assert result.message == "\n".join( - [ - "Stable knowledge:", - "structure:", - "- Main runtime lives in nanocode.py.", - "workflow:", - "- Project test command is make test.", - ] - ) - def test_command_dispatcher_auto_compacts_only_when_history_exceeds_keep_recent(tmp_path): session = make_session(tmp_path, compact_at=2) agent = Agent(session) From 21623ad053ca6a6f28dddb1fe5781c22c1035f2b Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 04:23:00 -0700 Subject: [PATCH 025/144] Remove unused agent constants --- nanocode.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/nanocode.py b/nanocode.py index 6de2678..4781a1d 100644 --- a/nanocode.py +++ b/nanocode.py @@ -5232,7 +5232,6 @@ class Agent: COMPLETED_PLAN_STATUSES: ClassVar[set[PlanStatus]] = {PlanStatus.DONE, PlanStatus.BLOCKED} MAX_COMPLETED_GOAL_TOOL_RESULTS: ClassVar[int] = 50 RECENT_EDITS: ClassVar[int] = 20 - PLAN_MODE_GIT_READONLY: ClassVar[frozenset[str]] = GIT_READONLY_COMMANDS RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." RULE_CLOSE_SOURCE: ClassVar[str] = "close the hypothesis before forgetting its source." RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after edit failures prefer ReplaceRange after Read." @@ -5242,7 +5241,6 @@ class Agent: RULE_EDIT_SIGNATURE: ClassVar[str] = "use ReplaceRange for read ranges or repeated text, and use the exact tool signature." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked verification only when blocker=user." - RULE_FINAL_ACTION: ClassVar[str] = "continue with a useful action or finish with goal.complete=true." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." def __init__(self, session: Session): @@ -6051,7 +6049,7 @@ def _plan_mode_tool_error(self, tool_calls: list[JsonValue]) -> str: continue if tool_class is GitTool: args = call.args[1:] if call.args and isinstance(call.args[0], str) and call.args[0].startswith("cwd=") else call.args - if args and args[0] in self.PLAN_MODE_GIT_READONLY: + if args and args[0] in GIT_READONLY_COMMANDS: continue return "plan mode allows readonly discovery only; blocked " + _format_tool_call_summary(call) return "" From 4ee49278f45a70bcf644e1dad3d39fa04c252edc Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 04:27:49 -0700 Subject: [PATCH 026/144] Derive command handlers from command specs --- nanocode.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/nanocode.py b/nanocode.py index 4781a1d..29b409a 100644 --- a/nanocode.py +++ b/nanocode.py @@ -6728,6 +6728,7 @@ class CommandDispatcher: MODEL_CONFIGURED_LABEL = "---- Configured models ----" MODEL_DISCOVERED_LABEL = "---- Discovered models ----" MODEL_LABELS = frozenset((MODEL_CONFIGURED_LABEL, MODEL_DISCOVERED_LABEL)) + COMMAND_ALIASES = {"/context-budget": "/context", "/context_budget": "/context"} def __init__( self, @@ -6744,25 +6745,12 @@ def __init__( self.select_reasoning = select_reasoning self.select_model = select_model self.select_provider = select_provider - self.handlers: dict[str, Callable[[str], str]] = { - "/help": self._help, - "/status": self._status, - "/rules": self._rules, - "/compact": self._compact, - "/config": self._config, - "/context": self._context, - "/context-budget": self._context, - "/context_budget": self._context, - "/set": self._set, - "/api": self._api, - "/clean": self._clean, - "/model": self._model, - "/reason": self._reason, - "/reason-payload": self._reason_payload, - "/provider": self._provider, - "/plan": self._plan, - "/yolo": self._yolo, + self.handlers = { + spec.name: getattr(self, "_" + spec.name[1:].replace("-", "_")) + for spec in COMMANDS + if spec.category != "Control" } + self.handlers.update({alias: self.handlers[target] for alias, target in self.COMMAND_ALIASES.items()}) def dispatch(self, user_input: str) -> CommandResult: stripped = user_input.strip() @@ -7132,22 +7120,6 @@ def _apply_config_value(self, key: str, value: str) -> str: return "Usage: /set " + key + " [on|off]" setattr(target, attr, value == "on") return "" - if key == "provider.reasoning": - if value not in REASONING_CHOICES: - return "Usage: /set " + key + " [" + "|".join(REASONING_CHOICES) + "]" - setattr(target, attr, value) - return "" - if key == "provider.chat_reasoning": - if value not in CHAT_REASONING_CHOICES: - return "Usage: /set " + key + " [" + "|".join(CHAT_REASONING_CHOICES) + "]" - setattr(target, attr, value) - return "" - if key == "runtime.context_budget": - if value not in CONTEXT_BUDGET_CHOICES: - return "Usage: /set " + key + " [" + "|".join(CONTEXT_BUDGET_CHOICES) + "]" - setattr(target, attr, value) - self.agent.apply_context_budget() - return "" if key == "provider.temperature": if value == "off": setattr(target, attr, None) @@ -7160,6 +7132,14 @@ def _apply_config_value(self, key: str, value: str) -> str: return "Usage: /set " + key + " " setattr(target, attr, parsed_float) return "" + choices = CONFIG_VALUE_COMPLETIONS.get(key) + if choices: + if value not in choices: + return "Usage: /set " + key + " [" + "|".join(choices) + "]" + setattr(target, attr, value) + if key == "runtime.context_budget": + self.agent.apply_context_budget() + return "" if key in CONFIG_INT_KEYS: try: parsed_int = int(value) From 018cd517b803790b9550df656c793f3083c7bc3a Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 06:23:09 -0700 Subject: [PATCH 027/144] Simplify agent state updater actions --- nanocode.py | 101 +++++++++++++++++++++------------------------------- 1 file changed, 41 insertions(+), 60 deletions(-) diff --git a/nanocode.py b/nanocode.py index 29b409a..1e209d4 100644 --- a/nanocode.py +++ b/nanocode.py @@ -4650,7 +4650,6 @@ def apply(self, response: Json) -> None: plan_replaced = self._apply_plan(actions) if goal_changed and not plan_replaced: self.blackboard.plan = [] - self._apply_work_mode(actions) self._apply_known(actions) self._apply_hypotheses(actions) self._apply_user_rules(actions) @@ -4673,7 +4672,7 @@ def _format_state_report( before_hypotheses: list[str], before_known: list[str], before_user_rules: str, - before_extra_state: str, + before_extra_state: tuple[str, dict[str, list[str]]], ) -> str: current = self.blackboard lines = [] @@ -4786,22 +4785,23 @@ def _compact(self, text: str, limit: int = 140) -> str: def _apply_goal(self, actions: list[Json]) -> bool: changed = False - for action in actions: - action_type = _json_str(action.get("type")) - if action_type == "goal": - update = _json_str(action.get("text")) - complete = action.get("complete") - if update is not None: - goal_changed = update != self.blackboard.goal - changed = changed or (goal_changed and complete is not True) - self.blackboard.goal = update - if isinstance(complete, bool): - self.blackboard.goal_reached = complete + for action in self._actions_of_type(actions, "goal"): + update = _json_str(action.get("text")) + complete = action.get("complete") + if update is not None: + goal_changed = update != self.blackboard.goal + changed = changed or (goal_changed and complete is not True) + self.blackboard.goal = update + if isinstance(complete, bool): + self.blackboard.goal_reached = complete + if "work_mode" in action: + mode = _json_str(action.get("work_mode")) or WorkMode.NORMAL + self.blackboard.work_mode = WorkMode(mode) if mode in ALL_WORK_MODES else WorkMode.NORMAL return changed def _apply_plan(self, actions: list[Json]) -> bool: replaced = False - for update in [action for action in actions if _json_str(action.get("type")) == "plan"]: + for update in self._actions_of_type(actions, "plan"): items = _json_list(update.get("items")) if update.get("mode") != "patch": if not items: @@ -4876,29 +4876,16 @@ def _normalize_doing_items(plan: list[PlanItem]) -> None: seen = True def _apply_known(self, actions: list[Json]) -> None: - for action in actions: - values = _json_list(action.get("items")) if _json_str(action.get("type")) == "known" else [] - for raw in values: - item = KnownItem.from_json(raw) - if item is not None: - self._add_known_item(item.text, item.source) + for raw in self._action_items(actions, "known"): + item = KnownItem.from_json(raw) + if item is not None: + self._add_known_item(item.text, item.source) def _apply_hypotheses(self, actions: list[Json]) -> None: - for action in actions: - values = _json_list(action.get("items")) if _json_str(action.get("type")) == "hypothesis" else [] - for raw in values: - item = Hypothesis.from_json(raw) - if item is not None: - self._add_hypothesis(item) - - def _apply_work_mode(self, actions: list[Json]) -> None: - for action in actions: - if _json_str(action.get("type")) != "goal": - continue - if "work_mode" not in action: - continue - mode = _json_str(action.get("work_mode")) or WorkMode.NORMAL - self.blackboard.work_mode = WorkMode(mode) if mode in ALL_WORK_MODES else WorkMode.NORMAL + for raw in self._action_items(actions, "hypothesis"): + item = Hypothesis.from_json(raw) + if item is not None: + self._add_hypothesis(item) def _add_hypothesis(self, item: Hypothesis) -> None: for index, existing in enumerate(self.blackboard.hypotheses): @@ -4922,9 +4909,7 @@ def _hypothesis_key(self, text: str) -> str: def _apply_user_rules(self, actions: list[Json]) -> None: changed = False - for action in actions: - if _json_str(action.get("type")) != "user_rule": - continue + for action in self._actions_of_type(actions, "user_rule"): rule = (_json_str(action.get("text")) or "").strip() changed = self.session.state.user_rules.add(rule) or changed if changed: @@ -4954,14 +4939,8 @@ def _known_facts_overlap(self, left: KnownItem | str, right: KnownItem | str) -> def _known_fact_key(self, fact: KnownItem | str) -> str: return re.sub(r"\s+", " ", KnownItem.text_of(fact)).strip(" \t\r\n。.;；").lower() - def _before_extra_state(self) -> str: - return json.dumps( - { - "verification": self.blackboard.verification.format(), - "stable_knowledge": self.blackboard.stable_knowledge, - }, - ensure_ascii=False, - ) + def _before_extra_state(self) -> tuple[str, dict[str, list[str]]]: + return self.blackboard.verification.format(), {key: list(value) for key, value in self.blackboard.stable_knowledge.items()} def _apply_extra_state(self, actions: list[Json], *, goal_changed: bool, plan_replaced: bool) -> None: self._apply_stable_knowledge(actions) @@ -4988,15 +4967,12 @@ def _append_state_section(self, lines: list[str], title: str, rows: list[str] | lines.append(title) lines.extend(rows or []) - def _append_extra_state_report(self, lines: list[str], before_extra_state: str) -> None: - try: - before = _json_dict(json.loads(before_extra_state)) - except json.JSONDecodeError: - before = {} - if self.blackboard.stable_knowledge != before.get("stable_knowledge", []): + def _append_extra_state_report(self, lines: list[str], before_extra_state: tuple[str, dict[str, list[str]]]) -> None: + before_verification, before_stable_knowledge = before_extra_state + if self.blackboard.stable_knowledge != before_stable_knowledge: self._append_state_section(lines, " Stable_Knowledge", self._format_stable_knowledge_rows()) verification = self.blackboard.verification.format() - if verification == before.get("verification", ""): + if verification == before_verification: return self._append_state_section(lines, " Verify " + self._format_verification()) @@ -5018,12 +4994,17 @@ def _format_stable_knowledge_rows(self) -> list[str]: return rows def _apply_stable_knowledge(self, actions: list[Json]) -> None: - for action in actions: - values = _json_list(action.get("items")) if _json_str(action.get("type")) == "stable_knowledge" else [] - for raw in values: - category, fact = self._stable_knowledge_item_from_json(raw) - if fact: - self._add_stable_knowledge_item(category, fact) + for raw in self._action_items(actions, "stable_knowledge"): + category, fact = self._stable_knowledge_item_from_json(raw) + if fact: + self._add_stable_knowledge_item(category, fact) + + @staticmethod + def _actions_of_type(actions: list[Json], action_type: str) -> Iterator[Json]: + return (action for action in actions if _json_str(action.get("type")) == action_type) + + def _action_items(self, actions: list[Json], action_type: str) -> Iterator[JsonValue]: + return (raw for action in self._actions_of_type(actions, action_type) for raw in _json_list(action.get("items"))) def _stable_knowledge_item_from_json(self, value: JsonValue) -> tuple[str, str]: item = _json_dict(value) @@ -5062,7 +5043,7 @@ def _format_verification(self) -> str: return " | ".join(parts) def _apply_verification(self, actions: list[Json]) -> None: - for data in [action for action in actions if _json_str(action.get("type")) == "verify"]: + for data in self._actions_of_type(actions, "verify"): kind = _json_str(data.get("kind")) if kind is not None: self.blackboard.verification.kind = kind if kind and all(part in VALID_VERIFICATION_KINDS for part in kind.split("+")) else "" From 850308eed87933f7467a8617c25b215c84151fe7 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 06:28:34 -0700 Subject: [PATCH 028/144] Simplify state and choice formatting helpers --- nanocode.py | 52 ++++++++++++++----------------------- tests/test_nanocode_loop.py | 7 ----- 2 files changed, 19 insertions(+), 40 deletions(-) diff --git a/nanocode.py b/nanocode.py index 1e209d4..e77c93d 100644 --- a/nanocode.py +++ b/nanocode.py @@ -4721,29 +4721,27 @@ def _format_rows(self, items: list[Any], render: Callable[[int, Any], str | list return rows def compact_report(self) -> str: - sections = [] - if " Plan" in self.latest_report and self.blackboard.plan: - sections.append("Plan") - if " Hypotheses" in self.latest_report and self.blackboard.hypotheses: - sections.append("Hypotheses") - if " Known" in self.latest_report and self.blackboard.known: - sections.append("Known") + sections = [ + (name, rows) + for name, changed, rows in ( + ("Plan", " Plan" in self.latest_report and self.blackboard.plan, self.latest_compact_plan_rows or self._compact_plan_rows()), + ( + "Hypotheses", + " Hypotheses" in self.latest_report and self.blackboard.hypotheses, + self._compact_rows(self.blackboard.hypotheses, lambda item: self._compact(item.format(), 100)), + ), + ("Known", " Known" in self.latest_report and self.blackboard.known, self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100))), + ) + if changed + ] if not sections: return "" - lines = [" + ".join(sections) + " Updated"] + lines = [" + ".join(name for name, _ in sections) + " Updated"] grouped = len(sections) > 1 - if "Plan" in sections: - if grouped: - lines.append("Plan") - lines.extend(self.latest_compact_plan_rows or self._compact_plan_rows()) - if "Hypotheses" in sections: + for name, rows in sections: if grouped: - lines.append("Hypotheses") - lines.extend(self._compact_hypothesis_rows()) - if "Known" in sections: - if grouped: - lines.append("Known") - lines.extend(self._compact_known_rows()) + lines.append(name) + lines.extend(rows) return "\n".join(lines) def _compact_plan_rows(self) -> list[str]: @@ -4767,12 +4765,6 @@ def _compact_changed_plan_rows(self, before_plan: list[str], plan: list[str]) -> def _compact_plan_row(self, index: int, item: PlanItem) -> str: return " " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text, 90) - def _compact_known_rows(self) -> list[str]: - return self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100)) - - def _compact_hypothesis_rows(self) -> list[str]: - return self._compact_rows(self.blackboard.hypotheses, lambda item: self._compact(item.format(), 100)) - def _compact_rows(self, items: list[Any], render: Callable[[Any], str]) -> list[str]: offset = max(0, len(items) - self.COMPACT_DISPLAY_LIMIT) rows = [" ... " + str(offset) + " older"] if offset else [] @@ -7518,12 +7510,6 @@ def flush() -> None: flush() return tuple(visible) - def _choice_enabled(self, choices: tuple[str, ...], disabled: set[str]) -> tuple[str, ...]: - return tuple(choice for choice in choices if choice not in disabled) - - def _choice_initial_index(self, enabled_choices: tuple[str, ...], current: str) -> int: - return enabled_choices.index(current) if current in enabled_choices else 0 - def _run_choice_application( self, title: str, @@ -7535,7 +7521,7 @@ def _run_choice_application( state: dict[str, str | int | bool] = {"query": "", "selected": 0, "searching": False} def enabled() -> tuple[str, ...]: - return self._choice_enabled(self._visible_choices(choices, labels, disabled, str(state["query"])), disabled) + return tuple(choice for choice in self._visible_choices(choices, labels, disabled, str(state["query"])) if choice not in disabled) def clamp_selection() -> None: options = enabled() @@ -7667,7 +7653,7 @@ def _type(event): event.app.invalidate() options = enabled() - state["selected"] = self._choice_initial_index(options, current) if options else 0 + state["selected"] = options.index(current) if current in options else 0 content = FormattedTextControl(choice_fragments, focusable=True) choice_window = Window(content, dont_extend_height=True) app = Application( diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index d12cd2d..2350115 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -630,13 +630,6 @@ def run(self): assert attrs.bold is True assert captured["erase_when_done"] is True assert captured["layout"] is not None - assert loop._choice_initial_index(("off", "minimal", "low", "medium"), "medium") == 3 - - loop._select_model(("old", "new"), "new") - assert loop._choice_initial_index(("old", "new"), "new") == 1 - - loop._select_provider(("one", "two"), "two") - assert loop._choice_initial_index(("one", "two"), "two") == 1 def test_agent_loop_choice_prompt_filters_with_slash_search(tmp_path): From 44207085ef7d0a97a7b26a522085e8f07c41a840 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 06:29:59 -0700 Subject: [PATCH 029/144] Fix choice filtering helper removal --- nanocode.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nanocode.py b/nanocode.py index e77c93d..ccd0d3f 100644 --- a/nanocode.py +++ b/nanocode.py @@ -7533,7 +7533,7 @@ def clamp_selection() -> None: def choice_fragments(): query = str(state["query"]) visible = self._visible_choices(choices, labels, disabled, query) - options = self._choice_enabled(visible, disabled) + options = tuple(choice for choice in visible if choice not in disabled) clamp_selection() suffix = (" /" + query) if query else "" if query and not state["searching"]: From 32ebce1c0ef3364089da2239b705197cfdf9745f Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 06:33:52 -0700 Subject: [PATCH 030/144] Trim small agent control helpers --- nanocode.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/nanocode.py b/nanocode.py index ccd0d3f..5055dfe 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1662,8 +1662,6 @@ def release(self) -> None: self.file = None try: os.remove(self.path) - except FileNotFoundError: - pass except OSError: pass @@ -6119,16 +6117,13 @@ def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | ) def _gate_protocol_actions(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: - action_gate = self._gate_action_types( + return self._gate_action_types( ctx.actions, allowed=self.PLAN_ACTION_TYPES if self.session.settings.plan_mode else self.ACT_ACTION_TYPES, on_message=on_message, retry_message="Retrying: use a valid agent action.", feedback_message=self._error("this step only accepts agent work actions."), - ) - if action_gate is not None: - return True - return False + ) is not None def _gate_tool_actions(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: if self._gate_forget_actions(ctx.actions, on_message, self._remember_agent_error) is not None: From a2d6676463464dec15a081583401fcf419ed78e6 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 06:35:01 -0700 Subject: [PATCH 031/144] Reuse status bar fragments in selectors --- nanocode.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/nanocode.py b/nanocode.py index 5055dfe..6dade5f 100644 --- a/nanocode.py +++ b/nanocode.py @@ -7453,12 +7453,7 @@ def _read_input(self, prompt: str) -> str: multiline=False, enable_history_search=True, refresh_interval=StatusBar.INTERVAL, - bottom_toolbar=lambda: self.status_bar._fragments( - 0.0, - now=time.monotonic(), - show_sweep=False, - show_elapsed=False, - ), + bottom_toolbar=self._status_bar_fragments, ) def _choice_style(self) -> Style: @@ -7471,7 +7466,7 @@ def _choice_style(self) -> Style: } ) - def _choice_bottom_toolbar(self): + def _status_bar_fragments(self): return self.status_bar._fragments( 0.0, now=time.monotonic(), @@ -7657,7 +7652,7 @@ def _type(event): [ choice_window, Window( - FormattedTextControl(lambda: self._choice_bottom_toolbar(), style="class:bottom-toolbar.text"), + FormattedTextControl(self._status_bar_fragments, style="class:bottom-toolbar.text"), style="class:bottom-toolbar", dont_extend_height=True, height=Dimension(min=1), From 026345c5cbd6254735e29f2eabe5741fb32063fb Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 06:40:59 -0700 Subject: [PATCH 032/144] Clarify agent phase prompts --- design.md | 2 +- nanocode.py | 416 +++++++++++++++++++++++++++++----------------------- 2 files changed, 236 insertions(+), 182 deletions(-) diff --git a/design.md b/design.md index 64e9410..5766bf3 100644 --- a/design.md +++ b/design.md @@ -125,7 +125,7 @@ ACT user prompt, top -> bottom | Current Decision | section-local limits | | - Recent Edits | | | - Known | | -| - Task Code / Work Mode | | +| - Current Phase / Work Mode | | | - Goal / Plan / Hypotheses / Verify | | | - Errors | | | - Latest User Request | | diff --git a/nanocode.py b/nanocode.py index 6dade5f..1af965e 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1381,11 +1381,7 @@ def _bound_tool_output(output: str, *, log_path: str = "", max_chars: int = MAX_ if original_chars <= max_chars: return BoundedToolOutput(output, False, original_lines, original_chars) - header = ( - "[tool result excerpt]\n" - "excerpted: true\n" - "original_lines: " + str(original_lines) + "\noriginal_chars: " + str(original_chars) + "\n" - ) + header = "[tool result excerpt]\nexcerpted: true\noriginal_lines: " + str(original_lines) + "\noriginal_chars: " + str(original_chars) + "\n" labels = ("\n--- head ---\n", "\n--- middle ---\n", "\n--- tail ---\n") body_budget = max_chars - len(header) - sum(len(label) for label in labels) if body_budget <= 0: @@ -1517,11 +1513,7 @@ def latest_raw_blocks(self) -> list[str]: def unreduced_recent_blocks(self, checkpoint: int) -> list[str]: latest_keys = set(self.blocks_by_key(self.latest)) - return [ - block - for block in self.recent - if self.result_key(block) not in latest_keys and self._needs_reduction(block, checkpoint) - ] + return [block for block in self.recent if self.result_key(block) not in latest_keys and self._needs_reduction(block, checkpoint)] def unreduced_blocks(self, checkpoint: int) -> list[str]: seen: set[str] = set() @@ -2526,7 +2518,9 @@ class ReplaceRangeTool(Tool): "Pass exact before_context and after_context when known; empty boundary context is allowed for non-empty replacements.", "Content is only the replacement for that range; do not include boundary lines.", ) - SIGNATURE: ClassVar[str] = "ReplaceRange(filepath, [[start,end,fingerprint,before_context,after_context,content], ...]) -> ReplaceRangeToolResult" + SIGNATURE: ClassVar[str] = ( + "ReplaceRange(filepath, [[start,end,fingerprint,before_context,after_context,content], ...]) -> ReplaceRangeToolResult" + ) EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Single range: ["code.py", [["10", "12", "a1b2c3", "before\\n", "after\\n", "replacement\\n"]]]', 'Two ranges: ["code.py", [["10", "12", "a1b2c3", "before\\n", "after\\n", "replacement\\n"], ["20", "20", "d4e5f6", "prev\\n", "next\\n", "inserted\\n"]]]', @@ -2963,7 +2957,9 @@ class PlanModeGitTool(GitTool): class ToolResultTool(Tool): NAME: ClassVar[str] = "Recall" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY - DESCRIPTION: ClassVar[tuple[str, ...]] = ("Recall stored tool results by tr.* key; pass optional 0-based line ranges to read exact slices from the stored full log.",) + DESCRIPTION: ClassVar[tuple[str, ...]] = ( + "Recall stored tool results by tr.* key; pass optional 0-based line ranges to read exact slices from the stored full log.", + ) SIGNATURE: ClassVar[str] = "Recall(key...[, range_token...]) -> RecallToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["tr.1"]', @@ -3109,7 +3105,11 @@ def _content(self, item: ToolResultItem) -> str: }, ["kind", "method", "criteria", "status", "blocker", "context"], ), - "keep": ("Keep visible raw tool result keys in context during observe.", {"source": TOOL_STRING_LIST_SCHEMA, "reason": TOOL_STRING_SCHEMA}, ["source", "reason"]), + "keep": ( + "Keep visible raw tool result keys in context during observe.", + {"source": TOOL_STRING_LIST_SCHEMA, "reason": TOOL_STRING_SCHEMA}, + ["source", "reason"], + ), } @@ -3136,86 +3136,148 @@ def _state_tool_schema(name: str) -> Json: AGENT_SYSTEM_PROMPT = """You are nanocode, a coding agent. -OUTPUT -- Use function tools for state updates and repository actions. -- Assistant text is optional; never use it instead of the next useful function tool. -- A completed task still needs goal.complete=true; assistant text alone does not complete work. -- State tools: goal, plan, hypothesis, known, stable_knowledge, user_rule, verify, forget. -- Repository tools: { __tool_names__ }. -- Repository tool calls require intention and args. -- Use the latest user language for user-facing text; keep it plain, concise, and direct. - -PRIORITY AND STATE -- Priority: Latest User Request > User Rules > Current Goal > Plan/Known/Stable Knowledge > Conversation History. -- Latest User Request overrides stale Goal, but Task Code decides whether to begin a new task. -- Task Code: new = align latest request with goal/plan or readonly discovery; working = continue current Goal; verifying = run/record verification; done = wait for next request. -- If Task Code is working or verifying, do not rewrite Goal unless the user changed the task. -- Never repeat a previous completion as the answer. -- User Rules are mandatory long-term behavior rules; add them only when the user explicitly asks to remember future behavior. - -MEMORY AND TOOL RESULTS -- Known = settled current-task facts that still matter after visible tool results disappear. -- Hypotheses = investigation directions with status { __hypothesis_status_text__ }. -- Stable Knowledge = rare reusable codebase facts: stack, structure, workflow, convention, gotcha. -- Do not store intentions, TODOs, guesses, user requests, routine observations, or duplicate facts in Known. -- Tool Result Index, Kept Tool Results, Unreduced Tool Results, and Latest Tool Results are support context; do not restate raw results. -- OBSERVE keeps useful raw results and forgets noise. ACT must not keep results. -- In ACT, use forget only when a visible result is already irrelevant; first preserve any needed conclusion in Plan, Known, Hypotheses, or Verify. Forget preserves logs and Recall. +Use function tools to update state and work on the repository. +Assistant text is optional. Do not answer with text when a useful tool call should be made. +A task is complete only after goal.complete=true is set. + +User-facing text must use the latest user language. Keep it plain, concise, and direct. + +Available state tools: +goal, plan, hypothesis, known, stable_knowledge, user_rule, verify, forget + +Available repository tools: +{ __tool_names__ } + +All repository tool calls require: +- intention: the concrete question to answer or outcome to achieve +- args: tool arguments + +PRIORITY +Latest User Request > User Rules > Current Goal > Plan/Known/Stable Knowledge > Conversation History. + +Current Phase: +- new: align latest request with current state, or start readonly discovery +- working: continue the current goal +- verifying: run or record verification +- done: wait for the next user request + +Do not rewrite the Goal when Current Phase is working/verifying unless the user changed the task. +Never repeat a previous completion as the answer. + +STATE +Known: +- settled current-task facts that matter after tool results disappear +- not intentions, TODOs, guesses, routine observations, duplicates, or raw logs + +Hypotheses: +- competing investigation directions +- status: { __hypothesis_status_text__ } +- each hypothesis should imply a concrete check + +Stable Knowledge: +- rare reusable codebase facts: stack, structure, workflow, convention, gotcha + +User Rules: +- only explicit future-behavior requests from the user + +Tool Results: +- visible tool results are temporary support context +- OBSERVE owns keep/forget cleanup +- ACT may forget irrelevant visible results only after preserving useful conclusions in goal, plan, known, hypothesis, or verify WORKFLOW -- No Goal: set goal. If enough context is known, also set plan or call the first useful readonly tools. -- Goal but no Plan: set a short plan, or call readonly discovery first when planning needs context. -- Goal and Plan: execute the next useful frontier with tools. Batch independent searches/reads/recalls/checks; serialize only when later args depend on earlier results. -- After edits or explicit checks: verify with the smallest relevant test/build/lint/static check. -- Complete only when the goal is done, Plan items are done/blocked with context, and verification passed or is blocked by the user. -- Never repeat an unchanged goal, unchanged plan, or no-op state update. Move to the next workflow state. - -STATE UPDATES -- user_rule: only explicit future-behavior memory requests. -- known/hypothesis: only when facts or investigation status changed. -- Pair state updates with the next frontier action when its args are known. +If there is no Goal: +- set a Goal +- if enough context is known, also set a short Plan or call the first useful readonly tools + +If there is a Goal but no Plan: +- set a short Plan +- or run readonly discovery first if planning needs context + +If there is a Goal and Plan: +- execute the next useful frontier +- batch independent searches, reads, recalls, and checks +- serialize only when later arguments depend on earlier results + +Prefer useful tool calls over state-only turns. +Pair state updates with the next frontier tool call when tool arguments are already known. PLANNING -- Use plans only for real tasks; usually 2-5 concrete outcome steps. -- Update Plan only when status, text, context, or ordering changes. -- Pair Plan/Known/Hypothesis updates with the next frontier action whenever its arguments are known. -- Use patch for small Plan changes; use replace only when restructuring. -- At most one item may be doing. -- Done context must cite result context; blocked context must name the concrete blocker. -- Add a verify step only for edits, explicit checks, or correctness-sensitive changes. -- If Plan is complete and verification passed/blocked, finish by default. To continue tools, first reopen Plan with a todo/doing item explaining why completion is insufficient. +Use a Plan only for real multi-step work. +Usually keep it to 2-5 concrete outcome steps. + +Plan rules: +- update only when status, text, context, or order changes +- use patch for small changes; replace only for restructuring +- at most one item may be doing +- done context must cite supporting result context +- blocked context must name the concrete blocker +- add a verify step only for edits, explicit checks, or correctness-sensitive work + +If all Plan items are done/blocked and verification passed/blocked, finish by default. +To continue tools after that, first reopen the Plan with a todo/doing item explaining why completion is insufficient. INVESTIGATION -- Use work_mode=investigate for competing explanations, root-cause reasoning, or branch elimination. -- Track plausible directions separately; each should imply a concrete check. -- Mark hypotheses ruled_out when result context eliminates them, confirmed before root-cause completion. -- Prefer useful readonly tool batches over intermediate state-only turns. - -EDITING AND DISCOVERY -- Use Search/ListDir/LineCount when target file/path/symbol/range is unknown. -- Read only known paths/ranges or search-narrowed targets; read small ranges around likely matches. -- Stop discovery when exact target and next edit/check are clear; do not repeat equivalent searches. -- Edit incrementally: one small coherent change per edit action. -- New file: create a minimal skeleton first; grow large content with focused ReplaceRange chunks. -- Existing file: inspect exact target before editing. Never rewrite a large file in one action. -- Use Edit for one tiny exact literal block that appears once. -- Use ReplaceRange after Read for ranges, repeated text, insertions, and structural edits; use ReplaceRange(filepath, ranges) for several known independent ranges in one file. +Use work_mode=investigate for root-cause analysis, competing explanations, or branch elimination. + +Rules: +- track plausible directions separately +- mark hypotheses ruled_out when evidence eliminates them +- mark hypotheses confirmed before claiming root cause +- stop investigating when the exact target and next edit/check are clear + +DISCOVERY AND EDITING +Use Search/ListDir/LineCount when path, symbol, range, or target is unknown. +Use Read only for known paths/ranges or search-narrowed targets. +Read small ranges around likely matches. + +Stop discovery once the next edit/check is clear. + +Editing rules: +- make one small coherent change per edit action +- new file: create a minimal skeleton first, then grow with focused ReplaceRange chunks +- existing file: inspect the exact target before editing +- never rewrite a large file in one action +- use Edit only for one tiny exact literal block that appears once +- use ReplaceRange after Read for ranges, repeated text, insertions, and structural edits +- use ReplaceRange(filepath, ranges) for several known independent ranges in one file VERIFICATION -- Verification strength: none for simple answers, light for read/static confirmation, tool for code changes or requested checks, user for visual/manual confirmation. -- Verify action requires kind, method, criteria, status passed|failed|blocked, context, and blocker when blocked. -- Passed context must cite concrete recent tool result context. Blocked verification must set blocker and context. -- If verification fails, record failed and repair before completion. -- A build/test after a failed edit in the same tool batch does not verify that edit; repair or confirm the edit first. -- Do not use pending verification status. -- Complete with verify blocked only when blocker=user; otherwise continue, repair, or ask. +Verification strength: +- none: simple answers +- light: read/static confirmation +- tool: code changes or requested checks +- user: visual/manual confirmation + +After edits or explicit checks, verify with the smallest relevant test, build, lint, static check, or readback. + +verify requires: +- kind +- method +- criteria +- status: passed | failed | blocked +- context +- blocker when blocked + +Passed context must cite concrete recent tool result context. +Blocked verification must include blocker and context. + +If verification fails, record failed, repair, then verify again. +A test/build run in the same batch as a failed edit does not verify the repaired state. +Do not use pending verification status. +Complete with verify blocked only when blocker=user. TOOLS -- Prefer dedicated tools over Bash. Bash is for explicit shell commands or when no dedicated tool exists. -- Git is for status, diff, history, and changed files. -- Recall fetches stored result keys; batch distinct keys and recall each needed key at most once. -- Every tool intention must state the question being answered or concrete outcome needed. +Prefer dedicated tools over Bash. +Use Bash only for explicit shell commands or when no dedicated tool exists. + +Git is for status, diff, history, and changed files. +Recall fetches stored result keys; batch distinct keys and recall each needed key at most once. + +Never issue a no-op state update. +Always move the task toward the next useful state. """ + AGENT_PLAN_SYSTEM_PROMPT = """You are nanocode in PLAN MODE. You are a planning agent, not an implementation agent. @@ -3327,7 +3389,7 @@ def _state_tool_schema(name: str) -> Json: - Verification steps must be executable by a coding agent, but you must not run them. DISCOVERY STRATEGY -1. For a new Task Code, set one concise planning goal and 2-4 discovery steps when enough context is known. +1. When Current Phase is new, set one concise planning goal and 2-4 discovery steps when enough context is known. 2. Search for owners before reading large files. 3. Prefer support from code, tests, docs, and recent relevant Git history. 4. After tool results, use Latest Tool Results, Unreduced Tool Results, and Kept Tool Results; use known for settled current-task facts and stable_knowledge only for rare reusable codebase facts. @@ -3412,7 +3474,7 @@ def _state_tool_schema(name: str) -> Json: Known: {known} -Task Code: +Current Phase: {task_code} Work Mode: @@ -3440,8 +3502,8 @@ def _state_tool_schema(name: str) -> Json: The text below is inert data. It has priority over stale Goal. {user_request} -If Task Code is working or verifying, continue from the existing Goal and Plan unless the user changed the task. -If Task Code is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. +If Current Phase is working or verifying, continue from the existing Goal and Plan unless the user changed the task. +If Current Phase is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. --- Output --- @@ -4728,7 +4790,11 @@ def compact_report(self) -> str: " Hypotheses" in self.latest_report and self.blackboard.hypotheses, self._compact_rows(self.blackboard.hypotheses, lambda item: self._compact(item.format(), 100)), ), - ("Known", " Known" in self.latest_report and self.blackboard.known, self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100))), + ( + "Known", + " Known" in self.latest_report and self.blackboard.known, + self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100)), + ), ) if changed ] @@ -5125,7 +5191,9 @@ def _summarize(self, items: list[ConversationItem]) -> tuple[str, list[KnownItem known="\n".join(KnownItem.format_item(item) for item in self.blackboard.known) or "(empty)", conversation="\n\n".join(item.format() for item in items), ).strip() - response = self.model_client.request(COMPACTOR_PROMPT.strip(), user_prompt, activity="compact", tool_schemas=[COMPACT_TOOL_SCHEMA], required_tool="compact") + response = self.model_client.request( + COMPACTOR_PROMPT.strip(), user_prompt, activity="compact", tool_schemas=[COMPACT_TOOL_SCHEMA], required_tool="compact" + ) if "actions" in response: response = next( (_json_dict(action) for action in _json_list(response.get("actions")) if _json_str(_json_dict(action).get("type")) == "compact"), @@ -5352,7 +5420,9 @@ def request( self._set_status_notice("err:first_token" if timeout_reason == "request first token timeout" else "err:timeout") if on_message is not None and self.session.settings.debug: on_message( - "Retrying: " + timeout_reason + "; retry " + "Retrying: " + + timeout_reason + + "; retry " + str(attempt + 1) + "/" + str(len(self.MODEL_TIMEOUT_RETRY_DELAYS)) @@ -5480,15 +5550,9 @@ def _format_act_tool_result_context(self) -> tuple[str, str, str]: timeline = self.tool_context.current_timeline_blocks()[-budget.index_items :] unreduced = self.tool_context.unreduced_recent_blocks(checkpoint) latest = self.tool_context.latest_raw_blocks() - visible_keys = set( - ToolResultContext.blocks_by_key(timeline + unreduced + latest + self.tool_context.kept_results) - ) + visible_keys = set(ToolResultContext.blocks_by_key(timeline + unreduced + latest + self.tool_context.kept_results)) archived_limit = max(0, budget.index_items - len(timeline)) - archived = [ - item.format(result_key=key) - for key, item in self.session.state.tool_result_store.items() - if key not in visible_keys - ] + archived = [item.format(result_key=key) for key, item in self.session.state.tool_result_store.items() if key not in visible_keys] archived = archived[-archived_limit:] if archived_limit > 0 else archived sections = [] if archived: @@ -5641,14 +5705,18 @@ def stream_step( response = self.step(on_message=on_message) if _json_str(response.get("_format_error")): return AgentRunResult(), response, False - return self.handle_response( + return ( + self.handle_response( + response, + confirm=confirm, + on_auto_approve=on_auto_approve, + on_live_output=on_live_output, + on_live_done=on_live_done, + on_message=on_message, + ), response, - confirm=confirm, - on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, - on_message=on_message, - ), response, False + False, + ) committed = False latest_result = AgentRunResult() @@ -5702,14 +5770,18 @@ def on_stream_action(action: Json) -> bool: invalid_response = self._validate_action_response(response) if invalid_response is not None: return AgentRunResult(), invalid_response, False - return self.handle_response( + return ( + self.handle_response( + response, + confirm=confirm, + on_auto_approve=on_auto_approve, + on_live_output=on_live_output, + on_live_done=on_live_done, + on_message=on_message, + ), response, - confirm=confirm, - on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, - on_message=on_message, - ), response, False + False, + ) def _can_stream_tools(self) -> bool: return self.mode == AgentMode.ACT and isinstance(self.model_client, ModelClient) and self.session.config.provider.stream is not False @@ -5794,9 +5866,10 @@ def _should_observe_after_tools(self) -> bool: budget = self.context_budget() # Tool failures stay visible to ACT as Latest Tool Results plus feedback. # Very large failures still trigger observe through raw-context pressure. - return len(pending) >= budget.observe_after_results or self.tool_context.raw_context_chars( - self.blackboard.memory_checkpoint_tool_result_counter - ) >= budget.raw_chars + return ( + len(pending) >= budget.observe_after_results + or self.tool_context.raw_context_chars(self.blackboard.memory_checkpoint_tool_result_counter) >= budget.raw_chars + ) def _after_tool_execution(self, execution: ToolCallExecution) -> None: self._remember_tool_failure(execution) @@ -5816,11 +5889,7 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: rule = self.RULE_EDIT_SIGNATURE self._remember_agent_error( self._error( - "tool call args invalid: " - + _format_tool_call_summary(execution.call) - + " -> " - + detail - + ".", + "tool call args invalid: " + _format_tool_call_summary(execution.call) + " -> " + detail + ".", rule, ) ) @@ -5921,9 +5990,7 @@ def _gate_action_types( return AgentRunResult() def _plan_is_complete(self) -> bool: - return bool(self.blackboard.plan) and all( - item.status in self.COMPLETED_PLAN_STATUSES and item.context.strip() for item in self.blackboard.plan - ) + return bool(self.blackboard.plan) and all(item.status in self.COMPLETED_PLAN_STATUSES and item.context.strip() for item in self.blackboard.plan) def _verification_is_settled(self) -> bool: return self.blackboard.verification.status in {VerificationStatus.DONE, VerificationStatus.BLOCKED} @@ -5970,7 +6037,11 @@ def _is_pending_verify_action(action: Json) -> bool: def _investigate_completion_error(self) -> str: if self.blackboard.work_mode != WorkMode.INVESTIGATE or not self.blackboard.goal_reached: return "" - return "" if any(item.status == HypothesisStatus.CONFIRMED for item in self.blackboard.hypotheses) else "investigate completion requires a confirmed hypothesis" + return ( + "" + if any(item.status == HypothesisStatus.CONFIRMED for item in self.blackboard.hypotheses) + else "investigate completion requires a confirmed hypothesis" + ) def _forget_active_hypothesis_error(self, actions: list[Json]) -> str: forgotten = set(ToolResultContext.forget_result_keys_from_actions(actions)) @@ -5983,13 +6054,7 @@ def _forget_active_hypothesis_error(self, actions: list[Json]) -> str: item = Hypothesis.from_json(raw) if item is not None and item.status != HypothesisStatus.ACTIVE: released.update(key for key in item.source if key.startswith("tr.")) - protected = { - key - for item in self.blackboard.hypotheses - if item.status == HypothesisStatus.ACTIVE - for key in item.source - if key.startswith("tr.") - } + protected = {key for item in self.blackboard.hypotheses if item.status == HypothesisStatus.ACTIVE for key in item.source if key.startswith("tr.")} conflict = sorted((forgotten & protected) - released) return "active hypothesis source: " + ", ".join(conflict) if conflict else "" @@ -6110,20 +6175,19 @@ def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallbac return AgentRunResult(done=True, value=ctx.response) def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: - return ( - self._gate_protocol_actions(ctx, on_message) - or self._gate_tool_actions(ctx, on_message) - or self._gate_task_state(ctx, on_message) - ) + return self._gate_protocol_actions(ctx, on_message) or self._gate_tool_actions(ctx, on_message) or self._gate_task_state(ctx, on_message) def _gate_protocol_actions(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: - return self._gate_action_types( - ctx.actions, - allowed=self.PLAN_ACTION_TYPES if self.session.settings.plan_mode else self.ACT_ACTION_TYPES, - on_message=on_message, - retry_message="Retrying: use a valid agent action.", - feedback_message=self._error("this step only accepts agent work actions."), - ) is not None + return ( + self._gate_action_types( + ctx.actions, + allowed=self.PLAN_ACTION_TYPES if self.session.settings.plan_mode else self.ACT_ACTION_TYPES, + on_message=on_message, + retry_message="Retrying: use a valid agent action.", + feedback_message=self._error("this step only accepts agent work actions."), + ) + is not None + ) def _gate_tool_actions(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: if self._gate_forget_actions(ctx.actions, on_message, self._remember_agent_error) is not None: @@ -6171,12 +6235,7 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N self._drop_goal_rewrite_actions(ctx) if ctx.pending_verify_requested: self._warn_agent('ignored verify status="pending".', self.RULE_VERIFY_DIRECTLY) - if ( - ctx.goal_was_empty - and not ctx.has_goal_action - and ctx.state_or_work_requested - and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call) - ): + if ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): self._warn_agent("changed Goal without replacing Plan.", "replace Plan when the task scope changes.") @@ -6192,11 +6251,7 @@ def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback on_message(ctx.assistant_text) def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: - if ( - ctx.plan_was_empty - and not self.blackboard.plan - and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call) - ): + if ctx.plan_was_empty and not self.blackboard.plan and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): self._warn_agent("mutating work before Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ( ctx.plan_was_empty @@ -6206,11 +6261,7 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | ): self._warn_agent("Plan is empty after discovery.", "set a short Plan before more broad exploration.") - if ( - ctx.tool_calls - and not any(execution.outcome != "success" for execution in self.tool_runner.latest_executions) - and self._verification_is_settled() - ): + if ctx.tool_calls and not any(execution.outcome != "success" for execution in self.tool_runner.latest_executions) and self._verification_is_settled(): if self._plan_is_complete(): self._warn_agent("Plan and verification are complete; continuing tools without reopening Plan.") elif ctx.plan_was_complete and ctx.verification_was_settled: @@ -6352,11 +6403,7 @@ def _forget_tool_result_error(self, actions: list[Json]) -> str: return "" if not keys: return "missing tr.* source" - visible_keys = set( - ToolResultContext.blocks_by_key( - self.tool_context.kept_results + self.tool_context.latest + self.tool_context.recent - ) - ) + visible_keys = set(ToolResultContext.blocks_by_key(self.tool_context.kept_results + self.tool_context.latest + self.tool_context.recent)) missing = [key for key in keys if key not in visible_keys] return "not in visible tool results: " + ", ".join(missing) if missing else "" @@ -6637,7 +6684,9 @@ class CommandSpec: CommandSpec("/api", "Show or set provider API format", "Config", "/api [auto|chat|responses]"), CommandSpec("/model", "Show or set model and reasoning", "Config", "/model [model_name]"), CommandSpec("/reason", "Set reasoning effort", "Config", "/reason"), - CommandSpec("/reason-payload", "Show or set chat reasoning payload", "Config", "/reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]"), + CommandSpec( + "/reason-payload", "Show or set chat reasoning payload", "Config", "/reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" + ), CommandSpec("/provider", "Show or switch provider", "Config", "/provider [name]"), CommandSpec("/plan", "Toggle plan mode or ask for a readonly plan", "Config", "/plan [on|off|question]"), CommandSpec("/yolo", "Toggle yolo mode (skip confirmations)", "Config", "/yolo"), @@ -6713,11 +6762,7 @@ def __init__( self.select_reasoning = select_reasoning self.select_model = select_model self.select_provider = select_provider - self.handlers = { - spec.name: getattr(self, "_" + spec.name[1:].replace("-", "_")) - for spec in COMMANDS - if spec.category != "Control" - } + self.handlers = {spec.name: getattr(self, "_" + spec.name[1:].replace("-", "_")) for spec in COMMANDS if spec.category != "Control"} self.handlers.update({alias: self.handlers[target] for alias, target in self.COMMAND_ALIASES.items()}) def dispatch(self, user_input: str) -> CommandResult: @@ -6951,7 +6996,14 @@ def _status(self, args: str) -> str: return "\n".join( [ "provider: " + session.config.active_provider, - "model: " + (provider.model or "(empty)") + " api=" + api + " reasoning=" + (reasoning or "(empty)") + " stream=" + self._format_bool(provider.stream), + "model: " + + (provider.model or "(empty)") + + " api=" + + api + + " reasoning=" + + (reasoning or "(empty)") + + " stream=" + + self._format_bool(provider.stream), "session: " + session.session_id, "runtime: yolo=" + self._format_bool(session.settings.yolo) @@ -7251,9 +7303,7 @@ def _format_line(self, turn_elapsed: float, *, now: float, show_elapsed: bool) - session = self.session active_model = session.state.current_model_call_label or session.config.provider.model model = active_model.rsplit("/", 1)[-1] or active_model or "(no model)" - reasoning = session.state.current_model_call_reasoning_label or ( - session.config.provider.reasoning - ) + reasoning = session.state.current_model_call_reasoning_label or (session.config.provider.reasoning) modes = "".join(" | " + label for label, enabled in (("yolo", session.settings.yolo), ("plan", session.settings.plan_mode)) if enabled) context = str(len(session.state.conversation)) + "/" + str(session.settings.compact_at) last_tokens = _format_count(session.state.last_total_tokens) @@ -7270,13 +7320,7 @@ def _format_line(self, turn_elapsed: float, *, now: float, show_elapsed: bool) - elapsed = max(0.0, now - session.state.current_model_call_started_at) if session.state.current_model_call_has_content and elapsed > 0: rate = session.state.current_model_call_streaming_chars / 4 / elapsed - parts.append( - activity - + "(" - + str(session.state.turn_model_calls) - + "):" - + f"{elapsed:.1f}s" - ) + parts.append(activity + "(" + str(session.state.turn_model_calls) + "):" + f"{elapsed:.1f}s") if rate > 0: parts[3] += " " + _format_count(int(rate)) + "t/s" if session.state.status_notice and session.state.status_notice_until > now: @@ -7987,7 +8031,17 @@ def _print_message(self, message: str) -> None: if message.startswith("State Updated"): self._emit_segments(self._state_segments(message), message) return - if message.startswith(("Plan Updated", "Known Updated", "Hypotheses Updated", "Plan + Known Updated", "Plan + Hypotheses Updated", "Hypotheses + Known Updated", "Plan + Hypotheses + Known Updated")): + if message.startswith( + ( + "Plan Updated", + "Known Updated", + "Hypotheses Updated", + "Plan + Known Updated", + "Plan + Hypotheses Updated", + "Hypotheses + Known Updated", + "Plan + Hypotheses + Known Updated", + ) + ): self._emit_segments(self._compact_state_segments(message), message) return if message.startswith("Tool Result Context:"): From 34a46cce58a86c7cfa8d6f89eb97e25e45f877cb Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 06:44:34 -0700 Subject: [PATCH 033/144] Normalize direct repository tool actions --- nanocode.py | 12 +++++++++++- tests/test_nanocode_agent.py | 19 +++++++++++++++++++ 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/nanocode.py b/nanocode.py index 1af965e..791c078 100644 --- a/nanocode.py +++ b/nanocode.py @@ -5966,7 +5966,17 @@ def _validate_action_response(self, response: Json) -> Json | None: return None def _response_actions(self, response: Json) -> list[Json]: - return [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action] + return [self._normalize_action(action) for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action] + + @staticmethod + def _normalize_action(action: Json) -> Json: + action_type = _json_str(action.get("type")) + if action_type not in TOOL_REGISTRY: + return action + normalized = dict(action) + normalized["type"] = "tool" + normalized["name"] = action_type + return normalized def _gate_action_types( self, diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 5fa4a44..306bf88 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2686,6 +2686,25 @@ def test_agent_plan_mode_rejects_invalid_action_instead_of_completing(tmp_path): assert messages == ["Protocol_Gate: invalid action type(s): invalid."] +def test_agent_normalizes_direct_repo_tool_action_type(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("old\n", encoding="utf-8") + agent = Agent(_session(tmp_path, debug=True)) + _seed_plan(agent, "change sample") + messages = [] + + result = agent.handle_response( + {"actions": [{"type": "Edit", "intention": "change sample", "args": ["sample.txt", "old", "new"]}]}, + confirm=lambda call, tool: True, + on_message=messages.append, + ) + + assert result.done is False + assert path.read_text(encoding="utf-8") == "new\n" + assert agent.tool_runner.latest_executions[0].call.name == "Edit" + assert not any("Protocol_Gate" in message for message in messages) + + def test_agent_plan_mode_stores_proposed_plan_completion(tmp_path): agent = Agent(_session(tmp_path, plan_mode=True)) _seed_plan(agent, "plan change") From f45b0ad012077c0e11dfbc6844c402361eb40d12 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 06:56:33 -0700 Subject: [PATCH 034/144] format code --- nanocode.py | 106 ++++++++-------------------------------------------- 1 file changed, 16 insertions(+), 90 deletions(-) diff --git a/nanocode.py b/nanocode.py index 791c078..19ce100 100644 --- a/nanocode.py +++ b/nanocode.py @@ -139,12 +139,7 @@ class PlanStatus(StrEnum): BLOCKED = "blocked" def __str__(self) -> str: - symbols = { - PlanStatus.TODO: "○", - PlanStatus.DOING: "◔", - PlanStatus.DONE: "✓", - PlanStatus.BLOCKED: "☒", - } + symbols = {PlanStatus.TODO: "○", PlanStatus.DOING: "◔", PlanStatus.DONE: "✓", PlanStatus.BLOCKED: "☒"} return f"{symbols.get(self, '')} {self.value}".strip() @@ -441,10 +436,7 @@ class ProviderProfile: # vendor-specific branches through request construction. DashScope intentionally # defaults to Chat because Responses support differs by model family and region. PROVIDER_PROFILES: dict[str, ProviderProfile] = { - "api.openai.com": ProviderProfile( - api="responses", - chat_reasoning_rules=(ChatReasoningRule("reasoning_effort", ("o1", "o3", "o4", "gpt-5")),), - ), + "api.openai.com": ProviderProfile(api="responses", chat_reasoning_rules=(ChatReasoningRule("reasoning_effort", ("o1", "o3", "o4", "gpt-5")),)), "openrouter.ai": ProviderProfile(api="responses", chat_reasoning="reasoning"), "opencode.ai": ProviderProfile(chat_reasoning_rules=(ChatReasoningRule("reasoning", ("deepseek-v4",)),)), "api.deepseek.com": ProviderProfile(chat_reasoning="thinking"), @@ -4202,10 +4194,7 @@ def _read_streaming_content( if output_chars <= 0: continue first_output_seen = self._mark_stream_output( - output_chars, - first_output_seen, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, + output_chars, first_output_seen, request_deadline=request_deadline, first_token_timeout=first_token_timeout ) if isinstance(content, str) and content: parts.append(content) @@ -4238,20 +4227,14 @@ def _read_responses_stream( if response_content and not parts and not completed_content: completed_content = response_content first_output_seen = self._mark_stream_output( - len(response_content), - first_output_seen, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, + len(response_content), first_output_seen, request_deadline=request_deadline, first_token_timeout=first_token_timeout ) continue fallback_content = self._responses_event_content(data) if fallback_content and not parts and not completed_content: completed_content = fallback_content first_output_seen = self._mark_stream_output( - len(fallback_content), - first_output_seen, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, + len(fallback_content), first_output_seen, request_deadline=request_deadline, first_token_timeout=first_token_timeout ) continue output = self._responses_stream_output(data) @@ -4394,9 +4377,7 @@ def _record_usage(self, usage: Json, config: ProviderConfig, *, elapsed: float = self.session.state.session_completion_tokens += completion_tokens self.session.state.session_total_tokens += total_tokens self.session.state.model_usage.setdefault(config.model or "(empty)", ModelUsage()).add( - prompt_tokens=prompt_tokens, - completion_tokens=completion_tokens, - total_tokens=total_tokens, + prompt_tokens=prompt_tokens, completion_tokens=completion_tokens, total_tokens=total_tokens ) @staticmethod @@ -5135,13 +5116,7 @@ def _reset_stale_verification(self, actions: list[Json], *, goal_changed: bool, if ( plan_replaced and not any(_json_str(action.get("type")) == "verify" for action in actions) - and verification.status - in { - VerificationStatus.REQUIRED, - VerificationStatus.DONE, - VerificationStatus.FAILED, - VerificationStatus.BLOCKED, - } + and verification.status in {VerificationStatus.REQUIRED, VerificationStatus.DONE, VerificationStatus.FAILED, VerificationStatus.BLOCKED} ): verification.reset() @@ -5254,18 +5229,7 @@ class Agent: MAX_AGENT_FEEDBACK_ERRORS: ClassVar[int] = 8 MAX_AGENT_FEEDBACK_ERROR_LEN: ClassVar[int] = 220 MODEL_TIMEOUT_RETRY_DELAYS: ClassVar[tuple[int, ...]] = (3, 10, 20, 30, 60, 120) - blackboard: Blackboard - ACT_ACTION_TYPES: ClassVar[set[str]] = { - "goal", - "plan", - "hypothesis", - "known", - "stable_knowledge", - "tool", - "verify", - "user_rule", - "forget", - } + ACT_ACTION_TYPES: ClassVar[set[str]] = {"goal", "plan", "hypothesis", "known", "stable_knowledge", "tool", "verify", "user_rule", "forget"} PLAN_ACTION_TYPES: ClassVar[set[str]] = ACT_ACTION_TYPES - {"user_rule", "forget"} OBSERVE_ACTION_TYPES: ClassVar[set[str]] = {"keep", "hypothesis", "known", "stable_knowledge", "forget"} COMPLETED_PLAN_STATUSES: ClassVar[set[PlanStatus]] = {PlanStatus.DONE, PlanStatus.BLOCKED} @@ -5284,7 +5248,7 @@ class Agent: def __init__(self, session: Session): self.session = session - self.blackboard = Blackboard() + self.blackboard: Blackboard = Blackboard() self.recent_edits: list[str] = [] self.tool_context = ToolResultContext() self.model_client = ModelClient(session) @@ -5419,17 +5383,7 @@ def request( delay = self.MODEL_TIMEOUT_RETRY_DELAYS[attempt] self._set_status_notice("err:first_token" if timeout_reason == "request first token timeout" else "err:timeout") if on_message is not None and self.session.settings.debug: - on_message( - "Retrying: " - + timeout_reason - + "; retry " - + str(attempt + 1) - + "/" - + str(len(self.MODEL_TIMEOUT_RETRY_DELAYS)) - + " in " - + str(delay) - + "s." - ) + on_message(f"Retrying: {timeout_reason}; retry {attempt + 1}/{len(self.MODEL_TIMEOUT_RETRY_DELAYS)} in {delay}s.") attempt += 1 time.sleep(delay) raise LLMError("request model timeout") @@ -5707,12 +5661,7 @@ def stream_step( return AgentRunResult(), response, False return ( self.handle_response( - response, - confirm=confirm, - on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, - on_message=on_message, + response, confirm=confirm, on_auto_approve=on_auto_approve, on_live_output=on_live_output, on_live_done=on_live_done, on_message=on_message ), response, False, @@ -5772,12 +5721,7 @@ def on_stream_action(action: Json) -> bool: return AgentRunResult(), invalid_response, False return ( self.handle_response( - response, - confirm=confirm, - on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, - on_message=on_message, + response, confirm=confirm, on_auto_approve=on_auto_approve, on_live_output=on_live_output, on_live_done=on_live_done, on_message=on_message ), response, False, @@ -5839,13 +5783,7 @@ def execute_tool_calls( on_live_output: ToolLiveOutputCallback | None = None, on_live_done: ToolLiveDoneCallback | None = None, ) -> str: - self.tool_runner.execute( - tool_calls, - confirm=confirm, - on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, - ) + self.tool_runner.execute(tool_calls, confirm=confirm, on_auto_approve=on_auto_approve, on_live_output=on_live_output, on_live_done=on_live_done) self.tool_context.append_latest( self.tool_runner.latest_executions, max_index_items=self.context_budget().index_items, @@ -5951,9 +5889,7 @@ def _remember_recent_edit(self, execution: ToolCallExecution) -> None: def _invalid_action_response(self, response: Json, reason: str) -> Json: return { "actions": [], - "_format_error": "Invalid function-tool response: " - + reason - + ". Use the provided function tools. Bad output: " + "_format_error": f"Invalid function-tool response: {reason}. Use the provided function tools. Bad output: " + _shorten(json.dumps(response, ensure_ascii=False)), } @@ -5992,11 +5928,7 @@ def _gate_action_types( if not invalid: return None (remember_error or self._remember_agent_error)(feedback_message + " Invalid action(s): " + ", ".join(invalid) + ".") - self._report_gate( - on_message, - retry_message, - "Protocol_Gate: invalid action type(s): " + ", ".join(invalid) + ".", - ) + self._report_gate(on_message, retry_message, "Protocol_Gate: invalid action type(s): " + ", ".join(invalid) + ".") return AgentRunResult() def _plan_is_complete(self) -> bool: @@ -6348,13 +6280,7 @@ def _run_tool_actions( if report: on_message(report) if self.session.settings.debug and self.tool_runner.skipped_after_failure_count: - on_message( - "Tool Calls Skipped: " - + str(self.tool_runner.skipped_after_failure_count) - + " after " - + self.tool_runner.skipped_after_failure_key - + " failed" - ) + on_message(f"Tool Calls Skipped: {self.tool_runner.skipped_after_failure_count} after {self.tool_runner.skipped_after_failure_key} failed") self.compactor.maybe_compact() return True From f98bf24c3e6f90a459963ad57f1a05212d4d5f6d Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 07:03:36 -0700 Subject: [PATCH 035/144] Trim runtime and tool duplication --- nanocode.py | 78 +++++++++++++++++++++++------------------------------ 1 file changed, 33 insertions(+), 45 deletions(-) diff --git a/nanocode.py b/nanocode.py index 19ce100..36302a1 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2048,8 +2048,6 @@ def make(cls, session: Session, args: list[str]) -> Self: path_set = False for raw_option in args[1:]: option = str(raw_option) - if option.startswith("ignore_case") or option.startswith("case_sensitive"): - raise ToolCallArgError("Search supports only path=, glob=, and context= options; ignore_case is not supported") if option.startswith("path="): if path_set: raise ToolCallArgError("path option cannot be combined with positional path") @@ -2060,7 +2058,7 @@ def make(cls, session: Session, args: list[str]) -> Self: try: context_lines = cls._parse_context_arg(option) except ValueError: - raise ToolCallArgError("context must be an integer between 0 and " + str(cls.MAX_CONTEXT_LINES)) + raise ToolCallArgError(f"context must be an integer between 0 and {cls.MAX_CONTEXT_LINES}") continue if option.startswith("glob=") or option.startswith("glob_pattern="): if glob_pattern: @@ -2587,9 +2585,7 @@ def _preview_warning(self) -> str: return "" if self.start == 0 and self.end == 0 and not os.path.exists(self.filepath): return "" - if self.end == 0: - return "# warning: broad range replacement; prefer smaller semantic ranges" - if self.end - self.start > 20: + if self.end == 0 or self.end - self.start > 20: return "# warning: broad range replacement; prefer smaller semantic ranges" return "" @@ -3194,6 +3190,13 @@ def _state_tool_schema(name: str) -> Json: Prefer useful tool calls over state-only turns. Pair state updates with the next frontier tool call when tool arguments are already known. +FORWARD PROGRESS +- Advance as far as safely possible in each turn. +- Batch independent tool calls whenever their arguments are known. +- Do not stop after Goal, Plan, Known, or Hypothesis updates if a useful repository tool call is clear. +- Serialize only when later arguments depend on earlier results. +- Ask the user only when the blocker cannot be resolved by available tools. + PLANNING Use a Plan only for real multi-step work. Usually keep it to 2-5 concrete outcome steps. @@ -3758,7 +3761,7 @@ def request( raise LLMError("request model timeout") except APIStatusError as error: body = getattr(error.response, "text", "") or str(getattr(error, "body", "")) or str(error) - raise LLMError("API request failed: HTTP " + str(error.status_code) + ": " + _shorten(body)) + raise LLMError(f"API request failed: HTTP {error.status_code}: {_shorten(body)}") except APIConnectionError as error: raise LLMError(str(error)) except APIError as error: @@ -3858,11 +3861,10 @@ def _read_chat_tool_stream( text_parts: list[str] = [] first_output_seen = False - stream_params = dict(params) self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) stopped = False tool_calls: dict[int, Json] = {} - for event in client.chat.completions.create(**stream_params, timeout=timeout): + for event in client.chat.completions.create(**params, timeout=timeout): data = self._sdk_json(event) event_usage = _json_dict(data.get("usage")) if event_usage: @@ -3967,10 +3969,9 @@ def _read_responses_tool_stream( first_output_seen = False function_calls: dict[str, Json] = {} - stream_params = dict(params) self._arm_stream_timeout(request_deadline=request_deadline, first_output_seen=False, first_token_timeout=first_token_timeout) stopped = False - for event in client.responses.create(**stream_params, timeout=timeout): + for event in client.responses.create(**params, timeout=timeout): data = self._sdk_json(event) event_type = _json_str(data.get("type")) or str(getattr(event, "type", "") or "") self._raise_responses_stream_error(data) @@ -4075,11 +4076,8 @@ def _chat_tool_response(self, result: JsonValue) -> Json: for call in (_json_dict(raw) for raw in _json_list(message.get("tool_calls"))) if call ] - if actions: - content = message.get("content") - return self._action_response(actions, content if isinstance(content, str) else "") content = message.get("content") - return self._action_response([], content if isinstance(content, str) else "") + return self._action_response(actions, content if isinstance(content, str) else "") def _responses_tool_response(self, result: JsonValue) -> Json: actions = [ @@ -4087,9 +4085,7 @@ def _responses_tool_response(self, result: JsonValue) -> Json: for item in (_json_dict(raw) for raw in _json_list(_json_dict(result).get("output"))) if _json_str(item.get("type")) == "function_call" ] - if actions: - return self._action_response(actions, self._responses_content(result) or "") - return self._action_response([], self._responses_content(result) or "") + return self._action_response(actions, self._responses_content(result) or "") @staticmethod def _action_response(actions: list[Json], assistant_text: str = "") -> Json: @@ -5480,13 +5476,11 @@ def _handle_format_gate(self, response: Json, format_error: str, consecutive_err if consecutive_errors >= self.MAX_CONSECUTIVE_FORMAT_ERRORS: self._report_gate( on_message, - "Stopped: invalid function/tool response " + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS) + " times in a row.", - "Format_Gate: stopped after " - + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS) - + " consecutive invalid function/tool responses. " + f"Stopped: invalid function/tool response {self.MAX_CONSECUTIVE_FORMAT_ERRORS} times in a row.", + f"Format_Gate: stopped after {self.MAX_CONSECUTIVE_FORMAT_ERRORS} consecutive invalid function/tool responses. " + self._format_gate_debug_details(response, format_error), ) - raise LLMError("invalid function/tool response " + str(self.MAX_CONSECUTIVE_FORMAT_ERRORS) + " times in a row: " + _shorten(format_error, 300)) + raise LLMError(f"invalid function/tool response {self.MAX_CONSECUTIVE_FORMAT_ERRORS} times in a row: {_shorten(format_error, 300)}") self._report_gate( on_message, self._format_gate_user_message("Retrying: invalid function/tool response", format_error), @@ -6682,6 +6676,8 @@ class CommandDispatcher: MODEL_DISCOVERED_LABEL = "---- Discovered models ----" MODEL_LABELS = frozenset((MODEL_CONFIGURED_LABEL, MODEL_DISCOVERED_LABEL)) COMMAND_ALIASES = {"/context-budget": "/context", "/context_budget": "/context"} + API_USAGE = "Usage: /api [auto|chat|responses]" + REASON_PAYLOAD_USAGE = "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" def __init__( self, @@ -6779,9 +6775,9 @@ def _api(self, args: str) -> str: if not value: resolved = provider.resolved_api() suffix = " (" + resolved + ")" if provider.api == "auto" else "" - return "provider.api: " + provider.api + suffix + "\nUsage: /api [auto|chat|responses]" + return "provider.api: " + provider.api + suffix + "\n" + self.API_USAGE if value not in {"auto", "chat", "responses"}: - return "Usage: /api [auto|chat|responses]" + return self.API_USAGE provider.api = value return "Set provider.api = " + value @@ -6839,15 +6835,9 @@ def _reason_payload(self, args: str) -> str: if not value: configured = provider.chat_reasoning or "off" resolved = provider.resolved_chat_reasoning() or "off" - return ( - "provider.chat_reasoning: " - + configured - + "\nprovider.resolved_chat_reasoning: " - + resolved - + "\nUsage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" - ) + return "provider.chat_reasoning: " + configured + "\nprovider.resolved_chat_reasoning: " + resolved + "\n" + self.REASON_PAYLOAD_USAGE if value not in CHAT_REASONING_CHOICES: - return "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" + return self.REASON_PAYLOAD_USAGE provider.chat_reasoning = value return "Set provider.chat_reasoning = " + value @@ -7534,29 +7524,27 @@ def choice_fragments(): bindings = KeyBindings() searching = Condition(lambda: bool(state["searching"])) + def move(event, delta: int) -> None: + options = enabled() + if options: + state["selected"] = min(max(int(state["selected"]) + delta, 0), len(options) - 1) + event.app.invalidate() + @bindings.add("up", eager=True) def _up(event): - state["selected"] = max(0, int(state["selected"]) - 1) - event.app.invalidate() + move(event, -1) @bindings.add("k", filter=~searching, eager=True) def _k(event): - state["selected"] = max(0, int(state["selected"]) - 1) - event.app.invalidate() + move(event, -1) @bindings.add("down", eager=True) def _down(event): - options = enabled() - if options: - state["selected"] = min(len(options) - 1, int(state["selected"]) + 1) - event.app.invalidate() + move(event, 1) @bindings.add("j", filter=~searching, eager=True) def _j(event): - options = enabled() - if options: - state["selected"] = min(len(options) - 1, int(state["selected"]) + 1) - event.app.invalidate() + move(event, 1) @bindings.add("/", eager=True) def _search(event): From 2e1784a48021bddfce71eaaaf80d385a9946b7c1 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 07:09:20 -0700 Subject: [PATCH 036/144] Simplify state update output --- nanocode.py | 12 ++++++++---- tests/test_nanocode_agent.py | 8 ++++---- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/nanocode.py b/nanocode.py index 36302a1..323ed71 100644 --- a/nanocode.py +++ b/nanocode.py @@ -4761,17 +4761,21 @@ def compact_report(self) -> str: sections = [ (name, rows) for name, changed, rows in ( - ("Plan", " Plan" in self.latest_report and self.blackboard.plan, self.latest_compact_plan_rows or self._compact_plan_rows()), + ("Goal", "\n Goal" in self.latest_report, [" " + self._compact(self.blackboard.goal or "(empty)")]), + ("Plan", "\n Plan" in self.latest_report and self.blackboard.plan, self.latest_compact_plan_rows or self._compact_plan_rows()), ( "Hypotheses", - " Hypotheses" in self.latest_report and self.blackboard.hypotheses, + "\n Hypotheses" in self.latest_report and self.blackboard.hypotheses, self._compact_rows(self.blackboard.hypotheses, lambda item: self._compact(item.format(), 100)), ), ( "Known", - " Known" in self.latest_report and self.blackboard.known, + "\n Known" in self.latest_report and self.blackboard.known, self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100)), ), + ("Stable Knowledge", "\n Stable_Knowledge" in self.latest_report, [" updated"]), + ("Verification", "\n Verify" in self.latest_report, [" " + self._format_verification()]), + ("User Rules", "\n User_Rules" in self.latest_report, [" updated"]), ) if changed ] @@ -6180,7 +6184,7 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback | None) -> None: if on_message is not None and self.state_updater.latest_report: - report = self.state_updater.latest_report if self.session.settings.debug else self.state_updater.compact_report() + report = self.state_updater.compact_report() if report: on_message(report) if on_message is not None and ctx.assistant_text and ctx.actions and not ctx.completion_message: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 306bf88..2eab1b4 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1962,7 +1962,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): agent.run("记住：prompt 改动不用测试", on_message=messages.append) - assert any(message.startswith("State Updated") for message in messages) + assert "User Rules Updated\n updated" in messages def test_main_agent_state_updates_are_compact_without_debug(tmp_path): @@ -1987,12 +1987,12 @@ def test_main_agent_state_updates_are_compact_without_debug(tmp_path): ) report = agent.state_updater.compact_report() - assert report.startswith("Plan + Known Updated") + assert report.startswith("Goal + Plan + Known Updated") + assert "\nGoal\n inspect project\n" in report assert "\nPlan\n" in report assert " ... 1 older\n 2. [✓ done] Read config\n 3. [◔ doing] Update code\n 4. [○ todo] Run tests" in report assert "\nKnown\n" in report assert " ... 1 older\n 2. fact two\n 3. fact three\n 4. fact four" in report - assert "inspect project" not in report assert "State Updated" not in report @@ -2180,7 +2180,7 @@ def test_agent_accepts_goal_without_plan_for_new_task(tmp_path): assert agent.blackboard.goal == "change map" assert agent.blackboard.task_code == nanocode.TaskCode.WORKING assert agent.blackboard.plan == [] - assert messages == ["State Updated | VERIFY:idle\n Goal change map"] + assert messages == ["Goal Updated\n change map"] def test_new_goal_clears_task_local_kept_results_only(tmp_path): From 3fbac4b187f8d4f0ee35e4f872dbd63d99d427b0 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 07:12:54 -0700 Subject: [PATCH 037/144] Remove verbose state update header --- nanocode.py | 55 +++++------------------------------- tests/test_nanocode_agent.py | 1 - 2 files changed, 7 insertions(+), 49 deletions(-) diff --git a/nanocode.py b/nanocode.py index 323ed71..3a649f8 100644 --- a/nanocode.py +++ b/nanocode.py @@ -4761,21 +4761,21 @@ def compact_report(self) -> str: sections = [ (name, rows) for name, changed, rows in ( - ("Goal", "\n Goal" in self.latest_report, [" " + self._compact(self.blackboard.goal or "(empty)")]), - ("Plan", "\n Plan" in self.latest_report and self.blackboard.plan, self.latest_compact_plan_rows or self._compact_plan_rows()), + ("Goal", " Goal" in self.latest_report, [" " + self._compact(self.blackboard.goal or "(empty)")]), + ("Plan", " Plan" in self.latest_report and self.blackboard.plan, self.latest_compact_plan_rows or self._compact_plan_rows()), ( "Hypotheses", - "\n Hypotheses" in self.latest_report and self.blackboard.hypotheses, + " Hypotheses" in self.latest_report and self.blackboard.hypotheses, self._compact_rows(self.blackboard.hypotheses, lambda item: self._compact(item.format(), 100)), ), ( "Known", - "\n Known" in self.latest_report and self.blackboard.known, + " Known" in self.latest_report and self.blackboard.known, self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100)), ), - ("Stable Knowledge", "\n Stable_Knowledge" in self.latest_report, [" updated"]), - ("Verification", "\n Verify" in self.latest_report, [" " + self._format_verification()]), - ("User Rules", "\n User_Rules" in self.latest_report, [" updated"]), + ("Stable Knowledge", " Stable_Knowledge" in self.latest_report, [" updated"]), + ("Verification", " Verify" in self.latest_report, [" " + self._format_verification()]), + ("User Rules", " User_Rules" in self.latest_report, [" updated"]), ) if changed ] @@ -4999,8 +4999,6 @@ def _apply_task_code(self, actions: list[Json]) -> None: self.blackboard.task_code = TaskCode.WORKING def _append_state_section(self, lines: list[str], title: str, rows: list[str] | None = None) -> None: - if not lines: - lines.append("State Updated | VERIFY:" + self.blackboard.verification.status) lines.append(title) lines.extend(rows or []) @@ -7956,9 +7954,6 @@ def _wait_confirm(self, prompt: str, *, default: bool) -> ConfirmationResult: return raw_answer def _print_message(self, message: str) -> None: - if message.startswith("State Updated"): - self._emit_segments(self._state_segments(message), message) - return if message.startswith( ( "Plan Updated", @@ -8108,33 +8103,6 @@ def _indent_segments(self, segments: list[tuple[str, str]], indent: str) -> list at_line_start = part.endswith("\n") return indented - def _state_segments(self, message: str) -> list[tuple[str, str]]: - lines = message.splitlines() - segments: list[tuple[str, str]] = [("ansibrightblack", "-" * 48 + "\n")] - for index, line in enumerate(lines): - if index == 0: - title, _, badge = line.partition("|") - badge = badge.strip() - segments.extend([("bold ansicyan", title.strip()), ("ansibrightblack", " | "), (self._verify_style(badge), badge), ("", "\n")]) - elif line.startswith(" Goal"): - segments.extend([("ansibrightblack", line[:10]), ("bold ansigreen", line[10:] + "\n")]) - elif line.startswith(" Plan"): - segments.extend([("ansibrightblack", " "), ("bold ansicyan", line.strip()), ("", "\n")]) - elif line.startswith(" Hypotheses"): - segments.extend([("ansibrightblack", " "), ("bold ansimagenta", line.strip()), ("", "\n")]) - elif line.startswith(" Known"): - segments.extend([("ansibrightblack", " "), ("bold ansiyellow", line.strip()), ("", "\n")]) - elif line.startswith(" Verify"): - status = line[10:].strip().split(" ", 1)[0] - segments.extend([("ansibrightblack", line[:10]), (self._verify_style("VERIFY:" + status), line[10:] + "\n")]) - elif line.startswith(" ..."): - segments.extend([("ansibrightblack", line + "\n")]) - elif line.startswith(" "): - segments.extend([("ansibrightblack", " "), ("ansiwhite", line[4:] + "\n")]) - else: - segments.extend([("ansiwhite", line + "\n")]) - return segments - def _compact_state_segments(self, message: str) -> list[tuple[str, str]]: segments: list[tuple[str, str]] = [] for line in message.splitlines(): @@ -8173,15 +8141,6 @@ def _tool_call_segments(self, tail: str, status_style: str) -> list[tuple[str, s segments.append(("", "\n")) return segments - def _verify_style(self, badge: str) -> str: - if "required" in badge: - return "bold ansimagenta" - if "done" in badge: - return "bold ansigreen" - if "failed" in badge or "blocked" in badge: - return "bold ansired" - return "ansibrightblack" - ############################ # Helpers diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 2eab1b4..ff2c12e 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2089,7 +2089,6 @@ def test_agent_state_report_only_includes_real_plan_and_known_changes(tmp_path): agent.apply_response(response) - assert "State Updated | VERIFY:idle" in agent.state_updater.latest_report assert " Plan\n" in agent.state_updater.latest_report assert " 1. [○ todo] Inspect file" in agent.state_updater.latest_report assert " Known\n" in agent.state_updater.latest_report From 9850457e7ddf007a2833df2758db62975924928f Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 07:34:21 -0700 Subject: [PATCH 038/144] Support all matches in Edit tool --- nanocode.py | 33 ++++++++++++++++++-------------- tests/test_nanocode_edit_tool.py | 33 ++++++++++++++++++++++++++++++-- 2 files changed, 50 insertions(+), 16 deletions(-) diff --git a/nanocode.py b/nanocode.py index 3a649f8..3c17d9a 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2355,15 +2355,16 @@ class EditTool(Tool): NAME: ClassVar[str] = "Edit" EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Replace/delete one unique exact literal text block in an existing file; best for tiny unambiguous edits, not regex.", - "If the target text is repeated, structural, or line ranges are clearer, use ReplaceRange.", + "Replace/delete exact literal text in an existing file; default requires one unique match, optional 'all' replaces every match.", + "If the target is structural or line ranges are clearer, use ReplaceRange.", ) - SIGNATURE: ClassVar[str] = "Edit(filepath, find, replace) -> EditToolResult" - EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["code.py", "old text", "new text"]',) + SIGNATURE: ClassVar[str] = "Edit(filepath, find, replace[, all]) -> EditToolResult" + EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["code.py", "old text", "new text"]', 'Example all args: ["code.py", "old", "new", "all"]') filepath: str = "" find: str = "" replace: str = "" + replace_all: bool = False cwd: str = "" @classmethod @@ -2372,14 +2373,16 @@ def cli_args(cls, args: list[str]) -> list[str]: @classmethod def make(cls, session: Session, args: list[str]) -> Self: - if len(args) != 3: + if len(args) not in (3, 4): raise ToolCallArgError( "Edit args error: got " + str(len(args)) - + ' args; expected ["filepath", "find", "replace"]. Example: Edit("nanocode.py", "old text", "new text"). Do not call Edit().' + + ' args; expected ["filepath", "find", "replace", optional "all"]. Example: Edit("nanocode.py", "old text", "new text").' ) + if len(args) == 4 and str(args[3]) != "all": + raise ToolCallArgError('Edit fourth arg must be exactly "all"') find = str(args[1]) - return cls(filepath=session.resolve_path(args[0]), find=find, replace=str(args[2]), cwd=session.cwd) + return cls(filepath=session.resolve_path(args[0]), find=find, replace=str(args[2]), replace_all=len(args) == 4, cwd=session.cwd) def preview(self) -> str: label = f'Edit({self.filepath}, find="{self.find}")' @@ -2396,9 +2399,10 @@ def preview(self) -> str: return label + "\n# preview unavailable: empty find creates missing files only" if self.find not in content: return label - if content.count(self.find) != 1: - return label + "\n# preview unavailable: target `find` text matched multiple times; use ReplaceRange or a larger unique find block" - return _make_unified_diff(content, content.replace(self.find, self.replace, 1), self.filepath) or label + replacements = content.count(self.find) + if replacements != 1 and not self.replace_all: + return label + '\n# preview unavailable: target `find` text matched multiple times; pass "all" to replace all matches or use ReplaceRange' + return _make_unified_diff(content, content.replace(self.find, self.replace, -1 if self.replace_all else 1), self.filepath) or label def call(self) -> str: created = False @@ -2414,11 +2418,12 @@ def call(self) -> str: raise ToolCallError("empty find creates missing files only") if self.find not in content: raise ToolCallError("target `find` text not found") - if content.count(self.find) != 1: - raise ToolCallError("target `find` text matched multiple times; use ReplaceRange or a larger unique find block") + replacements = content.count(self.find) + if replacements != 1 and not self.replace_all: + raise ToolCallError('target `find` text matched multiple times; pass "all" to replace all matches or use ReplaceRange') with open(self.filepath, "w", encoding="utf-8") as f: - f.write(content.replace(self.find, self.replace, 1)) + f.write(content.replace(self.find, self.replace, -1 if self.replace_all else 1)) lines = [ "", @@ -2427,7 +2432,7 @@ def call(self) -> str: if created: lines.append("* created: true") else: - lines.append("* replacements: 1") + lines.append(f"* replacements: {replacements}") lines.append("") return "\n".join(lines) diff --git a/tests/test_nanocode_edit_tool.py b/tests/test_nanocode_edit_tool.py index 1aef327..e709328 100644 --- a/tests/test_nanocode_edit_tool.py +++ b/tests/test_nanocode_edit_tool.py @@ -33,12 +33,34 @@ def test_edit_tool_rejects_repeated_find_text(tmp_path): tool = EditTool.make(session, ["sample.txt", "beta", "BETA"]) - assert "matched multiple times" in tool.preview() + assert 'pass "all"' in tool.preview() with pytest.raises(ToolCallError, match="matched multiple times"): tool.call() assert path.read_text(encoding="utf-8") == "alpha\nbeta\nbeta\n" +def test_edit_tool_replaces_all_exact_matches_when_requested(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\nbeta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + tool = EditTool.make(session, ["sample.txt", "beta", "BETA", "all"]) + display = tool.preview() + result = tool.call() + + assert display.count("-beta") == 2 + assert display.count("+BETA") == 2 + assert path.read_text(encoding="utf-8") == "alpha\nBETA\nBETA\n" + assert result == "\n".join( + [ + "", + "* path: sample.txt", + "* replacements: 2", + "", + ] + ) + + def test_edit_tool_raises_when_find_text_is_missing(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\n", encoding="utf-8") @@ -73,10 +95,17 @@ def test_edit_tool_creates_missing_file_with_empty_find(tmp_path): def test_edit_tool_rejects_wrong_arg_count_with_actionable_error(tmp_path): session = Session(cwd=str(tmp_path)) - with pytest.raises(ToolCallError, match=r'Edit args error: got 0 args; expected \["filepath", "find", "replace"\]'): + with pytest.raises(ToolCallError, match=r'Edit args error: got 0 args; expected \["filepath", "find", "replace", optional "all"\]'): EditTool.make(session, []) +def test_edit_tool_rejects_invalid_fourth_arg(tmp_path): + session = Session(cwd=str(tmp_path)) + + with pytest.raises(ToolCallError, match='fourth arg must be exactly "all"'): + EditTool.make(session, ["sample.txt", "beta", "BETA", "first"]) + + def test_edit_tool_rejects_empty_find_text_for_existing_file(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\n", encoding="utf-8") From cbe4795688251e3cb4c84959358499f3bccdb517 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 07:41:44 -0700 Subject: [PATCH 039/144] Show line numbers in Read output --- nanocode.py | 11 +++++++-- tests/test_nanocode_read_tool.py | 41 ++++++++++++++++---------------- 2 files changed, 30 insertions(+), 22 deletions(-) diff --git a/nanocode.py b/nanocode.py index 3c17d9a..f4a8413 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1745,8 +1745,9 @@ class ReadTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Read a single known UTF-8 file; pass multiple 0-based start,end ranges for it.", "Each range returns at most 600 lines.", + 'Content is line-numbered as "line | code"; edit text must use only code after " | ".', ) - SIGNATURE: ClassVar[str] = "Read(filepath[, range_token...]) -> ReadToolResult" + SIGNATURE: ClassVar[str] = "Read(filepath[, range_token...]) -> ReadToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["code.py", "0,80", "160,220"]', 'Example args: ["code.py"]', @@ -1817,6 +1818,10 @@ def call(self) -> str: lines.append("") return "\n".join(lines) + @staticmethod + def _numbered_content(content: str, start: int) -> str: + return "".join(f"{start + index:>7} | {line}" for index, line in enumerate(content.splitlines(keepends=True))) + def _read_range(self, start: int, end: int) -> tuple[str, int, int, str, bool, int]: target_filepath = self.filepath total_lines = 0 @@ -1864,6 +1869,7 @@ def _format_range_result( lines = [ indent + "" + str(start) + ":" + str(fingerprint_end) + "", indent + "" + fingerprint + "", + indent + 'Line prefixes are display-only; use only code after " | " in edits.', ] if truncated: note = ( @@ -1877,7 +1883,7 @@ def _format_range_result( indent + "" + note + "", ] ) - lines.extend([indent + "", content, indent + ""]) + lines.extend([indent + "", self._numbered_content(content, start), indent + ""]) return lines @@ -3230,6 +3236,7 @@ def _state_tool_schema(name: str) -> Json: Use Search/ListDir/LineCount when path, symbol, range, or target is unknown. Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. +Read line prefixes are display-only; edit text starts after " | ". Stop discovery once the next edit/check is clear. diff --git a/tests/test_nanocode_read_tool.py b/tests/test_nanocode_read_tool.py index 3795782..8cc22c7 100644 --- a/tests/test_nanocode_read_tool.py +++ b/tests/test_nanocode_read_tool.py @@ -16,8 +16,9 @@ def test_read_tool_reads_requested_line_range(tmp_path): assert result.startswith("") assert "1:3" in result assert "" in result - assert "beta\ngamma\n" in result - assert "alpha" not in result + assert "" in result + assert " 1 | beta\n 2 | gamma\n" in result + assert " 0 | alpha" not in result def test_read_tool_rejects_empty_args_with_actionable_error(tmp_path): @@ -48,10 +49,10 @@ def test_read_tool_reads_multiple_line_range_tokens(tmp_path): assert "1:2, 3:5" in tool.preview() assert "1:2" in result assert "3:5" in result - assert "one\n" in result - assert "three\nfour\n" in result - assert "zero\n" not in result - assert "two\n" not in result + assert " 1 | one\n" in result + assert " 3 | three\n 4 | four\n" in result + assert " 0 | zero" not in result + assert " 2 | two" not in result def test_read_tool_reads_colon_and_comma_range_tokens(tmp_path): @@ -66,10 +67,10 @@ def test_read_tool_reads_colon_and_comma_range_tokens(tmp_path): assert "1:2, 3:5" in tool.preview() assert "1:2" in result assert "3:5" in result - assert "one\n" in result - assert "three\nfour\n" in result - assert "zero\n" not in result - assert "two\n" not in result + assert " 1 | one\n" in result + assert " 3 | three\n 4 | four\n" in result + assert " 0 | zero" not in result + assert " 2 | two" not in result def test_read_tool_reads_to_eof_when_end_is_zero(tmp_path): @@ -79,8 +80,8 @@ def test_read_tool_reads_to_eof_when_end_is_zero(tmp_path): result = ReadTool.make(session, ["sample.txt", "1,0"]).call() - assert "beta\ngamma\n" in result - assert "alpha" not in result + assert " 1 | beta\n 2 | gamma\n" in result + assert " 0 | alpha" not in result def test_read_tool_allows_omitted_range_for_full_file_read(tmp_path): @@ -94,7 +95,7 @@ def test_read_tool_allows_omitted_range_for_full_file_read(tmp_path): assert tool.start == 0 assert tool.end == 0 assert "0:0" in result - assert "alpha\nbeta\n" in result + assert " 0 | alpha\n 1 | beta\n" in result def test_read_tool_reads_range_token_when_numeric_filenames_exist(tmp_path): @@ -108,7 +109,7 @@ def test_read_tool_reads_range_token_when_numeric_filenames_exist(tmp_path): assert tool.ranges == [(1, 3)] assert "1:3" in result - assert "one\ntwo\n" in result + assert " 1 | one\n 2 | two\n" in result assert "numeric filename" not in result @@ -124,8 +125,8 @@ def test_read_tool_truncates_full_file_reads_after_600_lines(tmp_path): assert "605" in result assert "Read returned 600 lines from 0:600 of 605 total lines" in result assert "Use Search to locate relevant text or Read smaller ranges in batches." in result - assert "line-0599\n" in result - assert "line-0600\n" not in result + assert " 599 | line-0599\n" in result + assert " 600 | line-0600\n" not in result def test_read_tool_truncates_large_bounded_ranges_after_600_lines(tmp_path): @@ -139,8 +140,8 @@ def test_read_tool_truncates_large_bounded_ranges_after_600_lines(tmp_path): assert "true" in result assert "700" in result assert "Read returned 600 lines from 10:610 of 700 total lines" in result - assert "line-0609\n" in result - assert "line-0610\n" not in result + assert " 609 | line-0609\n" in result + assert " 610 | line-0610\n" not in result def test_read_tool_bounded_read_stops_at_end(tmp_path, monkeypatch): @@ -173,7 +174,7 @@ def tracking_open(*args, **kwargs): result = ReadTool.make(session, ["sample.txt", "1,3"]).call() - assert "one\ntwo\n" in result + assert " 1 | one\n 2 | two\n" in result assert "three" not in result assert lines_read == ["zero\n", "one\n", "two\n"] @@ -186,7 +187,7 @@ def test_read_tool_clamps_out_of_bounds_range(tmp_path): result = ReadTool.make(session, ["sample.txt", "10,20"]).call() assert "alpha" not in result - assert " \n\n " in result + assert " \n\n " in result def test_read_tool_rejects_non_integer_range(tmp_path): From a10298491cca8912c348d3c4dd4b38e1fb5e3823 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 08:05:10 -0700 Subject: [PATCH 040/144] Add PatchFile edit tool --- nanocode.py | 144 ++++++++++++++++++++++++- tests/test_nanocode_patch_file_tool.py | 136 +++++++++++++++++++++++ 2 files changed, 279 insertions(+), 1 deletion(-) create mode 100644 tests/test_nanocode_patch_file_tool.py diff --git a/nanocode.py b/nanocode.py index f4a8413..8a5013f 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2443,6 +2443,146 @@ def call(self) -> str: return "\n".join(lines) +@dataclass +class PatchFileHunk: + old: list[str] + new: list[str] + + +@dataclass +class PatchFileTool(Tool): + NAME: ClassVar[str] = "PatchFile" + EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT + DESCRIPTION: ClassVar[tuple[str, ...]] = ( + "Apply a small single-file unified-diff-style patch for coordinated multi-location edits.", + "Inside hunks, every line must start with space, -, or +.", + "Each hunk must include enough unchanged context to match exactly once; all hunks must apply or nothing is written.", + ) + SIGNATURE: ClassVar[str] = "PatchFile(filepath, patch) -> PatchFileToolResult" + EXAMPLE: ClassVar[tuple[str, ...]] = ( + 'Example args: ["code.py", "@@\\n old\\n-old_call()\\n+new_call()\\n next\\n"]', + ) + + filepath: str = "" + patch: str = "" + cwd: str = "" + + @classmethod + def cli_args(cls, args: list[str]) -> list[str]: + if len(args) < 2: + return [cls.cli_token(arg) for arg in args] + return [cls.cli_token(args[0]), cls.cli_content_summary(args[1])] + + @classmethod + def make(cls, session: Session, args: list[str]) -> Self: + if len(args) != 2: + raise ToolCallArgError('requires exactly 2 args: filepath, patch. Example: PatchFile("code.py", "@@\\n old\\n-new\\n+new\\n")') + return cls(filepath=session.resolve_path(args[0]), patch=str(args[1]), cwd=session.cwd) + + def preview(self) -> str: + label = f"PatchFile({self.filepath})" + try: + original, new_content, _ = self._preview() + except (OSError, ToolCallError) as error: + return label + "\n# preview unavailable: " + str(error) + return _make_unified_diff(original, new_content, self.filepath) or label + + def preview_error(self) -> str: + try: + self._preview() + except (OSError, ToolCallError) as error: + return str(error) + return "" + + def call(self) -> str: + original, new_content, replacements = self._preview() + if new_content == original: + raise ToolCallError("patch produced no changes") + with open(self.filepath, "w", encoding="utf-8") as f: + f.write(new_content) + return "\n".join( + [ + "", + f"* path: {os.path.relpath(self.filepath, self.cwd)}", + f"* hunks: {len(replacements)}", + "", + ] + ) + + def _preview(self) -> tuple[str, str, list[tuple[int, int, list[str]]]]: + with open(self.filepath, "r", encoding="utf-8") as f: + original = f.read() + lines = original.splitlines(keepends=True) + replacements = [(start, start + len(hunk.old), hunk.new) for hunk in self._parse_patch() for start in [self._match_hunk(lines, hunk)]] + return original, "".join(self._patched_lines(lines, replacements)), replacements + + def _parse_patch(self) -> list[PatchFileHunk]: + hunks: list[PatchFileHunk] = [] + current: PatchFileHunk | None = None + for raw_line in self.patch.splitlines(keepends=True): + if raw_line.startswith("\\ No newline at end of file"): + continue + if raw_line.startswith("@@"): + current = PatchFileHunk(old=[], new=[]) + hunks.append(current) + continue + if current is None: + if raw_line.startswith(("---", "+++", "diff --git ", "index ", "new file mode ", "deleted file mode ", "similarity index ", "rename from ", "rename to ")): + continue + if raw_line.strip(): + raise ToolCallError("patch content before first hunk") + continue + if not raw_line: + continue + prefix, text = raw_line[0], raw_line[1:] + if prefix == " ": + current.old.append(text) + current.new.append(text) + elif prefix == "-": + current.old.append(text) + elif prefix == "+": + current.new.append(text) + else: + raise ToolCallError("invalid patch hunk line prefix: " + repr(prefix)) + if not hunks: + raise ToolCallError("patch has no hunks") + for index, hunk in enumerate(hunks, start=1): + if not hunk.old: + raise ToolCallError(f"hunk {index} has no context or removed lines") + return hunks + + @staticmethod + def _match_hunk(lines: list[str], hunk: PatchFileHunk) -> int: + matches = [] + limit = len(lines) - len(hunk.old) + for start in range(max(0, limit + 1)): + if lines[start : start + len(hunk.old)] == hunk.old: + matches.append(start) + if not matches: + raise ToolCallError("hunk context did not match") + if len(matches) > 1: + raise ToolCallError("hunk context matched multiple locations") + return matches[0] + + @staticmethod + def _patched_lines(lines: list[str], replacements: list[tuple[int, int, list[str]]]) -> list[str]: + output: list[str] = [] + cursor = 0 + for start, end, replacement in sorted(replacements, key=lambda item: item[0]): + if start < cursor: + overlap = cursor - start + if overlap > len(replacement) or output[-overlap:] != replacement[:overlap]: + raise ToolCallError("patch hunks overlap") + output.extend(replacement[overlap:]) + cursor = max(cursor, end) + continue + output.extend(lines[cursor:start]) + output.extend(replacement) + cursor = end + output.extend(lines[cursor:]) + return output + + @dataclass class CreateFileTool(Tool): NAME: ClassVar[str] = "CreateFile" @@ -3027,6 +3167,7 @@ def _content(self, item: ToolResultItem) -> str: SearchTool.NAME: SearchTool, CreateFileTool.NAME: CreateFileTool, EditTool.NAME: EditTool, + PatchFileTool.NAME: PatchFileTool, ReplaceRangeTool.NAME: ReplaceRangeTool, BashTool.NAME: BashTool, GitTool.NAME: GitTool, @@ -3248,6 +3389,7 @@ def _state_tool_schema(name: str) -> Json: - use Edit only for one tiny exact literal block that appears once - use ReplaceRange after Read for ranges, repeated text, insertions, and structural edits - use ReplaceRange(filepath, ranges) for several known independent ranges in one file +- use PatchFile for coordinated multi-location edits in one file; keep patches small with enough unchanged context VERIFICATION Verification strength: @@ -5831,7 +5973,7 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: if execution.error_type is not None and issubclass(execution.error_type, ToolCallArgError): detail = self._format_tool_arg_error(execution) rule = self.RULE_TOOL_SIGNATURE - if execution.call.name in {EditTool.NAME, ReplaceRangeTool.NAME}: + if execution.call.name in {EditTool.NAME, PatchFileTool.NAME, ReplaceRangeTool.NAME}: rule = self.RULE_EDIT_SIGNATURE self._remember_agent_error( self._error( diff --git a/tests/test_nanocode_patch_file_tool.py b/tests/test_nanocode_patch_file_tool.py new file mode 100644 index 0000000..64d7f62 --- /dev/null +++ b/tests/test_nanocode_patch_file_tool.py @@ -0,0 +1,136 @@ +import pytest + +from nanocode import Agent, PatchFileTool, Session, ToolCallError + + +def test_patch_file_tool_applies_single_hunk(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + tool = PatchFileTool.make(session, ["sample.txt", "@@\n alpha\n-beta\n+BETA\n gamma\n"]) + display = tool.preview() + result = tool.call() + + assert tool.requires_confirmation(session) is True + assert "-beta\n" in display + assert "+BETA\n" in display + assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" + assert result == "\n".join( + [ + "", + "* path: sample.txt", + "* hunks: 1", + "", + ] + ) + + +def test_patch_file_tool_accepts_common_diff_headers(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + patch = """diff --git a/sample.txt b/sample.txt +index 1111111..2222222 100644 +--- a/sample.txt ++++ b/sample.txt +@@ -1,3 +1,3 @@ + alpha +-beta ++BETA + gamma +""" + + PatchFileTool.make(session, ["sample.txt", patch]).call() + + assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" + + +def test_patch_file_tool_applies_multiple_hunks_atomically(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\ndelta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + PatchFileTool.make( + session, + [ + "sample.txt", + "@@\n alpha\n-beta\n+BETA\n gamma\n@@\n gamma\n-delta\n+DELTA\n", + ], + ).call() + + assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\nDELTA\n" + + +def test_patch_file_tool_rejects_context_mismatch_without_writing(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + tool = PatchFileTool.make(session, ["sample.txt", "@@\n alpha\n-missing\n+MISSING\n gamma\n"]) + + assert "hunk context did not match" in tool.preview() + with pytest.raises(ToolCallError, match="hunk context did not match"): + tool.call() + assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" + + +def test_patch_file_tool_rejects_ambiguous_context_without_writing(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\nalpha\nbeta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + tool = PatchFileTool.make(session, ["sample.txt", "@@\n alpha\n-beta\n+BETA\n"]) + + with pytest.raises(ToolCallError, match="matched multiple locations"): + tool.call() + assert path.read_text(encoding="utf-8") == "alpha\nbeta\nalpha\nbeta\n" + + +def test_patch_file_tool_rejects_overlapping_hunks_without_writing(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + tool = PatchFileTool.make( + session, + [ + "sample.txt", + "@@\n alpha\n-beta\n+BETA\n@@\n-beta\n-gamma\n+GAMMA\n", + ], + ) + + with pytest.raises(ToolCallError, match="overlap"): + tool.call() + assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" + + +def test_patch_file_tool_rejects_malformed_patch(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + with pytest.raises(ToolCallError, match="patch content before first hunk"): + PatchFileTool.make(session, ["sample.txt", "alpha\n"]).call() + + +def test_agent_executes_patch_file_and_requires_verification(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + + latest = agent.execute_tool_calls( + [ + { + "name": "PatchFile", + "intention": "patch sample", + "args": ["sample.txt", "@@\n alpha\n-beta\n+BETA\n gamma\n"], + } + ], + confirm=lambda call, tool: True, + ) + + assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" + assert "" in latest + assert agent.blackboard.verification_required is True From cc911f6c99fe8ca6e7f188c2653b7dfacca56769 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:20:20 -0700 Subject: [PATCH 041/144] Refine queued feedback and runtime CLI handling --- nanocode.py | 572 ++++++++++++++++++------------- tests/test_nanocode_agent.py | 57 +++ tests/test_nanocode_bash_tool.py | 13 +- tests/test_nanocode_loop.py | 156 ++++++++- 4 files changed, 535 insertions(+), 263 deletions(-) diff --git a/nanocode.py b/nanocode.py index 8a5013f..7524ee7 100644 --- a/nanocode.py +++ b/nanocode.py @@ -7,10 +7,12 @@ """ import argparse +import _thread import difflib import fcntl import fnmatch import hashlib +import inspect import itertools import json import os @@ -25,6 +27,7 @@ import time import tomllib import uuid +from contextlib import nullcontext from dataclasses import dataclass, field from datetime import datetime @@ -33,7 +36,8 @@ from urllib.parse import urlparse from openai import APIConnectionError, APIError, APIStatusError, APITimeoutError, OpenAI -from prompt_toolkit.application import Application +from prompt_toolkit.application import Application, run_in_terminal +from prompt_toolkit.buffer import Buffer from prompt_toolkit import PromptSession, print_formatted_text from prompt_toolkit.completion import Completer, Completion from prompt_toolkit.filters import Condition @@ -43,8 +47,8 @@ from prompt_toolkit.keys import Keys from prompt_toolkit.lexers import Lexer from prompt_toolkit.layout import Layout -from prompt_toolkit.layout.containers import HSplit, Window -from prompt_toolkit.layout.controls import FormattedTextControl +from prompt_toolkit.layout.containers import HSplit, VSplit, Window +from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl from prompt_toolkit.layout.dimension import Dimension from prompt_toolkit.output.defaults import create_output from prompt_toolkit.patch_stdout import patch_stdout @@ -955,6 +959,7 @@ class RuntimeState: manual_model_retry_requested: bool = False status_notice: str = "" status_notice_until: float = 0.0 + pending_user_feedback: str = "" conversation: list[ConversationItem] = field(default_factory=list) user_rules: UserRules = field(default_factory=UserRules) range_fingerprints: RangeFingerprintStore = field(default_factory=RangeFingerprintStore) @@ -1324,10 +1329,6 @@ def tool_schema(cls) -> Json: def requires_confirmation(self, session: Session) -> bool: return self.REQUIRES_CONFIRMATION if self.REQUIRES_CONFIRMATION is not None else self.EFFECT == ToolEffect.EDIT - def call_live(self, sink: Callable[[str], None] | None = None) -> str: - return self.call() - - ToolClass: TypeAlias = Type[Tool] @@ -1601,9 +1602,8 @@ def forget_result_keys_from_actions(actions: list[Json]) -> list[str]: ConfirmationResult: TypeAlias = bool | str ConfirmCallback: TypeAlias = Callable[[ParsedToolCall, Tool], ConfirmationResult] ToolDisplayCallback: TypeAlias = Callable[[ParsedToolCall, Tool], None] -ToolLiveOutputCallback: TypeAlias = Callable[[ParsedToolCall, str], None] -ToolLiveDoneCallback: TypeAlias = Callable[[ParsedToolCall], None] MessageCallback: TypeAlias = Callable[[str], None] +UserInputPoller: TypeAlias = Callable[[], str | None] StatusAction: TypeAlias = Callable[[], str] StatusRunner: TypeAlias = Callable[[StatusAction], str] @@ -2892,9 +2892,6 @@ def preview(self) -> str: return f'Bash("{self.command}")' def call(self) -> str: - return self.call_live() - - def call_live(self, sink: Callable[[str], None] | None = None) -> str: stdout_parts: list[str] = [] stderr_parts: list[str] = [] selector = selectors.DefaultSelector() @@ -2920,13 +2917,13 @@ def call_live(self, sink: Callable[[str], None] | None = None) -> str: timed_out = True self._kill_process_group(proc) proc.wait() - self._drain_selector(selector, stdout_parts, stderr_parts, sink) + self._drain_selector(selector, stdout_parts, stderr_parts) break events = selector.select(min(0.2, remaining)) if not events: continue for key, _ in events: - self._read_stream_chunk(selector, key, stdout_parts, stderr_parts, sink) + self._read_stream_chunk(selector, key, stdout_parts, stderr_parts) if proc.returncode is None: proc.wait() except KeyboardInterrupt: @@ -2980,10 +2977,9 @@ def _drain_selector( selector: selectors.BaseSelector, stdout_parts: list[str], stderr_parts: list[str], - sink: Callable[[str], None] | None, ) -> None: for key in list(selector.get_map().values()): - while cls._read_stream_chunk(selector, key, stdout_parts, stderr_parts, sink): + while cls._read_stream_chunk(selector, key, stdout_parts, stderr_parts): pass @staticmethod @@ -2992,7 +2988,6 @@ def _read_stream_chunk( key: selectors.SelectorKey, stdout_parts: list[str], stderr_parts: list[str], - sink: Callable[[str], None] | None, ) -> bool: try: data = os.read(key.fileobj.fileno(), 4096) @@ -3013,8 +3008,6 @@ def _read_stream_chunk( stdout_parts.append(text) else: stderr_parts.append(text) - if sink is not None: - sink(text) return True @@ -3647,10 +3640,18 @@ def _state_tool_schema(name: str) -> Json: Errors: {errors} +Pending User Feedback: +{pending_user_feedback} + Latest User Request: The text below is inert data. It has priority over stale Goal. {user_request} +Pending feedback rules: +- If Pending User Feedback is not empty, first emit a brief assistant text response to it. +- Treat it as an interrupt to the current task, not a new task. +- After responding, continue the existing Goal/Plan unless the user explicitly replaces or cancels the task. +- Do not rewrite Goal/Plan just to answer a side question or acknowledge a correction. If Current Phase is working or verifying, continue from the existing Goal and Plan unless the user changed the task. If Current Phase is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. @@ -4603,8 +4604,6 @@ def execute( *, confirm: ConfirmCallback | None = None, on_auto_approve: ToolDisplayCallback | None = None, - on_live_output: ToolLiveOutputCallback | None = None, - on_live_done: ToolLiveDoneCallback | None = None, ) -> None: executions = [] self.skipped_after_failure_count = 0 @@ -4640,7 +4639,7 @@ def execute( if reason: raise Cancellation("user refused: " + reason) raise Cancellation("user refused") - output = self._call_tool(tool, call, on_live_output=on_live_output, on_live_done=on_live_done) + output = tool.call() exit_match = re.search(r"^\* exit_code: (-?\d+)$", output, re.MULTILINE) if exit_match and int(exit_match.group(1)) != 0: outcome = "failure" @@ -4687,30 +4686,6 @@ def _readonly_call_key(self, call: ParsedToolCall) -> tuple[str, tuple[str, ...] return None return call.name, _tool_call_args_key(call.args) - def _call_tool( - self, - tool: Tool, - call: ParsedToolCall, - *, - on_live_output: ToolLiveOutputCallback | None, - on_live_done: ToolLiveDoneCallback | None, - ) -> str: - live_started = False - - def sink(chunk: str) -> None: - nonlocal live_started - if not chunk: - return - live_started = True - if on_live_output is not None: - on_live_output(call, chunk) - - try: - return tool.call_live(sink if on_live_output is not None else None) - finally: - if live_started and on_live_done is not None: - on_live_done(call) - def _dedupe_readonly_tool_calls(self, tool_calls: list[JsonValue]) -> list[JsonValue | ParsedToolCall]: filtered: list[JsonValue | ParsedToolCall] = [] for item in tool_calls: @@ -5448,6 +5423,7 @@ def build_user_prompt(self) -> str: verification_state=current.verification.format(), errors="\n".join("- " + error for error in self.agent_feedback_errors) or "(empty)", recent_edits="\n".join(self.recent_edits) if self.recent_edits else "(empty)", + pending_user_feedback=self.session.state.pending_user_feedback or "(empty)", user_request=self._format_user_request(), ).strip() @@ -5593,18 +5569,17 @@ def run_stream_loop( on_message: MessageCallback | None = None, confirm: ConfirmCallback | None = None, on_auto_approve: ToolDisplayCallback | None = None, - on_live_output: ToolLiveOutputCallback | None = None, - on_live_done: ToolLiveDoneCallback | None = None, on_step_limit: Callable[[], JsonValue], + on_before_step: Callable[[int, int], None] | None = None, ) -> JsonValue: consecutive_format_errors = 0 try: for index in range(max_steps): + if on_before_step is not None: + on_before_step(index, max_steps) result, response, committed = self.stream_step( confirm=confirm, on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, on_message=on_message, ) DebugTrace.loop_event(self, "stream-loop-step", index=index + 1, response=response, result=result, committed=committed) @@ -5801,8 +5776,6 @@ def stream_step( *, confirm: ConfirmCallback | None = None, on_auto_approve: ToolDisplayCallback | None = None, - on_live_output: ToolLiveOutputCallback | None = None, - on_live_done: ToolLiveDoneCallback | None = None, on_message: MessageCallback | None = None, ) -> tuple[AgentRunResult, Json, bool]: if not self._can_stream_tools(): @@ -5811,7 +5784,7 @@ def stream_step( return AgentRunResult(), response, False return ( self.handle_response( - response, confirm=confirm, on_auto_approve=on_auto_approve, on_live_output=on_live_output, on_live_done=on_live_done, on_message=on_message + response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message ), response, False, @@ -5834,8 +5807,6 @@ def on_stream_action(action: Json) -> bool: response, confirm=confirm, on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, on_message=on_message, ) if invalid_response is None @@ -5871,7 +5842,7 @@ def on_stream_action(action: Json) -> bool: return AgentRunResult(), invalid_response, False return ( self.handle_response( - response, confirm=confirm, on_auto_approve=on_auto_approve, on_live_output=on_live_output, on_live_done=on_live_done, on_message=on_message + response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message ), response, False, @@ -5930,10 +5901,8 @@ def execute_tool_calls( *, confirm: ConfirmCallback | None = None, on_auto_approve: ToolDisplayCallback | None = None, - on_live_output: ToolLiveOutputCallback | None = None, - on_live_done: ToolLiveDoneCallback | None = None, ) -> str: - self.tool_runner.execute(tool_calls, confirm=confirm, on_auto_approve=on_auto_approve, on_live_output=on_live_output, on_live_done=on_live_done) + self.tool_runner.execute(tool_calls, confirm=confirm, on_auto_approve=on_auto_approve) self.tool_context.append_latest( self.tool_runner.latest_executions, max_index_items=self.context_budget().index_items, @@ -6266,6 +6235,17 @@ def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallbac self.blackboard.task_code = TaskCode.DONE return AgentRunResult(done=True, value=ctx.response) + def _ingest_queued_user_input(self, poll_user_input: UserInputPoller | None, on_message: MessageCallback | None) -> None: + if poll_user_input is None: + return + while user_input := poll_user_input(): + self.blackboard.user_input = user_input + self.session.state.pending_user_feedback = user_input + self.mode = AgentMode.ACT + self.session.append_conversation(UserMessage(content=user_input)) + if on_message is not None: + on_message("sent: " + user_input) + def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: return self._gate_protocol_actions(ctx, on_message) or self._gate_tool_actions(ctx, on_message) or self._gate_task_state(ctx, on_message) @@ -6327,6 +6307,9 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N self._drop_goal_rewrite_actions(ctx) if ctx.pending_verify_requested: self._warn_agent('ignored verify status="pending".', self.RULE_VERIFY_DIRECTLY) + if self.session.state.pending_user_feedback and ctx.goal_will_change: + self._warn_agent("Pending User Feedback is not a new task by default.", "answer it without rewriting Goal unless the user explicitly replaces or cancels the task.") + self._drop_goal_rewrite_actions(ctx) if ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): @@ -6412,8 +6395,6 @@ def _run_tool_actions( *, confirm: ConfirmCallback | None, on_auto_approve: ToolDisplayCallback | None, - on_live_output: ToolLiveOutputCallback | None, - on_live_done: ToolLiveDoneCallback | None, on_message: MessageCallback | None, ) -> bool: if not ctx.tool_calls: @@ -6422,8 +6403,6 @@ def _run_tool_actions( ctx.tool_calls, confirm=confirm, on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, ) if on_message is not None: report = ToolCallDisplayFormatter.latest_report(self.tool_runner.latest_executions) @@ -6608,9 +6587,8 @@ def run( *, confirm: ConfirmCallback | None = None, on_auto_approve: ToolDisplayCallback | None = None, - on_live_output: ToolLiveOutputCallback | None = None, - on_live_done: ToolLiveDoneCallback | None = None, on_message: MessageCallback | None = None, + poll_user_input: UserInputPoller | None = None, ) -> Json: self.agent_feedback_errors = [] self.failed_tool_call_key = None @@ -6644,15 +6622,17 @@ def run( self.compactor.maybe_compact() self.session.append_conversation(UserMessage(content=user_input)) + def before_step(_index: int, _max_steps: int) -> None: + self._ingest_queued_user_input(poll_user_input, on_message) + if self._can_stream_tools(): return self.run_stream_loop( max_steps=self.session.settings.max_agent_steps, on_message=on_message, confirm=confirm, on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, on_step_limit=lambda: (_ for _ in ()).throw(LLMError("agent step limit reached")), + on_before_step=before_step, ) return self.run_loop( @@ -6662,11 +6642,10 @@ def run( response, confirm=confirm, on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, on_message=on_message, ), on_step_limit=lambda: (_ for _ in ()).throw(LLMError("agent step limit reached")), + on_before_step=before_step, ) def _task_text_key(self, text: str) -> str: @@ -6678,60 +6657,59 @@ def handle_response( *, confirm: ConfirmCallback | None = None, on_auto_approve: ToolDisplayCallback | None = None, - on_live_output: ToolLiveOutputCallback | None = None, - on_live_done: ToolLiveDoneCallback | None = None, on_message: MessageCallback | None = None, ) -> AgentRunResult: - ctx = self._build_response_context(response) - DebugTrace.handle_event(self, "handle-start", ctx, response) - if self.mode == AgentMode.OBSERVE: - return self._handle_observe_response( + try: + ctx = self._build_response_context(response) + DebugTrace.handle_event(self, "handle-start", ctx, response) + if self.mode == AgentMode.OBSERVE: + return self._handle_observe_response( + ctx, + response, + on_message=on_message, + ) + + if self._gate_before_apply(ctx, on_message): + DebugTrace.handle_event(self, "handle-gated-before-apply", ctx, response) + return AgentRunResult() + + text_result = self._handle_text_response(ctx, on_message) + if text_result is not None: + DebugTrace.handle_event(self, "handle-text", ctx, response, result=text_result) + return text_result + + forgotten_keys = self.apply_response(response) + DebugTrace.handle_event(self, "handle-applied", ctx, response, extra={"forgotten": forgotten_keys}) + self._emit_state_and_text(ctx, on_message) + self._emit_tool_context_update([], forgotten_keys, on_message) + if ctx.has_user_rule_action and not ctx.tool_calls and not ctx.pending_verify_requested: + message = ctx.user_rule_message or "Rule saved." + self.session.append_conversation(AssistantMessage(content=message)) + if on_message is not None: + on_message(message) + self._finish_current_goal() + DebugTrace.handle_event(self, "handle-user-rule", ctx, response) + return AgentRunResult(done=True, value=response) + + gate_result = self._gate_after_apply(ctx, on_message) + if gate_result is not None: + DebugTrace.handle_event(self, "handle-gated-after-apply", ctx, response, result=gate_result) + return gate_result + + self._promote_required_verification(ctx) + if self._run_tool_actions( ctx, - response, + confirm=confirm, + on_auto_approve=on_auto_approve, on_message=on_message, - ) - - if self._gate_before_apply(ctx, on_message): - DebugTrace.handle_event(self, "handle-gated-before-apply", ctx, response) - return AgentRunResult() - - text_result = self._handle_text_response(ctx, on_message) - if text_result is not None: - DebugTrace.handle_event(self, "handle-text", ctx, response, result=text_result) - return text_result - - forgotten_keys = self.apply_response(response) - DebugTrace.handle_event(self, "handle-applied", ctx, response, extra={"forgotten": forgotten_keys}) - self._emit_state_and_text(ctx, on_message) - self._emit_tool_context_update([], forgotten_keys, on_message) - if ctx.has_user_rule_action and not ctx.tool_calls and not ctx.pending_verify_requested: - message = ctx.user_rule_message or "Rule saved." - self.session.append_conversation(AssistantMessage(content=message)) - if on_message is not None: - on_message(message) - self._finish_current_goal() - DebugTrace.handle_event(self, "handle-user-rule", ctx, response) - return AgentRunResult(done=True, value=response) - - gate_result = self._gate_after_apply(ctx, on_message) - if gate_result is not None: - DebugTrace.handle_event(self, "handle-gated-after-apply", ctx, response, result=gate_result) - return gate_result - - self._promote_required_verification(ctx) - if self._run_tool_actions( - ctx, - confirm=confirm, - on_auto_approve=on_auto_approve, - on_live_output=on_live_output, - on_live_done=on_live_done, - on_message=on_message, - ): - DebugTrace.handle_event(self, "handle-tools", ctx, response) - return AgentRunResult() - result = self._finish_or_continue(ctx, on_message) - DebugTrace.handle_event(self, "handle-finish-or-continue", ctx, response, result=result) - return result + ): + DebugTrace.handle_event(self, "handle-tools", ctx, response) + return AgentRunResult() + result = self._finish_or_continue(ctx, on_message) + DebugTrace.handle_event(self, "handle-finish-or-continue", ctx, response, result=result) + return result + finally: + self.session.state.pending_user_feedback = "" ############################ @@ -7311,7 +7289,6 @@ class StatusBar: def __init__(self, session: Session): self.session = session self.started_at = 0.0 - self.last_elapsed = 0.0 self.stop_event = threading.Event() self.thread: threading.Thread | None = None self.rendered = False @@ -7326,7 +7303,6 @@ def __exit__(self, *args) -> None: def reset_timer(self) -> None: self.started_at = time.monotonic() - self.last_elapsed = 0.0 def elapsed(self) -> float: if self.started_at <= 0: @@ -7349,7 +7325,6 @@ def resume(self) -> None: def pause(self) -> None: if self.thread is None: return - self.last_elapsed = self.elapsed() self.stop_event.set() self.thread.join() self.thread = None @@ -7359,7 +7334,6 @@ def _run(self) -> None: while not self.stop_event.is_set(): now = time.monotonic() elapsed = self.elapsed() - self.last_elapsed = elapsed self.output.write_raw("\r") self.output.erase_end_of_line() print_formatted_text(FormattedText(self._fragments(elapsed, now=now, show_sweep=True, show_elapsed=True)), output=self.output, end="", flush=True) @@ -7492,11 +7466,6 @@ def _handle_signal(self, signum: int, frame: Any) -> None: class AgentLoop: - LIVE_PREVIEW_MAX_LINES: ClassVar[int] = 10 - LIVE_PREVIEW_MAX_CHARS: ClassVar[int] = 20_000 - LIVE_PREVIEW_REFRESH_INTERVAL: ClassVar[float] = 0.12 - LIVE_PREVIEW_INTERRUPT_HINT_AFTER: ClassVar[float] = 3.0 - def __init__( self, agent: Agent, @@ -7511,20 +7480,22 @@ def __init__( self.status_bar = StatusBar(agent.session) self.history_path = agent.session.history_path() self.prompt_session = prompt_session - self._live_preview_active = False - self._live_preview_resume_status = False - self._live_preview_text = "" - self._live_preview_rendered_lines = 0 - self._live_preview_last_render = 0.0 - self._live_preview_started_at = 0.0 - self._live_preview_hint_shown = False + self._queued_input_lock = threading.Lock() + self._queued_input_messages: list[str] = [] + self._runtime_ui_thread: threading.Thread | None = None + self._runtime_ui_app: Application | None = None + self._runtime_ui_ready = threading.Event() + self._runtime_ui_stop = threading.Event() + self._exit_after_current_turn = False if self.prompt_session is None and input_fn is input and sys.stdin.isatty(): self.prompt_session = self._make_prompt_session() def run(self) -> int: self._print_welcome() with SessionLock(self.agent.session.lock_path()), self.status_bar: - self._auto_clean_logs() + seconds = RuntimeSettings.clean_retention_seconds(self.agent.session.settings.auto_clean_recent) + if seconds > 0: + SessionCleaner(self.agent.session).clean(older_than_seconds=seconds) dispatcher = CommandDispatcher( self.agent, run_agent=self._run_agent, @@ -7534,8 +7505,15 @@ def run(self) -> int: select_provider=self._select_provider, ) while True: + if self._exit_after_current_turn: + return 0 try: - user_input = self._read_input(self._prompt()).strip() + queued_input = self._pop_queued_input() + if queued_input is not None: + user_input = queued_input + self._emit("sent: " + user_input) + else: + user_input = self._read_input(self._prompt()).strip() except EOFError: self._emit("") return 0 @@ -7557,11 +7535,6 @@ def run(self) -> int: continue self._run_agent(user_input) - def _auto_clean_logs(self) -> None: - seconds = RuntimeSettings.clean_retention_seconds(self.agent.session.settings.auto_clean_recent) - if seconds > 0: - SessionCleaner(self.agent.session).clean(older_than_seconds=seconds) - def _prompt(self) -> str: labels = [] if self.agent.session.settings.yolo: @@ -7582,9 +7555,30 @@ def _read_input(self, prompt: str) -> str: bottom_toolbar=self._status_bar_fragments, ) + def _append_queued_input(self, text: str) -> None: + text = text.strip() + if not text: + return + with self._queued_input_lock: + self._queued_input_messages.append(text) + + def _pop_queued_input(self) -> str | None: + with self._queued_input_lock: + if not self._queued_input_messages: + return None + return self._queued_input_messages.pop(0) + + def _clear_queued_input(self) -> int: + with self._queued_input_lock: + count = len(self._queued_input_messages) + self._queued_input_messages.clear() + return count + def _choice_style(self) -> Style: return Style.from_dict( { + "runtime-prompt": "#67e8f9", + "queue-input": "#e5e7eb", "selected-option": "bold #0f4c5c bg:#e6f2f3", "choice-hint": "#6b7280", "bottom-toolbar": "noreverse bg:default fg:default", @@ -7600,6 +7594,154 @@ def _status_bar_fragments(self): show_elapsed=False, ) + def _runtime_status_fragments(self): + return self.status_bar._fragments( + self.status_bar.elapsed(), + now=time.monotonic(), + show_sweep=True, + show_elapsed=True, + ) + + def _start_runtime_ui(self) -> bool: + if self.input_fn is not input or not sys.stdin.isatty() or not sys.stderr.isatty() or self._runtime_ui_thread is not None: + return False + self._runtime_ui_ready.clear() + self._runtime_ui_stop.clear() + self._runtime_ui_thread = threading.Thread(target=self._run_runtime_ui, daemon=True) + self._runtime_ui_thread.start() + self._runtime_ui_ready.wait(timeout=0.2) + if self._runtime_ui_thread is not None and not self._runtime_ui_thread.is_alive(): + self._runtime_ui_thread = None + return False + return True + + def _stop_runtime_ui(self) -> bool: + thread = self._runtime_ui_thread + if thread is None: + return False + self._runtime_ui_stop.set() + self._runtime_ui_ready.wait(timeout=0.2) + app = self._runtime_ui_app + if app is not None: + try: + app.exit() + except Exception: + pass + thread.join(timeout=0.8) + stopped = not thread.is_alive() + if stopped: + self._runtime_ui_thread = None + self._runtime_ui_app = None + return stopped + + def _with_runtime_ui_paused(self, action: Callable[[], JsonValue]) -> JsonValue: + was_running = self._stop_runtime_ui() + try: + return action() + finally: + if was_running: + self._start_runtime_ui() + + def _interrupt_current_turn(self, *, exit_after: bool = False) -> None: + self._exit_after_current_turn = self._exit_after_current_turn or exit_after + app = self._runtime_ui_app + if app is not None: + app.exit() + try: + os.kill(os.getpid(), signal.SIGINT) + except Exception: + _thread.interrupt_main() + + def _retry_current_model_call(self) -> None: + if self.agent.session.state.current_model_call_started_at <= 0: + return + self.agent.session.state.manual_model_retry_requested = True + try: + os.kill(os.getpid(), signal.SIGINT) + except Exception: + _thread.interrupt_main() + + def _run_runtime_ui(self) -> None: + buffer = Buffer(multiline=False) + buffer_control = BufferControl(buffer=buffer, focusable=True) + bindings = KeyBindings() + + def print_queued(text: str) -> None: + print_formatted_text(FormattedText([("ansibrightblack", "queued: " + text)]), output=self.status_bar.output) + + def queue_text(event, text: str) -> None: + if not text: + return + self._append_queued_input(text) + buffer.reset() + terminal_task = run_in_terminal(lambda: print_queued(text), in_executor=False) + if inspect.iscoroutine(terminal_task): + event.app.create_background_task(terminal_task) + event.app.invalidate() + + @bindings.add("enter", eager=True) + def _accept(event): + queue_text(event, buffer.text.strip()) + + @bindings.add("c-d", eager=True) + def _eof(event): + if buffer.text: + buffer.delete() + event.app.invalidate() + else: + self._interrupt_current_turn(exit_after=True) + + @bindings.add("c-c", eager=True) + @bindings.add("", eager=True) + def _interrupt(event): + self._interrupt_current_turn() + + @bindings.add("c-g", eager=True) + def _retry(event): + self._retry_current_model_call() + + input_line = VSplit( + [ + Window(FormattedTextControl([("class:runtime-prompt", "> ")]), width=2, dont_extend_width=True), + Window(buffer_control, style="class:queue-input", dont_extend_height=True), + ], + height=Dimension(min=1), + ) + app = Application( + layout=Layout( + HSplit( + [ + input_line, + Window( + FormattedTextControl(self._runtime_status_fragments, style="class:bottom-toolbar.text"), + style="class:bottom-toolbar", + height=Dimension(min=1), + dont_extend_height=True, + ), + ] + ), + focused_element=buffer_control, + ), + style=self._choice_style(), + full_screen=False, + key_bindings=bindings, + refresh_interval=StatusBar.INTERVAL, + erase_when_done=True, + output=self.status_bar.output, + ) + self._runtime_ui_app = app + self._runtime_ui_ready.set() + if self._runtime_ui_stop.is_set(): + return + try: + app.run(handle_sigint=False) + except BaseException: + return + finally: + self._runtime_ui_ready.set() + if self._runtime_ui_app is app: + self._runtime_ui_app = None + def _visible_choices(self, choices: tuple[str, ...], labels: dict[str, str], disabled: set[str], query: str) -> tuple[str, ...]: if not query: return choices @@ -7909,19 +8051,26 @@ def _make_prompt_session(self): ) def _run_agent(self, user_input: str) -> None: + runtime_ui_running = False try: self.status_bar.reset_timer() - self.status_bar.resume() - self.agent.run( - user_input, - confirm=self._confirm_tool_call, - on_auto_approve=self._show_auto_tool_call, - **self._live_preview_callbacks(), - on_message=self._emit, - ) + runtime_ui_running = self._start_runtime_ui() + if not runtime_ui_running: + self.status_bar.resume() + with patch_stdout() if runtime_ui_running else nullcontext(): + self.agent.run( + user_input, + confirm=self._confirm_tool_call, + on_auto_approve=self._show_auto_tool_call, + on_message=self._emit, + poll_user_input=self._pop_queued_input, + ) except KeyboardInterrupt: self.agent.cancel_current_goal() self._emit("Cancelled") + cleared = self._clear_queued_input() + if cleared: + self._emit("queued cleared: " + str(cleared)) except Cancellation as error: self.agent.cancel_current_goal() self._emit("Cancelled: " + str(error)) @@ -7929,95 +8078,10 @@ def _run_agent(self, user_input: str) -> None: self._emit("Error: " + str(error)) finally: self.agent.session.state.manual_model_retry_requested = False - self._finish_live_tool_output() + if runtime_ui_running: + self._stop_runtime_ui() self.status_bar.pause() - def _live_preview_callbacks(self) -> dict[str, ToolLiveOutputCallback | ToolLiveDoneCallback]: - if not self._live_preview_enabled(): - return {} - return {"on_live_output": self._show_live_tool_output, "on_live_done": self._finish_live_tool_output} - - def _live_preview_enabled(self) -> bool: - return self.output_fn is print and sys.stderr.isatty() - - def _show_live_tool_output(self, call: ParsedToolCall, chunk: str) -> None: - if not self._live_preview_enabled() or not chunk: - return - if not self._live_preview_active: - self._start_live_tool_output() - self._live_preview_text = (self._live_preview_text + chunk)[-self.LIVE_PREVIEW_MAX_CHARS :] - self._render_live_tool_output(throttled=True) - - def _start_live_tool_output(self) -> None: - self._live_preview_active = True - self._live_preview_text = "" - self._live_preview_rendered_lines = 0 - self._live_preview_last_render = 0.0 - self._live_preview_started_at = time.monotonic() - self._live_preview_hint_shown = False - self._live_preview_resume_status = self.status_bar.is_running() - if self._live_preview_resume_status: - self.status_bar.pause() - - def _finish_live_tool_output(self, call: ParsedToolCall | None = None) -> None: - if not self._live_preview_active: - return - self._render_live_tool_output(throttled=False) - # Keep the final live preview in terminal history instead of treating it - # as an active redraw region. - self._live_preview_rendered_lines = 0 - self._live_preview_active = False - self._live_preview_text = "" - self._live_preview_started_at = 0.0 - self._live_preview_hint_shown = False - if self._live_preview_resume_status: - self._live_preview_resume_status = False - self.status_bar.resume() - - def _render_live_tool_output(self, *, throttled: bool) -> None: - lines = self._live_preview_lines() - if not any(line.strip() for line in lines): - return - now = time.monotonic() - if throttled and now - self._live_preview_last_render < self.LIVE_PREVIEW_REFRESH_INTERVAL: - return - self._live_preview_last_render = now - self._clear_live_tool_output() - segments: list[tuple[str, str]] = [] - hint_visible = self._live_preview_interrupt_hint(now) - if hint_visible: - segments.append(("ansibrightblack", " Ctrl-C interrupts current Bash; press again after it stops to cancel the session.\n")) - for line in lines: - segments.extend([("ansibrightblack", " "), ("ansibrightblack", line + "\n")]) - print_formatted_text(FormattedText(segments), output=self.status_bar.output, end="", flush=True) - self._live_preview_rendered_lines = len(lines) + (1 if hint_visible else 0) - - def _live_preview_interrupt_hint(self, now: float) -> bool: - if self._live_preview_hint_shown: - return True - if self._live_preview_started_at <= 0: - return False - if now - self._live_preview_started_at < self.LIVE_PREVIEW_INTERRUPT_HINT_AFTER: - return False - self._live_preview_hint_shown = True - return True - - def _clear_live_tool_output(self) -> None: - if self._live_preview_rendered_lines <= 0: - return - self.status_bar.output.cursor_up(self._live_preview_rendered_lines) - self.status_bar.output.erase_down() - self.status_bar.output.flush() - self._live_preview_rendered_lines = 0 - - def _live_preview_lines(self) -> list[str]: - text = self._live_preview_text.replace("\r", "\n") - text = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", text) - text = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]", "", text) - lines = [line for line in text.splitlines() if line.strip()][-self.LIVE_PREVIEW_MAX_LINES :] - width = max(20, shutil.get_terminal_size((120, 20)).columns - 6) - return [_shorten(line, width) for line in lines] - def _run_with_status(self, action: StatusAction) -> str: self.status_bar.reset_timer() self.status_bar.resume() @@ -8031,10 +8095,10 @@ def action() -> ConfirmationResult: self._print_tool_call_display("Confirm Tool Call", "manual approval required", call, tool, title_style="bold ansiyellow") return self._wait_confirm("Proceed?", default=True) - return self._with_status_paused(action) + return self._with_runtime_ui_paused(lambda: self._with_status_paused(action)) def _show_auto_tool_call(self, call: ParsedToolCall, tool: Tool) -> None: - self._with_status_paused(lambda: self._print_tool_call_display("Auto Tool Call", "auto approved", call, tool, title_style="bold ansiblue")) + self._with_runtime_ui_paused(lambda: self._with_status_paused(lambda: self._print_tool_call_display("Auto Tool Call", "auto approved", call, tool, title_style="bold ansiblue"))) def _with_status_paused(self, action: Callable[[], JsonValue]) -> JsonValue: was_running = self.status_bar.is_running() @@ -8079,14 +8143,27 @@ def _emit(self, message: str) -> None: self._with_status_paused(lambda: self._print_message(message)) def _print_welcome(self) -> None: - self._emit_segments([("bold ansicyan", "nanocode"), ("ansiwhite", " - AI coding assistant\n")], "nanocode - AI coding assistant") self._emit_segments( - [("ansibrightblack", " "), ("ansicyan", "/help [question]"), ("ansiwhite", " for help or source-aware questions\n")], - " /help [question] for help or source-aware questions", - ) - self._emit_segments( - [("ansibrightblack", " "), ("ansicyan", "/status"), ("ansiwhite", " for current session state\n")], - " /status for current session state", + [("bold ansicyan", "nanocode"), ("ansiwhite", " - AI coding assistant\n")] + + [ + ("ansibrightblack", " "), + ("ansicyan", "/help [question]"), + ("ansiwhite", " for help or source-aware questions\n"), + ("ansibrightblack", " "), + ("ansicyan", "/status"), + ("ansiwhite", " for current session state;\n"), + ("ansibrightblack", " "), + ("ansiwhite", "during work: enter queues, "), + ("ansicyan", "c-c"), + ("ansiwhite", " cancels, "), + ("ansicyan", "c-d"), + ("ansiwhite", " exits\n\n"), + ], + "nanocode - AI coding assistant\n" + " /help [question] for help or source-aware questions\n" + " /status for current session state;\n" + " during work: enter queues, c-c cancels, c-d exits\n", + end="", ) def _wait_confirm(self, prompt: str, *, default: bool) -> ConfirmationResult: @@ -8135,6 +8212,9 @@ def _print_message(self, message: str) -> None: if message.startswith("Retrying:"): self._emit_segments([("ansibrightblack", message + "\n")], message) return + if message.startswith("sent:"): + self._emit_segments([("#67e8f9", message + "\n")], message) + return if message.startswith("Error:"): self._emit_segments([("bold ansired", message + "\n")], message) return diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index ff2c12e..0e7ad33 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -460,6 +460,18 @@ def test_act_prompt_uses_first_todo_as_current_focus(tmp_path): assert "Current Focus:\n- [○ todo] edit command handler (id=p2)" in prompt +def test_act_prompt_tells_model_to_reply_to_pending_feedback_first(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.session.state.pending_user_feedback = "focus on sed" + + prompt = agent.build_user_prompt() + + assert "Pending User Feedback:\nfocus on sed" in prompt + assert "Pending feedback rules:" in prompt + assert "first emit a brief assistant text response" in prompt + assert "not a new task" in prompt + + def test_act_prompt_includes_kept_tool_results(tmp_path): (tmp_path / "sample.txt").write_text("alpha unique\n", encoding="utf-8") (tmp_path / "other.txt").write_text("beta unique\n", encoding="utf-8") @@ -703,6 +715,19 @@ def test_observe_can_forget_old_kept_result_while_forgetting_latest(tmp_path): assert messages == ["Tool Result Context: -tr.1 -tr.2"] +def test_pending_user_feedback_does_not_rewrite_goal_by_default(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + _seed_plan(agent, "implement demo") + agent.session.state.pending_user_feedback = "how many lines?" + + result = agent.handle_response({"actions": [{"type": "goal", "text": "answer line count"}]}) + + assert result.done is False + assert agent.blackboard.goal == "implement demo" + assert agent.session.state.pending_user_feedback == "" + assert any("Pending User Feedback is not a new task" in error for error in agent.agent_feedback_errors) + + def test_keep_tool_results_ignore_non_tool_sources(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) @@ -2644,6 +2669,38 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert agent.blackboard.verification_required is False +def test_agent_run_ingests_queued_user_input_before_next_model_call(tmp_path): + class FakeModelClient: + def __init__(self): + self.user_prompts = [] + self.responses = [ + {"actions": [{"type": "goal", "text": "initial task"}]}, + {"actions": [{"type": "known", "items": ["queued feedback was visible"]}]}, + {"actions": [{"type": "goal", "complete": True, "message_for_complete": "done"}]}, + ] + + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): + self.user_prompts.append(user_prompt) + return self.responses.pop(0) + + queued_inputs = [None, "use chinese", None] + messages = [] + agent = Agent(Session(cwd=str(tmp_path))) + agent.model_client = FakeModelClient() + + response = agent.run("initial task", on_message=messages.append, poll_user_input=lambda: queued_inputs.pop(0) if queued_inputs else None) + + assert response["actions"][0]["message_for_complete"] == "done" + assert messages == ["Goal Updated\n initial task", "sent: use chinese", "Known Updated\n 1. queued feedback was visible", "done"] + assert [item.content for item in agent.session.state.conversation if isinstance(item, nanocode.UserMessage)] == ["initial task", "use chinese"] + assert agent.blackboard.user_input == "use chinese" + assert "use chinese" not in agent.model_client.user_prompts[0] + assert "use chinese" in agent.model_client.user_prompts[1] + assert "Pending User Feedback:\nuse chinese" in agent.model_client.user_prompts[1] + assert "Pending User Feedback:\n(empty)" in agent.model_client.user_prompts[2] + assert "Latest User Request:" in agent.model_client.user_prompts[1] + + def test_agent_plan_mode_tool_gate_allows_only_readonly_tools(tmp_path): agent = Agent(_session(tmp_path, plan_mode=True)) diff --git a/tests/test_nanocode_bash_tool.py b/tests/test_nanocode_bash_tool.py index f45e6fc..abc1e8a 100644 --- a/tests/test_nanocode_bash_tool.py +++ b/tests/test_nanocode_bash_tool.py @@ -43,17 +43,22 @@ def test_bash_tool_times_out_and_reports_timeout(tmp_path): assert "timeout" in result -def test_bash_tool_kills_process_group_on_interrupt(tmp_path): +def test_bash_tool_kills_process_group_on_interrupt(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path), settings=RuntimeSettings(shell_timeout=30)) pid_file = tmp_path / "pid" tool = BashTool.make(session, [f"echo $$ > {pid_file}; printf started; sleep 30"]) + original_read_chunk = BashTool._read_stream_chunk - def interrupt_on_output(chunk: str) -> None: - if "started" in chunk: + def interrupt_on_output(selector, key, stdout_parts, stderr_parts): + result = original_read_chunk(selector, key, stdout_parts, stderr_parts) + if "started" in "".join(stdout_parts): raise KeyboardInterrupt() + return result + + monkeypatch.setattr(BashTool, "_read_stream_chunk", staticmethod(interrupt_on_output)) try: - result = tool.call_live(interrupt_on_output) + result = tool.call() assert "* exit_code: -1" in result assert "* interrupted: true" in result assert "* reason: user_ctrl_c" in result diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 2350115..7b50228 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -271,18 +271,6 @@ def __init__(self): assert captured == [" Read sample.txt 0:1"] -def test_agent_loop_live_preview_interrupt_hint_latches(tmp_path): - class FakeAgent: - def __init__(self): - self.session = make_session(tmp_path, model="model") - - loop = AgentLoop(FakeAgent(), output_fn=lambda message: None) - loop._live_preview_started_at = time.monotonic() - loop.LIVE_PREVIEW_INTERRUPT_HINT_AFTER - 0.1 - - assert loop._live_preview_interrupt_hint(time.monotonic()) is True - assert loop._live_preview_interrupt_hint(time.monotonic()) is True - - def test_agent_loop_renders_tool_result_context_as_weak_status(tmp_path): class FakeAgent: def __init__(self): @@ -521,7 +509,7 @@ def __init__(self): self.blackboard = Blackboard() self.runs = [] - def run(self, user_input, *, confirm=None, on_auto_approve=None, on_message=None): + def run(self, user_input, *, confirm=None, on_auto_approve=None, on_message=None, poll_user_input=None): self.runs.append(user_input) if on_message is not None: on_message("assistant response") @@ -540,6 +528,148 @@ def run(self, user_input, *, confirm=None, on_auto_approve=None, on_message=None assert loop.agent.runs == ["hello"] +def test_agent_loop_consumes_queued_input_before_prompt(tmp_path): + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + self.blackboard = Blackboard() + self.runs = [] + + def run(self, user_input, **kwargs): + self.runs.append(user_input) + + inputs = iter(["/exit"]) + output = [] + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: next(inputs), output_fn=output.append) + + loop._append_queued_input(" queued message ") + + assert loop.run() == 0 + assert loop.agent.runs == ["queued message"] + assert "sent: queued message" in output + + +def test_agent_loop_run_agent_uses_runtime_ui_without_status_thread(tmp_path, monkeypatch): + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + self.blackboard = Blackboard() + self.runs = [] + self.poll_user_input = None + + def run(self, user_input, **kwargs): + self.runs.append(user_input) + self.poll_user_input = kwargs["poll_user_input"] + + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "", output_fn=lambda message: None) + calls = [] + monkeypatch.setattr(loop, "_start_runtime_ui", lambda: calls.append("start-ui") or True) + monkeypatch.setattr(loop, "_stop_runtime_ui", lambda: calls.append("stop-ui") or True) + monkeypatch.setattr(loop.status_bar, "reset_timer", lambda: calls.append("reset")) + monkeypatch.setattr(loop.status_bar, "resume", lambda: calls.append("resume")) + monkeypatch.setattr(loop.status_bar, "pause", lambda: calls.append("pause")) + + loop._run_agent("hello") + + assert loop.agent.runs == ["hello"] + assert loop.agent.poll_user_input.__self__ is loop + assert loop.agent.poll_user_input.__func__ is AgentLoop._pop_queued_input + assert calls == ["reset", "start-ui", "stop-ui", "pause"] + + +def test_agent_loop_clears_queued_input_on_cancel(tmp_path, monkeypatch): + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + self.blackboard = Blackboard() + + def run(self, user_input, **kwargs): + raise KeyboardInterrupt + + def cancel_current_goal(self): + pass + + output = [] + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "", output_fn=output.append) + monkeypatch.setattr(loop, "_start_runtime_ui", lambda: False) + loop._append_queued_input("queued message") + + loop._run_agent("hello") + + assert loop._pop_queued_input() is None + assert "queued cleared: 1" in output + + +def test_agent_loop_runtime_ui_pause_restarts_for_confirm(tmp_path, monkeypatch): + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "", output_fn=lambda message: None) + calls = [] + monkeypatch.setattr(loop, "_stop_runtime_ui", lambda: calls.append("stop-ui") or True) + monkeypatch.setattr(loop, "_start_runtime_ui", lambda: calls.append("start-ui") or True) + monkeypatch.setattr(loop, "_with_status_paused", lambda action: action()) + monkeypatch.setattr(loop, "_print_tool_call_display", lambda *args, **kwargs: calls.append("display")) + monkeypatch.setattr(loop, "_wait_confirm", lambda *args, **kwargs: True) + + result = loop._confirm_tool_call(ParsedToolCall("Edit", "edit", ["a", "b", "c"]), object()) + + assert result is True + assert calls == ["stop-ui", "display", "start-ui"] + + +def test_agent_loop_runtime_interrupt_requests_sigint(tmp_path, monkeypatch): + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + + class FakeApp: + def __init__(self): + self.exited = False + + def exit(self): + self.exited = True + + app = FakeApp() + calls = [] + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "", output_fn=lambda message: None) + loop._runtime_ui_app = app + monkeypatch.setattr(nanocode.os, "kill", lambda pid, sig: calls.append((pid, sig))) + + loop._interrupt_current_turn(exit_after=True) + + assert loop._exit_after_current_turn is True + assert app.exited is True + assert calls == [(nanocode.os.getpid(), nanocode.signal.SIGINT)] + + +def test_agent_loop_runtime_retry_requests_model_retry(tmp_path, monkeypatch): + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + + class FakeApp: + def __init__(self): + self.exited = False + + def exit(self): + self.exited = True + + app = FakeApp() + calls = [] + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "", output_fn=lambda message: None) + loop._runtime_ui_app = app + loop.agent.session.state.current_model_call_started_at = 1.0 + monkeypatch.setattr(nanocode.os, "kill", lambda pid, sig: calls.append((pid, sig))) + + loop._retry_current_model_call() + + assert loop.agent.session.state.manual_model_retry_requested is True + assert app.exited is False + assert calls == [(nanocode.os.getpid(), nanocode.signal.SIGINT)] + + def test_agent_loop_model_command_prompts_for_reasoning_effort(tmp_path): class FakeAgent: def __init__(self): From 64a2f4afd5fa68a181eb7349d2bc6baa2ccf176a Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:24:49 -0700 Subject: [PATCH 042/144] Enforce user language for assistant replies --- nanocode.py | 4 ++-- tests/test_nanocode_agent.py | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index 7524ee7..0b3799f 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3273,7 +3273,7 @@ def _state_tool_schema(name: str) -> Json: Assistant text is optional. Do not answer with text when a useful tool call should be made. A task is complete only after goal.complete=true is set. -User-facing text must use the latest user language. Keep it plain, concise, and direct. +All user-facing assistant text must use the latest user language, including progress, pending-feedback replies, and final answers. Keep it plain, concise, and direct. Available state tools: goal, plan, hypothesis, known, stable_knowledge, user_rule, verify, forget @@ -3659,7 +3659,7 @@ def _state_tool_schema(name: str) -> Json: Use function tools for task state and repository actions. Assistant text is optional; never use it instead of the next useful function tool. Goal completion still requires goal.complete=true. -Use the latest user language for user-facing text. +Use the latest user language for every user-facing assistant text response, including pending-feedback replies and final answers. YOUR OUTPUT: """ diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 0e7ad33..65c231a 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -470,6 +470,8 @@ def test_act_prompt_tells_model_to_reply_to_pending_feedback_first(tmp_path): assert "Pending feedback rules:" in prompt assert "first emit a brief assistant text response" in prompt assert "not a new task" in prompt + assert "latest user language" in prompt + assert "pending-feedback replies" in prompt def test_act_prompt_includes_kept_tool_results(tmp_path): From e381ca2e9fe289caa075431932fb68b5379e15ad Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:33:59 -0700 Subject: [PATCH 043/144] Improve PatchFile mismatch diagnostics --- nanocode.py | 23 ++++++++++++++++------- tests/test_nanocode_patch_file_tool.py | 5 +++-- 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/nanocode.py b/nanocode.py index 0b3799f..3c18315 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1178,7 +1178,7 @@ def stream_action(cls, session: Session, *, activity: str, action: Json) -> None session, activity=activity, label="stream-action", - payload={"action": cls.response_summary({"actions": [action]})}, + payload={"summary": cls.response_summary({"actions": [action]}), "action": action}, ) @classmethod @@ -2456,6 +2456,7 @@ class PatchFileTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Apply a small single-file unified-diff-style patch for coordinated multi-location edits.", "Inside hunks, every line must start with space, -, or +.", + "Context lines must be exact file text, without Read display prefixes or added indentation.", "Each hunk must include enough unchanged context to match exactly once; all hunks must apply or nothing is written.", ) SIGNATURE: ClassVar[str] = "PatchFile(filepath, patch) -> PatchFileToolResult" @@ -2513,7 +2514,11 @@ def _preview(self) -> tuple[str, str, list[tuple[int, int, list[str]]]]: with open(self.filepath, "r", encoding="utf-8") as f: original = f.read() lines = original.splitlines(keepends=True) - replacements = [(start, start + len(hunk.old), hunk.new) for hunk in self._parse_patch() for start in [self._match_hunk(lines, hunk)]] + replacements = [ + (start, start + len(hunk.old), hunk.new) + for index, hunk in enumerate(self._parse_patch(), start=1) + for start in [self._match_hunk(lines, hunk, index)] + ] return original, "".join(self._patched_lines(lines, replacements)), replacements def _parse_patch(self) -> list[PatchFileHunk]: @@ -2551,19 +2556,23 @@ def _parse_patch(self) -> list[PatchFileHunk]: raise ToolCallError(f"hunk {index} has no context or removed lines") return hunks - @staticmethod - def _match_hunk(lines: list[str], hunk: PatchFileHunk) -> int: + @classmethod + def _match_hunk(cls, lines: list[str], hunk: PatchFileHunk, index: int) -> int: matches = [] limit = len(lines) - len(hunk.old) for start in range(max(0, limit + 1)): if lines[start : start + len(hunk.old)] == hunk.old: matches.append(start) if not matches: - raise ToolCallError("hunk context did not match") + raise ToolCallError(f"hunk {index} context did not match; first old line: {cls._line_preview(hunk.old[0])}") if len(matches) > 1: - raise ToolCallError("hunk context matched multiple locations") + raise ToolCallError(f"hunk {index} context matched multiple locations") return matches[0] + @staticmethod + def _line_preview(line: str) -> str: + return repr(line.rstrip("\n"))[:120] + @staticmethod def _patched_lines(lines: list[str], replacements: list[tuple[int, int, list[str]]]) -> list[str]: output: list[str] = [] @@ -3382,7 +3391,7 @@ def _state_tool_schema(name: str) -> Json: - use Edit only for one tiny exact literal block that appears once - use ReplaceRange after Read for ranges, repeated text, insertions, and structural edits - use ReplaceRange(filepath, ranges) for several known independent ranges in one file -- use PatchFile for coordinated multi-location edits in one file; keep patches small with enough unchanged context +- use PatchFile for coordinated multi-location edits in one file; copy context exactly and keep patches small VERIFICATION Verification strength: diff --git a/tests/test_nanocode_patch_file_tool.py b/tests/test_nanocode_patch_file_tool.py index 64d7f62..7777351 100644 --- a/tests/test_nanocode_patch_file_tool.py +++ b/tests/test_nanocode_patch_file_tool.py @@ -69,8 +69,9 @@ def test_patch_file_tool_rejects_context_mismatch_without_writing(tmp_path): tool = PatchFileTool.make(session, ["sample.txt", "@@\n alpha\n-missing\n+MISSING\n gamma\n"]) - assert "hunk context did not match" in tool.preview() - with pytest.raises(ToolCallError, match="hunk context did not match"): + assert "hunk 1 context did not match" in tool.preview() + assert "first old line: 'alpha'" in tool.preview() + with pytest.raises(ToolCallError, match="hunk 1 context did not match"): tool.call() assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" From 84429a3fc7e675426107806d8d2077e346eb0d43 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:35:44 -0700 Subject: [PATCH 044/144] Move runtime status line above queued input --- nanocode.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/nanocode.py b/nanocode.py index 3c18315..777b974 100644 --- a/nanocode.py +++ b/nanocode.py @@ -7716,17 +7716,18 @@ def _retry(event): ], height=Dimension(min=1), ) + status_line = Window( + FormattedTextControl(self._runtime_status_fragments, style="class:bottom-toolbar.text"), + style="class:bottom-toolbar", + height=Dimension(min=1), + dont_extend_height=True, + ) app = Application( layout=Layout( HSplit( [ + status_line, input_line, - Window( - FormattedTextControl(self._runtime_status_fragments, style="class:bottom-toolbar.text"), - style="class:bottom-toolbar", - height=Dimension(min=1), - dont_extend_height=True, - ), ] ), focused_element=buffer_control, From d038b3773dc5482980bfc9256b737c86e3e03b6f Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:39:38 -0700 Subject: [PATCH 045/144] Tolerate duplicate empty PatchFile hunk markers --- nanocode.py | 2 ++ tests/test_nanocode_patch_file_tool.py | 10 ++++++++++ 2 files changed, 12 insertions(+) diff --git a/nanocode.py b/nanocode.py index 777b974..18aa1e7 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2528,6 +2528,8 @@ def _parse_patch(self) -> list[PatchFileHunk]: if raw_line.startswith("\\ No newline at end of file"): continue if raw_line.startswith("@@"): + if current is not None and not current.old and not current.new: + continue current = PatchFileHunk(old=[], new=[]) hunks.append(current) continue diff --git a/tests/test_nanocode_patch_file_tool.py b/tests/test_nanocode_patch_file_tool.py index 7777351..8199d35 100644 --- a/tests/test_nanocode_patch_file_tool.py +++ b/tests/test_nanocode_patch_file_tool.py @@ -62,6 +62,16 @@ def test_patch_file_tool_applies_multiple_hunks_atomically(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\nDELTA\n" +def test_patch_file_tool_ignores_duplicate_empty_hunk_markers(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + PatchFileTool.make(session, ["sample.txt", "@@\n@@\n alpha\n-beta\n+BETA\n gamma\n"]).call() + + assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" + + def test_patch_file_tool_rejects_context_mismatch_without_writing(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") From 9c70c609807568652356f579fbc2438f67c4b285 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:41:48 -0700 Subject: [PATCH 046/144] Suppress empty queued input redraw artifacts --- nanocode.py | 4 ++-- tests/test_nanocode_loop.py | 45 +++++++++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index 18aa1e7..e421a52 100644 --- a/nanocode.py +++ b/nanocode.py @@ -7681,14 +7681,14 @@ def print_queued(text: str) -> None: print_formatted_text(FormattedText([("ansibrightblack", "queued: " + text)]), output=self.status_bar.output) def queue_text(event, text: str) -> None: + buffer.reset() + event.app.invalidate() if not text: return self._append_queued_input(text) - buffer.reset() terminal_task = run_in_terminal(lambda: print_queued(text), in_executor=False) if inspect.iscoroutine(terminal_task): event.app.create_background_task(terminal_task) - event.app.invalidate() @bindings.add("enter", eager=True) def _accept(event): diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 7b50228..39f8693 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -600,6 +600,51 @@ def cancel_current_goal(self): assert "queued cleared: 1" in output +def test_agent_loop_runtime_ui_empty_enter_only_refreshes(tmp_path, monkeypatch): + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + + class FakePromptApp: + def __init__(self): + self.invalidated = 0 + self.background_tasks = [] + + def invalidate(self): + self.invalidated += 1 + + def create_background_task(self, task): + self.background_tasks.append(task) + + class FakeEvent: + def __init__(self, app): + self.app = app + + def handler(bindings, key): + return next(binding.handler for binding in bindings.bindings if binding.keys == (key,)) + + prompt_app = FakePromptApp() + + class FakeApplication: + def __init__(self, **kwargs): + self.bindings = kwargs["key_bindings"] + + def run(self, handle_sigint=False): + handler(self.bindings, nanocode.Keys.ControlM)(FakeEvent(prompt_app)) + + terminal_calls = [] + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "", output_fn=lambda message: None) + monkeypatch.setattr(nanocode, "Application", FakeApplication) + monkeypatch.setattr(nanocode, "run_in_terminal", lambda *args, **kwargs: terminal_calls.append((args, kwargs))) + + loop._run_runtime_ui() + + assert loop._pop_queued_input() is None + assert prompt_app.invalidated == 1 + assert prompt_app.background_tasks == [] + assert terminal_calls == [] + + def test_agent_loop_runtime_ui_pause_restarts_for_confirm(tmp_path, monkeypatch): class FakeAgent: def __init__(self): From c0a879c6bbf32c16806383c7781c64cdbc329bf2 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:44:08 -0700 Subject: [PATCH 047/144] Emphasize user language for assistant text --- nanocode.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index e421a52..cbabfd0 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3284,7 +3284,10 @@ def _state_tool_schema(name: str) -> Json: Assistant text is optional. Do not answer with text when a useful tool call should be made. A task is complete only after goal.complete=true is set. -All user-facing assistant text must use the latest user language, including progress, pending-feedback replies, and final answers. Keep it plain, concise, and direct. +Language rule: all user-facing assistant text MUST use the latest user language. +This includes chat text, progress text, pending-feedback replies, direct responses, and message_for_complete. +Do not switch to English when the latest user request is Chinese. Preserve code, identifiers, paths, commands, config keys, API names, and quoted text exactly. +Keep user-facing text plain, concise, and direct. Available state tools: goal, plan, hypothesis, known, stable_knowledge, user_rule, verify, forget @@ -3670,7 +3673,8 @@ def _state_tool_schema(name: str) -> Json: Use function tools for task state and repository actions. Assistant text is optional; never use it instead of the next useful function tool. Goal completion still requires goal.complete=true. -Use the latest user language for every user-facing assistant text response, including pending-feedback replies and final answers. +Language rule: every chat/progress/response text must use the latest user language, including pending-feedback replies and final answers. +Do not switch to English when the latest user request is Chinese. YOUR OUTPUT: """ From 84b5ac52c9c743d70fced6e7c475ef154166105c Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:49:57 -0700 Subject: [PATCH 048/144] Make read output and PatchFile indentation less ambiguous --- nanocode.py | 45 ++++++++++++++++++-------- tests/test_nanocode_patch_file_tool.py | 16 +++++++++ tests/test_nanocode_read_tool.py | 38 +++++++++++----------- 3 files changed, 66 insertions(+), 33 deletions(-) diff --git a/nanocode.py b/nanocode.py index cbabfd0..642f959 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1745,7 +1745,7 @@ class ReadTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Read a single known UTF-8 file; pass multiple 0-based start,end ranges for it.", "Each range returns at most 600 lines.", - 'Content is line-numbered as "line | code"; edit text must use only code after " | ".', + 'Content is line-numbered as "line |code"; edit text starts immediately after "|".', ) SIGNATURE: ClassVar[str] = "Read(filepath[, range_token...]) -> ReadToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( @@ -1820,7 +1820,7 @@ def call(self) -> str: @staticmethod def _numbered_content(content: str, start: int) -> str: - return "".join(f"{start + index:>7} | {line}" for index, line in enumerate(content.splitlines(keepends=True))) + return "".join(f"{start + index:>7} |{line}" for index, line in enumerate(content.splitlines(keepends=True))) def _read_range(self, start: int, end: int) -> tuple[str, int, int, str, bool, int]: target_filepath = self.filepath @@ -1869,7 +1869,7 @@ def _format_range_result( lines = [ indent + "" + str(start) + ":" + str(fingerprint_end) + "", indent + "" + fingerprint + "", - indent + 'Line prefixes are display-only; use only code after " | " in edits.', + indent + 'Line prefixes are display-only; code starts immediately after "|".', ] if truncated: note = ( @@ -2447,6 +2447,8 @@ def call(self) -> str: class PatchFileHunk: old: list[str] new: list[str] + alt_old: list[str] + alt_new: list[str] @dataclass @@ -2455,8 +2457,8 @@ class PatchFileTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Apply a small single-file unified-diff-style patch for coordinated multi-location edits.", - "Inside hunks, every line must start with space, -, or +.", - "Context lines must be exact file text, without Read display prefixes or added indentation.", + "Inside hunks, every line should start with space, -, or +; indented context copied without the extra marker is tolerated.", + "Context lines must be exact file text, without Read display prefixes.", "Each hunk must include enough unchanged context to match exactly once; all hunks must apply or nothing is written.", ) SIGNATURE: ClassVar[str] = "PatchFile(filepath, patch) -> PatchFileToolResult" @@ -2515,9 +2517,10 @@ def _preview(self) -> tuple[str, str, list[tuple[int, int, list[str]]]]: original = f.read() lines = original.splitlines(keepends=True) replacements = [ - (start, start + len(hunk.old), hunk.new) + (start, start + len(old), new) for index, hunk in enumerate(self._parse_patch(), start=1) - for start in [self._match_hunk(lines, hunk, index)] + for old, new in [self._select_hunk_variant(lines, hunk, index)] + for start in [self._match_hunk(lines, old, index)] ] return original, "".join(self._patched_lines(lines, replacements)), replacements @@ -2530,7 +2533,7 @@ def _parse_patch(self) -> list[PatchFileHunk]: if raw_line.startswith("@@"): if current is not None and not current.old and not current.new: continue - current = PatchFileHunk(old=[], new=[]) + current = PatchFileHunk(old=[], new=[], alt_old=[], alt_new=[]) hunks.append(current) continue if current is None: @@ -2545,10 +2548,14 @@ def _parse_patch(self) -> list[PatchFileHunk]: if prefix == " ": current.old.append(text) current.new.append(text) + current.alt_old.append(raw_line) + current.alt_new.append(raw_line) elif prefix == "-": current.old.append(text) + current.alt_old.append(text) elif prefix == "+": current.new.append(text) + current.alt_new.append(" " + text) else: raise ToolCallError("invalid patch hunk line prefix: " + repr(prefix)) if not hunks: @@ -2558,15 +2565,25 @@ def _parse_patch(self) -> list[PatchFileHunk]: raise ToolCallError(f"hunk {index} has no context or removed lines") return hunks + def _select_hunk_variant(self, lines: list[str], hunk: PatchFileHunk, index: int) -> tuple[list[str], list[str]]: + if self._hunk_matches(lines, hunk.old): + return hunk.old, hunk.new + if (hunk.alt_old != hunk.old or hunk.alt_new != hunk.new) and self._hunk_matches(lines, hunk.alt_old): + return hunk.alt_old, hunk.alt_new + raise ToolCallError(f"hunk {index} context did not match; first old line: {self._line_preview(hunk.old[0])}") + + @staticmethod + def _hunk_matches(lines: list[str], old: list[str]) -> bool: + limit = len(lines) - len(old) + return any(lines[start : start + len(old)] == old for start in range(max(0, limit + 1))) + @classmethod - def _match_hunk(cls, lines: list[str], hunk: PatchFileHunk, index: int) -> int: + def _match_hunk(cls, lines: list[str], old: list[str], index: int) -> int: matches = [] - limit = len(lines) - len(hunk.old) + limit = len(lines) - len(old) for start in range(max(0, limit + 1)): - if lines[start : start + len(hunk.old)] == hunk.old: + if lines[start : start + len(old)] == old: matches.append(start) - if not matches: - raise ToolCallError(f"hunk {index} context did not match; first old line: {cls._line_preview(hunk.old[0])}") if len(matches) > 1: raise ToolCallError(f"hunk {index} context matched multiple locations") return matches[0] @@ -3384,7 +3401,7 @@ def _state_tool_schema(name: str) -> Json: Use Search/ListDir/LineCount when path, symbol, range, or target is unknown. Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. -Read line prefixes are display-only; edit text starts after " | ". +Read line prefixes are display-only; edit text starts immediately after "|". Stop discovery once the next edit/check is clear. diff --git a/tests/test_nanocode_patch_file_tool.py b/tests/test_nanocode_patch_file_tool.py index 8199d35..713d36c 100644 --- a/tests/test_nanocode_patch_file_tool.py +++ b/tests/test_nanocode_patch_file_tool.py @@ -72,6 +72,22 @@ def test_patch_file_tool_ignores_duplicate_empty_hunk_markers(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" +def test_patch_file_tool_accepts_indented_context_without_extra_marker(tmp_path): + path = tmp_path / "sample.py" + path.write_text("def run():\n while True:\n if done:\n return 0\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + PatchFileTool.make( + session, + [ + "sample.py", + '@@\n while True:\n if done:\n+ print("done")\n return 0\n', + ], + ).call() + + assert path.read_text(encoding="utf-8") == 'def run():\n while True:\n if done:\n print("done")\n return 0\n' + + def test_patch_file_tool_rejects_context_mismatch_without_writing(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") diff --git a/tests/test_nanocode_read_tool.py b/tests/test_nanocode_read_tool.py index 8cc22c7..241c918 100644 --- a/tests/test_nanocode_read_tool.py +++ b/tests/test_nanocode_read_tool.py @@ -17,8 +17,8 @@ def test_read_tool_reads_requested_line_range(tmp_path): assert "1:3" in result assert "" in result assert "" in result - assert " 1 | beta\n 2 | gamma\n" in result - assert " 0 | alpha" not in result + assert " 1 |beta\n 2 |gamma\n" in result + assert " 0 |alpha" not in result def test_read_tool_rejects_empty_args_with_actionable_error(tmp_path): @@ -49,10 +49,10 @@ def test_read_tool_reads_multiple_line_range_tokens(tmp_path): assert "1:2, 3:5" in tool.preview() assert "1:2" in result assert "3:5" in result - assert " 1 | one\n" in result - assert " 3 | three\n 4 | four\n" in result - assert " 0 | zero" not in result - assert " 2 | two" not in result + assert " 1 |one\n" in result + assert " 3 |three\n 4 |four\n" in result + assert " 0 |zero" not in result + assert " 2 |two" not in result def test_read_tool_reads_colon_and_comma_range_tokens(tmp_path): @@ -67,10 +67,10 @@ def test_read_tool_reads_colon_and_comma_range_tokens(tmp_path): assert "1:2, 3:5" in tool.preview() assert "1:2" in result assert "3:5" in result - assert " 1 | one\n" in result - assert " 3 | three\n 4 | four\n" in result - assert " 0 | zero" not in result - assert " 2 | two" not in result + assert " 1 |one\n" in result + assert " 3 |three\n 4 |four\n" in result + assert " 0 |zero" not in result + assert " 2 |two" not in result def test_read_tool_reads_to_eof_when_end_is_zero(tmp_path): @@ -80,8 +80,8 @@ def test_read_tool_reads_to_eof_when_end_is_zero(tmp_path): result = ReadTool.make(session, ["sample.txt", "1,0"]).call() - assert " 1 | beta\n 2 | gamma\n" in result - assert " 0 | alpha" not in result + assert " 1 |beta\n 2 |gamma\n" in result + assert " 0 |alpha" not in result def test_read_tool_allows_omitted_range_for_full_file_read(tmp_path): @@ -95,7 +95,7 @@ def test_read_tool_allows_omitted_range_for_full_file_read(tmp_path): assert tool.start == 0 assert tool.end == 0 assert "0:0" in result - assert " 0 | alpha\n 1 | beta\n" in result + assert " 0 |alpha\n 1 |beta\n" in result def test_read_tool_reads_range_token_when_numeric_filenames_exist(tmp_path): @@ -109,7 +109,7 @@ def test_read_tool_reads_range_token_when_numeric_filenames_exist(tmp_path): assert tool.ranges == [(1, 3)] assert "1:3" in result - assert " 1 | one\n 2 | two\n" in result + assert " 1 |one\n 2 |two\n" in result assert "numeric filename" not in result @@ -125,8 +125,8 @@ def test_read_tool_truncates_full_file_reads_after_600_lines(tmp_path): assert "605" in result assert "Read returned 600 lines from 0:600 of 605 total lines" in result assert "Use Search to locate relevant text or Read smaller ranges in batches." in result - assert " 599 | line-0599\n" in result - assert " 600 | line-0600\n" not in result + assert " 599 |line-0599\n" in result + assert " 600 |line-0600\n" not in result def test_read_tool_truncates_large_bounded_ranges_after_600_lines(tmp_path): @@ -140,8 +140,8 @@ def test_read_tool_truncates_large_bounded_ranges_after_600_lines(tmp_path): assert "true" in result assert "700" in result assert "Read returned 600 lines from 10:610 of 700 total lines" in result - assert " 609 | line-0609\n" in result - assert " 610 | line-0610\n" not in result + assert " 609 |line-0609\n" in result + assert " 610 |line-0610\n" not in result def test_read_tool_bounded_read_stops_at_end(tmp_path, monkeypatch): @@ -174,7 +174,7 @@ def tracking_open(*args, **kwargs): result = ReadTool.make(session, ["sample.txt", "1,3"]).call() - assert " 1 | one\n 2 | two\n" in result + assert " 1 |one\n 2 |two\n" in result assert "three" not in result assert lines_read == ["zero\n", "one\n", "two\n"] From b707d21eeeafa9716e214de1334d4fee58137331 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:53:42 -0700 Subject: [PATCH 049/144] print session id on exit --- nanocode.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/nanocode.py b/nanocode.py index 642f959..ae700ba 100644 --- a/nanocode.py +++ b/nanocode.py @@ -8611,7 +8611,9 @@ def main(argv: list[str] | None = None) -> int: print("Missing config: " + ", ".join(missing), file=sys.stderr) print("Edit " + (os.path.expanduser(args.config) if args.config else ConfigFile.path()) + " or run `nanocode --init-config`.", file=sys.stderr) return 2 - return AgentLoop(Agent(session)).run() + exit_code = AgentLoop(Agent(session)).run() + print("session: " + session.session_id, file=sys.stderr) + return exit_code except ConfigError as error: print("Error: " + str(error), file=sys.stderr) return 2 From 69a0250897e1aee5b7da0e033eb1a72bf331bc3c Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 09:55:37 -0700 Subject: [PATCH 050/144] Encourage Unix text tools in Bash guidance Also print the session id when nanocode exits. --- nanocode.py | 10 +++++++--- tests/test_nanocode_agent.py | 10 ++++++++++ 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/nanocode.py b/nanocode.py index ae700ba..dae8818 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2885,7 +2885,9 @@ def _replacement_lines(content: str, *, has_following_line: bool) -> list[str]: class BashTool(Tool): NAME: ClassVar[str] = "Bash" DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Run one explicit shell command via bash -lc in cwd; not for search, listing, or file edits when dedicated tools exist.", + "Run one explicit shell command via bash -lc in cwd.", + "Use for tests, builds, and fast Unix text-tool work such as find, sed, awk, perl, xargs, and grep when that is the clearest path.", + "Mechanical shell edits are allowed, but verify afterward with Git diff, Read, tests, or another focused check.", ) SIGNATURE: ClassVar[str] = "Bash(command) -> BashToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["python3 -m py_compile nanocode.py"]', 'Example args: ["make test"]') @@ -3441,8 +3443,10 @@ def _state_tool_schema(name: str) -> Json: Complete with verify blocked only when blocker=user. TOOLS -Prefer dedicated tools over Bash. -Use Bash only for explicit shell commands or when no dedicated tool exists. +Prefer dedicated tools for precise file reads/searches and structured edits. +Use Bash for explicit shell commands, tests/builds, and fast Unix text-tool work: find, sed, awk, perl, xargs, grep. +Mechanical shell edits are allowed; verify afterward with Git diff, Read, tests, or another focused check. +For complex code changes, prefer ReplaceRange or PatchFile over shell rewrites. Git is for status, diff, history, and changed files. Recall fetches stored result keys; batch distinct keys and recall each needed key at most once. diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 65c231a..a69902d 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -474,6 +474,16 @@ def test_act_prompt_tells_model_to_reply_to_pending_feedback_first(tmp_path): assert "pending-feedback replies" in prompt +def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + + prompt = agent._system_prompt() + + assert "find, sed, awk, perl, xargs, grep" in prompt + assert "Mechanical shell edits are allowed" in prompt + assert "verify afterward" in prompt + + def test_act_prompt_includes_kept_tool_results(tmp_path): (tmp_path / "sample.txt").write_text("alpha unique\n", encoding="utf-8") (tmp_path / "other.txt").write_text("beta unique\n", encoding="utf-8") From cec301f81c3a44cc35dc7832ce302c6c9712c425 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 10:12:50 -0700 Subject: [PATCH 051/144] Restore Bash live preview with final frame history --- nanocode.py | 95 ++++++++++++++++++++++++++++++-- tests/test_nanocode_bash_tool.py | 19 ++++++- tests/test_nanocode_loop.py | 31 +++++++++++ 3 files changed, 138 insertions(+), 7 deletions(-) diff --git a/nanocode.py b/nanocode.py index dae8818..fd3d9cc 100644 --- a/nanocode.py +++ b/nanocode.py @@ -47,7 +47,7 @@ from prompt_toolkit.keys import Keys from prompt_toolkit.lexers import Lexer from prompt_toolkit.layout import Layout -from prompt_toolkit.layout.containers import HSplit, VSplit, Window +from prompt_toolkit.layout.containers import ConditionalContainer, HSplit, VSplit, Window from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl from prompt_toolkit.layout.dimension import Dimension from prompt_toolkit.output.defaults import create_output @@ -1602,6 +1602,7 @@ def forget_result_keys_from_actions(actions: list[Json]) -> list[str]: ConfirmationResult: TypeAlias = bool | str ConfirmCallback: TypeAlias = Callable[[ParsedToolCall, Tool], ConfirmationResult] ToolDisplayCallback: TypeAlias = Callable[[ParsedToolCall, Tool], None] +ToolOutputCallback: TypeAlias = Callable[[str, str], None] MessageCallback: TypeAlias = Callable[[str], None] UserInputPoller: TypeAlias = Callable[[], str | None] StatusAction: TypeAlias = Callable[[], str] @@ -2897,6 +2898,7 @@ class BashTool(Tool): bash_path: str = "" cwd: str = "" timeout: int = 60 + live_output: ToolOutputCallback | None = None @classmethod def cli_args(cls, args: list[str]) -> list[str]: @@ -2947,13 +2949,13 @@ def call(self) -> str: timed_out = True self._kill_process_group(proc) proc.wait() - self._drain_selector(selector, stdout_parts, stderr_parts) + self._drain_selector(selector, stdout_parts, stderr_parts, self.live_output) break events = selector.select(min(0.2, remaining)) if not events: continue for key, _ in events: - self._read_stream_chunk(selector, key, stdout_parts, stderr_parts) + self._read_stream_chunk(selector, key, stdout_parts, stderr_parts, self.live_output) if proc.returncode is None: proc.wait() except KeyboardInterrupt: @@ -2967,6 +2969,8 @@ def call(self) -> str: proc.wait() raise finally: + if self.live_output is not None: + self.live_output("", "") selector.close() stdout_text = "".join(stdout_parts) @@ -3007,9 +3011,10 @@ def _drain_selector( selector: selectors.BaseSelector, stdout_parts: list[str], stderr_parts: list[str], + live_output: ToolOutputCallback | None = None, ) -> None: for key in list(selector.get_map().values()): - while cls._read_stream_chunk(selector, key, stdout_parts, stderr_parts): + while cls._read_stream_chunk(selector, key, stdout_parts, stderr_parts, live_output): pass @staticmethod @@ -3018,6 +3023,7 @@ def _read_stream_chunk( key: selectors.SelectorKey, stdout_parts: list[str], stderr_parts: list[str], + live_output: ToolOutputCallback | None = None, ) -> bool: try: data = os.read(key.fileobj.fileno(), 4096) @@ -3034,10 +3040,16 @@ def _read_stream_chunk( pass return False text = data.decode("utf-8", errors="replace") + stream = "stdout" if key.data == "stdout" else "stderr" if key.data == "stdout": stdout_parts.append(text) else: stderr_parts.append(text) + if live_output is not None: + try: + live_output(stream, text) + except Exception: + pass return True @@ -4630,6 +4642,7 @@ class ToolCallRunner: def __init__(self, session: Session, protected_result_keys: Callable[[], set[str]] | None = None): self.session = session self.protected_result_keys = protected_result_keys or (lambda: set()) + self.live_output: ToolOutputCallback | None = None self.latest_executions: list[ToolCallExecution] = [] self.skipped_after_failure_count = 0 self.skipped_after_failure_key = "" @@ -4655,6 +4668,8 @@ def execute( try: call = item if isinstance(item, ParsedToolCall) else self.parse_tool_call(item) tool = self._make_tool(call) + if isinstance(tool, BashTool): + tool.live_output = self.live_output requires_verification = tool.EFFECT == ToolEffect.EDIT preview_error = getattr(tool, "preview_error", None) if callable(preview_error): @@ -7502,6 +7517,9 @@ def _handle_signal(self, signum: int, frame: Any) -> None: class AgentLoop: + BASH_LIVE_PREVIEW_LINES: ClassVar[int] = 6 + BASH_LIVE_PREVIEW_CHARS: ClassVar[int] = 8000 + def __init__( self, agent: Agent, @@ -7522,6 +7540,8 @@ def __init__( self._runtime_ui_app: Application | None = None self._runtime_ui_ready = threading.Event() self._runtime_ui_stop = threading.Event() + self._tool_live_preview_lock = threading.Lock() + self._tool_live_preview_text = "" self._exit_after_current_turn = False if self.prompt_session is None and input_fn is input and sys.stdin.isatty(): self.prompt_session = self._make_prompt_session() @@ -7617,6 +7637,7 @@ def _choice_style(self) -> Style: "queue-input": "#e5e7eb", "selected-option": "bold #0f4c5c bg:#e6f2f3", "choice-hint": "#6b7280", + "bash-preview": "#6b7280", "bottom-toolbar": "noreverse bg:default fg:default", "bottom-toolbar.text": "noreverse bg:default fg:default", } @@ -7749,10 +7770,19 @@ def _retry(event): height=Dimension(min=1), dont_extend_height=True, ) + bash_preview = ConditionalContainer( + Window( + FormattedTextControl(self._tool_live_preview_fragments, style="class:bash-preview"), + height=Dimension.exact(self.BASH_LIVE_PREVIEW_LINES), + dont_extend_height=True, + ), + filter=Condition(self._has_tool_live_preview), + ) app = Application( layout=Layout( HSplit( [ + bash_preview, status_line, input_line, ] @@ -8089,11 +8119,15 @@ def _make_prompt_session(self): def _run_agent(self, user_input: str) -> None: runtime_ui_running = False + tool_runner = getattr(self.agent, "tool_runner", None) + old_live_output = getattr(tool_runner, "live_output", None) try: self.status_bar.reset_timer() runtime_ui_running = self._start_runtime_ui() if not runtime_ui_running: self.status_bar.resume() + if tool_runner is not None: + tool_runner.live_output = self._show_tool_live_output with patch_stdout() if runtime_ui_running else nullcontext(): self.agent.run( user_input, @@ -8114,6 +8148,9 @@ def _run_agent(self, user_input: str) -> None: except Exception as error: self._emit("Error: " + str(error)) finally: + if tool_runner is not None: + tool_runner.live_output = old_live_output + self._clear_tool_live_preview() self.agent.session.state.manual_model_retry_requested = False if runtime_ui_running: self._stop_runtime_ui() @@ -8129,13 +8166,61 @@ def _run_with_status(self, action: StatusAction) -> str: def _confirm_tool_call(self, call: ParsedToolCall, tool: Tool) -> ConfirmationResult: def action() -> ConfirmationResult: + self._clear_tool_live_preview() self._print_tool_call_display("Confirm Tool Call", "manual approval required", call, tool, title_style="bold ansiyellow") return self._wait_confirm("Proceed?", default=True) return self._with_runtime_ui_paused(lambda: self._with_status_paused(action)) def _show_auto_tool_call(self, call: ParsedToolCall, tool: Tool) -> None: - self._with_runtime_ui_paused(lambda: self._with_status_paused(lambda: self._print_tool_call_display("Auto Tool Call", "auto approved", call, tool, title_style="bold ansiblue"))) + def action() -> None: + self._clear_tool_live_preview() + self._print_tool_call_display("Auto Tool Call", "auto approved", call, tool, title_style="bold ansiblue") + + self._with_runtime_ui_paused(lambda: self._with_status_paused(action)) + + def _show_tool_live_output(self, _stream: str, text: str) -> None: + if self.output_fn is not print: + return + if not text: + self._finish_tool_live_preview() + return + app = self._runtime_ui_app + if app is None: + print_formatted_text(FormattedText([("ansibrightblack", text)]), end="", flush=True) + return + with self._tool_live_preview_lock: + self._tool_live_preview_text = (self._tool_live_preview_text + text)[-self.BASH_LIVE_PREVIEW_CHARS :] + app.invalidate() + + def _finish_tool_live_preview(self) -> None: + frame = self._tool_live_preview_frame() + app = self._runtime_ui_app + self._clear_tool_live_preview() + if app is not None and frame: + print_formatted_text(FormattedText([("ansibrightblack", frame + "\n")]), end="", flush=True) + + def _clear_tool_live_preview(self) -> None: + with self._tool_live_preview_lock: + self._tool_live_preview_text = "" + app = self._runtime_ui_app + if app is not None: + app.invalidate() + + def _has_tool_live_preview(self) -> bool: + with self._tool_live_preview_lock: + return bool(self._tool_live_preview_text) + + def _tool_live_preview_fragments(self): + frame = self._tool_live_preview_frame() + return [("class:bash-preview", frame)] if frame else [("", "")] + + def _tool_live_preview_frame(self) -> str: + with self._tool_live_preview_lock: + text = self._tool_live_preview_text + if not text: + return "" + return "\n".join(text.splitlines()[-self.BASH_LIVE_PREVIEW_LINES :]) def _with_status_paused(self, action: Callable[[], JsonValue]) -> JsonValue: was_running = self.status_bar.is_running() diff --git a/tests/test_nanocode_bash_tool.py b/tests/test_nanocode_bash_tool.py index abc1e8a..15f3dbe 100644 --- a/tests/test_nanocode_bash_tool.py +++ b/tests/test_nanocode_bash_tool.py @@ -34,6 +34,21 @@ def test_bash_tool_returns_nonzero_exit_and_stderr(tmp_path): assert "\nnope\n" in result +def test_bash_tool_streams_live_output_while_collecting_result(tmp_path): + session = Session(cwd=str(tmp_path)) + tool = BashTool.make(session, ["printf out; printf err >&2"]) + chunks = [] + tool.live_output = lambda stream, text: chunks.append((stream, text)) + + result = tool.call() + + assert "".join(text for stream, text in chunks if stream == "stdout") == "out" + assert "".join(text for stream, text in chunks if stream == "stderr") == "err" + assert chunks[-1] == ("", "") + assert "\nout\n" in result + assert "\nerr\n" in result + + def test_bash_tool_times_out_and_reports_timeout(tmp_path): session = Session(cwd=str(tmp_path), settings=RuntimeSettings(shell_timeout=0)) @@ -49,8 +64,8 @@ def test_bash_tool_kills_process_group_on_interrupt(tmp_path, monkeypatch): tool = BashTool.make(session, [f"echo $$ > {pid_file}; printf started; sleep 30"]) original_read_chunk = BashTool._read_stream_chunk - def interrupt_on_output(selector, key, stdout_parts, stderr_parts): - result = original_read_chunk(selector, key, stdout_parts, stderr_parts) + def interrupt_on_output(selector, key, stdout_parts, stderr_parts, live_output=None): + result = original_read_chunk(selector, key, stdout_parts, stderr_parts, live_output) if "started" in "".join(stdout_parts): raise KeyboardInterrupt() return result diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 39f8693..2efc275 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -664,6 +664,37 @@ def __init__(self): assert calls == ["stop-ui", "display", "start-ui"] +def test_agent_loop_bash_live_preview_keeps_latest_lines(tmp_path, monkeypatch): + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + + class FakeApp: + def __init__(self): + self.invalidated = 0 + + def invalidate(self): + self.invalidated += 1 + + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "") + app = FakeApp() + loop._runtime_ui_app = app + printed = [] + monkeypatch.setattr(nanocode, "print_formatted_text", lambda formatted, **kwargs: printed.append(list(formatted))) + + loop._show_tool_live_output("stdout", "\n".join("line" + str(index) for index in range(8))) + + assert app.invalidated == 1 + assert loop._has_tool_live_preview() is True + assert loop._tool_live_preview_fragments() == [("class:bash-preview", "line2\nline3\nline4\nline5\nline6\nline7")] + + loop._show_tool_live_output("", "") + + assert app.invalidated == 2 + assert loop._has_tool_live_preview() is False + assert printed == [[("ansibrightblack", "line2\nline3\nline4\nline5\nline6\nline7\n")]] + + def test_agent_loop_runtime_interrupt_requests_sigint(tmp_path, monkeypatch): class FakeAgent: def __init__(self): From aaa0f6b6edea1e8cc1720d23afafcdbedaf67db4 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 10:24:48 -0700 Subject: [PATCH 052/144] Rename ListDir tool to List --- README.md | 2 +- nanocode.py | 26 +++++++++---------- tests/test_nanocode_agent.py | 4 +-- ...dir_tool.py => test_nanocode_list_tool.py} | 22 ++++++++-------- 4 files changed, 27 insertions(+), 27 deletions(-) rename tests/{test_nanocode_list_dir_tool.py => test_nanocode_list_tool.py} (75%) diff --git a/README.md b/README.md index 747d683..9a02326 100644 --- a/README.md +++ b/README.md @@ -79,7 +79,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Tools -- File: `Read`, `LineCount`, `ListDir`, `Search`. +- File: `Read`, `LineCount`, `List`, `Search`. - Edit: `Edit`, `ReplaceRange`. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. diff --git a/nanocode.py b/nanocode.py index fd3d9cc..d7ac585 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1930,14 +1930,14 @@ def call(self) -> str: @dataclass -class ListDirTool(Tool): - NAME: ClassVar[str] = "ListDir" +class ListTool(Tool): + NAME: ClassVar[str] = "List" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "List one directory non-recursively; optional glob filters immediate entry names.", - "Batch multiple ListDir actions in one turn when checking several known directories.", + "Batch multiple List actions in one turn when checking several known directories.", ) - SIGNATURE: ClassVar[str] = "ListDir([dirpath][, glob]) -> ListDirToolResult" + SIGNATURE: ClassVar[str] = "List([dirpath][, glob]) -> ListToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["src"]', 'Example args: ["src", "*.py"]', "Current dir args: []") dirpath: str = "" @@ -1954,8 +1954,8 @@ def make(cls, session: Session, args: list[str]) -> Self: def preview(self) -> str: if self.glob_pattern: - return f'ListDir({self.dirpath}, "{self.glob_pattern}")' - return f"ListDir({self.dirpath})" + return f'List({self.dirpath}, "{self.glob_pattern}")' + return f"List({self.dirpath})" def requires_confirmation(self, session: Session) -> bool: return not session.is_path_in_cwd(self.dirpath) @@ -1988,10 +1988,10 @@ def call(self) -> str: } ) entries.sort(key=lambda item: (self._entry_type_sort_key(str(item["type"])), str(item["name"]))) - lines = [""] + lines = [""] for e in entries: lines.append(f"* ({e['type']}): {os.path.relpath(str(e['path']), self.cwd)}") - lines.append("") + lines.append("") return "\n".join(lines) @@ -3198,7 +3198,7 @@ def _content(self, item: ToolResultItem) -> str: TOOL_REGISTRY: dict[str, ToolClass] = { ReadTool.NAME: ReadTool, LineCountTool.NAME: LineCountTool, - ListDirTool.NAME: ListDirTool, + ListTool.NAME: ListTool, SearchTool.NAME: SearchTool, CreateFileTool.NAME: CreateFileTool, EditTool.NAME: EditTool, @@ -3208,7 +3208,7 @@ def _content(self, item: ToolResultItem) -> str: GitTool.NAME: GitTool, ToolResultTool.NAME: ToolResultTool, } -PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListDirTool, SearchTool, PlanModeGitTool, ToolResultTool) +PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, SearchTool, PlanModeGitTool, ToolResultTool) TOOL_STRING_SCHEMA: Json = {"type": "string"} @@ -3412,7 +3412,7 @@ def _state_tool_schema(name: str) -> Json: - stop investigating when the exact target and next edit/check are clear DISCOVERY AND EDITING -Use Search/ListDir/LineCount when path, symbol, range, or target is unknown. +Use Search/List/LineCount when path, symbol, range, or target is unknown. Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. Read line prefixes are display-only; edit text starts immediately after "|". @@ -3476,7 +3476,7 @@ def _state_tool_schema(name: str) -> Json: - Assistant text is optional; never use it instead of the next useful function tool. - A completed plan-mode task still needs goal.complete=true. - Allowed state tools: goal, plan, hypothesis, known, stable_knowledge, verify. -- Allowed repository tools: Read, LineCount, ListDir, Search, Recall, and readonly Git. +- Allowed repository tools: Read, LineCount, List, Search, Recall, and readonly Git. - Repository tool calls require intention and args. - Do not invent fields when a tool schema already fits. @@ -3493,7 +3493,7 @@ def _state_tool_schema(name: str) -> Json: - If the user mixes languages, follow the dominant language of the latest request. READONLY DISCOVERY -- Allowed tools: Read, LineCount, ListDir, Search, Recall. +- Allowed tools: Read, LineCount, List, Search, Recall. - Git is allowed only for readonly inspection: status, diff, log, show, rev-parse, ls-files, grep, blame. - Use only the provided readonly function tools. Do not request any other tools. - Use the smallest useful discovery batch. diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index a69902d..3ae35c9 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -3352,8 +3352,8 @@ def test_agent_warns_when_discovery_runs_long_without_plan(tmp_path, monkeypatch agent.blackboard.goal = "investigate" _set_context_budget(monkeypatch, agent, planless_discovery_tool_calls=2) - agent.handle_response({"actions": [{"type": "tool", "name": "ListDir", "intention": "inspect root", "args": ["."]}]}) - agent.handle_response({"actions": [{"type": "tool", "name": "ListDir", "intention": "inspect root again", "args": ["."]}]}) + agent.handle_response({"actions": [{"type": "tool", "name": "List", "intention": "inspect root", "args": ["."]}]}) + agent.handle_response({"actions": [{"type": "tool", "name": "List", "intention": "inspect root again", "args": ["."]}]}) assert any("Plan is empty after discovery" in error for error in agent.agent_feedback_errors) diff --git a/tests/test_nanocode_list_dir_tool.py b/tests/test_nanocode_list_tool.py similarity index 75% rename from tests/test_nanocode_list_dir_tool.py rename to tests/test_nanocode_list_tool.py index 89591c4..07a317d 100644 --- a/tests/test_nanocode_list_dir_tool.py +++ b/tests/test_nanocode_list_tool.py @@ -1,6 +1,6 @@ import pytest -from nanocode import ListDirTool, Session, ToolCallError +from nanocode import ListTool, Session, ToolCallError def test_list_dir_tool_lists_filtered_entries_relative_to_cwd(tmp_path): @@ -10,14 +10,14 @@ def test_list_dir_tool_lists_filtered_entries_relative_to_cwd(tmp_path): (src / "notes.md").write_text("notes\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = ListDirTool.make(session, ["src", "*.py"]) + tool = ListTool.make(session, ["src", "*.py"]) assert tool.requires_confirmation(session) is False assert tool.call() == "\n".join( [ - "", + "", "* (file): src/app.py", - "", + "", ] ) @@ -29,16 +29,16 @@ def test_list_dir_tool_sorts_dirs_before_files_then_by_name(tmp_path): (tmp_path / "a_dir").mkdir() session = Session(cwd=str(tmp_path)) - result = ListDirTool.make(session, ["."]).call() + result = ListTool.make(session, ["."]).call() assert result == "\n".join( [ - "", + "", "* (dir): a_dir", "* (dir): z_dir", "* (file): a.txt", "* (file): b.txt", - "", + "", ] ) @@ -47,13 +47,13 @@ def test_list_dir_tool_defaults_to_cwd(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - result = ListDirTool.make(session, []).call() + result = ListTool.make(session, []).call() assert result == "\n".join( [ - "", + "", "* (file): sample.txt", - "", + "", ] ) @@ -63,7 +63,7 @@ def test_list_dir_tool_rejects_non_directory(tmp_path): path.write_text("alpha\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = ListDirTool.make(session, ["sample.txt"]) + tool = ListTool.make(session, ["sample.txt"]) with pytest.raises(ToolCallError, match="not a directory"): tool.call() From 6825e38d98a1837d0b497e47150ae09241add3bd Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 10:49:10 -0700 Subject: [PATCH 053/144] Prevent repeated recalls for consumed tool results --- nanocode.py | 48 +++++++++++++++++++++++++++++++ tests/test_nanocode_agent.py | 56 ++++++++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+) diff --git a/nanocode.py b/nanocode.py index d7ac585..32403f6 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1389,6 +1389,7 @@ def _bound_tool_output(output: str, *, log_path: str = "", max_chars: int = MAX_ RESULT_KEY_PATTERN: re.Pattern[str] = re.compile(r"\b(?:(?:result_)?key|recall)[:=]\s*(tr\.\d+)\b") +TOOL_RESULT_KEY_REF_PATTERN: re.Pattern[str] = re.compile(r"\btr\.\d+\b") def _format_tool_call_summary(call: ParsedToolCall) -> str: @@ -1598,6 +1599,15 @@ def forget_result_keys_from_actions(actions: list[Json]) -> list[str]: keys.extend(key for key in _source_from_json(action) if key.startswith("tr.")) return list(dict.fromkeys(keys)) + @staticmethod + def referenced_result_keys_from_actions(actions: list[Json]) -> list[str]: + keys: list[str] = [] + for action in actions: + if _json_str(action.get("type")) == "tool": + continue + keys.extend(TOOL_RESULT_KEY_REF_PATTERN.findall(json.dumps(action, ensure_ascii=False))) + return list(dict.fromkeys(keys)) + ConfirmationResult: TypeAlias = bool | str ConfirmCallback: TypeAlias = Callable[[ParsedToolCall, Tool], ConfirmationResult] @@ -3657,6 +3667,9 @@ def _state_tool_schema(name: str) -> Json: --- Current Decision --- +Unconsumed Tool Results: +{unconsumed_tool_results} + Recent Edits: {recent_edits} @@ -3701,6 +3714,7 @@ def _state_tool_schema(name: str) -> Json: - Do not rewrite Goal/Plan just to answer a side question or acknowledge a correction. If Current Phase is working or verifying, continue from the existing Goal and Plan unless the user changed the task. If Current Phase is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. +Before repeating or broadening tool calls, summarize unconsumed tr.* keys into state or forget them. Prefer citing tr.* sources; do not Recall the same key again after summarizing it. --- Output --- @@ -5429,6 +5443,7 @@ def __init__(self, session: Session): self.blackboard: Blackboard = Blackboard() self.recent_edits: list[str] = [] self.tool_context = ToolResultContext() + self.unconsumed_tool_result_keys: list[str] = [] self.model_client = ModelClient(session) self.tool_runner = ToolCallRunner(session, self._protected_tool_result_keys) self.state_updater = AgentStateUpdater(session, self.blackboard) @@ -5465,6 +5480,7 @@ def build_user_prompt(self) -> str: tool_result_index=tool_result_index or "(empty)", unreduced_tool_results=unreduced_tool_results or "(empty)", latest_tool_results=latest_tool_results or "(empty)", + unconsumed_tool_results=self._format_unconsumed_tool_results(), task_code=current.task_code, work_mode=current.work_mode, goal=current.goal or "(empty)", @@ -5486,6 +5502,14 @@ def _format_current_focus(self) -> str: ) return item.format() if item else "(empty)" + def _format_unconsumed_tool_results(self) -> str: + keys = [key for key in self.unconsumed_tool_result_keys if key in self.session.state.tool_result_store] + if len(keys) != len(self.unconsumed_tool_result_keys): + self.unconsumed_tool_result_keys = keys + if not keys: + return "(empty)" + return "\n".join(self.session.state.tool_result_store[key].format(result_key=key) for key in keys) + def build_observe_prompt(self) -> str: current = self.blackboard unreduced = "\n\n".join(self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter)) @@ -5701,6 +5725,7 @@ def _prune_tool_result_store(self) -> None: def _protected_tool_result_keys(self) -> set[str]: keys = self.blackboard.source_result_keys() + keys.update(self.unconsumed_tool_result_keys) keys.update(ToolResultContext.blocks_by_key(self.tool_context.kept_results)) return keys @@ -5909,11 +5934,14 @@ def apply_response(self, response: Json) -> list[str]: actions = self._response_actions(response) if self._goal_changes_task(actions): self.tool_context.kept_results = [] + self.unconsumed_tool_result_keys = [] self.tool_context.compact_observed(self.tool_context.recent + self.tool_context.latest) self._mark_memory_checkpoint() self.blackboard.hypotheses = [] self.state_updater.apply(response) forgotten = self.tool_context.forget_results(ToolResultContext.forget_result_keys_from_actions(actions)) + consumed = ToolResultContext.referenced_result_keys_from_actions(actions) + forgotten + self._consume_tool_results(consumed or (self.unconsumed_tool_result_keys if self._has_result_consuming_state_action(actions) else [])) if self.mode != AgentMode.OBSERVE and self._has_memory_update_action(actions): self._mark_memory_checkpoint() return forgotten @@ -5946,6 +5974,13 @@ def _has_memory_update_action(self, actions: list[Json]) -> bool: return True return False + def _has_result_consuming_state_action(self, actions: list[Json]) -> bool: + return any( + _json_str(action.get("type")) in {"goal", "plan", "known", "hypothesis", "stable_knowledge", "verify", "forget"} + and not self._is_pending_verify_action(action) + for action in actions + ) + def execute_tool_calls( self, tool_calls: list[JsonValue], @@ -5963,10 +5998,23 @@ def execute_tool_calls( self.session.state.session_tool_calls += len(self.tool_runner.latest_executions) for execution in self.tool_runner.latest_executions: self._after_tool_execution(execution) + self._add_unconsumed_tool_results(execution.result_key for execution in self.tool_runner.latest_executions) if self._should_observe_after_tools(): self.mode = AgentMode.OBSERVE return "\n\n".join(self.tool_context.latest) + def _add_unconsumed_tool_results(self, keys: Iterable[str]) -> None: + seen = set(self.unconsumed_tool_result_keys) + for key in keys: + if key and key not in seen: + self.unconsumed_tool_result_keys.append(key) + seen.add(key) + + def _consume_tool_results(self, keys: Iterable[str]) -> None: + consumed = set(keys) + if consumed: + self.unconsumed_tool_result_keys = [key for key in self.unconsumed_tool_result_keys if key not in consumed] + def _should_observe_after_tools(self) -> bool: pending = self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter) if not pending: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 3ae35c9..a9fb884 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -168,6 +168,58 @@ def test_agent_tool_results_go_to_latest_tool_results_and_store(tmp_path): assert os.path.isdir(session.tool_results_dir()) +def test_agent_tracks_unconsumed_tool_results_until_state_references_them(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\n", encoding="utf-8") + agent = Agent(Session(cwd=str(tmp_path))) + + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) + + assert agent.unconsumed_tool_result_keys == ["tr.1"] + prompt = agent.build_user_prompt() + assert "Unconsumed Tool Results:" in prompt + assert "- result_key: tr.1" in prompt + assert "read sample" in prompt + + agent.handle_response({"actions": [{"type": "known", "items": [{"source": ["tr.1"], "text": "sample contains alpha"}]}]}) + + assert agent.unconsumed_tool_result_keys == [] + assert "Unconsumed Tool Results:\n(empty)" in agent.build_user_prompt() + + +def test_agent_tool_actions_do_not_consume_unconsumed_tool_results(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\n", encoding="utf-8") + agent = Agent(Session(cwd=str(tmp_path))) + + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) + agent.handle_response({"actions": [{"type": "tool", "name": "Recall", "intention": "read full sample", "args": ["tr.1"]}]}) + + assert agent.unconsumed_tool_result_keys == ["tr.1"] + + +def test_agent_state_update_without_sources_consumes_unconsumed_tool_results(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\n", encoding="utf-8") + agent = Agent(Session(cwd=str(tmp_path))) + + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) + agent.handle_response({"actions": [{"type": "known", "items": [{"text": "sample contains alpha"}]}]}) + + assert agent.unconsumed_tool_result_keys == [] + + +def test_agent_forget_consumes_unconsumed_tool_result(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\n", encoding="utf-8") + agent = Agent(Session(cwd=str(tmp_path))) + + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) + agent.handle_response({"actions": [{"type": "forget", "source": ["tr.1"], "reason": "not needed"}]}) + + assert agent.unconsumed_tool_result_keys == [] + + def test_agent_dedupes_same_batch_readonly_tool_calls_keeping_latest(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\n", encoding="utf-8") @@ -2225,6 +2277,7 @@ def test_new_goal_clears_task_local_kept_results_only(tmp_path): agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] agent.tool_context.latest = ['- ok tool=Read args=["latest.py"] key=tr.3\n output:\nlatest raw'] agent.tool_context.recent = ['- ok tool=Read args=["recent.py"] key=tr.4\n out: 3 lines, 12 chars; recall=tr.4'] + agent.unconsumed_tool_result_keys = ["tr.1", "tr.3"] agent.apply_response( { @@ -2239,6 +2292,7 @@ def test_new_goal_clears_task_local_kept_results_only(tmp_path): ) assert agent.tool_context.kept_results == [] + assert agent.unconsumed_tool_result_keys == [] assert "latest.py" in _blocks_text(agent.tool_context.latest) assert "latest raw" not in _blocks_text(agent.tool_context.latest) assert "recent.py" in _blocks_text(agent.tool_context.recent) @@ -2249,6 +2303,7 @@ def test_same_goal_keeps_task_local_tool_results(tmp_path): agent.blackboard.goal = "same goal" agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] agent.tool_context.latest = ['- ok tool=Read args=["new.py"] key=tr.2\n output:\npending raw'] + agent.unconsumed_tool_result_keys = ["tr.2"] agent.apply_response( { @@ -2264,6 +2319,7 @@ def test_same_goal_keeps_task_local_tool_results(tmp_path): assert "selected result" in _blocks_text(agent.tool_context.kept_results) assert "pending raw" in _blocks_text(agent.tool_context.latest) + assert agent.unconsumed_tool_result_keys == [] def test_agent_state_report_does_not_repeat_goal_for_restarted_task_when_text_matches(tmp_path): From 8b67418354b67d4105e11b3fe514ec7bc489705a Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 10:50:49 -0700 Subject: [PATCH 054/144] Clarify git commit scope for tool usage --- nanocode.py | 1 + 1 file changed, 1 insertion(+) diff --git a/nanocode.py b/nanocode.py index 32403f6..3f24f05 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3072,6 +3072,7 @@ class GitTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run git without a shell for repository state, history, status, diff, and changed files.", "Pass each git argument separately; optional first arg cwd=path changes repository directory.", + "By default, stage/commit only files changed for the current task; include unrelated dirty files only when the user explicitly asks.", ) SIGNATURE: ClassVar[str] = "Git([cwd=path,] git_arg...) -> GitToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( From 1cd791beee39849dc8969b851ee4597f87cc5e3d Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 10:53:59 -0700 Subject: [PATCH 055/144] Prefer dedicated tools over bash for repository inspection --- nanocode.py | 3 ++- tests/test_nanocode_agent.py | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/nanocode.py b/nanocode.py index 3f24f05..14bd4be 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2897,7 +2897,7 @@ class BashTool(Tool): NAME: ClassVar[str] = "Bash" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run one explicit shell command via bash -lc in cwd.", - "Use for tests, builds, and fast Unix text-tool work such as find, sed, awk, perl, xargs, and grep when that is the clearest path.", + "Prefer List/Search/Read/Git for repository inspection; use Bash for tests, builds, and fast Unix text-tool work such as find, sed, awk, perl, xargs, and grep when that is the clearest path.", "Mechanical shell edits are allowed, but verify afterward with Git diff, Read, tests, or another focused check.", ) SIGNATURE: ClassVar[str] = "Bash(command) -> BashToolResult" @@ -3467,6 +3467,7 @@ def _state_tool_schema(name: str) -> Json: TOOLS Prefer dedicated tools for precise file reads/searches and structured edits. +Prefer List/Search/Read/Git for repository inspection. Do not use Bash just to list files or inspect git state. Use Bash for explicit shell commands, tests/builds, and fast Unix text-tool work: find, sed, awk, perl, xargs, grep. Mechanical shell edits are allowed; verify afterward with Git diff, Read, tests, or another focused check. For complex code changes, prefer ReplaceRange or PatchFile over shell rewrites. diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index a9fb884..7d900f5 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -531,6 +531,7 @@ def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): prompt = agent._system_prompt() + assert "Do not use Bash just to list files or inspect git state." in prompt assert "find, sed, awk, perl, xargs, grep" in prompt assert "Mechanical shell edits are allowed" in prompt assert "verify afterward" in prompt From aa7306183a4af6baf2666add8e26b5921494fda2 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 10:55:47 -0700 Subject: [PATCH 056/144] Revert specialized bash inspection guidance --- nanocode.py | 3 +-- tests/test_nanocode_agent.py | 1 - 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/nanocode.py b/nanocode.py index 14bd4be..3f24f05 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2897,7 +2897,7 @@ class BashTool(Tool): NAME: ClassVar[str] = "Bash" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run one explicit shell command via bash -lc in cwd.", - "Prefer List/Search/Read/Git for repository inspection; use Bash for tests, builds, and fast Unix text-tool work such as find, sed, awk, perl, xargs, and grep when that is the clearest path.", + "Use for tests, builds, and fast Unix text-tool work such as find, sed, awk, perl, xargs, and grep when that is the clearest path.", "Mechanical shell edits are allowed, but verify afterward with Git diff, Read, tests, or another focused check.", ) SIGNATURE: ClassVar[str] = "Bash(command) -> BashToolResult" @@ -3467,7 +3467,6 @@ def _state_tool_schema(name: str) -> Json: TOOLS Prefer dedicated tools for precise file reads/searches and structured edits. -Prefer List/Search/Read/Git for repository inspection. Do not use Bash just to list files or inspect git state. Use Bash for explicit shell commands, tests/builds, and fast Unix text-tool work: find, sed, awk, perl, xargs, grep. Mechanical shell edits are allowed; verify afterward with Git diff, Read, tests, or another focused check. For complex code changes, prefer ReplaceRange or PatchFile over shell rewrites. diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 7d900f5..a9fb884 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -531,7 +531,6 @@ def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): prompt = agent._system_prompt() - assert "Do not use Bash just to list files or inspect git state." in prompt assert "find, sed, awk, perl, xargs, grep" in prompt assert "Mechanical shell edits are allowed" in prompt assert "verify afterward" in prompt From 7cd257c80e6bc3364437c40f62944383f1962dd8 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 11:01:37 -0700 Subject: [PATCH 057/144] Generalize bash guidance and one-shot text completion --- nanocode.py | 9 ++++++--- tests/test_nanocode_agent.py | 28 +++++++++++++++++++++++++++- 2 files changed, 33 insertions(+), 4 deletions(-) diff --git a/nanocode.py b/nanocode.py index 3f24f05..d19e9ec 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2897,7 +2897,8 @@ class BashTool(Tool): NAME: ClassVar[str] = "Bash" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run one explicit shell command via bash -lc in cwd.", - "Use for tests, builds, and fast Unix text-tool work such as find, sed, awk, perl, xargs, and grep when that is the clearest path.", + "Prefer dedicated tools when they provide structured repo access; use Bash when shell semantics or pipelines are the clearest path.", + "Good Bash uses include tests, builds, and Unix text-tool pipelines with find, sed, awk, perl, xargs, or grep.", "Mechanical shell edits are allowed, but verify afterward with Git diff, Read, tests, or another focused check.", ) SIGNATURE: ClassVar[str] = "Bash(command) -> BashToolResult" @@ -3467,7 +3468,8 @@ def _state_tool_schema(name: str) -> Json: TOOLS Prefer dedicated tools for precise file reads/searches and structured edits. -Use Bash for explicit shell commands, tests/builds, and fast Unix text-tool work: find, sed, awk, perl, xargs, grep. +Bash is for shell semantics: tests/builds, explicit commands, and fast Unix text-tool pipelines with find, sed, awk, perl, xargs, or grep. +Prefer dedicated tools when they give cleaner structured repo access. Mechanical shell edits are allowed; verify afterward with Git diff, Read, tests, or another focused check. For complex code changes, prefer ReplaceRange or PatchFile over shell rewrites. @@ -6326,7 +6328,8 @@ def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallbac self.session.append_conversation(AssistantMessage(content=ctx.assistant_text)) if on_message is not None: on_message(ctx.assistant_text) - if self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start: + active_task = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) + if active_task and (self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start): return AgentRunResult() if self.blackboard.verification_required or self.blackboard.verification.status == VerificationStatus.REQUIRED: self._warn_agent("assistant text cannot finish while verification is required.", self.RULE_VERIFY_DIRECTLY) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index a9fb884..6c179a1 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -531,7 +531,10 @@ def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): prompt = agent._system_prompt() - assert "find, sed, awk, perl, xargs, grep" in prompt + assert "Bash is for shell semantics" in prompt + for name in ("find", "sed", "awk", "perl", "xargs", "grep"): + assert name in prompt + assert "structured repo access" in prompt assert "Mechanical shell edits are allowed" in prompt assert "verify afterward" in prompt @@ -3697,6 +3700,29 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert session.state.conversation[-1].content == "hello" +def test_agent_run_allows_assistant_text_after_one_shot_tool_without_goal(tmp_path): + class FakeModelClient: + def __init__(self): + self.responses = [ + {"actions": [{"type": "tool", "name": "List", "intention": "list current directory", "args": []}]}, + {"actions": [], "_assistant_text": "listed files"}, + ] + + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): + return self.responses.pop(0) + + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + agent.model_client = FakeModelClient() + messages = [] + + response = agent.run("ls", on_message=messages.append) + + assert response == {"actions": [], "_assistant_text": "listed files"} + assert messages[-1] == "listed files" + assert agent.blackboard.task_code == nanocode.TaskCode.DONE + + def test_agent_run_treats_assistant_text_as_progress_with_unfinished_task_context(tmp_path): class FakeModelClient: def __init__(self): From f4c3cd9301514160e9727ce4431c12887c1b931a Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 11:39:24 -0700 Subject: [PATCH 058/144] Simplify tool result handling and catch action format errors --- nanocode.py | 98 +++++--------------------- tests/test_nanocode_agent.py | 130 ++++++++++++++--------------------- 2 files changed, 69 insertions(+), 159 deletions(-) diff --git a/nanocode.py b/nanocode.py index d19e9ec..bc200f3 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1599,16 +1599,6 @@ def forget_result_keys_from_actions(actions: list[Json]) -> list[str]: keys.extend(key for key in _source_from_json(action) if key.startswith("tr.")) return list(dict.fromkeys(keys)) - @staticmethod - def referenced_result_keys_from_actions(actions: list[Json]) -> list[str]: - keys: list[str] = [] - for action in actions: - if _json_str(action.get("type")) == "tool": - continue - keys.extend(TOOL_RESULT_KEY_REF_PATTERN.findall(json.dumps(action, ensure_ascii=False))) - return list(dict.fromkeys(keys)) - - ConfirmationResult: TypeAlias = bool | str ConfirmCallback: TypeAlias = Callable[[ParsedToolCall, Tool], ConfirmationResult] ToolDisplayCallback: TypeAlias = Callable[[ParsedToolCall, Tool], None] @@ -3372,11 +3362,16 @@ def _state_tool_schema(name: str) -> Json: Tool Results: - visible tool results are temporary support context +- inspect visible results before deciding the next action - OBSERVE owns keep/forget cleanup -- ACT may forget irrelevant visible results only after preserving useful conclusions in goal, plan, known, hypothesis, or verify +- preserve useful conclusions in goal, plan, known, hypothesis, or verify; forget noise when it no longer helps WORKFLOW -If there is no Goal: +If the latest request is simple conversation or a one-shot lookup: +- answer directly, using tools first only when needed +- do not create Goal or Plan just to report the answer + +If there is no Goal and the request needs task tracking: - set a Goal - if enough context is known, also set a short Plan or call the first useful readonly tools @@ -3670,9 +3665,6 @@ def _state_tool_schema(name: str) -> Json: --- Current Decision --- -Unconsumed Tool Results: -{unconsumed_tool_results} - Recent Edits: {recent_edits} @@ -3717,7 +3709,7 @@ def _state_tool_schema(name: str) -> Json: - Do not rewrite Goal/Plan just to answer a side question or acknowledge a correction. If Current Phase is working or verifying, continue from the existing Goal and Plan unless the user changed the task. If Current Phase is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. -Before repeating or broadening tool calls, summarize unconsumed tr.* keys into state or forget them. Prefer citing tr.* sources; do not Recall the same key again after summarizing it. +Before repeating or broadening tool calls, inspect visible tool results and use them to update state, choose the next frontier, or forget noise. --- Output --- @@ -5446,7 +5438,6 @@ def __init__(self, session: Session): self.blackboard: Blackboard = Blackboard() self.recent_edits: list[str] = [] self.tool_context = ToolResultContext() - self.unconsumed_tool_result_keys: list[str] = [] self.model_client = ModelClient(session) self.tool_runner = ToolCallRunner(session, self._protected_tool_result_keys) self.state_updater = AgentStateUpdater(session, self.blackboard) @@ -5483,7 +5474,6 @@ def build_user_prompt(self) -> str: tool_result_index=tool_result_index or "(empty)", unreduced_tool_results=unreduced_tool_results or "(empty)", latest_tool_results=latest_tool_results or "(empty)", - unconsumed_tool_results=self._format_unconsumed_tool_results(), task_code=current.task_code, work_mode=current.work_mode, goal=current.goal or "(empty)", @@ -5505,14 +5495,6 @@ def _format_current_focus(self) -> str: ) return item.format() if item else "(empty)" - def _format_unconsumed_tool_results(self) -> str: - keys = [key for key in self.unconsumed_tool_result_keys if key in self.session.state.tool_result_store] - if len(keys) != len(self.unconsumed_tool_result_keys): - self.unconsumed_tool_result_keys = keys - if not keys: - return "(empty)" - return "\n".join(self.session.state.tool_result_store[key].format(result_key=key) for key in keys) - def build_observe_prompt(self) -> str: current = self.blackboard unreduced = "\n\n".join(self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter)) @@ -5728,7 +5710,6 @@ def _prune_tool_result_store(self) -> None: def _protected_tool_result_keys(self) -> set[str]: keys = self.blackboard.source_result_keys() - keys.update(self.unconsumed_tool_result_keys) keys.update(ToolResultContext.blocks_by_key(self.tool_context.kept_results)) return keys @@ -5937,14 +5918,11 @@ def apply_response(self, response: Json) -> list[str]: actions = self._response_actions(response) if self._goal_changes_task(actions): self.tool_context.kept_results = [] - self.unconsumed_tool_result_keys = [] self.tool_context.compact_observed(self.tool_context.recent + self.tool_context.latest) self._mark_memory_checkpoint() self.blackboard.hypotheses = [] self.state_updater.apply(response) forgotten = self.tool_context.forget_results(ToolResultContext.forget_result_keys_from_actions(actions)) - consumed = ToolResultContext.referenced_result_keys_from_actions(actions) + forgotten - self._consume_tool_results(consumed or (self.unconsumed_tool_result_keys if self._has_result_consuming_state_action(actions) else [])) if self.mode != AgentMode.OBSERVE and self._has_memory_update_action(actions): self._mark_memory_checkpoint() return forgotten @@ -5977,13 +5955,6 @@ def _has_memory_update_action(self, actions: list[Json]) -> bool: return True return False - def _has_result_consuming_state_action(self, actions: list[Json]) -> bool: - return any( - _json_str(action.get("type")) in {"goal", "plan", "known", "hypothesis", "stable_knowledge", "verify", "forget"} - and not self._is_pending_verify_action(action) - for action in actions - ) - def execute_tool_calls( self, tool_calls: list[JsonValue], @@ -6001,23 +5972,10 @@ def execute_tool_calls( self.session.state.session_tool_calls += len(self.tool_runner.latest_executions) for execution in self.tool_runner.latest_executions: self._after_tool_execution(execution) - self._add_unconsumed_tool_results(execution.result_key for execution in self.tool_runner.latest_executions) if self._should_observe_after_tools(): self.mode = AgentMode.OBSERVE return "\n\n".join(self.tool_context.latest) - def _add_unconsumed_tool_results(self, keys: Iterable[str]) -> None: - seen = set(self.unconsumed_tool_result_keys) - for key in keys: - if key and key not in seen: - self.unconsumed_tool_result_keys.append(key) - seen.add(key) - - def _consume_tool_results(self, keys: Iterable[str]) -> None: - consumed = set(keys) - if consumed: - self.unconsumed_tool_result_keys = [key for key in self.unconsumed_tool_result_keys if key not in consumed] - def _should_observe_after_tools(self) -> bool: pending = self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter) if not pending: @@ -6115,8 +6073,13 @@ def _invalid_action_response(self, response: Json, reason: str) -> Json: } def _validate_action_response(self, response: Json) -> Json | None: - if not isinstance(response.get("actions"), list): + actions = response.get("actions") + if not isinstance(actions, list): return self._invalid_action_response(response, "expected actions array") + action_errors = [_json_str(action.get("_format_error")) for action in (_json_dict(item) for item in actions)] + action_errors = [error for error in action_errors if error] + if action_errors: + return self._invalid_action_response(response, "; ".join(action_errors)) extra_keys = sorted(str(key) for key in response.keys() if key not in {"actions", "_assistant_text"} and not str(key).startswith("_format_")) if extra_keys: return self._invalid_action_response(response, "unexpected top-level keys: " + ", ".join(extra_keys)) @@ -6331,10 +6294,6 @@ def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallbac active_task = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) if active_task and (self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start): return AgentRunResult() - if self.blackboard.verification_required or self.blackboard.verification.status == VerificationStatus.REQUIRED: - self._warn_agent("assistant text cannot finish while verification is required.", self.RULE_VERIFY_DIRECTLY) - self.blackboard.task_code = TaskCode.VERIFYING - return AgentRunResult() self.blackboard.task_code = TaskCode.DONE return AgentRunResult(done=True, value=ctx.response) @@ -6630,25 +6589,11 @@ def _finish_or_continue(self, ctx: ResponseContext, on_message: MessageCallback def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: if self.blackboard.verification.status == VerificationStatus.REQUIRED: if self.blackboard.verification_required: - return self._reject_completion( - on_message, - self._error("edited files need verification before completion.", self.RULE_VERIFY_DIRECTLY), - "Retrying: verify edited files before completion.", - "Verification_Gate: edit completion requires verification.", - ) - return self._reject_completion( - on_message, - self._error("verification required before completion.", self.RULE_VERIFY_DIRECTLY), - "Retrying: verification is required before completion.", - "Verification_Gate: retrying until verification is passed or blocked.", - ) + self._warn_agent("edited files need verification before completion.", self.RULE_VERIFY_DIRECTLY) + else: + self._warn_agent("verification required before completion.", self.RULE_VERIFY_DIRECTLY) if self.blackboard.verification.status == VerificationStatus.FAILED and self.blackboard.goal_reached: - return self._reject_completion( - on_message, - self._error("verification failed; fix the reported issue first."), - "Retrying: verification failed; fix the reported issue first.", - "Verification_Gate: verification failed; fix before completion.", - ) + self._warn_agent("verification failed; fix the reported issue first.") completion_plan_error = self._completion_plan_error(ctx) if completion_plan_error: return self._reject_completion( @@ -6659,12 +6604,7 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N ) blocked_completion_error = self._blocked_verification_completion_error() if blocked_completion_error: - return self._reject_completion( - on_message, - self._error("blocked verification completion invalid: " + blocked_completion_error + ".", self.RULE_BLOCKED_BY_USER), - "Retrying: blocked verification needs blocker=user.", - "Verification_Gate: " + blocked_completion_error + ".", - ) + self._warn_agent("blocked verification completion invalid: " + blocked_completion_error + ".", self.RULE_BLOCKED_BY_USER) investigate_completion_error = self._investigate_completion_error() if investigate_completion_error: return self._reject_completion( diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 6c179a1..b23cbf4 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -168,58 +168,6 @@ def test_agent_tool_results_go_to_latest_tool_results_and_store(tmp_path): assert os.path.isdir(session.tool_results_dir()) -def test_agent_tracks_unconsumed_tool_results_until_state_references_them(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - agent = Agent(Session(cwd=str(tmp_path))) - - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) - - assert agent.unconsumed_tool_result_keys == ["tr.1"] - prompt = agent.build_user_prompt() - assert "Unconsumed Tool Results:" in prompt - assert "- result_key: tr.1" in prompt - assert "read sample" in prompt - - agent.handle_response({"actions": [{"type": "known", "items": [{"source": ["tr.1"], "text": "sample contains alpha"}]}]}) - - assert agent.unconsumed_tool_result_keys == [] - assert "Unconsumed Tool Results:\n(empty)" in agent.build_user_prompt() - - -def test_agent_tool_actions_do_not_consume_unconsumed_tool_results(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - agent = Agent(Session(cwd=str(tmp_path))) - - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) - agent.handle_response({"actions": [{"type": "tool", "name": "Recall", "intention": "read full sample", "args": ["tr.1"]}]}) - - assert agent.unconsumed_tool_result_keys == ["tr.1"] - - -def test_agent_state_update_without_sources_consumes_unconsumed_tool_results(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - agent = Agent(Session(cwd=str(tmp_path))) - - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) - agent.handle_response({"actions": [{"type": "known", "items": [{"text": "sample contains alpha"}]}]}) - - assert agent.unconsumed_tool_result_keys == [] - - -def test_agent_forget_consumes_unconsumed_tool_result(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - agent = Agent(Session(cwd=str(tmp_path))) - - agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) - agent.handle_response({"actions": [{"type": "forget", "source": ["tr.1"], "reason": "not needed"}]}) - - assert agent.unconsumed_tool_result_keys == [] - - def test_agent_dedupes_same_batch_readonly_tool_calls_keeping_latest(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\n", encoding="utf-8") @@ -526,6 +474,16 @@ def test_act_prompt_tells_model_to_reply_to_pending_feedback_first(tmp_path): assert "pending-feedback replies" in prompt +def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + + prompt = agent._system_prompt() + + assert "simple conversation or a one-shot lookup" in prompt + assert "do not create Goal or Plan just to report the answer" in prompt + assert "inspect visible results before deciding the next action" in prompt + + def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) @@ -2280,7 +2238,6 @@ def test_new_goal_clears_task_local_kept_results_only(tmp_path): agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] agent.tool_context.latest = ['- ok tool=Read args=["latest.py"] key=tr.3\n output:\nlatest raw'] agent.tool_context.recent = ['- ok tool=Read args=["recent.py"] key=tr.4\n out: 3 lines, 12 chars; recall=tr.4'] - agent.unconsumed_tool_result_keys = ["tr.1", "tr.3"] agent.apply_response( { @@ -2295,7 +2252,6 @@ def test_new_goal_clears_task_local_kept_results_only(tmp_path): ) assert agent.tool_context.kept_results == [] - assert agent.unconsumed_tool_result_keys == [] assert "latest.py" in _blocks_text(agent.tool_context.latest) assert "latest raw" not in _blocks_text(agent.tool_context.latest) assert "recent.py" in _blocks_text(agent.tool_context.recent) @@ -2306,7 +2262,6 @@ def test_same_goal_keeps_task_local_tool_results(tmp_path): agent.blackboard.goal = "same goal" agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] agent.tool_context.latest = ['- ok tool=Read args=["new.py"] key=tr.2\n output:\npending raw'] - agent.unconsumed_tool_result_keys = ["tr.2"] agent.apply_response( { @@ -2322,7 +2277,6 @@ def test_same_goal_keeps_task_local_tool_results(tmp_path): assert "selected result" in _blocks_text(agent.tool_context.kept_results) assert "pending raw" in _blocks_text(agent.tool_context.latest) - assert agent.unconsumed_tool_result_keys == [] def test_agent_state_report_does_not_repeat_goal_for_restarted_task_when_text_matches(tmp_path): @@ -2909,14 +2863,6 @@ def __init__(self): }, {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, {"actions": [{"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}]}, - {"actions": [{"type": "tool", "name": "Read", "intention": "inspect changed sample", "args": ["sample.txt", "0,1"]}]}, - {"actions": [{"type": "keep", "source": ["tr.2"], "reason": "keep useful result"}]}, - { - "actions": [ - {"type": "verify", "kind": "change_check", "method": "Read sample.txt", "criteria": ["sample text is new"], "status": "passed", "context": "sample.txt contains new"}, - {"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}, - ] - }, ] def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): @@ -2933,15 +2879,13 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert response["actions"][-1]["message_for_complete"] == "done" assert any(message.startswith("[success] Edit sample.txt") for message in messages) - assert any(message.startswith("[success] Read sample.txt") for message in messages) assert not any(message.startswith("State Updated") for message in messages) - assert agent.blackboard.verification.status == VerificationStatus.DONE - assert agent.blackboard.verification.context == "sample.txt contains new" + assert any("edited files need verification before completion" in error for error in agent.agent_feedback_errors) assert (tmp_path / "sample.txt").read_text(encoding="utf-8") == "new\n" assert messages[-1] == "done" -def test_agent_reports_edit_verification_gate_in_debug(tmp_path): +def test_agent_warns_but_allows_completion_when_verification_required(tmp_path): agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "change sample") agent.blackboard.goal_reached = True @@ -2952,11 +2896,14 @@ def test_agent_reports_edit_verification_gate_in_debug(tmp_path): result = agent._finish_or_continue(ctx, messages.append) - assert result.done is False - assert messages == ["Verification_Gate: edit completion requires verification."] + assert result.done is True + assert messages == ["done"] + assert agent.agent_feedback_errors == [ + 'Warning: edited files need verification before completion. Rule: run verification tools, then report verify status="passed"|"failed"|"blocked".' + ] -def test_agent_plain_text_cannot_finish_when_verification_required(tmp_path): +def test_agent_plain_text_can_finish_without_active_task_when_verification_required(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.blackboard.verification_required = True agent.blackboard.verification.status = VerificationStatus.REQUIRED @@ -2967,11 +2914,9 @@ def test_agent_plain_text_cannot_finish_when_verification_required(tmp_path): result = agent._handle_text_response(ctx, messages.append) assert result is not None - assert result.done is False - assert agent.blackboard.task_code == nanocode.TaskCode.VERIFYING - assert agent.agent_feedback_errors == [ - 'Warning: assistant text cannot finish while verification is required. Rule: run verification tools, then report verify status="passed"|"failed"|"blocked".' - ] + assert result.done is True + assert agent.blackboard.task_code == nanocode.TaskCode.DONE + assert agent.agent_feedback_errors == [] assert messages == ["Done."] @@ -3610,7 +3555,7 @@ def test_agent_allows_tool_after_reopening_completed_plan_without_context(tmp_pa assert any("Continuing tools after completed Plan" in error for error in agent.agent_feedback_errors) -def test_agent_blocks_verify_blocked_completion_without_manual_context(tmp_path): +def test_agent_warns_on_verify_blocked_completion_without_manual_context(tmp_path): agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "verify") messages = [] @@ -3625,9 +3570,9 @@ def test_agent_blocks_verify_blocked_completion_without_manual_context(tmp_path) on_message=messages.append, ) - assert result.done is False - assert messages[-1] == "Verification_Gate: verify blocked requires blocker=user before completion." - assert not agent.session.state.conversation + assert result.done is True + assert any("verify blocked requires blocker=user before completion" in error for error in agent.agent_feedback_errors) + assert messages[-1] == "done" def test_agent_allows_verify_blocked_completion_with_user_blocker(tmp_path): @@ -3936,6 +3881,31 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert messages[-1] == "done" +def test_agent_run_retries_action_level_format_error(tmp_path): + class FakeModelClient: + def __init__(self): + self.user_prompts = [] + self.responses = [ + {"actions": [{"type": "goal", "_format_error": "invalid tool arguments: bad json"}]}, + {"actions": _final_actions()}, + ] + + def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): + self.user_prompts.append(user_prompt) + return self.responses.pop(0) + + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + agent.model_client = FakeModelClient() + messages = [] + + response = agent.run("answer", on_message=messages.append) + + assert response["actions"][-1]["message_for_complete"] == "done" + assert len(agent.model_client.user_prompts) == 2 + assert agent.agent_feedback_errors + + def test_agent_feedback_survives_goal_complete_until_next_run(tmp_path): class FakeModelClient: def __init__(self): From 60863ea72d55ee3ea4a589353aff62533e6caa50 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 11:48:13 -0700 Subject: [PATCH 059/144] Clarify one-shot completion prompt rules --- nanocode.py | 14 +++++++++----- tests/test_nanocode_agent.py | 4 +++- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/nanocode.py b/nanocode.py index bc200f3..8d3a851 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3315,7 +3315,7 @@ def _state_tool_schema(name: str) -> Json: Use function tools to update state and work on the repository. Assistant text is optional. Do not answer with text when a useful tool call should be made. -A task is complete only after goal.complete=true is set. +Tracked tasks are complete only after goal.complete=true is set. Language rule: all user-facing assistant text MUST use the latest user language. This includes chat text, progress text, pending-feedback replies, direct responses, and message_for_complete. @@ -3368,8 +3368,9 @@ def _state_tool_schema(name: str) -> Json: WORKFLOW If the latest request is simple conversation or a one-shot lookup: -- answer directly, using tools first only when needed -- do not create Goal or Plan just to report the answer +- use tools only until the requested answer is visible +- then answer directly with assistant text and stop +- do not create Goal, Plan, or Known just to report the answer If there is no Goal and the request needs task tracking: - set a Goal @@ -3709,12 +3710,15 @@ def _state_tool_schema(name: str) -> Json: - Do not rewrite Goal/Plan just to answer a side question or acknowledge a correction. If Current Phase is working or verifying, continue from the existing Goal and Plan unless the user changed the task. If Current Phase is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. -Before repeating or broadening tool calls, inspect visible tool results and use them to update state, choose the next frontier, or forget noise. +Before repeating or broadening tool calls, inspect visible tool results. +If they already answer a one-shot request, answer directly instead of calling more tools. +Otherwise use them to update state, choose the next frontier, or forget noise. --- Output --- Use function tools for task state and repository actions. -Assistant text is optional; never use it instead of the next useful function tool. Goal completion still requires goal.complete=true. +For one-shot requests with no Goal or Plan, assistant text is the final answer once visible results answer the request. +For tracked tasks, assistant text is optional; never use it instead of the next useful function tool. Goal completion requires goal.complete=true. Language rule: every chat/progress/response text must use the latest user language, including pending-feedback replies and final answers. Do not switch to English when the latest user request is Chinese. diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index b23cbf4..5d1aba3 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -480,8 +480,10 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path): prompt = agent._system_prompt() assert "simple conversation or a one-shot lookup" in prompt - assert "do not create Goal or Plan just to report the answer" in prompt + assert "then answer directly with assistant text and stop" in prompt + assert "do not create Goal, Plan, or Known just to report the answer" in prompt assert "inspect visible results before deciding the next action" in prompt + assert "Tracked tasks are complete only after goal.complete=true is set" in prompt def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): From 5024acfabb738890cba913fcfa31aa1faa8f229d Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 22:07:59 -0700 Subject: [PATCH 060/144] Soften non-deterministic agent gates --- nanocode.py | 9 +-------- tests/test_nanocode_agent.py | 15 +++++++-------- 2 files changed, 8 insertions(+), 16 deletions(-) diff --git a/nanocode.py b/nanocode.py index 8d3a851..b26a8a6 100644 --- a/nanocode.py +++ b/nanocode.py @@ -6370,7 +6370,6 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N ) if self.blackboard.task_code != TaskCode.NEW and ctx.goal_will_change and not ctx.has_fresh_plan_action: self._warn_agent("rewrote Goal after the task was active.", "replace Plan when the task scope changes.") - self._drop_goal_rewrite_actions(ctx) if ctx.pending_verify_requested: self._warn_agent('ignored verify status="pending".', self.RULE_VERIFY_DIRECTLY) if self.session.state.pending_user_feedback and ctx.goal_will_change: @@ -6380,7 +6379,6 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): self._warn_agent("changed Goal without replacing Plan.", "replace Plan when the task scope changes.") - self._drop_goal_rewrite_actions(ctx) return False def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback | None) -> None: @@ -6611,12 +6609,7 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N self._warn_agent("blocked verification completion invalid: " + blocked_completion_error + ".", self.RULE_BLOCKED_BY_USER) investigate_completion_error = self._investigate_completion_error() if investigate_completion_error: - return self._reject_completion( - on_message, - self._error(investigate_completion_error + ".", "mark a hypothesis confirmed before completing."), - "Retrying: confirm a hypothesis before completing.", - "Completion_Gate: " + investigate_completion_error + ".", - ) + self._warn_agent(investigate_completion_error + ".", "mark a hypothesis confirmed when claiming a root cause.") completion_message = (ctx.completion_message or ctx.assistant_text or "Done.") if self.blackboard.goal_reached else "" plan_mode_completion_error = self._plan_mode_completion_error(completion_message) if self.blackboard.goal_reached else "" if plan_mode_completion_error: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 5d1aba3..c8a1cc4 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -3174,7 +3174,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert "previous task context is still present" in " ".join(agent.agent_feedback_errors) -def test_agent_run_ignores_goal_rewrite_after_task_is_working(tmp_path): +def test_agent_run_warns_on_goal_rewrite_after_task_is_working(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") class FakeModelClient: @@ -3211,7 +3211,6 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): response = agent.run("read sample") assert response["actions"][-1]["message_for_complete"] == "done" - assert agent.blackboard.goal == "read sample" assert [item.text for item in agent.blackboard.plan] == ["Read sample"] assert len(agent.tool_runner.latest_executions) == 1 assert "rewrote Goal after the task was active" in " ".join(agent.agent_feedback_errors) @@ -3243,7 +3242,7 @@ def test_agent_allows_plan_with_multiple_doing_items(tmp_path): assert agent.agent_feedback_errors == [] -def test_agent_ignores_goal_rewrite_after_task_is_working(tmp_path): +def test_agent_warns_but_keeps_goal_rewrite_after_task_is_working(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.blackboard.task_code = nanocode.TaskCode.WORKING agent.blackboard.goal = "read sample" @@ -3252,8 +3251,8 @@ def test_agent_ignores_goal_rewrite_after_task_is_working(tmp_path): result = agent.handle_response({"actions": [{"type": "goal", "text": "read sample again", "complete": False}]}) assert result.done is False - assert agent.blackboard.goal == "read sample" - assert [item.text for item in agent.blackboard.plan] == ["Read sample"] + assert agent.blackboard.goal == "read sample again" + assert agent.blackboard.plan == [] assert "rewrote Goal after the task was active" in " ".join(agent.agent_feedback_errors) @@ -3742,7 +3741,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert agent.blackboard.plan == [nanocode.PlanItem(id="p1", text="answer", status=nanocode.PlanStatus.DONE, context="answered")] -def test_investigate_completion_requires_root_cause_hypothesis(tmp_path): +def test_investigate_completion_without_root_cause_hypothesis_warns(tmp_path): agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "find bug") agent.blackboard.work_mode = nanocode.WorkMode.INVESTIGATE @@ -3758,10 +3757,10 @@ def test_investigate_completion_requires_root_cause_hypothesis(tmp_path): on_message=messages.append, ) - assert result.done is False + assert result.done is True assert agent.blackboard.goal_reached is False assert any("confirmed hypothesis" in error for error in agent.agent_feedback_errors) - assert messages[-1] == "Completion_Gate: investigate completion requires a confirmed hypothesis." + assert messages[-1] == "done" result = agent.handle_response( { From 5a2fde64eb23f0f9556a73441ac9af78214c27a4 Mon Sep 17 00:00:00 2001 From: hit9 Date: Mon, 18 May 2026 22:38:58 -0700 Subject: [PATCH 061/144] Clarify task shapes in agent prompt --- nanocode.py | 55 ++++++++++++++++++++++----------- tests/test_nanocode_agent.py | 59 +++++++++++++++++++++++++++++++++--- 2 files changed, 93 insertions(+), 21 deletions(-) diff --git a/nanocode.py b/nanocode.py index b26a8a6..a78abd9 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3344,6 +3344,23 @@ def _state_tool_schema(name: str) -> Json: Do not rewrite the Goal when Current Phase is working/verifying unless the user changed the task. Never repeat a previous completion as the answer. +TASK SHAPES +Chat: +- direct conversation, clarification, or explanation that needs no repository action +- answer with assistant text only +- do not use Goal, Plan, Known, or Verify + +One-shot: +- one bounded lookup/check/tool batch whose visible result answers the request +- call needed tools, then answer with assistant text and stop +- do not create Goal, Plan, Known, or Verify just to report the result + +Tracked task: +- multi-step work, edits, debugging, investigation, explicit verification, or work that may span turns +- set Goal; set Plan once enough context is known +- record Verify only after edits, explicit checks, or correctness-sensitive work +- complete with goal.complete=true + STATE Known: - settled current-task facts that matter after tool results disappear @@ -3367,12 +3384,16 @@ def _state_tool_schema(name: str) -> Json: - preserve useful conclusions in goal, plan, known, hypothesis, or verify; forget noise when it no longer helps WORKFLOW -If the latest request is simple conversation or a one-shot lookup: +Classify the latest request as Chat, One-shot, or Tracked task before deciding state tools. + +If the request is Chat: +- answer directly and stop + +If the request is One-shot: - use tools only until the requested answer is visible -- then answer directly with assistant text and stop -- do not create Goal, Plan, or Known just to report the answer +- answer directly and stop -If there is no Goal and the request needs task tracking: +If there is no Goal and the request is a Tracked task: - set a Goal - if enough context is known, also set a short Plan or call the first useful readonly tools @@ -3483,7 +3504,7 @@ def _state_tool_schema(name: str) -> Json: OUTPUT PROTOCOL - Use function tools for state updates and readonly repository actions. - Assistant text is optional; never use it instead of the next useful function tool. -- A completed plan-mode task still needs goal.complete=true. +- PLAN MODE is a tracked planning task; complete it with goal.complete=true. - Allowed state tools: goal, plan, hypothesis, known, stable_knowledge, verify. - Allowed repository tools: Read, LineCount, List, Search, Recall, and readonly Git. - Repository tool calls require intention and args. @@ -3717,8 +3738,9 @@ def _state_tool_schema(name: str) -> Json: --- Output --- Use function tools for task state and repository actions. -For one-shot requests with no Goal or Plan, assistant text is the final answer once visible results answer the request. -For tracked tasks, assistant text is optional; never use it instead of the next useful function tool. Goal completion requires goal.complete=true. +Chat: answer with assistant text only. +One-shot with no Goal or Plan: assistant text is the final answer once visible results answer the request. +Tracked task: assistant text is optional; never use it instead of the next useful function tool. Goal completion requires goal.complete=true. Language rule: every chat/progress/response text must use the latest user language, including pending-feedback replies and final answers. Do not switch to English when the latest user request is Chinese. @@ -5405,7 +5427,7 @@ class ResponseContext: has_plan_action: bool has_fresh_plan_action: bool has_user_rule_action: bool - has_non_readonly_tool_call: bool + has_edit_tool_call: bool has_state_update_action: bool state_or_work_requested: bool @@ -6227,16 +6249,15 @@ def _build_response_context(self, response: Json) -> ResponseContext: actions = [action for action in raw_actions if not self._is_pending_verify_action(action)] tool_calls = [action for action in actions if _json_str(action.get("type")) == "tool"] action_types = {_json_str(action.get("type")) for action in actions} - has_non_readonly_tool_call = False + has_edit_tool_call = False for value in tool_calls: try: call = self.tool_runner.parse_tool_call(value) except ToolCallArgError: - has_non_readonly_tool_call = True - break + continue tool_class = TOOL_REGISTRY.get(call.name) - if tool_class is None or tool_class.EFFECT != ToolEffect.READONLY: - has_non_readonly_tool_call = True + if tool_class is not None and tool_class.EFFECT == ToolEffect.EDIT: + has_edit_tool_call = True break goal_update = next( ( @@ -6279,7 +6300,7 @@ def _build_response_context(self, response: Json) -> ResponseContext: has_plan_action="plan" in action_types, has_fresh_plan_action=has_fresh_plan_action, has_user_rule_action="user_rule" in action_types, - has_non_readonly_tool_call=has_non_readonly_tool_call, + has_edit_tool_call=has_edit_tool_call, has_state_update_action=bool(action_types & {"goal", "plan", "known", "hypothesis", "stable_knowledge"}), state_or_work_requested=bool( tool_calls @@ -6375,9 +6396,9 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N if self.session.state.pending_user_feedback and ctx.goal_will_change: self._warn_agent("Pending User Feedback is not a new task by default.", "answer it without rewriting Goal unless the user explicitly replaces or cancels the task.") self._drop_goal_rewrite_actions(ctx) - if ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): + if ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested and (ctx.pending_verify_requested or ctx.has_edit_tool_call): self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) - if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): + if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or ctx.has_edit_tool_call): self._warn_agent("changed Goal without replacing Plan.", "replace Plan when the task scope changes.") return False @@ -6390,7 +6411,7 @@ def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback on_message(ctx.assistant_text) def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: - if ctx.plan_was_empty and not self.blackboard.plan and (ctx.pending_verify_requested or ctx.has_non_readonly_tool_call): + if ctx.plan_was_empty and not self.blackboard.plan and (ctx.pending_verify_requested or ctx.has_edit_tool_call): self._warn_agent("mutating work before Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ( ctx.plan_was_empty diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index c8a1cc4..0282199 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -479,13 +479,64 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path): prompt = agent._system_prompt() - assert "simple conversation or a one-shot lookup" in prompt - assert "then answer directly with assistant text and stop" in prompt - assert "do not create Goal, Plan, or Known just to report the answer" in prompt - assert "inspect visible results before deciding the next action" in prompt + assert "TASK SHAPES" in prompt + assert "Chat:" in prompt + assert "One-shot:" in prompt + assert "Tracked task:" in prompt + assert "Classify the latest request as Chat, One-shot, or Tracked task" in prompt + assert "call needed tools, then answer with assistant text and stop" in prompt + assert "do not create Goal, Plan, Known, or Verify just to report the result" in prompt + assert "record Verify only after edits, explicit checks, or correctness-sensitive work" in prompt assert "Tracked tasks are complete only after goal.complete=true is set" in prompt +def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + + prompt = agent.build_user_prompt() + + assert "Chat: answer with assistant text only." in prompt + assert "One-shot with no Goal or Plan: assistant text is the final answer" in prompt + assert "Tracked task: assistant text is optional" in prompt + assert "Goal completion requires goal.complete=true" in prompt + + +def test_one_shot_bash_does_not_require_goal_or_plan(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + + result = agent.handle_response( + { + "actions": [ + {"type": "tool", "name": "Bash", "intention": "run one-shot check", "args": ["printf ok"]} + ] + }, + confirm=lambda call, tool: True, + ) + + assert result.done is False + assert len(agent.tool_runner.latest_executions) == 1 + assert not any("mutating work before" in error for error in agent.agent_feedback_errors) + + +def test_edit_tool_without_goal_or_plan_warns(tmp_path): + (tmp_path / "sample.txt").write_text("old\n", encoding="utf-8") + agent = Agent(Session(cwd=str(tmp_path))) + + result = agent.handle_response( + { + "actions": [ + {"type": "tool", "name": "Edit", "intention": "edit sample", "args": ["sample.txt", "old", "new"]} + ] + }, + confirm=lambda call, tool: True, + ) + + assert result.done is False + assert (tmp_path / "sample.txt").read_text(encoding="utf-8") == "new\n" + assert any("mutating work before Goal/Plan was set" in error for error in agent.agent_feedback_errors) + assert any("mutating work before Plan was set" in error for error in agent.agent_feedback_errors) + + def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) From c156d5a33b07a6969ef5917aa543eb22d52dc86b Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 06:05:41 -0700 Subject: [PATCH 062/144] add optional CodeGraph integration --- README.md | 2 + design.md | 5 + nanocode.py | 266 +++++++++++++++++++++++++- tests/test_nanocode_agent.py | 23 +++ tests/test_nanocode_codegraph_tool.py | 100 ++++++++++ tests/test_nanocode_commands.py | 62 ++++++ tests/test_nanocode_loop.py | 3 + 7 files changed, 456 insertions(+), 5 deletions(-) create mode 100644 tests/test_nanocode_codegraph_tool.py diff --git a/README.md b/README.md index 9a02326..5c55f5e 100644 --- a/README.md +++ b/README.md @@ -80,6 +80,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Tools - File: `Read`, `LineCount`, `List`, `Search`. +- Codebase: `CodeGraph` when the local `codegraph` CLI is installed and initialized. - Edit: `Edit`, `ReplaceRange`. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. @@ -88,6 +89,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. - Info: `/help [question]`, `/status`, `/rules`, `/compact`. - Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/reason-payload [value]`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. +- CodeGraph: `/codegraph [status|sync|init|index]`. - Maintenance: `/clean`. - Exit: `/exit`, `/quit`. diff --git a/design.md b/design.md index 5766bf3..861920c 100644 --- a/design.md +++ b/design.md @@ -67,6 +67,7 @@ When the model outputs `goal` with a different current-task goal: ACT mode receives a working context: - goal, plan, hypotheses, verification +- environment, including whether local CodeGraph is available - Tool Result Index - Kept Tool Results - Unreduced Tool Results @@ -88,6 +89,10 @@ OBSERVE receives a smaller cleanup context: OBSERVE reduces tool-result noise before ACT continues. +Optional tools can be environment-gated. For example, CodeGraph is shown to the +model only when the local `codegraph` CLI exists and the current project has a +`.codegraph` index. + Context layout: Layout rules: diff --git a/nanocode.py b/nanocode.py index a78abd9..b15b20d 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2357,6 +2357,131 @@ def call(self) -> str: return self._call_python() +@dataclass +class CodeGraphTool(Tool): + NAME: ClassVar[str] = "CodeGraph" + MAX_NODES: ClassVar[int] = 40 + MAX_CODE_BLOCKS: ClassVar[int] = 8 + EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY + DESCRIPTION: ClassVar[tuple[str, ...]] = ( + "Use local CodeGraph for semantic codebase context, call-flow exploration, architecture questions, or impact analysis.", + "If paths is empty, builds AI-ready context for query; if paths is non-empty, reports affected tests/symbols/files.", + 'Returned code snippets are line-numbered as "line |code" location hints; use Read before exact edits.', + ) + SIGNATURE: ClassVar[str] = "CodeGraph(query[, paths]) -> CodeGraphToolResult" + EXAMPLE: ClassVar[tuple[str, ...]] = ( + 'Example args: ["How does tool execution work?"]', + 'Impact args: ["What is affected by these changes?", ["nanocode.py"]]', + ) + + query: str = "" + paths: list[str] = field(default_factory=list) + codegraph_path: str = "" + cwd: str = "" + timeout: int = 60 + + @classmethod + def cli_args(cls, args: list[JsonValue]) -> list[str]: + if len(args) == 2: + return [cls.cli_token(args[0]), str(len(_json_list(args[1])) or 1) + " paths"] + return [cls.cli_token(arg) for arg in args] + + @classmethod + def make(cls, session: Session, args: list[JsonValue]) -> Self: + if len(args) not in (1, 2): + raise ToolCallArgError("requires args: query[, paths]") + query = str(args[0]).strip() + if not query: + raise ToolCallArgError("query cannot be empty") + codegraph_path = shutil.which("codegraph") + if not codegraph_path: + raise ToolCallError("codegraph not found; install CodeGraph first") + paths = cls._paths_from_arg(session, args[1]) if len(args) == 2 else [] + return cls(query=query, paths=paths, codegraph_path=codegraph_path, cwd=session.cwd, timeout=session.settings.shell_timeout) + + @staticmethod + def _paths_from_arg(session: Session, value: JsonValue) -> list[str]: + raw_paths = _json_list(value) or ([value] if value else []) + paths = [] + for raw_path in raw_paths: + resolved = session.resolve_path(str(raw_path)) + if not session.is_path_in_cwd(resolved): + raise ToolCallError("path outside cwd: " + str(raw_path)) + paths.append(os.path.relpath(resolved, session.cwd)) + return paths + + def preview(self) -> str: + if self.paths: + return "CodeGraph(" + json.dumps(self.query, ensure_ascii=False) + ", " + json.dumps(self.paths, ensure_ascii=False) + ")" + return "CodeGraph(" + json.dumps(self.query, ensure_ascii=False) + ")" + + def call(self) -> str: + if not os.path.isdir(os.path.join(self.cwd, ".codegraph")): + raise ToolCallError("CodeGraph not initialized; run /codegraph init") + cmd = ( + [self.codegraph_path, "affected", "--path", self.cwd, *self.paths] + if self.paths + else [ + self.codegraph_path, + "context", + self.query, + "--path", + self.cwd, + "--max-nodes", + str(self.MAX_NODES), + "--max-code", + str(self.MAX_CODE_BLOCKS), + "--format", + "markdown", + ] + ) + try: + proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) + except subprocess.TimeoutExpired as error: + return self._format(-1, error.stdout or "", (error.stderr or "") + "timeout") + return self._format(proc.returncode, self._number_code_blocks(_clean_terminal_output(proc.stdout)), _clean_terminal_output(proc.stderr)) + + def _format(self, exit_code: int, stdout: str, stderr: str) -> str: + lines = ["", "* mode: " + ("impact" if self.paths else "context"), "* exit_code: " + str(exit_code)] + if stdout: + lines.extend(["", stdout.rstrip("\n"), ""]) + if stderr: + lines.extend(["", stderr.rstrip("\n"), ""]) + lines.append("") + return "\n".join(lines) + + @classmethod + def _number_code_blocks(cls, text: str) -> str: + heading_pattern = re.compile(r"^#### .+ \(([^():]+):(\d+)\)\s*$") + lines = text.splitlines(keepends=True) + numbered: list[str] = [] + pending_start: int | None = None + in_code_block = False + current_line = 0 + for line in lines: + heading = heading_pattern.match(line.rstrip("\n")) + if not in_code_block and heading: + try: + pending_start = int(heading.group(2)) + except ValueError: + pending_start = None + numbered.append(line) + continue + if line.startswith("```"): + in_code_block = not in_code_block + current_line = pending_start or 0 + numbered.append(line) + if not in_code_block: + pending_start = None + continue + if in_code_block and pending_start is not None: + numbered.append(f"{current_line:>7} |{line}") + current_line += 1 + continue + numbered.append(line) + return "".join(numbered) + + @dataclass class EditTool(Tool): NAME: ClassVar[str] = "Edit" @@ -3202,6 +3327,7 @@ def _content(self, item: ToolResultItem) -> str: LineCountTool.NAME: LineCountTool, ListTool.NAME: ListTool, SearchTool.NAME: SearchTool, + CodeGraphTool.NAME: CodeGraphTool, CreateFileTool.NAME: CreateFileTool, EditTool.NAME: EditTool, PatchFileTool.NAME: PatchFileTool, @@ -3210,7 +3336,7 @@ def _content(self, item: ToolResultItem) -> str: GitTool.NAME: GitTool, ToolResultTool.NAME: ToolResultTool, } -PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, SearchTool, PlanModeGitTool, ToolResultTool) +PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, SearchTool, CodeGraphTool, PlanModeGitTool, ToolResultTool) TOOL_STRING_SCHEMA: Json = {"type": "string"} @@ -3442,9 +3568,11 @@ def _state_tool_schema(name: str) -> Json: DISCOVERY AND EDITING Use Search/List/LineCount when path, symbol, range, or target is unknown. +When Environment says codegraph is available and CodeGraph is in available tools, use CodeGraph for semantic codebase context, call-flow exploration, architecture questions, or impact analysis. Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. Read line prefixes are display-only; edit text starts immediately after "|". +CodeGraph line prefixes are location hints; use Read before exact edits. Stop discovery once the next edit/check is clear. @@ -5491,7 +5619,14 @@ def build_user_prompt(self) -> str: current = self.blackboard conversation = self.session.state.conversation return AGENT_USER_PROMPT_TEMPLATE.format( - environment="\n".join(["- system: " + self.session.system, "- arch: " + self.session.arch, "- cwd: " + self.session.cwd]), + environment="\n".join( + [ + "- system: " + self.session.system, + "- arch: " + self.session.arch, + "- cwd: " + self.session.cwd, + "- codegraph: " + self._codegraph_status_label(), + ] + ), conversation_history="\n\n".join(item.format() for item in conversation) if conversation else "(empty)", user_rules=self.session.state.user_rules.format(), known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", @@ -5538,7 +5673,7 @@ def build_observe_prompt(self) -> str: ).strip() def _system_prompt(self, template: str | None = None, *, tools: Iterable[ToolClass] | None = None) -> str: - tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) + tool_classes = self._available_tool_classes(tools) return ( (template or AGENT_SYSTEM_PROMPT) .replace("{ __tool_names__ }", "|".join(tool.NAME for tool in tool_classes)) @@ -5546,6 +5681,22 @@ def _system_prompt(self, template: str | None = None, *, tools: Iterable[ToolCla .strip() ) + def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> tuple[ToolClass, ...]: + tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) + if self._codegraph_available(): + return tool_classes + return tuple(tool for tool in tool_classes if tool is not CodeGraphTool) + + def _codegraph_available(self) -> bool: + return bool(shutil.which("codegraph") and os.path.isdir(os.path.join(self.session.cwd, ".codegraph"))) + + def _codegraph_status_label(self) -> str: + if not shutil.which("codegraph"): + return "not installed" + if not os.path.isdir(os.path.join(self.session.cwd, ".codegraph")): + return "not initialized; run /codegraph init" + return "available" + def _format_user_request(self) -> str: user_request = self.blackboard.user_input or "(empty)" fence = "`" * max(3, max((len(match.group(0)) for match in re.finditer(r"`{3,}", user_request)), default=0) + 1) @@ -5840,10 +5991,10 @@ def _tool_schemas(self) -> list[Json]: tool_classes: Iterable[ToolClass] = () elif self.session.settings.plan_mode: action_names = self.PLAN_ACTION_TYPES - {"tool"} - tool_classes = PLAN_MODE_TOOLS + tool_classes = self._available_tool_classes(PLAN_MODE_TOOLS) else: action_names = self.ACT_ACTION_TYPES - {"tool"} - tool_classes = TOOL_REGISTRY.values() + tool_classes = self._available_tool_classes() actions = [_state_tool_schema(name) for name in STATE_TOOL_PARAMS if name in action_names] return actions + [tool.tool_schema() for tool in tool_classes] @@ -6805,6 +6956,7 @@ class CommandSpec: CommandSpec("/compact", "Compact conversation history", "Info", "/compact"), CommandSpec("/config", "Show resolved runtime config", "Config", "/config"), CommandSpec("/context", "Show or set context budget", "Config", "/context [low|medium|high]"), + CommandSpec("/codegraph", "Run CodeGraph maintenance", "Config", "/codegraph [status|sync|init|index]"), CommandSpec("/set", "Set a runtime config override", "Config", "/set "), CommandSpec("/api", "Show or set provider API format", "Config", "/api [auto|chat|responses]"), CommandSpec("/model", "Show or set model and reasoning", "Config", "/model [model_name]"), @@ -6873,6 +7025,7 @@ class CommandDispatcher: COMMAND_ALIASES = {"/context-budget": "/context", "/context_budget": "/context"} API_USAGE = "Usage: /api [auto|chat|responses]" REASON_PAYLOAD_USAGE = "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" + CODEGRAPH_USAGE = "Usage: /codegraph [status|sync|init|index]" def __init__( self, @@ -7160,6 +7313,81 @@ def _context(self, args: str) -> str: return "Set runtime.context_budget = " + value + "\n" + self._format_context_budget() return self._format_context_budget() + def _codegraph(self, args: str) -> str: + command = args.strip() + if command not in {"status", "sync", "init", "index"}: + return self.CODEGRAPH_USAGE + codegraph_path = shutil.which("codegraph") + if not codegraph_path: + return "codegraph not found; install CodeGraph first" + argv = { + "status": [codegraph_path, "status", "-j", "."], + "sync": [codegraph_path, "sync", "-q", "."], + "init": [codegraph_path, "init", ".", "--index"], + "index": [codegraph_path, "index", "-q", "."], + }[command] + return self._with_status(lambda: self._run_codegraph(command, argv)) + + def _run_codegraph(self, command: str, argv: list[str]) -> str: + try: + proc = subprocess.run( + argv, + cwd=self.agent.session.cwd, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + timeout=max(300, self.agent.session.settings.shell_timeout), + env=_plain_command_env(), + ) + return self._format_codegraph_command_result(command, proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) + except subprocess.TimeoutExpired as error: + return self._format_codegraph_command_result( + command, + -1, + _clean_terminal_output(error.stdout or ""), + _clean_terminal_output(error.stderr or "") + "timeout", + ) + + def _format_codegraph_command_result(self, command: str, exit_code: int, stdout: str, stderr: str) -> str: + if command == "status" and exit_code == 0: + return self._format_codegraph_status(stdout) + if exit_code == 0: + detail = stdout or stderr + return "CodeGraph " + command + " completed." + ("\n" + detail if detail else "") + lines = ["CodeGraph " + command + " failed (exit " + str(exit_code) + ")."] + if stderr: + lines.append(stderr) + if stdout: + lines.append(stdout) + return "\n".join(lines) + + def _format_codegraph_status(self, stdout: str) -> str: + try: + data = json.loads(stdout) + except json.JSONDecodeError: + return stdout or "CodeGraph status unavailable." + pending = _json_dict(data.get("pendingChanges")) + return "\n".join( + [ + "CodeGraph: " + ("initialized" if data.get("initialized") else "not initialized"), + "project: " + (_json_str(data.get("projectPath")) or self.agent.session.cwd), + "index: files=" + + str(data.get("fileCount", 0)) + + " nodes=" + + str(data.get("nodeCount", 0)) + + " edges=" + + str(data.get("edgeCount", 0)) + + " backend=" + + (_json_str(data.get("backend")) or "unknown"), + "pending: added=" + + str(pending.get("added", 0)) + + " modified=" + + str(pending.get("modified", 0)) + + " removed=" + + str(pending.get("removed", 0)), + ] + ) + def _format_context_budget(self) -> str: budget = self.agent.context_budget() return "\n".join( @@ -8528,6 +8756,28 @@ def _make_unified_diff(old_content: str, new_content: str, filepath: str) -> str ) +TERMINAL_ESCAPE_RE = re.compile(r"\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])") + + +def _plain_command_env() -> dict[str, str]: + env = os.environ.copy() + env.update({"CI": "1", "NO_COLOR": "1", "TERM": "dumb"}) + return env + + +def _clean_terminal_output(text: str) -> str: + lines = [] + for raw_line in TERMINAL_ESCAPE_RE.sub("", text.replace("\r", "\n")).splitlines(): + line = raw_line.rstrip() + if re.search(r"\b\d{1,3}%$", line) and ("█" in line or "░" in line): + continue + if lines and line == lines[-1]: + continue + if line or (lines and lines[-1]): + lines.append(line) + return "\n".join(lines).strip("\n") + + def _format_process_result(tag: str, exit_code: int, stdout: str, stderr: str) -> str: lines = [f"<{tag}>", f"* exit_code: {exit_code}"] if stdout: @@ -8629,6 +8879,12 @@ def get_completions(self, document, complete_event): if value.startswith(text): yield Completion(value, start_position=-len(text)) return + if text.startswith("/codegraph "): + text = text[len("/codegraph ") :] + for value in ("status", "sync", "init", "index"): + if value.startswith(text): + yield Completion(value, start_position=-len(text)) + return if text.startswith("/reason-payload "): text = text[len("/reason-payload ") :] for value in CHAT_REASONING_CHOICES: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 0282199..03c8dd8 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -488,6 +488,29 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path): assert "do not create Goal, Plan, Known, or Verify just to report the result" in prompt assert "record Verify only after edits, explicit checks, or correctness-sensitive work" in prompt assert "Tracked tasks are complete only after goal.complete=true is set" in prompt + assert "When Environment says codegraph is available" in prompt + assert "CodeGraph line prefixes are location hints" in prompt + + +def test_codegraph_tool_is_hidden_until_available(tmp_path, monkeypatch): + agent = Agent(Session(cwd=str(tmp_path))) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") + + tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] + + assert "CodeGraph" not in tool_names + assert "- codegraph: not installed" in agent.build_user_prompt() + + +def test_codegraph_tool_is_visible_when_initialized(tmp_path, monkeypatch): + (tmp_path / ".codegraph").mkdir() + agent = Agent(Session(cwd=str(tmp_path))) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + + tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] + + assert "CodeGraph" in tool_names + assert "- codegraph: available" in agent.build_user_prompt() def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_path): diff --git a/tests/test_nanocode_codegraph_tool.py b/tests/test_nanocode_codegraph_tool.py new file mode 100644 index 0000000..3ad28cd --- /dev/null +++ b/tests/test_nanocode_codegraph_tool.py @@ -0,0 +1,100 @@ +import nanocode +import pytest + +from nanocode import CodeGraphTool, Session, ToolCallError + + +def _init_codegraph_project(tmp_path): + (tmp_path / ".codegraph").mkdir() + return Session(cwd=str(tmp_path)) + + +def test_codegraph_tool_requires_binary(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") + + with pytest.raises(ToolCallError, match="codegraph not found"): + CodeGraphTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) + + +def test_codegraph_tool_requires_initialized_project(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + tool = CodeGraphTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) + + assert tool.requires_confirmation(Session(cwd=str(tmp_path))) is False + with pytest.raises(ToolCallError, match="/codegraph init"): + tool.call() + + +def test_codegraph_tool_context_numbers_code_blocks(tmp_path, monkeypatch): + session = _init_codegraph_project(tmp_path) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + seen = {} + + def fake_run(cmd, **kwargs): + seen["cmd"] = cmd + return nanocode.subprocess.CompletedProcess( + cmd, + 0, + "\n".join( + [ + "## Code Context", + "", + "#### Tool (nanocode.py:1284)", + "", + "```python", + "class Tool:", + " NAME: ClassVar[str]", + "```", + ] + ), + "", + ) + + monkeypatch.setattr(nanocode.subprocess, "run", fake_run) + + result = CodeGraphTool.make(session, ["Tool class"]).call() + + assert seen["cmd"] == [ + "/fake/codegraph", + "context", + "Tool class", + "--path", + str(tmp_path), + "--max-nodes", + "40", + "--max-code", + "8", + "--format", + "markdown", + ] + assert "" in result + assert "* mode: context" in result + assert " 1284 |class Tool:\n 1285 | NAME: ClassVar[str]" in result + + +def test_codegraph_tool_impact_uses_paths(tmp_path, monkeypatch): + session = _init_codegraph_project(tmp_path) + (tmp_path / "nanocode.py").write_text("# sample\n", encoding="utf-8") + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + seen = {} + + def fake_run(cmd, **kwargs): + seen["cmd"] = cmd + return nanocode.subprocess.CompletedProcess(cmd, 0, "affected tests\n", "") + + monkeypatch.setattr(nanocode.subprocess, "run", fake_run) + + result = CodeGraphTool.make(session, ["impact", ["nanocode.py"]]).call() + + assert seen["cmd"] == ["/fake/codegraph", "affected", "--path", str(tmp_path), "nanocode.py"] + assert "* mode: impact" in result + assert "affected tests" in result + + +def test_codegraph_tool_rejects_paths_outside_cwd(tmp_path, monkeypatch): + other = tmp_path.parent / "other.py" + other.write_text("# outside\n", encoding="utf-8") + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + + with pytest.raises(ToolCallError, match="path outside cwd"): + CodeGraphTool.make(Session(cwd=str(tmp_path)), ["impact", [str(other)]]) diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 0ecc6f8..5e64e0c 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -194,6 +194,68 @@ def test_context_command_shows_and_sets_budget(tmp_path): assert invalid_result.message == "Usage: /context [low|medium|high]" +def test_codegraph_command_runs_maintenance_subcommands(tmp_path, monkeypatch): + session = make_session(tmp_path) + dispatcher = CommandDispatcher(Agent(session)) + seen = {} + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + + def fake_run(cmd, **kwargs): + seen["cmd"] = cmd + seen["cwd"] = kwargs["cwd"] + return nanocode.subprocess.CompletedProcess( + cmd, + 0, + '{"initialized":true,"projectPath":"/repo","fileCount":2,"nodeCount":3,"edgeCount":4,"backend":"native","pendingChanges":{"added":1,"modified":0,"removed":0}}\n', + "", + ) + + monkeypatch.setattr(nanocode.subprocess, "run", fake_run) + + result = dispatcher.dispatch("/codegraph status") + usage_result = dispatcher.dispatch("/codegraph nope") + + assert result.status == CommandStatus.HANDLED + assert seen == {"cmd": ["/fake/codegraph", "status", "-j", "."], "cwd": str(tmp_path)} + assert result.message == "\n".join( + [ + "CodeGraph: initialized", + "project: /repo", + "index: files=2 nodes=3 edges=4 backend=native", + "pending: added=1 modified=0 removed=0", + ] + ) + assert usage_result.message == "Usage: /codegraph [status|sync|init|index]" + + +def test_codegraph_command_strips_terminal_control_output(tmp_path, monkeypatch): + session = make_session(tmp_path) + dispatcher = CommandDispatcher(Agent(session)) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + + def fake_run(cmd, **kwargs): + return nanocode.subprocess.CompletedProcess(cmd, 0, "\x1b[1mTitle\x1b[0m\r\x1b[KParsing ███░ 50%\nDone\nDone\n", "") + + monkeypatch.setattr(nanocode.subprocess, "run", fake_run) + + result = dispatcher.dispatch("/codegraph sync") + + assert "CodeGraph sync completed." in result.message + assert "Title" in result.message + assert "Done" in result.message + assert "\x1b" not in result.message + assert "50%" not in result.message + assert result.message.count("Done") == 1 + + +def test_codegraph_command_reports_missing_binary(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") + + result = CommandDispatcher(Agent(make_session(tmp_path))).dispatch("/codegraph status") + + assert result.message == "codegraph not found; install CodeGraph first" + + def test_plan_command_toggles_plan_mode(tmp_path): session = make_session(tmp_path) dispatcher = CommandDispatcher(Agent(session)) diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 2efc275..843911f 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -372,9 +372,11 @@ def test_agent_loop_command_completer_matches_slash_commands(): model_completions = list(nanocode.CommandCompleter(models=["qwen3", "deepseek"]).get_completions(Document("/model q"), CompleteEvent(completion_requested=True))) plan_completions = list(completer.get_completions(Document("/plan "), CompleteEvent(completion_requested=True))) api_completions = list(completer.get_completions(Document("/api r"), CompleteEvent(completion_requested=True))) + codegraph_completions = list(completer.get_completions(Document("/codegraph s"), CompleteEvent(completion_requested=True))) reason_payload_completions = list(completer.get_completions(Document("/reason-payload rea"), CompleteEvent(completion_requested=True))) assert "/help" in [completion.text for completion in slash_completions] + assert "/codegraph" in [completion.text for completion in slash_completions] assert "/api" in [completion.text for completion in slash_completions] assert "/reason-payload" in [completion.text for completion in slash_completions] assert "/plan" in [completion.text for completion in slash_completions] @@ -386,6 +388,7 @@ def test_agent_loop_command_completer_matches_slash_commands(): assert [completion.text for completion in model_completions] == ["qwen3"] assert [completion.text for completion in plan_completions] == ["on", "off"] assert [completion.text for completion in api_completions] == ["responses"] + assert [completion.text for completion in codegraph_completions] == ["status", "sync"] assert [completion.text for completion in reason_payload_completions] == ["reasoning", "reasoning_effort"] From dd62a80c6ee11be1d75d0e93d56898bd06b03f80 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 06:21:22 -0700 Subject: [PATCH 063/144] prevent planless command loops --- .gitignore | 1 + nanocode.py | 27 +++++++++++++++- tests/test_nanocode_agent.py | 60 ++++++++++++++++++++++++++++++++++++ 3 files changed, 87 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 3a6f213..5a741ba 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,7 @@ __pycache__/ *.pyc .env* .nanocode +.codegraph/ .venv/ .mypy_cache/ .ruff_cache/ diff --git a/nanocode.py b/nanocode.py index b15b20d..3eb1335 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3860,6 +3860,7 @@ def _state_tool_schema(name: str) -> Json: If Current Phase is working or verifying, continue from the existing Goal and Plan unless the user changed the task. If Current Phase is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. Before repeating or broadening tool calls, inspect visible tool results. +If Current Phase is new and visible tool results answer the request, answer with assistant text and stop. If they already answer a one-shot request, answer directly instead of calling more tools. Otherwise use them to update state, choose the next frontier, or forget noise. @@ -5338,7 +5339,11 @@ def _apply_task_code(self, actions: list[Json]) -> None: if "verify" in action_types: self.blackboard.task_code = TaskCode.WORKING return - if any(action_type in action_types for action_type in ("goal", "plan", "known", "stable_knowledge", "tool")) and not self.blackboard.goal_reached: + tracked_state = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) + if ( + ("goal" in action_types or "plan" in action_types or "hypothesis" in action_types or (tracked_state and "tool" in action_types)) + and not self.blackboard.goal_reached + ): self.blackboard.task_code = TaskCode.WORKING def _append_state_section(self, lines: list[str], title: str, rows: list[str] | None = None) -> None: @@ -6528,6 +6533,23 @@ def keep(action: Json) -> bool: ctx.response["actions"] = [action for action in _json_list(ctx.response.get("actions")) if not isinstance(action, dict) or keep(action)] def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: + if ( + not (self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) + and self._latest_successful_bash_result() + and ctx.tool_calls + and not ctx.assistant_text + and not ctx.has_goal_action + and not ctx.has_plan_action + ): + return self._reject_agent( + on_message, + self._error( + "successful command result is already visible with no active task.", + "answer the one-shot result or create Goal/Plan before more tool calls.", + ), + "Retrying: answer the visible command result or start a tracked task.", + "Task_Gate: planless command loop.", + ) if ( self.blackboard.task_code == TaskCode.NEW and self.task_alignment_required @@ -6553,6 +6575,9 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N self._warn_agent("changed Goal without replacing Plan.", "replace Plan when the task scope changes.") return False + def _latest_successful_bash_result(self) -> bool: + return any(execution.call.name == BashTool.NAME and execution.outcome == "success" for execution in self.tool_runner.latest_executions) + def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback | None) -> None: if on_message is not None and self.state_updater.latest_report: report = self.state_updater.compact_report() diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 03c8dd8..746e67c 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -520,12 +520,14 @@ def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_pat assert "Chat: answer with assistant text only." in prompt assert "One-shot with no Goal or Plan: assistant text is the final answer" in prompt + assert "If Current Phase is new and visible tool results answer the request" in prompt assert "Tracked task: assistant text is optional" in prompt assert "Goal completion requires goal.complete=true" in prompt def test_one_shot_bash_does_not_require_goal_or_plan(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) + agent.blackboard.task_code = nanocode.TaskCode.NEW result = agent.handle_response( { @@ -538,9 +540,67 @@ def test_one_shot_bash_does_not_require_goal_or_plan(tmp_path): assert result.done is False assert len(agent.tool_runner.latest_executions) == 1 + assert agent.blackboard.task_code == nanocode.TaskCode.NEW + assert "Current Phase:\nnew" in agent.build_user_prompt() assert not any("mutating work before" in error for error in agent.agent_feedback_errors) +def test_tracked_task_tool_keeps_working_phase(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.blackboard.goal = "inspect sample" + agent.blackboard.task_code = nanocode.TaskCode.NEW + + result = agent.handle_response( + {"actions": [{"type": "tool", "name": "Bash", "intention": "run check", "args": ["printf ok"]}]}, + confirm=lambda call, tool: True, + ) + + assert result.done is False + assert agent.blackboard.task_code == nanocode.TaskCode.WORKING + + +def test_planless_successful_bash_requires_answer_or_tracked_task_before_more_tools(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.blackboard.task_code = nanocode.TaskCode.NEW + + first = agent.handle_response( + {"actions": [{"type": "tool", "name": "Bash", "intention": "run check", "args": ["printf ok"]}]}, + confirm=lambda call, tool: True, + ) + second = agent.handle_response( + {"actions": [{"type": "tool", "name": "Bash", "intention": "repeat check", "args": ["printf ok"]}]}, + confirm=lambda call, tool: True, + ) + + assert first.done is False + assert second.done is False + assert agent.session.state.turn_tool_calls == 1 + assert any("successful command result is already visible" in error for error in agent.agent_feedback_errors) + + +def test_planless_successful_bash_allows_tracked_task_before_more_tools(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.blackboard.task_code = nanocode.TaskCode.NEW + + agent.handle_response( + {"actions": [{"type": "tool", "name": "Bash", "intention": "run check", "args": ["printf ok"]}]}, + confirm=lambda call, tool: True, + ) + result = agent.handle_response( + { + "actions": [ + {"type": "goal", "text": "run more checks", "complete": False}, + {"type": "tool", "name": "Bash", "intention": "run another check", "args": ["printf ok"]}, + ] + }, + confirm=lambda call, tool: True, + ) + + assert result.done is False + assert agent.session.state.turn_tool_calls == 2 + assert agent.blackboard.goal == "run more checks" + + def test_edit_tool_without_goal_or_plan_warns(tmp_path): (tmp_path / "sample.txt").write_text("old\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) From dc10ce8fcf6c8f5f290599f0afbad7f4102a37c7 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 06:34:24 -0700 Subject: [PATCH 064/144] split CodeGraph symbol and context tools --- README.md | 2 +- design.md | 6 +- nanocode.py | 167 +++++++++++++++++--------- tests/test_nanocode_agent.py | 10 +- tests/test_nanocode_codegraph_tool.py | 74 ++++++++---- 5 files changed, 173 insertions(+), 86 deletions(-) diff --git a/README.md b/README.md index 5c55f5e..f175a67 100644 --- a/README.md +++ b/README.md @@ -80,7 +80,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Tools - File: `Read`, `LineCount`, `List`, `Search`. -- Codebase: `CodeGraph` when the local `codegraph` CLI is installed and initialized. +- Codebase: `CodeGraphSymbol`, `CodeGraphContext` when the local `codegraph` CLI is installed and initialized. - Edit: `Edit`, `ReplaceRange`. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. diff --git a/design.md b/design.md index 861920c..1d8e912 100644 --- a/design.md +++ b/design.md @@ -89,9 +89,9 @@ OBSERVE receives a smaller cleanup context: OBSERVE reduces tool-result noise before ACT continues. -Optional tools can be environment-gated. For example, CodeGraph is shown to the -model only when the local `codegraph` CLI exists and the current project has a -`.codegraph` index. +Optional tools can be environment-gated. For example, CodeGraph tools are shown +to the model only when the local `codegraph` CLI exists and the current project +has a `.codegraph` index. Context layout: diff --git a/nanocode.py b/nanocode.py index 3eb1335..0eae934 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2358,83 +2358,58 @@ def call(self) -> str: @dataclass -class CodeGraphTool(Tool): - NAME: ClassVar[str] = "CodeGraph" +class CodeGraphContextTool(Tool): + NAME: ClassVar[str] = "CodeGraphContext" MAX_NODES: ClassVar[int] = 40 MAX_CODE_BLOCKS: ClassVar[int] = 8 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Use local CodeGraph for semantic codebase context, call-flow exploration, architecture questions, or impact analysis.", - "If paths is empty, builds AI-ready context for query; if paths is non-empty, reports affected tests/symbols/files.", + "Use local CodeGraph for semantic codebase context, call-flow exploration, architecture questions, or implementation lookup.", + "Query works best as a concise search-style phrase with symbols, paths, concepts, or relationships; avoid broad chatty questions.", 'Returned code snippets are line-numbered as "line |code" location hints; use Read before exact edits.', ) - SIGNATURE: ClassVar[str] = "CodeGraph(query[, paths]) -> CodeGraphToolResult" + SIGNATURE: ClassVar[str] = "CodeGraphContext(query) -> CodeGraphContextToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Example args: ["How does tool execution work?"]', - 'Impact args: ["What is affected by these changes?", ["nanocode.py"]]', + 'Example args: ["Tool class schema generation"]', + 'Example args: ["Agent tool result context layout"]', ) query: str = "" - paths: list[str] = field(default_factory=list) codegraph_path: str = "" cwd: str = "" timeout: int = 60 - @classmethod - def cli_args(cls, args: list[JsonValue]) -> list[str]: - if len(args) == 2: - return [cls.cli_token(args[0]), str(len(_json_list(args[1])) or 1) + " paths"] - return [cls.cli_token(arg) for arg in args] - @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: - if len(args) not in (1, 2): - raise ToolCallArgError("requires args: query[, paths]") + if len(args) != 1: + raise ToolCallArgError("requires args: query") query = str(args[0]).strip() if not query: raise ToolCallArgError("query cannot be empty") codegraph_path = shutil.which("codegraph") if not codegraph_path: raise ToolCallError("codegraph not found; install CodeGraph first") - paths = cls._paths_from_arg(session, args[1]) if len(args) == 2 else [] - return cls(query=query, paths=paths, codegraph_path=codegraph_path, cwd=session.cwd, timeout=session.settings.shell_timeout) - - @staticmethod - def _paths_from_arg(session: Session, value: JsonValue) -> list[str]: - raw_paths = _json_list(value) or ([value] if value else []) - paths = [] - for raw_path in raw_paths: - resolved = session.resolve_path(str(raw_path)) - if not session.is_path_in_cwd(resolved): - raise ToolCallError("path outside cwd: " + str(raw_path)) - paths.append(os.path.relpath(resolved, session.cwd)) - return paths + return cls(query=query, codegraph_path=codegraph_path, cwd=session.cwd, timeout=session.settings.shell_timeout) def preview(self) -> str: - if self.paths: - return "CodeGraph(" + json.dumps(self.query, ensure_ascii=False) + ", " + json.dumps(self.paths, ensure_ascii=False) + ")" - return "CodeGraph(" + json.dumps(self.query, ensure_ascii=False) + ")" + return "CodeGraphContext(" + json.dumps(self.query, ensure_ascii=False) + ")" def call(self) -> str: if not os.path.isdir(os.path.join(self.cwd, ".codegraph")): raise ToolCallError("CodeGraph not initialized; run /codegraph init") - cmd = ( - [self.codegraph_path, "affected", "--path", self.cwd, *self.paths] - if self.paths - else [ - self.codegraph_path, - "context", - self.query, - "--path", - self.cwd, - "--max-nodes", - str(self.MAX_NODES), - "--max-code", - str(self.MAX_CODE_BLOCKS), - "--format", - "markdown", - ] - ) + cmd = [ + self.codegraph_path, + "context", + self.query, + "--path", + self.cwd, + "--max-nodes", + str(self.MAX_NODES), + "--max-code", + str(self.MAX_CODE_BLOCKS), + "--format", + "markdown", + ] try: proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) except subprocess.TimeoutExpired as error: @@ -2442,12 +2417,12 @@ def call(self) -> str: return self._format(proc.returncode, self._number_code_blocks(_clean_terminal_output(proc.stdout)), _clean_terminal_output(proc.stderr)) def _format(self, exit_code: int, stdout: str, stderr: str) -> str: - lines = ["", "* mode: " + ("impact" if self.paths else "context"), "* exit_code: " + str(exit_code)] + lines = ["", "* exit_code: " + str(exit_code)] if stdout: lines.extend(["", stdout.rstrip("\n"), ""]) if stderr: lines.extend(["", stderr.rstrip("\n"), ""]) - lines.append("") + lines.append("") return "\n".join(lines) @classmethod @@ -2482,6 +2457,87 @@ def _number_code_blocks(cls, text: str) -> str: return "".join(numbered) +@dataclass +class CodeGraphSymbolTool(Tool): + NAME: ClassVar[str] = "CodeGraphSymbol" + MAX_RESULTS: ClassVar[int] = 12 + EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY + DESCRIPTION: ClassVar[tuple[str, ...]] = ( + "Use local CodeGraph to find symbol definitions and locations by exact or partial name.", + "Prefer this over broad text Search when you know a class, function, method, or variable name.", + "Use Read on the returned file/range before exact edits.", + ) + SIGNATURE: ClassVar[str] = "CodeGraphSymbol(symbol) -> CodeGraphSymbolToolResult" + EXAMPLE: ClassVar[tuple[str, ...]] = ( + 'Example args: ["Tool"]', + 'Example args: ["Agent.run"]', + ) + + symbol: str = "" + codegraph_path: str = "" + cwd: str = "" + timeout: int = 60 + + @classmethod + def make(cls, session: Session, args: list[JsonValue]) -> Self: + if len(args) != 1: + raise ToolCallArgError("requires args: symbol") + symbol = str(args[0]).strip() + if not symbol: + raise ToolCallArgError("symbol cannot be empty") + codegraph_path = shutil.which("codegraph") + if not codegraph_path: + raise ToolCallError("codegraph not found; install CodeGraph first") + return cls(symbol=symbol, codegraph_path=codegraph_path, cwd=session.cwd, timeout=session.settings.shell_timeout) + + def preview(self) -> str: + return "CodeGraphSymbol(" + json.dumps(self.symbol, ensure_ascii=False) + ")" + + def call(self) -> str: + if not os.path.isdir(os.path.join(self.cwd, ".codegraph")): + raise ToolCallError("CodeGraph not initialized; run /codegraph init") + cmd = [self.codegraph_path, "query", self.symbol, "--path", self.cwd, "--limit", str(self.MAX_RESULTS), "-j"] + try: + proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) + except subprocess.TimeoutExpired as error: + return self._format(-1, error.stdout or "", (error.stderr or "") + "timeout") + return self._format(proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) + + def _format(self, exit_code: int, stdout: str, stderr: str) -> str: + lines = ["", "* exit_code: " + str(exit_code)] + symbols = self._symbols(stdout) + if symbols: + lines.extend(["", *symbols, ""]) + elif stdout: + lines.extend(["", stdout.rstrip("\n"), ""]) + if stderr: + lines.extend(["", stderr.rstrip("\n"), ""]) + lines.append("") + return "\n".join(lines) + + @classmethod + def _symbols(cls, stdout: str) -> list[str]: + try: + values = _json_list(json.loads(stdout)) + except json.JSONDecodeError: + return [] + lines = [] + for index, item in enumerate(values, 1): + node = _json_dict(_json_dict(item).get("node")) + if not node: + continue + line_range = str(node.get("startLine") or "?") + if node.get("endLine") and node.get("endLine") != node.get("startLine"): + line_range += "-" + str(node["endLine"]) + text = f"{index}. {node.get('kind') or 'symbol'} {node.get('qualifiedName') or node.get('name') or '(unknown)'} {node.get('filePath') or '?'}:{line_range}" + if node.get("signature"): + text += " " + str(node["signature"]) + if isinstance(_json_dict(item).get("score"), int | float): + text += " score=" + f"{float(_json_dict(item)['score']):.1f}" + lines.append(text) + return lines + + @dataclass class EditTool(Tool): NAME: ClassVar[str] = "Edit" @@ -3327,7 +3383,8 @@ def _content(self, item: ToolResultItem) -> str: LineCountTool.NAME: LineCountTool, ListTool.NAME: ListTool, SearchTool.NAME: SearchTool, - CodeGraphTool.NAME: CodeGraphTool, + CodeGraphContextTool.NAME: CodeGraphContextTool, + CodeGraphSymbolTool.NAME: CodeGraphSymbolTool, CreateFileTool.NAME: CreateFileTool, EditTool.NAME: EditTool, PatchFileTool.NAME: PatchFileTool, @@ -3336,7 +3393,7 @@ def _content(self, item: ToolResultItem) -> str: GitTool.NAME: GitTool, ToolResultTool.NAME: ToolResultTool, } -PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, SearchTool, CodeGraphTool, PlanModeGitTool, ToolResultTool) +PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, SearchTool, CodeGraphContextTool, CodeGraphSymbolTool, PlanModeGitTool, ToolResultTool) TOOL_STRING_SCHEMA: Json = {"type": "string"} @@ -3568,11 +3625,9 @@ def _state_tool_schema(name: str) -> Json: DISCOVERY AND EDITING Use Search/List/LineCount when path, symbol, range, or target is unknown. -When Environment says codegraph is available and CodeGraph is in available tools, use CodeGraph for semantic codebase context, call-flow exploration, architecture questions, or impact analysis. Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. Read line prefixes are display-only; edit text starts immediately after "|". -CodeGraph line prefixes are location hints; use Read before exact edits. Stop discovery once the next edit/check is clear. @@ -5690,7 +5745,7 @@ def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> t tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) if self._codegraph_available(): return tool_classes - return tuple(tool for tool in tool_classes if tool is not CodeGraphTool) + return tuple(tool for tool in tool_classes if tool not in (CodeGraphContextTool, CodeGraphSymbolTool)) def _codegraph_available(self) -> bool: return bool(shutil.which("codegraph") and os.path.isdir(os.path.join(self.session.cwd, ".codegraph"))) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 746e67c..28cb325 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -488,8 +488,8 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path): assert "do not create Goal, Plan, Known, or Verify just to report the result" in prompt assert "record Verify only after edits, explicit checks, or correctness-sensitive work" in prompt assert "Tracked tasks are complete only after goal.complete=true is set" in prompt - assert "When Environment says codegraph is available" in prompt - assert "CodeGraph line prefixes are location hints" in prompt + assert "CodeGraphContext" not in prompt + assert "CodeGraphSymbol" not in prompt def test_codegraph_tool_is_hidden_until_available(tmp_path, monkeypatch): @@ -498,7 +498,8 @@ def test_codegraph_tool_is_hidden_until_available(tmp_path, monkeypatch): tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] - assert "CodeGraph" not in tool_names + assert "CodeGraphContext" not in tool_names + assert "CodeGraphSymbol" not in tool_names assert "- codegraph: not installed" in agent.build_user_prompt() @@ -509,7 +510,8 @@ def test_codegraph_tool_is_visible_when_initialized(tmp_path, monkeypatch): tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] - assert "CodeGraph" in tool_names + assert "CodeGraphContext" in tool_names + assert "CodeGraphSymbol" in tool_names assert "- codegraph: available" in agent.build_user_prompt() diff --git a/tests/test_nanocode_codegraph_tool.py b/tests/test_nanocode_codegraph_tool.py index 3ad28cd..e671567 100644 --- a/tests/test_nanocode_codegraph_tool.py +++ b/tests/test_nanocode_codegraph_tool.py @@ -1,7 +1,9 @@ +import json + import nanocode import pytest -from nanocode import CodeGraphTool, Session, ToolCallError +from nanocode import CodeGraphContextTool, CodeGraphSymbolTool, Session, ToolCallArgError, ToolCallError def _init_codegraph_project(tmp_path): @@ -13,12 +15,12 @@ def test_codegraph_tool_requires_binary(tmp_path, monkeypatch): monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") with pytest.raises(ToolCallError, match="codegraph not found"): - CodeGraphTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) + CodeGraphContextTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) def test_codegraph_tool_requires_initialized_project(tmp_path, monkeypatch): monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") - tool = CodeGraphTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) + tool = CodeGraphContextTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) assert tool.requires_confirmation(Session(cwd=str(tmp_path))) is False with pytest.raises(ToolCallError, match="/codegraph init"): @@ -52,7 +54,7 @@ def fake_run(cmd, **kwargs): monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - result = CodeGraphTool.make(session, ["Tool class"]).call() + result = CodeGraphContextTool.make(session, ["Tool class"]).call() assert seen["cmd"] == [ "/fake/codegraph", @@ -67,34 +69,62 @@ def fake_run(cmd, **kwargs): "--format", "markdown", ] - assert "" in result - assert "* mode: context" in result + assert "" in result assert " 1284 |class Tool:\n 1285 | NAME: ClassVar[str]" in result -def test_codegraph_tool_impact_uses_paths(tmp_path, monkeypatch): +def test_codegraph_tool_rejects_extra_args(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + + with pytest.raises(ToolCallArgError, match="requires args: query"): + CodeGraphContextTool.make(Session(cwd=str(tmp_path)), ["impact", ["nanocode.py"]]) + + +def test_codegraph_symbol_tool_formats_locations(tmp_path, monkeypatch): session = _init_codegraph_project(tmp_path) - (tmp_path / "nanocode.py").write_text("# sample\n", encoding="utf-8") monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") seen = {} def fake_run(cmd, **kwargs): seen["cmd"] = cmd - return nanocode.subprocess.CompletedProcess(cmd, 0, "affected tests\n", "") + return nanocode.subprocess.CompletedProcess( + cmd, + 0, + json.dumps( + [ + { + "node": { + "kind": "class", + "name": "Tool", + "qualifiedName": "Tool", + "filePath": "nanocode.py", + "startLine": 1284, + "endLine": 1330, + }, + "score": 90.005, + }, + { + "node": { + "kind": "method", + "name": "tool_schema", + "qualifiedName": "Tool::tool_schema", + "filePath": "nanocode.py", + "startLine": 1316, + "endLine": 1327, + "signature": "(cls) -> Json", + }, + "score": 32.99, + }, + ] + ), + "", + ) monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - result = CodeGraphTool.make(session, ["impact", ["nanocode.py"]]).call() - - assert seen["cmd"] == ["/fake/codegraph", "affected", "--path", str(tmp_path), "nanocode.py"] - assert "* mode: impact" in result - assert "affected tests" in result - - -def test_codegraph_tool_rejects_paths_outside_cwd(tmp_path, monkeypatch): - other = tmp_path.parent / "other.py" - other.write_text("# outside\n", encoding="utf-8") - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + result = CodeGraphSymbolTool.make(session, ["Tool"]).call() - with pytest.raises(ToolCallError, match="path outside cwd"): - CodeGraphTool.make(Session(cwd=str(tmp_path)), ["impact", [str(other)]]) + assert seen["cmd"] == ["/fake/codegraph", "query", "Tool", "--path", str(tmp_path), "--limit", "12", "-j"] + assert "" in result + assert "1. class Tool nanocode.py:1284-1330 score=90.0" in result + assert "2. method Tool::tool_schema nanocode.py:1316-1327 (cls) -> Json score=33.0" in result From b88bfc2d01ad6e4edb7dc5a9ab800c1e52f80a05 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 06:36:48 -0700 Subject: [PATCH 065/144] add dynamic CodeGraph usage hint --- nanocode.py | 22 ++++++++++++++-------- tests/test_nanocode_agent.py | 6 +++++- 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/nanocode.py b/nanocode.py index 0eae934..f7a91a2 100644 --- a/nanocode.py +++ b/nanocode.py @@ -5679,14 +5679,7 @@ def build_user_prompt(self) -> str: current = self.blackboard conversation = self.session.state.conversation return AGENT_USER_PROMPT_TEMPLATE.format( - environment="\n".join( - [ - "- system: " + self.session.system, - "- arch: " + self.session.arch, - "- cwd: " + self.session.cwd, - "- codegraph: " + self._codegraph_status_label(), - ] - ), + environment=self._format_environment(), conversation_history="\n\n".join(item.format() for item in conversation) if conversation else "(empty)", user_rules=self.session.state.user_rules.format(), known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", @@ -5708,6 +5701,19 @@ def build_user_prompt(self) -> str: user_request=self._format_user_request(), ).strip() + def _format_environment(self) -> str: + lines = [ + "- system: " + self.session.system, + "- arch: " + self.session.arch, + "- cwd: " + self.session.cwd, + "- codegraph: " + self._codegraph_status_label(), + ] + if self._codegraph_available(): + lines.append( + "- codegraph_hint: use CodeGraphSymbol for known names; use CodeGraphContext for cross-file context/call flow; use Search/Read for exact paths or literals." + ) + return "\n".join(lines) + def _format_current_focus(self) -> str: plan = self.blackboard.plan item = next((item for item in plan if item.status == PlanStatus.DOING), None) or next( diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 28cb325..9aaed4b 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -501,6 +501,7 @@ def test_codegraph_tool_is_hidden_until_available(tmp_path, monkeypatch): assert "CodeGraphContext" not in tool_names assert "CodeGraphSymbol" not in tool_names assert "- codegraph: not installed" in agent.build_user_prompt() + assert "codegraph_hint" not in agent.build_user_prompt() def test_codegraph_tool_is_visible_when_initialized(tmp_path, monkeypatch): @@ -512,7 +513,10 @@ def test_codegraph_tool_is_visible_when_initialized(tmp_path, monkeypatch): assert "CodeGraphContext" in tool_names assert "CodeGraphSymbol" in tool_names - assert "- codegraph: available" in agent.build_user_prompt() + prompt = agent.build_user_prompt() + assert "- codegraph: available" in prompt + assert "use CodeGraphSymbol for known names" in prompt + assert "use CodeGraphContext for cross-file context/call flow" in prompt def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_path): From 2ca296132c0f932cd60f2c1d6107dffefc3d6109 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 06:39:54 -0700 Subject: [PATCH 066/144] accept case-insensitive tool names --- nanocode.py | 12 ++++++++++-- tests/test_nanocode_agent.py | 17 +++++++++++++++++ 2 files changed, 27 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index f7a91a2..ca4d668 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3396,6 +3396,12 @@ def _content(self, item: ToolResultItem) -> str: PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, SearchTool, CodeGraphContextTool, CodeGraphSymbolTool, PlanModeGitTool, ToolResultTool) +def _canonical_tool_name(name: str | None) -> str: + if not name: + return "" + return next((tool_name for tool_name in TOOL_REGISTRY if tool_name.lower() == name.lower()), name) + + TOOL_STRING_SCHEMA: Json = {"type": "string"} TOOL_NULLABLE_STRING_SCHEMA: Json = {"type": ["string", "null"]} TOOL_ITEMS_SCHEMA: Json = {"type": "array", "items": TOOL_JSON_VALUE_SCHEMA} @@ -5025,6 +5031,7 @@ def parse_tool_call(self, value: JsonValue) -> ParsedToolCall: name = _json_str(item.get("name")) if not name: raise ToolCallArgError('tool action missing required field: name. Use {"type":"tool","name":"Read","intention":"...","args":["path"]}.') + name = _canonical_tool_name(name) intention = _json_str(item.get("intention")) or "" raw_args = _json_list(item.get("args")) args: list[JsonValue] = list(raw_args) if name == ReplaceRangeTool.NAME else [_json_str(arg) or "" for arg in raw_args] @@ -6334,11 +6341,12 @@ def _response_actions(self, response: Json) -> list[Json]: @staticmethod def _normalize_action(action: Json) -> Json: action_type = _json_str(action.get("type")) - if action_type not in TOOL_REGISTRY: + tool_name = _canonical_tool_name(action_type) + if tool_name not in TOOL_REGISTRY: return action normalized = dict(action) normalized["type"] = "tool" - normalized["name"] = action_type + normalized["name"] = tool_name return normalized def _gate_action_types( diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 9aaed4b..0a3c55c 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2928,6 +2928,23 @@ def test_agent_normalizes_direct_repo_tool_action_type(tmp_path): assert not any("Protocol_Gate" in message for message in messages) +def test_agent_normalizes_lowercase_repo_tool_names(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("needle\n", encoding="utf-8") + agent = Agent(_session(tmp_path, debug=True)) + _seed_plan(agent, "find sample") + messages = [] + + result = agent.handle_response( + {"actions": [{"type": "search", "intention": "find sample", "args": ["needle", "sample.txt"]}]}, + on_message=messages.append, + ) + + assert result.done is False + assert agent.tool_runner.latest_executions[0].call.name == "Search" + assert not any("Protocol_Gate" in message for message in messages) + + def test_agent_plan_mode_stores_proposed_plan_completion(tmp_path): agent = Agent(_session(tmp_path, plan_mode=True)) _seed_plan(agent, "plan change") From 16ef3455adfb44d968375e6be08faf4e39351901 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 06:47:36 -0700 Subject: [PATCH 067/144] clarify gate feedback and finish goal-only text replies --- nanocode.py | 18 +++++++++--------- tests/test_nanocode_agent.py | 4 ++-- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/nanocode.py b/nanocode.py index ca4d668..ac00693 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3903,7 +3903,7 @@ def _state_tool_schema(name: str) -> Json: Verification: {verification_state} -Errors: +Blocking Feedback - Fix Before Next Action: {errors} Pending User Feedback: @@ -5702,7 +5702,7 @@ def build_user_prompt(self) -> str: current_focus=self._format_current_focus(), hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", verification_state=current.verification.format(), - errors="\n".join("- " + error for error in self.agent_feedback_errors) or "(empty)", + errors="\n".join("! " + error for error in self.agent_feedback_errors) or "(empty)", recent_edits="\n".join(self.recent_edits) if self.recent_edits else "(empty)", pending_user_feedback=self.session.state.pending_user_feedback or "(empty)", user_request=self._format_user_request(), @@ -5909,7 +5909,7 @@ def run_stream_loop( def _remember_format_gate(self, format_error: str) -> None: remember_error = self._remember_observe_error if self.mode == AgentMode.OBSERVE else self._remember_agent_error - remember_error(self._format_gate_user_message("Error: invalid function/tool response", format_error) + " Rule: " + self.RULE_FUNCTION_TOOLS) + remember_error(self._format_gate_user_message("Error: invalid function/tool response", format_error) + " Next: " + self.RULE_FUNCTION_TOOLS) def _handle_format_gate(self, response: Json, format_error: str, consecutive_errors: int, on_message: MessageCallback | None) -> None: self._set_status_notice("err:format") @@ -5981,7 +5981,7 @@ def _remember_observe_error(self, text: str) -> None: @staticmethod def _feedback(level: str, text: str, rule: str = "") -> str: - return level + ": " + text + ((" Rule: " + rule) if rule else "") + return level + " blocked: " + text + ((" Next: " + rule) if rule else "") def _error(self, text: str, rule: str = "") -> str: return self._feedback("Error", text, rule) @@ -6541,7 +6541,7 @@ def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallbac self.session.append_conversation(AssistantMessage(content=ctx.assistant_text)) if on_message is not None: on_message(ctx.assistant_text) - active_task = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) + active_task = bool(self.blackboard.plan or self.blackboard.hypotheses) if active_task and (self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start): return AgentRunResult() self.blackboard.task_code = TaskCode.DONE @@ -6613,11 +6613,11 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N return self._reject_agent( on_message, self._error( - "successful command result is already visible with no active task.", - "answer the one-shot result or create Goal/Plan before more tool calls.", + "last command result is visible with no active task.", + "answer the user now, or create Goal/Plan before calling more tools.", ), - "Retrying: answer the visible command result or start a tracked task.", - "Task_Gate: planless command loop.", + "Retrying: answer the visible command result, or create Goal/Plan before more tools.", + "Task_Gate: visible command result needs answer or Goal/Plan.", ) if ( self.blackboard.task_code == TaskCode.NEW diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 0a3c55c..b8ecce9 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -581,7 +581,7 @@ def test_planless_successful_bash_requires_answer_or_tracked_task_before_more_to assert first.done is False assert second.done is False assert agent.session.state.turn_tool_calls == 1 - assert any("successful command result is already visible" in error for error in agent.agent_feedback_errors) + assert any("last command result is visible" in error for error in agent.agent_feedback_errors) def test_planless_successful_bash_allows_tracked_task_before_more_tools(tmp_path): @@ -3058,7 +3058,7 @@ def test_agent_warns_but_allows_completion_when_verification_required(tmp_path): assert result.done is True assert messages == ["done"] assert agent.agent_feedback_errors == [ - 'Warning: edited files need verification before completion. Rule: run verification tools, then report verify status="passed"|"failed"|"blocked".' + 'Warning blocked: edited files need verification before completion. Next: run verification tools, then report verify status="passed"|"failed"|"blocked".' ] From a18ee544b288c45d505eaac40429167fad48fec2 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 06:53:47 -0700 Subject: [PATCH 068/144] clarify CodeGraph as static analysis index --- nanocode.py | 11 ++++++----- tests/test_nanocode_agent.py | 6 ++++-- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/nanocode.py b/nanocode.py index ac00693..21c7b70 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2364,8 +2364,9 @@ class CodeGraphContextTool(Tool): MAX_CODE_BLOCKS: ClassVar[int] = 8 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Use local CodeGraph for semantic codebase context, call-flow exploration, architecture questions, or implementation lookup.", - "Query works best as a concise search-style phrase with symbols, paths, concepts, or relationships; avoid broad chatty questions.", + "CodeGraph is a whole-project static-analysis index; use CodeGraphContext for semantic context that plain text search cannot infer well: cross-file relationships, call flow, ownership, architecture, and implementation lookup.", + "Prefer this when the question is about how code connects; use Search for exact literals and Read for exact paths/ranges.", + "Query works best as a concise search-style phrase with symbols, paths, concepts, or relationships.", 'Returned code snippets are line-numbered as "line |code" location hints; use Read before exact edits.', ) SIGNATURE: ClassVar[str] = "CodeGraphContext(query) -> CodeGraphContextToolResult" @@ -2463,8 +2464,8 @@ class CodeGraphSymbolTool(Tool): MAX_RESULTS: ClassVar[int] = 12 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Use local CodeGraph to find symbol definitions and locations by exact or partial name.", - "Prefer this over broad text Search when you know a class, function, method, or variable name.", + "Use CodeGraph's whole-project static-analysis index to find symbol definitions and locations by exact or partial name.", + "Prefer this over broad text Search when you know a class, function, method, variable, or qualified name; it returns structured locations directly.", "Use Read on the returned file/range before exact edits.", ) SIGNATURE: ClassVar[str] = "CodeGraphSymbol(symbol) -> CodeGraphSymbolToolResult" @@ -5717,7 +5718,7 @@ def _format_environment(self) -> str: ] if self._codegraph_available(): lines.append( - "- codegraph_hint: use CodeGraphSymbol for known names; use CodeGraphContext for cross-file context/call flow; use Search/Read for exact paths or literals." + "- codegraph_hint: CodeGraph is a whole-project static-analysis index; prefer CodeGraphSymbol for known names and CodeGraphContext for cross-file relationships, call flow, architecture, or implementation lookup; use Search/Read for exact literals, paths, and edit ranges." ) return "\n".join(lines) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index b8ecce9..f7047ca 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -515,8 +515,10 @@ def test_codegraph_tool_is_visible_when_initialized(tmp_path, monkeypatch): assert "CodeGraphSymbol" in tool_names prompt = agent.build_user_prompt() assert "- codegraph: available" in prompt - assert "use CodeGraphSymbol for known names" in prompt - assert "use CodeGraphContext for cross-file context/call flow" in prompt + assert "CodeGraph is a whole-project static-analysis index" in prompt + assert "prefer CodeGraphSymbol for known names" in prompt + assert "CodeGraphContext for cross-file relationships" in prompt + assert "use Search/Read for exact literals, paths, and edit ranges" in prompt def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_path): From f6870108e01ae3ac4e7dba0a70f775d1e89332d1 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 07:00:07 -0700 Subject: [PATCH 069/144] refine CodeGraph tool descriptions --- nanocode.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/nanocode.py b/nanocode.py index 21c7b70..551b714 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2364,15 +2364,17 @@ class CodeGraphContextTool(Tool): MAX_CODE_BLOCKS: ClassVar[int] = 8 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "CodeGraph is a whole-project static-analysis index; use CodeGraphContext for semantic context that plain text search cannot infer well: cross-file relationships, call flow, ownership, architecture, and implementation lookup.", - "Prefer this when the question is about how code connects; use Search for exact literals and Read for exact paths/ranges.", - "Query works best as a concise search-style phrase with symbols, paths, concepts, or relationships.", + "Use CodeGraphContext for indexed, low-noise context from the whole-project static-analysis graph.", + "Best for cross-file relationships, call flow, ownership, architecture, and implementation lookup.", + "Use Search for exact literals and Read for exact paths/ranges.", + "Query should be search-like, not chat-like: symbols, paths, concepts, or relationships.", 'Returned code snippets are line-numbered as "line |code" location hints; use Read before exact edits.', ) SIGNATURE: ClassVar[str] = "CodeGraphContext(query) -> CodeGraphContextToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["Tool class schema generation"]', 'Example args: ["Agent tool result context layout"]', + 'Example args: ["ToolCallRunner parse_tool_call"]', ) query: str = "" @@ -2464,8 +2466,9 @@ class CodeGraphSymbolTool(Tool): MAX_RESULTS: ClassVar[int] = 12 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Use CodeGraph's whole-project static-analysis index to find symbol definitions and locations by exact or partial name.", - "Prefer this over broad text Search when you know a class, function, method, variable, or qualified name; it returns structured locations directly.", + "Use CodeGraphSymbol for indexed, low-noise symbol lookup from the whole-project static-analysis graph.", + "Best when you know a class, function, method, variable, or qualified name.", + "Use Search for exact literals or non-symbol text.", "Use Read on the returned file/range before exact edits.", ) SIGNATURE: ClassVar[str] = "CodeGraphSymbol(symbol) -> CodeGraphSymbolToolResult" From 6a46d125e3103bdc6769c87b352ab9b902ead6c8 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 07:26:35 -0700 Subject: [PATCH 070/144] prioritize CodeGraph for structural lookup --- nanocode.py | 20 ++++++++++++-------- tests/test_nanocode_agent.py | 6 +++--- 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/nanocode.py b/nanocode.py index 551b714..6844522 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2365,8 +2365,8 @@ class CodeGraphContextTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Use CodeGraphContext for indexed, low-noise context from the whole-project static-analysis graph.", - "Best for cross-file relationships, call flow, ownership, architecture, and implementation lookup.", - "Use Search for exact literals and Read for exact paths/ranges.", + "Prefer it over Search for structural code questions: implementation locations, cross-file relationships, call flow, ownership, and architecture.", + "Use Search only for exact literals; use Read for exact paths/ranges.", "Query should be search-like, not chat-like: symbols, paths, concepts, or relationships.", 'Returned code snippets are line-numbered as "line |code" location hints; use Read before exact edits.', ) @@ -2467,7 +2467,7 @@ class CodeGraphSymbolTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Use CodeGraphSymbol for indexed, low-noise symbol lookup from the whole-project static-analysis graph.", - "Best when you know a class, function, method, variable, or qualified name.", + "Prefer it over Search when you know or can guess a class, function, method, variable, or qualified name.", "Use Search for exact literals or non-symbol text.", "Use Read on the returned file/range before exact edits.", ) @@ -3386,9 +3386,9 @@ def _content(self, item: ToolResultItem) -> str: ReadTool.NAME: ReadTool, LineCountTool.NAME: LineCountTool, ListTool.NAME: ListTool, - SearchTool.NAME: SearchTool, - CodeGraphContextTool.NAME: CodeGraphContextTool, CodeGraphSymbolTool.NAME: CodeGraphSymbolTool, + CodeGraphContextTool.NAME: CodeGraphContextTool, + SearchTool.NAME: SearchTool, CreateFileTool.NAME: CreateFileTool, EditTool.NAME: EditTool, PatchFileTool.NAME: PatchFileTool, @@ -3397,7 +3397,7 @@ def _content(self, item: ToolResultItem) -> str: GitTool.NAME: GitTool, ToolResultTool.NAME: ToolResultTool, } -PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, SearchTool, CodeGraphContextTool, CodeGraphSymbolTool, PlanModeGitTool, ToolResultTool) +PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, CodeGraphSymbolTool, CodeGraphContextTool, SearchTool, PlanModeGitTool, ToolResultTool) def _canonical_tool_name(name: str | None) -> str: @@ -3513,7 +3513,8 @@ def _state_tool_schema(name: str) -> Json: Language rule: all user-facing assistant text MUST use the latest user language. This includes chat text, progress text, pending-feedback replies, direct responses, and message_for_complete. Do not switch to English when the latest user request is Chinese. Preserve code, identifiers, paths, commands, config keys, API names, and quoted text exactly. -Keep user-facing text plain, concise, and direct. +User-facing text is read in a terminal: keep it plain, concise, direct, and CLI-friendly. +Avoid Markdown tables, large headings, decorative formatting, and long nested bullets unless the user asks for them. Available state tools: goal, plan, hypothesis, known, stable_knowledge, user_rule, verify, forget @@ -3714,6 +3715,8 @@ def _state_tool_schema(name: str) -> Json: - Use the latest user language for all user-facing text, including progress and the final proposed plan. - Preserve code, identifiers, filenames, command names, config keys, API names, and quoted text exactly. - If the user mixes languages, follow the dominant language of the latest request. +- User-facing text is read in a terminal: keep it plain, concise, direct, and CLI-friendly. +- Avoid Markdown tables, large headings, decorative formatting, and long nested bullets unless the user asks for them. READONLY DISCOVERY - Allowed tools: Read, LineCount, List, Search, Recall. @@ -3937,6 +3940,7 @@ def _state_tool_schema(name: str) -> Json: Tracked task: assistant text is optional; never use it instead of the next useful function tool. Goal completion requires goal.complete=true. Language rule: every chat/progress/response text must use the latest user language, including pending-feedback replies and final answers. Do not switch to English when the latest user request is Chinese. +Terminal output rule: every chat/progress/response text should be plain, concise, and CLI-friendly. Avoid Markdown tables, large headings, decorative formatting, and long nested bullets unless requested. YOUR OUTPUT: """ @@ -5721,7 +5725,7 @@ def _format_environment(self) -> str: ] if self._codegraph_available(): lines.append( - "- codegraph_hint: CodeGraph is a whole-project static-analysis index; prefer CodeGraphSymbol for known names and CodeGraphContext for cross-file relationships, call flow, architecture, or implementation lookup; use Search/Read for exact literals, paths, and edit ranges." + "- codegraph_hint: CodeGraph is a whole-project static-analysis index. For structural code lookup, prefer CodeGraphSymbol for known or guessed names and CodeGraphContext for implementation locations, relationships, call flow, and architecture. Use Search only for exact literals; use Read for exact paths/ranges." ) return "\n".join(lines) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index f7047ca..34f6c86 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -516,9 +516,9 @@ def test_codegraph_tool_is_visible_when_initialized(tmp_path, monkeypatch): prompt = agent.build_user_prompt() assert "- codegraph: available" in prompt assert "CodeGraph is a whole-project static-analysis index" in prompt - assert "prefer CodeGraphSymbol for known names" in prompt - assert "CodeGraphContext for cross-file relationships" in prompt - assert "use Search/Read for exact literals, paths, and edit ranges" in prompt + assert "prefer CodeGraphSymbol for known or guessed names" in prompt + assert "CodeGraphContext for implementation locations, relationships, call flow, and architecture" in prompt + assert "Use Search only for exact literals; use Read for exact paths/ranges" in prompt def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_path): From a9a9950800d6b0d48e8b4b6362b461bff5bf1e50 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 07:37:09 -0700 Subject: [PATCH 071/144] release 0.4.0 --- CHANGELOG.md | 22 ++++++++++++++++++++++ nanocode.py | 2 +- pyproject.toml | 2 +- 3 files changed, 24 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 457f767..eafa3e6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,27 @@ # Changelog +## 0.4.0 - 2026-05-19 + +### Added +- Added CodeGraph integration with separate `CodeGraphSymbol` and `CodeGraphContext` tools, plus `/codegraph` maintenance commands. +- Added queued user feedback during long-running turns. +- Added `PatchFile` for multi-location file edits. + +### Changed +- Moved model calls to the OpenAI SDK and function-tool protocol. +- Reworked task-shape prompts for chat, one-shot tasks, and tracked tasks. +- Prioritized CodeGraph for structural code lookup while keeping Search/Read for exact literals and edit ranges. +- Improved terminal UX with persistent status, queued-input handling, Bash live preview, and terminal-friendly assistant output rules. +- Renamed `ListDir` to `List`. +- Improved `Read`, `Edit`, `ReplaceRange`, `PatchFile`, `Bash`, and `Git` tool guidance. +- Simplified gate behavior so only deterministic, correctable model errors are refused. + +### Fixed +- Fixed duplicate final replies for goal-only text answers. +- Fixed repeated recall loops and several format/tool-name compatibility issues. +- Fixed PatchFile diagnostics and empty-hunk handling. +- Fixed queued feedback delivery, Ctrl-C/Ctrl-D handling, and Bash interrupt reporting. + ## 0.3.35 - 2026-05-16 ### Changed diff --git a/nanocode.py b/nanocode.py index 6844522..0320abd 100644 --- a/nanocode.py +++ b/nanocode.py @@ -54,7 +54,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.3.35" +__version__ = "0.4.0" JsonValue: TypeAlias = Any diff --git a/pyproject.toml b/pyproject.toml index 828786a..fc73e0b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.3.35" +version = "0.4.0" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" From 32ccfc8280390a09595605549f89a6c9a7d474d3 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 09:12:00 -0700 Subject: [PATCH 072/144] soften planless command result feedback --- nanocode.py | 11 +++-------- tests/test_nanocode_agent.py | 4 ++-- 2 files changed, 5 insertions(+), 10 deletions(-) diff --git a/nanocode.py b/nanocode.py index 0320abd..d24dde4 100644 --- a/nanocode.py +++ b/nanocode.py @@ -6618,14 +6618,9 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N and not ctx.has_goal_action and not ctx.has_plan_action ): - return self._reject_agent( - on_message, - self._error( - "last command result is visible with no active task.", - "answer the user now, or create Goal/Plan before calling more tools.", - ), - "Retrying: answer the visible command result, or create Goal/Plan before more tools.", - "Task_Gate: visible command result needs answer or Goal/Plan.", + self._warn_agent( + "last command result is visible with no active task.", + "answer the user when results are sufficient; create Goal/Plan for extended work.", ) if ( self.blackboard.task_code == TaskCode.NEW diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 34f6c86..af863cd 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -567,7 +567,7 @@ def test_tracked_task_tool_keeps_working_phase(tmp_path): assert agent.blackboard.task_code == nanocode.TaskCode.WORKING -def test_planless_successful_bash_requires_answer_or_tracked_task_before_more_tools(tmp_path): +def test_planless_successful_bash_warns_before_more_tools(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.blackboard.task_code = nanocode.TaskCode.NEW @@ -582,7 +582,7 @@ def test_planless_successful_bash_requires_answer_or_tracked_task_before_more_to assert first.done is False assert second.done is False - assert agent.session.state.turn_tool_calls == 1 + assert agent.session.state.turn_tool_calls == 2 assert any("last command result is visible" in error for error in agent.agent_feedback_errors) From 8d85e982336e659a615f47838c2b0878252136c1 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 10:54:52 -0700 Subject: [PATCH 073/144] replace codegraph with cymbal code inspection tools --- CHANGELOG.md | 4 +- README.md | 3 +- design.md | 9 +- nanocode.py | 511 +++++++++++++++----------- tests/test_nanocode_agent.py | 49 ++- tests/test_nanocode_codegraph_tool.py | 130 ------- tests/test_nanocode_commands.py | 63 +--- tests/test_nanocode_cymbal_tools.py | 199 ++++++++++ tests/test_nanocode_loop.py | 3 - 9 files changed, 538 insertions(+), 433 deletions(-) delete mode 100644 tests/test_nanocode_codegraph_tool.py create mode 100644 tests/test_nanocode_cymbal_tools.py diff --git a/CHANGELOG.md b/CHANGELOG.md index eafa3e6..614301e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,14 +3,14 @@ ## 0.4.0 - 2026-05-19 ### Added -- Added CodeGraph integration with separate `CodeGraphSymbol` and `CodeGraphContext` tools, plus `/codegraph` maintenance commands. +- Added indexed code inspection tools for symbol lookup, symbol investigation, and file outlines when the local index is available. - Added queued user feedback during long-running turns. - Added `PatchFile` for multi-location file edits. ### Changed - Moved model calls to the OpenAI SDK and function-tool protocol. - Reworked task-shape prompts for chat, one-shot tasks, and tracked tasks. -- Prioritized CodeGraph for structural code lookup while keeping Search/Read for exact literals and edit ranges. +- Prioritized indexed code inspection for structural lookup while keeping Search/Read for exact literals and edit ranges. - Improved terminal UX with persistent status, queued-input handling, Bash live preview, and terminal-friendly assistant output rules. - Renamed `ListDir` to `List`. - Improved `Read`, `Edit`, `ReplaceRange`, `PatchFile`, `Bash`, and `Git` tool guidance. diff --git a/README.md b/README.md index f175a67..ed853b7 100644 --- a/README.md +++ b/README.md @@ -80,7 +80,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Tools - File: `Read`, `LineCount`, `List`, `Search`. -- Codebase: `CodeGraphSymbol`, `CodeGraphContext` when the local `codegraph` CLI is installed and initialized. +- Codebase: `FindCodeSymbol`, `InspectCodeSymbol`, and `OutlineCodeFile` when the local `cymbal` CLI is installed. - Edit: `Edit`, `ReplaceRange`. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. @@ -89,7 +89,6 @@ nanocode currently targets macOS and Linux. Windows is not supported. - Info: `/help [question]`, `/status`, `/rules`, `/compact`. - Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/reason-payload [value]`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. -- CodeGraph: `/codegraph [status|sync|init|index]`. - Maintenance: `/clean`. - Exit: `/exit`, `/quit`. diff --git a/design.md b/design.md index 1d8e912..05adb60 100644 --- a/design.md +++ b/design.md @@ -67,7 +67,7 @@ When the model outputs `goal` with a different current-task goal: ACT mode receives a working context: - goal, plan, hypotheses, verification -- environment, including whether local CodeGraph is available +- environment, including whether local symbol inspection is available - Tool Result Index - Kept Tool Results - Unreduced Tool Results @@ -89,9 +89,10 @@ OBSERVE receives a smaller cleanup context: OBSERVE reduces tool-result noise before ACT continues. -Optional tools can be environment-gated. For example, CodeGraph tools are shown -to the model only when the local `codegraph` CLI exists and the current project -has a `.codegraph` index. +Optional tools can be environment-gated. For example, `FindCodeSymbol`, +`InspectCodeSymbol`, and `OutlineCodeFile` are shown only when the local +`cymbal` CLI exists. They accept symbol queries or file paths, not +natural-language questions. Context layout: diff --git a/nanocode.py b/nanocode.py index d24dde4..9a4a5d5 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1258,6 +1258,14 @@ def _function_tool_schema(name: str, description: str, parameters: Json) -> Json return {"type": "function", "function": {"name": name, "description": description, "parameters": parameters}} +def _cymbal_available() -> bool: + return bool(shutil.which("cymbal")) + + +def _cymbal_status_label() -> str: + return "available" if _cymbal_available() else "not installed" + + def _json_value_schema(depth: int = 3) -> Json: values: list[Json] = [{"type": "string"}, {"type": "number"}, {"type": "boolean"}, {"type": "null"}] if depth > 0: @@ -1892,7 +1900,10 @@ def _format_range_result( class LineCountTool(Tool): NAME: ClassVar[str] = "LineCount" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY - DESCRIPTION: ClassVar[tuple[str, ...]] = ("Count lines for one or more files. Useful before reading large files or deciding Read ranges.",) + DESCRIPTION: ClassVar[tuple[str, ...]] = ( + "Count lines for one or more files. Useful before reading large files or deciding Read ranges.", + "Returns total line count across all requested files.", + ) SIGNATURE: ClassVar[str] = "LineCount(*filepaths) -> LineCountToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["code.py", "other.py"]',) @@ -1935,6 +1946,7 @@ class ListTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "List one directory non-recursively; optional glob filters immediate entry names.", + "Returns each immediate entry with type and relative path.", "Batch multiple List actions in one turn when checking several known directories.", ) SIGNATURE: ClassVar[str] = "List([dirpath][, glob]) -> ListToolResult" @@ -2006,6 +2018,7 @@ class SearchTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Case-insensitive regex search before Read; use A|B|C for alternatives and \\n for multiline matches.", + "Returns matching file paths, 0-based line numbers, matched lines, and requested context lines.", "For exact text, escape regex metacharacters like braces, parens, dots, stars, and brackets.", "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py, set context=N for 0..30 lines; omitted path defaults to current directory.", "Second positional arg is always path, third positional arg is always glob; with path=, extra leading positional args are joined as regex alternatives.", @@ -2357,131 +2370,198 @@ def call(self) -> str: return self._call_python() +class CymbalResultFormatter: + MAX_OUTLINE_ITEMS: ClassVar[int] = 160 + MAX_SEARCH_ITEMS: ClassVar[int] = 80 + + @staticmethod + def read_start(value: JsonValue) -> int: + try: + return max(0, int(value) - 1) + except (TypeError, ValueError): + return 0 + + @classmethod + def location(cls, item: Json) -> str: + path = _json_str(item.get("rel_path")) or _json_str(item.get("file")) or "?" + start_value = item.get("start_line", item.get("line")) + if start_value is None: + return path + start = cls.read_start(start_value) + end_value = item.get("end_line") + if end_value is None: + return path + ":" + str(start) + try: + end = max(start, int(end_value)) + except (TypeError, ValueError): + end = start + return path + ":" + str(start) + ":" + str(end) + + @classmethod + def symbol_line(cls, item: Json) -> str: + name = _json_str(item.get("name")) or _json_str(item.get("implementer")) or _json_str(item.get("caller")) or _json_str(item.get("symbol")) or "(unknown)" + kind = _json_str(item.get("kind")) + extras = [] + if _json_str(item.get("caller")) and _json_str(item.get("symbol")): + extras.append("symbol=" + str(item["symbol"])) + if _json_str(item.get("target")): + extras.append("target=" + str(item["target"])) + if _json_str(item.get("signature")): + extras.append(str(item["signature"])) + if item.get("resolved") is False: + extras.append("unresolved") + return " ".join(part for part in (kind, name, cls.location(item), " ".join(extras)) if part) + + @classmethod + def format_investigate(cls, result: Json) -> list[str]: + lines: list[str] = [] + symbol = _json_dict(result.get("symbol")) + if symbol: + lines.append('Line numbers are 0-based and match Read/ReplaceRange ranges.') + lines.append("* symbol: " + cls.symbol_line(symbol)) + source = _json_str(result.get("source")) + if source and symbol: + lines.extend(["", ReadTool._numbered_content(source, cls.read_start(symbol.get("start_line"))).rstrip("\n"), ""]) + for label, key in (("members", "members"), ("references", "refs"), ("impact", "impact"), ("implementors", "implementors")): + items = [_json_dict(item) for item in _json_list(result.get(key))] + if items: + lines.extend(["<" + label + ">", *(cls.symbol_line(item) for item in items[:50]), ""]) + return lines + + @classmethod + def format_outline(cls, items: list[Json]) -> list[str]: + lines = ['Line numbers are 0-based and match Read/ReplaceRange ranges.', ""] + lines.extend(cls.symbol_line(item) for item in items[: cls.MAX_OUTLINE_ITEMS]) + if len(items) > cls.MAX_OUTLINE_ITEMS: + lines.append("... " + str(len(items) - cls.MAX_OUTLINE_ITEMS) + " more") + lines.append("") + return lines + + @classmethod + def format_symbol_search(cls, items: list[Json]) -> list[str]: + lines = ['Line numbers are 0-based and match Read/ReplaceRange ranges.', ""] + lines.extend(cls.symbol_line(item) for item in items[: cls.MAX_SEARCH_ITEMS]) + if len(items) > cls.MAX_SEARCH_ITEMS: + lines.append("... " + str(len(items) - cls.MAX_SEARCH_ITEMS) + " more") + lines.append("") + return lines + + @dataclass -class CodeGraphContextTool(Tool): - NAME: ClassVar[str] = "CodeGraphContext" - MAX_NODES: ClassVar[int] = 40 - MAX_CODE_BLOCKS: ClassVar[int] = 8 +class FindCodeSymbolTool(Tool): + NAME: ClassVar[str] = "FindCodeSymbol" + DEFAULT_LIMIT: ClassVar[int] = 20 + MAX_LIMIT: ClassVar[int] = 80 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Use CodeGraphContext for indexed, low-noise context from the whole-project static-analysis graph.", - "Prefer it over Search for structural code questions: implementation locations, cross-file relationships, call flow, ownership, and architecture.", - "Use Search only for exact literals; use Read for exact paths/ranges.", - "Query should be search-like, not chat-like: symbols, paths, concepts, or relationships.", - 'Returned code snippets are line-numbered as "line |code" location hints; use Read before exact edits.', - ) - SIGNATURE: ClassVar[str] = "CodeGraphContext(query) -> CodeGraphContextToolResult" - EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Example args: ["Tool class schema generation"]', - 'Example args: ["Agent tool result context layout"]', - 'Example args: ["ToolCallRunner parse_tool_call"]', + "Find indexed symbols by one name or prefix; results rank exact, prefix, then fuzzy matches.", + "Returns candidate name, kind, language, 0-based file/range, and signature.", + "Optional limit controls max returned symbols; default 20, max 80.", + "Input must be one symbol-like token, not natural language or literal text patterns.", ) + SIGNATURE: ClassVar[str] = "FindCodeSymbol(query[, limit]) -> FindCodeSymbolToolResult" + EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["Tool"]', 'Example args: ["tool_schema"]', 'Example args: ["Tool", 40]') query: str = "" - codegraph_path: str = "" + limit: int = DEFAULT_LIMIT + cymbal_path: str = "" cwd: str = "" timeout: int = 60 + @classmethod + def tool_schema(cls) -> Json: + schema = super().tool_schema() + schema["function"]["parameters"]["properties"]["args"] = { + "type": "array", + "minItems": 1, + "maxItems": 2, + "items": {"type": ["string", "number"], "description": "Symbol name/prefix, then optional max result count."}, + } + return schema + @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: - if len(args) != 1: - raise ToolCallArgError("requires args: query") + if not 1 <= len(args) <= 2: + raise ToolCallArgError("requires args: query[, limit]") query = str(args[0]).strip() if not query: raise ToolCallArgError("query cannot be empty") - codegraph_path = shutil.which("codegraph") - if not codegraph_path: - raise ToolCallError("codegraph not found; install CodeGraph first") - return cls(query=query, codegraph_path=codegraph_path, cwd=session.cwd, timeout=session.settings.shell_timeout) + if re.search(r"\s", query): + raise ToolCallArgError("query must be one symbol name or prefix; do not pass natural language") + limit = cls.DEFAULT_LIMIT + if len(args) == 2: + try: + limit = min(cls.MAX_LIMIT, max(1, int(args[1]))) + except (TypeError, ValueError): + raise ToolCallArgError("limit must be an integer") + cymbal_path = shutil.which("cymbal") + if not cymbal_path: + raise ToolCallError("cymbal not found") + return cls(query=query, limit=limit, cymbal_path=cymbal_path, cwd=session.cwd, timeout=session.settings.shell_timeout) def preview(self) -> str: - return "CodeGraphContext(" + json.dumps(self.query, ensure_ascii=False) + ")" + return "FindCodeSymbol(" + json.dumps(self.query, ensure_ascii=False) + ")" def call(self) -> str: - if not os.path.isdir(os.path.join(self.cwd, ".codegraph")): - raise ToolCallError("CodeGraph not initialized; run /codegraph init") - cmd = [ - self.codegraph_path, - "context", - self.query, - "--path", - self.cwd, - "--max-nodes", - str(self.MAX_NODES), - "--max-code", - str(self.MAX_CODE_BLOCKS), - "--format", - "markdown", - ] + cmd = [self.cymbal_path, "search", self.query, "--limit", str(self.limit), "--json"] try: proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) except subprocess.TimeoutExpired as error: return self._format(-1, error.stdout or "", (error.stderr or "") + "timeout") - return self._format(proc.returncode, self._number_code_blocks(_clean_terminal_output(proc.stdout)), _clean_terminal_output(proc.stderr)) + return self._format(proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) def _format(self, exit_code: int, stdout: str, stderr: str) -> str: - lines = ["", "* exit_code: " + str(exit_code)] - if stdout: + lines = ["", "* exit_code: " + str(exit_code)] + if items := self._symbol_results(stdout): + lines.extend(CymbalResultFormatter.format_symbol_search(items)) + elif stdout: lines.extend(["", stdout.rstrip("\n"), ""]) if stderr: lines.extend(["", stderr.rstrip("\n"), ""]) - lines.append("") + lines.append("") return "\n".join(lines) - @classmethod - def _number_code_blocks(cls, text: str) -> str: - heading_pattern = re.compile(r"^#### .+ \(([^():]+):(\d+)\)\s*$") - lines = text.splitlines(keepends=True) - numbered: list[str] = [] - pending_start: int | None = None - in_code_block = False - current_line = 0 - for line in lines: - heading = heading_pattern.match(line.rstrip("\n")) - if not in_code_block and heading: - try: - pending_start = int(heading.group(2)) - except ValueError: - pending_start = None - numbered.append(line) - continue - if line.startswith("```"): - in_code_block = not in_code_block - current_line = pending_start or 0 - numbered.append(line) - if not in_code_block: - pending_start = None - continue - if in_code_block and pending_start is not None: - numbered.append(f"{current_line:>7} |{line}") - current_line += 1 - continue - numbered.append(line) - return "".join(numbered) + @staticmethod + def _symbol_results(stdout: str) -> list[Json]: + try: + return [_json_dict(item) for item in _json_list(_json_dict(json.loads(stdout)).get("results"))] + except json.JSONDecodeError: + return [] @dataclass -class CodeGraphSymbolTool(Tool): - NAME: ClassVar[str] = "CodeGraphSymbol" - MAX_RESULTS: ClassVar[int] = 12 +class InspectCodeSymbolTool(Tool): + NAME: ClassVar[str] = "InspectCodeSymbol" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Use CodeGraphSymbol for indexed, low-noise symbol lookup from the whole-project static-analysis graph.", - "Prefer it over Search when you know or can guess a class, function, method, variable, or qualified name.", - "Use Search for exact literals or non-symbol text.", - "Use Read on the returned file/range before exact edits.", + "Inspect one indexed symbol, Class.member, or symbol prefix.", + "Returns line-numbered source plus members, references, shallow impact/callers, and implementors when available.", + "Use it to understand a class/function/API and nearby relationships from the index.", + "Symbol matching is case-insensitive; returned line numbers are 0-based.", + "Not for files, directories, module paths, natural language, or literal text patterns.", ) - SIGNATURE: ClassVar[str] = "CodeGraphSymbol(symbol) -> CodeGraphSymbolToolResult" + SIGNATURE: ClassVar[str] = "InspectCodeSymbol(symbol) -> InspectCodeSymbolToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["Tool"]', 'Example args: ["Agent.run"]', ) symbol: str = "" - codegraph_path: str = "" + cymbal_path: str = "" cwd: str = "" timeout: int = 60 + @classmethod + def tool_schema(cls) -> Json: + schema = super().tool_schema() + schema["function"]["parameters"]["properties"]["args"] = { + "type": "array", + "minItems": 1, + "maxItems": 1, + "items": {"type": "string", "description": "One symbol, Class.member, or symbol prefix."}, + } + return schema + @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: if len(args) != 1: @@ -2489,18 +2569,24 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: symbol = str(args[0]).strip() if not symbol: raise ToolCallArgError("symbol cannot be empty") - codegraph_path = shutil.which("codegraph") - if not codegraph_path: - raise ToolCallError("codegraph not found; install CodeGraph first") - return cls(symbol=symbol, codegraph_path=codegraph_path, cwd=session.cwd, timeout=session.settings.shell_timeout) + cymbal_path = shutil.which("cymbal") + if not cymbal_path: + raise ToolCallError("cymbal not found") + path_target = session.resolve_path(symbol) + dotted_path = session.resolve_path(symbol.replace(".", os.sep)) if "." in symbol and os.sep not in symbol else "" + if os.path.exists(path_target) or (dotted_path and os.path.exists(dotted_path)): + raise ToolCallArgError("symbol target looks like a file or directory; use OutlineCodeFile, List, Search, or Read") + if re.search(r"\s", symbol): + raise ToolCallArgError("symbol must be one symbol, Class.member, or symbol prefix; do not pass natural language") + if "." in symbol and not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?", symbol): + raise ToolCallArgError("symbol looks like a module path; use List/Search/Read for modules/packages, or pass a specific symbol") + return cls(symbol=symbol, cymbal_path=cymbal_path, cwd=session.cwd, timeout=session.settings.shell_timeout) def preview(self) -> str: - return "CodeGraphSymbol(" + json.dumps(self.symbol, ensure_ascii=False) + ")" + return "InspectCodeSymbol(" + json.dumps(self.symbol, ensure_ascii=False) + ")" def call(self) -> str: - if not os.path.isdir(os.path.join(self.cwd, ".codegraph")): - raise ToolCallError("CodeGraph not initialized; run /codegraph init") - cmd = [self.codegraph_path, "query", self.symbol, "--path", self.cwd, "--limit", str(self.MAX_RESULTS), "-j"] + cmd = [self.cymbal_path, "investigate", self.symbol, "--json"] try: proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) except subprocess.TimeoutExpired as error: @@ -2508,38 +2594,97 @@ def call(self) -> str: return self._format(proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) def _format(self, exit_code: int, stdout: str, stderr: str) -> str: - lines = ["", "* exit_code: " + str(exit_code)] - symbols = self._symbols(stdout) - if symbols: - lines.extend(["", *symbols, ""]) + lines = ["", "* exit_code: " + str(exit_code)] + if result := self._investigate_result(stdout): + lines.extend(CymbalResultFormatter.format_investigate(result)) elif stdout: lines.extend(["", stdout.rstrip("\n"), ""]) if stderr: lines.extend(["", stderr.rstrip("\n"), ""]) - lines.append("") + lines.append("") return "\n".join(lines) + @staticmethod + def _investigate_result(stdout: str) -> Json | None: + try: + data = _json_dict(json.loads(stdout)) + except json.JSONDecodeError: + return None + result = _json_dict(_json_dict(data.get("results")).get("result")) + return result or None + + +@dataclass +class OutlineCodeFileTool(Tool): + NAME: ClassVar[str] = "OutlineCodeFile" + EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY + DESCRIPTION: ClassVar[tuple[str, ...]] = ( + "Outline indexed symbols in one file.", + "Pass a file path only; directories and symbols are not supported.", + "Returns classes, functions, methods, kinds, signatures, and 0-based locations.", + ) + SIGNATURE: ClassVar[str] = "OutlineCodeFile(filepath) -> OutlineCodeFileToolResult" + EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["nanocode.py"]',) + + filepath: str = "" + cymbal_path: str = "" + cwd: str = "" + timeout: int = 60 + + @classmethod + def tool_schema(cls) -> Json: + schema = super().tool_schema() + schema["function"]["parameters"]["properties"]["args"] = { + "type": "array", + "minItems": 1, + "maxItems": 1, + "items": {"type": "string", "description": "One file path."}, + } + return schema + @classmethod - def _symbols(cls, stdout: str) -> list[str]: + def make(cls, session: Session, args: list[JsonValue]) -> Self: + if len(args) != 1: + raise ToolCallArgError("requires args: filepath") + filepath = session.resolve_path(str(args[0]).strip()) + if not os.path.isfile(filepath): + raise ToolCallArgError("filepath must be an existing file; directories and symbols are not supported") + cymbal_path = shutil.which("cymbal") + if not cymbal_path: + raise ToolCallError("cymbal not found") + return cls(filepath=filepath, cymbal_path=cymbal_path, cwd=session.cwd, timeout=session.settings.shell_timeout) + + def requires_confirmation(self, session: Session) -> bool: + return not session.is_path_in_cwd(self.filepath) + + def preview(self) -> str: + return "OutlineCodeFile(" + json.dumps(os.path.relpath(self.filepath, self.cwd), ensure_ascii=False) + ")" + + def call(self) -> str: + cmd = [self.cymbal_path, "outline", self.filepath, "--json"] try: - values = _json_list(json.loads(stdout)) + proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) + except subprocess.TimeoutExpired as error: + return self._format(-1, error.stdout or "", (error.stderr or "") + "timeout") + return self._format(proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) + + def _format(self, exit_code: int, stdout: str, stderr: str) -> str: + lines = ["", "* exit_code: " + str(exit_code)] + if items := self._outline_results(stdout): + lines.extend(CymbalResultFormatter.format_outline(items)) + elif stdout: + lines.extend(["", stdout.rstrip("\n"), ""]) + if stderr: + lines.extend(["", stderr.rstrip("\n"), ""]) + lines.append("") + return "\n".join(lines) + + @staticmethod + def _outline_results(stdout: str) -> list[Json]: + try: + return [_json_dict(item) for item in _json_list(_json_dict(json.loads(stdout)).get("results"))] except json.JSONDecodeError: return [] - lines = [] - for index, item in enumerate(values, 1): - node = _json_dict(_json_dict(item).get("node")) - if not node: - continue - line_range = str(node.get("startLine") or "?") - if node.get("endLine") and node.get("endLine") != node.get("startLine"): - line_range += "-" + str(node["endLine"]) - text = f"{index}. {node.get('kind') or 'symbol'} {node.get('qualifiedName') or node.get('name') or '(unknown)'} {node.get('filePath') or '?'}:{line_range}" - if node.get("signature"): - text += " " + str(node["signature"]) - if isinstance(_json_dict(item).get("score"), int | float): - text += " score=" + f"{float(_json_dict(item)['score']):.1f}" - lines.append(text) - return lines @dataclass @@ -2548,6 +2693,7 @@ class EditTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Replace/delete exact literal text in an existing file; default requires one unique match, optional 'all' replaces every match.", + "Returns changed path plus replacement count or created=true.", "If the target is structural or line ranges are clearer, use ReplaceRange.", ) SIGNATURE: ClassVar[str] = "Edit(filepath, find, replace[, all]) -> EditToolResult" @@ -2643,6 +2789,7 @@ class PatchFileTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Apply a small single-file unified-diff-style patch for coordinated multi-location edits.", + "Returns changed path and applied hunk count.", "Inside hunks, every line should start with space, -, or +; indented context copied without the extra marker is tolerated.", "Context lines must be exact file text, without Read display prefixes.", "Each hunk must include enough unchanged context to match exactly once; all hunks must apply or nothing is written.", @@ -2803,6 +2950,7 @@ class CreateFileTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Create a new UTF-8 file with short initial content; target file must not exist.", + "Returns changed path and created=true.", "For substantial new files, create only a small skeleton first, then grow it with focused ReplaceRange edits.", ) SIGNATURE: ClassVar[str] = "CreateFile(filepath, content) -> CreateFileToolResult" @@ -2869,6 +3017,7 @@ class ReplaceRangeTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Replace one or more small Read-backed [start,end) ranges in an existing file; best when exact line ranges are known or target text is not unique.", + "Returns changed path plus resolved ranges, fingerprints, and relocation info when applicable.", "Pass ranges as [[start,end,fingerprint,before_context,after_context,content], ...].", "Pass exact before_context and after_context when known; empty boundary context is allowed for non-empty replacements.", "Content is only the replacement for that range; do not include boundary lines.", @@ -3072,6 +3221,7 @@ class BashTool(Tool): NAME: ClassVar[str] = "Bash" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run one explicit shell command via bash -lc in cwd.", + "Returns exit_code plus stdout/stderr; long output is stored and bounded in context.", "Prefer dedicated tools when they provide structured repo access; use Bash when shell semantics or pipelines are the clearest path.", "Good Bash uses include tests, builds, and Unix text-tool pipelines with find, sed, awk, perl, xargs, or grep.", "Mechanical shell edits are allowed, but verify afterward with Git diff, Read, tests, or another focused check.", @@ -3247,6 +3397,7 @@ class GitTool(Tool): NAME: ClassVar[str] = "Git" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run git without a shell for repository state, history, status, diff, and changed files.", + "Returns exit_code plus stdout/stderr.", "Pass each git argument separately; optional first arg cwd=path changes repository directory.", "By default, stage/commit only files changed for the current task; include unrelated dirty files only when the user explicitly asks.", ) @@ -3310,6 +3461,7 @@ class PlanModeGitTool(GitTool): NAME: ClassVar[str] = "Git" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run readonly git commands only: status, diff, log, show, rev-parse, ls-files, grep, blame.", + "Returns exit_code plus stdout/stderr.", "Pass each git argument separately; optional first arg cwd=path changes repository directory.", ) @@ -3320,6 +3472,7 @@ class ToolResultTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Recall stored tool results by tr.* key; pass optional 0-based line ranges to read exact slices from the stored full log.", + "Returns recalled result metadata plus bounded content or requested full-log slices.", ) SIGNATURE: ClassVar[str] = "Recall(key...[, range_token...]) -> RecallToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( @@ -3386,8 +3539,9 @@ def _content(self, item: ToolResultItem) -> str: ReadTool.NAME: ReadTool, LineCountTool.NAME: LineCountTool, ListTool.NAME: ListTool, - CodeGraphSymbolTool.NAME: CodeGraphSymbolTool, - CodeGraphContextTool.NAME: CodeGraphContextTool, + FindCodeSymbolTool.NAME: FindCodeSymbolTool, + OutlineCodeFileTool.NAME: OutlineCodeFileTool, + InspectCodeSymbolTool.NAME: InspectCodeSymbolTool, SearchTool.NAME: SearchTool, CreateFileTool.NAME: CreateFileTool, EditTool.NAME: EditTool, @@ -3397,7 +3551,17 @@ def _content(self, item: ToolResultItem) -> str: GitTool.NAME: GitTool, ToolResultTool.NAME: ToolResultTool, } -PLAN_MODE_TOOLS: tuple[ToolClass, ...] = (ReadTool, LineCountTool, ListTool, CodeGraphSymbolTool, CodeGraphContextTool, SearchTool, PlanModeGitTool, ToolResultTool) +PLAN_MODE_TOOLS: tuple[ToolClass, ...] = ( + ReadTool, + LineCountTool, + ListTool, + FindCodeSymbolTool, + OutlineCodeFileTool, + InspectCodeSymbolTool, + SearchTool, + PlanModeGitTool, + ToolResultTool, +) def _canonical_tool_name(name: str | None) -> str: @@ -3635,7 +3799,7 @@ def _state_tool_schema(name: str) -> Json: - stop investigating when the exact target and next edit/check are clear DISCOVERY AND EDITING -Use Search/List/LineCount when path, symbol, range, or target is unknown. +{ __discovery_hint__ } Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. Read line prefixes are display-only; edit text starts immediately after "|". @@ -5721,11 +5885,10 @@ def _format_environment(self) -> str: "- system: " + self.session.system, "- arch: " + self.session.arch, "- cwd: " + self.session.cwd, - "- codegraph: " + self._codegraph_status_label(), ] - if self._codegraph_available(): + if self._inspect_code_available(): lines.append( - "- codegraph_hint: CodeGraph is a whole-project static-analysis index. For structural code lookup, prefer CodeGraphSymbol for known or guessed names and CodeGraphContext for implementation locations, relationships, call flow, and architecture. Use Search only for exact literals; use Read for exact paths/ranges." + "- inspect_code_hint: Use FindCodeSymbol for symbol/prefix candidates (case-insensitive, optional limit default 20 max 80), InspectCodeSymbol for chosen symbols, and OutlineCodeFile for known file structure. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." ) return "\n".join(lines) @@ -5758,25 +5921,31 @@ def _system_prompt(self, template: str | None = None, *, tools: Iterable[ToolCla return ( (template or AGENT_SYSTEM_PROMPT) .replace("{ __tool_names__ }", "|".join(tool.NAME for tool in tool_classes)) + .replace("{ __discovery_hint__ }", self._discovery_prompt_hint(tool_classes)) .replace("{ __hypothesis_status_text__ }", HYPOTHESIS_STATUS_TEXT) .strip() ) def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> tuple[ToolClass, ...]: tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) - if self._codegraph_available(): + if self._inspect_code_available(): return tool_classes - return tuple(tool for tool in tool_classes if tool not in (CodeGraphContextTool, CodeGraphSymbolTool)) + return tuple(tool for tool in tool_classes if tool not in (FindCodeSymbolTool, OutlineCodeFileTool, InspectCodeSymbolTool)) - def _codegraph_available(self) -> bool: - return bool(shutil.which("codegraph") and os.path.isdir(os.path.join(self.session.cwd, ".codegraph"))) + def _inspect_code_available(self) -> bool: + return _cymbal_available() - def _codegraph_status_label(self) -> str: - if not shutil.which("codegraph"): - return "not installed" - if not os.path.isdir(os.path.join(self.session.cwd, ".codegraph")): - return "not initialized; run /codegraph init" - return "available" + def _discovery_prompt_hint(self, tool_classes: Iterable[ToolClass]) -> str: + if FindCodeSymbolTool not in tool_classes and OutlineCodeFileTool not in tool_classes and InspectCodeSymbolTool not in tool_classes: + return "Use Search/List/LineCount when path, symbol, range, or target is unknown." + return ( + "For structural code discovery, prefer indexed code tools before Search/Read.\n" + "- Use FindCodeSymbol for symbol candidates by name or prefix.\n" + "- Use InspectCodeSymbol for line-numbered source, members, references, and implementors of one symbol.\n" + "- Use OutlineCodeFile for a file-level symbol outline.\n" + "- Use Search for exact literal text, config, comments, logs, or when no useful path/symbol guess exists.\n" + "- Use List/LineCount when path shape or file size is unknown." + ) def _format_user_request(self) -> str: user_request = self.blackboard.user_input or "(empty)" @@ -7053,7 +7222,6 @@ class CommandSpec: CommandSpec("/compact", "Compact conversation history", "Info", "/compact"), CommandSpec("/config", "Show resolved runtime config", "Config", "/config"), CommandSpec("/context", "Show or set context budget", "Config", "/context [low|medium|high]"), - CommandSpec("/codegraph", "Run CodeGraph maintenance", "Config", "/codegraph [status|sync|init|index]"), CommandSpec("/set", "Set a runtime config override", "Config", "/set "), CommandSpec("/api", "Show or set provider API format", "Config", "/api [auto|chat|responses]"), CommandSpec("/model", "Show or set model and reasoning", "Config", "/model [model_name]"), @@ -7122,7 +7290,6 @@ class CommandDispatcher: COMMAND_ALIASES = {"/context-budget": "/context", "/context_budget": "/context"} API_USAGE = "Usage: /api [auto|chat|responses]" REASON_PAYLOAD_USAGE = "Usage: /reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" - CODEGRAPH_USAGE = "Usage: /codegraph [status|sync|init|index]" def __init__( self, @@ -7386,6 +7553,7 @@ def _status(self, args: str) -> str: + session.settings.context_budget, "conversation: " + str(len(session.state.conversation)) + "/" + str(session.settings.compact_at), "tool_calls: turn=" + str(session.state.turn_tool_calls) + " session=" + str(session.state.session_tool_calls), + "tools: cymbal=" + _cymbal_status_label(), "tokens: last=" + _format_count(session.state.last_total_tokens) + " session=" + _format_count(session.state.session_total_tokens), "models:", model_usage, @@ -7410,81 +7578,6 @@ def _context(self, args: str) -> str: return "Set runtime.context_budget = " + value + "\n" + self._format_context_budget() return self._format_context_budget() - def _codegraph(self, args: str) -> str: - command = args.strip() - if command not in {"status", "sync", "init", "index"}: - return self.CODEGRAPH_USAGE - codegraph_path = shutil.which("codegraph") - if not codegraph_path: - return "codegraph not found; install CodeGraph first" - argv = { - "status": [codegraph_path, "status", "-j", "."], - "sync": [codegraph_path, "sync", "-q", "."], - "init": [codegraph_path, "init", ".", "--index"], - "index": [codegraph_path, "index", "-q", "."], - }[command] - return self._with_status(lambda: self._run_codegraph(command, argv)) - - def _run_codegraph(self, command: str, argv: list[str]) -> str: - try: - proc = subprocess.run( - argv, - cwd=self.agent.session.cwd, - text=True, - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - timeout=max(300, self.agent.session.settings.shell_timeout), - env=_plain_command_env(), - ) - return self._format_codegraph_command_result(command, proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) - except subprocess.TimeoutExpired as error: - return self._format_codegraph_command_result( - command, - -1, - _clean_terminal_output(error.stdout or ""), - _clean_terminal_output(error.stderr or "") + "timeout", - ) - - def _format_codegraph_command_result(self, command: str, exit_code: int, stdout: str, stderr: str) -> str: - if command == "status" and exit_code == 0: - return self._format_codegraph_status(stdout) - if exit_code == 0: - detail = stdout or stderr - return "CodeGraph " + command + " completed." + ("\n" + detail if detail else "") - lines = ["CodeGraph " + command + " failed (exit " + str(exit_code) + ")."] - if stderr: - lines.append(stderr) - if stdout: - lines.append(stdout) - return "\n".join(lines) - - def _format_codegraph_status(self, stdout: str) -> str: - try: - data = json.loads(stdout) - except json.JSONDecodeError: - return stdout or "CodeGraph status unavailable." - pending = _json_dict(data.get("pendingChanges")) - return "\n".join( - [ - "CodeGraph: " + ("initialized" if data.get("initialized") else "not initialized"), - "project: " + (_json_str(data.get("projectPath")) or self.agent.session.cwd), - "index: files=" - + str(data.get("fileCount", 0)) - + " nodes=" - + str(data.get("nodeCount", 0)) - + " edges=" - + str(data.get("edgeCount", 0)) - + " backend=" - + (_json_str(data.get("backend")) or "unknown"), - "pending: added=" - + str(pending.get("added", 0)) - + " modified=" - + str(pending.get("modified", 0)) - + " removed=" - + str(pending.get("removed", 0)), - ] - ) - def _format_context_budget(self) -> str: budget = self.agent.context_budget() return "\n".join( @@ -8976,12 +9069,6 @@ def get_completions(self, document, complete_event): if value.startswith(text): yield Completion(value, start_position=-len(text)) return - if text.startswith("/codegraph "): - text = text[len("/codegraph ") :] - for value in ("status", "sync", "init", "index"): - if value.startswith(text): - yield Completion(value, start_position=-len(text)) - return if text.startswith("/reason-payload "): text = text[len("/reason-payload ") :] for value in CHAT_REASONING_CHOICES: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index af863cd..e6903ff 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -474,7 +474,8 @@ def test_act_prompt_tells_model_to_reply_to_pending_feedback_first(tmp_path): assert "pending-feedback replies" in prompt -def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path): +def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") agent = Agent(Session(cwd=str(tmp_path))) prompt = agent._system_prompt() @@ -488,37 +489,49 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path): assert "do not create Goal, Plan, Known, or Verify just to report the result" in prompt assert "record Verify only after edits, explicit checks, or correctness-sensitive work" in prompt assert "Tracked tasks are complete only after goal.complete=true is set" in prompt - assert "CodeGraphContext" not in prompt - assert "CodeGraphSymbol" not in prompt + assert "InspectCodeSymbol" not in prompt + assert "OutlineCodeFile" not in prompt + assert "FindCodeSymbol" not in prompt + assert "Use Search/List/LineCount when path, symbol, range, or target is unknown" in prompt + assert "__discovery_hint__" not in prompt -def test_codegraph_tool_is_hidden_until_available(tmp_path, monkeypatch): +def test_inspect_code_tools_is_hidden_until_available(tmp_path, monkeypatch): agent = Agent(Session(cwd=str(tmp_path))) monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] - assert "CodeGraphContext" not in tool_names - assert "CodeGraphSymbol" not in tool_names - assert "- codegraph: not installed" in agent.build_user_prompt() - assert "codegraph_hint" not in agent.build_user_prompt() + assert "FindCodeSymbol" not in tool_names + assert "InspectCodeSymbol" not in tool_names + assert "OutlineCodeFile" not in tool_names + prompt = agent.build_user_prompt() + assert "- inspect_code:" not in prompt + assert "inspect_code_hint" not in prompt -def test_codegraph_tool_is_visible_when_initialized(tmp_path, monkeypatch): - (tmp_path / ".codegraph").mkdir() +def test_inspect_code_tools_is_visible_when_available(tmp_path, monkeypatch): agent = Agent(Session(cwd=str(tmp_path))) - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] - assert "CodeGraphContext" in tool_names - assert "CodeGraphSymbol" in tool_names + assert "FindCodeSymbol" in tool_names + assert "InspectCodeSymbol" in tool_names + assert "OutlineCodeFile" in tool_names + system_prompt = agent._system_prompt() + assert "prefer indexed code tools before Search/Read" in system_prompt + assert "Use FindCodeSymbol for symbol candidates by name or prefix" in system_prompt + assert "Use InspectCodeSymbol for line-numbered source, members, references, and implementors" in system_prompt prompt = agent.build_user_prompt() - assert "- codegraph: available" in prompt - assert "CodeGraph is a whole-project static-analysis index" in prompt - assert "prefer CodeGraphSymbol for known or guessed names" in prompt - assert "CodeGraphContext for implementation locations, relationships, call flow, and architecture" in prompt - assert "Use Search only for exact literals; use Read for exact paths/ranges" in prompt + assert "Use FindCodeSymbol for symbol/prefix candidates" in prompt + assert "InspectCodeSymbol for chosen symbols" in prompt + assert "OutlineCodeFile for known file structure" in prompt + assert "cymbal" not in prompt + assert "case-insensitive" in prompt + assert "optional limit default 20 max 80" in prompt + assert "Do not pass natural language" in prompt + assert "Use Search/Read for text, config, logs, commands, and exact ranges" in prompt def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_path): diff --git a/tests/test_nanocode_codegraph_tool.py b/tests/test_nanocode_codegraph_tool.py deleted file mode 100644 index e671567..0000000 --- a/tests/test_nanocode_codegraph_tool.py +++ /dev/null @@ -1,130 +0,0 @@ -import json - -import nanocode -import pytest - -from nanocode import CodeGraphContextTool, CodeGraphSymbolTool, Session, ToolCallArgError, ToolCallError - - -def _init_codegraph_project(tmp_path): - (tmp_path / ".codegraph").mkdir() - return Session(cwd=str(tmp_path)) - - -def test_codegraph_tool_requires_binary(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") - - with pytest.raises(ToolCallError, match="codegraph not found"): - CodeGraphContextTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) - - -def test_codegraph_tool_requires_initialized_project(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") - tool = CodeGraphContextTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) - - assert tool.requires_confirmation(Session(cwd=str(tmp_path))) is False - with pytest.raises(ToolCallError, match="/codegraph init"): - tool.call() - - -def test_codegraph_tool_context_numbers_code_blocks(tmp_path, monkeypatch): - session = _init_codegraph_project(tmp_path) - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") - seen = {} - - def fake_run(cmd, **kwargs): - seen["cmd"] = cmd - return nanocode.subprocess.CompletedProcess( - cmd, - 0, - "\n".join( - [ - "## Code Context", - "", - "#### Tool (nanocode.py:1284)", - "", - "```python", - "class Tool:", - " NAME: ClassVar[str]", - "```", - ] - ), - "", - ) - - monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - - result = CodeGraphContextTool.make(session, ["Tool class"]).call() - - assert seen["cmd"] == [ - "/fake/codegraph", - "context", - "Tool class", - "--path", - str(tmp_path), - "--max-nodes", - "40", - "--max-code", - "8", - "--format", - "markdown", - ] - assert "" in result - assert " 1284 |class Tool:\n 1285 | NAME: ClassVar[str]" in result - - -def test_codegraph_tool_rejects_extra_args(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") - - with pytest.raises(ToolCallArgError, match="requires args: query"): - CodeGraphContextTool.make(Session(cwd=str(tmp_path)), ["impact", ["nanocode.py"]]) - - -def test_codegraph_symbol_tool_formats_locations(tmp_path, monkeypatch): - session = _init_codegraph_project(tmp_path) - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") - seen = {} - - def fake_run(cmd, **kwargs): - seen["cmd"] = cmd - return nanocode.subprocess.CompletedProcess( - cmd, - 0, - json.dumps( - [ - { - "node": { - "kind": "class", - "name": "Tool", - "qualifiedName": "Tool", - "filePath": "nanocode.py", - "startLine": 1284, - "endLine": 1330, - }, - "score": 90.005, - }, - { - "node": { - "kind": "method", - "name": "tool_schema", - "qualifiedName": "Tool::tool_schema", - "filePath": "nanocode.py", - "startLine": 1316, - "endLine": 1327, - "signature": "(cls) -> Json", - }, - "score": 32.99, - }, - ] - ), - "", - ) - - monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - - result = CodeGraphSymbolTool.make(session, ["Tool"]).call() - - assert seen["cmd"] == ["/fake/codegraph", "query", "Tool", "--path", str(tmp_path), "--limit", "12", "-j"] - assert "" in result - assert "1. class Tool nanocode.py:1284-1330 score=90.0" in result - assert "2. method Tool::tool_schema nanocode.py:1316-1327 (cls) -> Json score=33.0" in result diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 5e64e0c..42e43b8 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -103,6 +103,7 @@ def test_status_reports_tokens_in_human_readable_format(tmp_path): assert "models:" in result.message assert "model: calls=2 tokens=2m" in result.message assert "tool_calls: turn=0 session=0" in result.message + assert "tools: cymbal=" in result.message assert "task: done" in result.message assert "blackboard" not in result.message @@ -194,68 +195,6 @@ def test_context_command_shows_and_sets_budget(tmp_path): assert invalid_result.message == "Usage: /context [low|medium|high]" -def test_codegraph_command_runs_maintenance_subcommands(tmp_path, monkeypatch): - session = make_session(tmp_path) - dispatcher = CommandDispatcher(Agent(session)) - seen = {} - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") - - def fake_run(cmd, **kwargs): - seen["cmd"] = cmd - seen["cwd"] = kwargs["cwd"] - return nanocode.subprocess.CompletedProcess( - cmd, - 0, - '{"initialized":true,"projectPath":"/repo","fileCount":2,"nodeCount":3,"edgeCount":4,"backend":"native","pendingChanges":{"added":1,"modified":0,"removed":0}}\n', - "", - ) - - monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - - result = dispatcher.dispatch("/codegraph status") - usage_result = dispatcher.dispatch("/codegraph nope") - - assert result.status == CommandStatus.HANDLED - assert seen == {"cmd": ["/fake/codegraph", "status", "-j", "."], "cwd": str(tmp_path)} - assert result.message == "\n".join( - [ - "CodeGraph: initialized", - "project: /repo", - "index: files=2 nodes=3 edges=4 backend=native", - "pending: added=1 modified=0 removed=0", - ] - ) - assert usage_result.message == "Usage: /codegraph [status|sync|init|index]" - - -def test_codegraph_command_strips_terminal_control_output(tmp_path, monkeypatch): - session = make_session(tmp_path) - dispatcher = CommandDispatcher(Agent(session)) - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/codegraph" if name == "codegraph" else "") - - def fake_run(cmd, **kwargs): - return nanocode.subprocess.CompletedProcess(cmd, 0, "\x1b[1mTitle\x1b[0m\r\x1b[KParsing ███░ 50%\nDone\nDone\n", "") - - monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - - result = dispatcher.dispatch("/codegraph sync") - - assert "CodeGraph sync completed." in result.message - assert "Title" in result.message - assert "Done" in result.message - assert "\x1b" not in result.message - assert "50%" not in result.message - assert result.message.count("Done") == 1 - - -def test_codegraph_command_reports_missing_binary(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") - - result = CommandDispatcher(Agent(make_session(tmp_path))).dispatch("/codegraph status") - - assert result.message == "codegraph not found; install CodeGraph first" - - def test_plan_command_toggles_plan_mode(tmp_path): session = make_session(tmp_path) dispatcher = CommandDispatcher(Agent(session)) diff --git a/tests/test_nanocode_cymbal_tools.py b/tests/test_nanocode_cymbal_tools.py new file mode 100644 index 0000000..bae4703 --- /dev/null +++ b/tests/test_nanocode_cymbal_tools.py @@ -0,0 +1,199 @@ +import json + +import nanocode +import pytest + +from nanocode import FindCodeSymbolTool, InspectCodeSymbolTool, OutlineCodeFileTool, Session, ToolCallArgError, ToolCallError + + +def test_inspect_code_requires_cymbal(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") + + with pytest.raises(ToolCallError, match="cymbal not found"): + InspectCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool"]) + + +def test_inspect_code_schema_accepts_only_one_target_arg(): + for tool in (InspectCodeSymbolTool, OutlineCodeFileTool): + args_schema = tool.tool_schema()["function"]["parameters"]["properties"]["args"] + assert args_schema["minItems"] == 1 + assert args_schema["maxItems"] == 1 + assert args_schema["items"]["type"] == "string" + args_schema = FindCodeSymbolTool.tool_schema()["function"]["parameters"]["properties"]["args"] + assert args_schema["minItems"] == 1 + assert args_schema["maxItems"] == 2 + assert args_schema["items"]["type"] == ["string", "number"] + + +def test_inspect_code_rejects_natural_language(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") + + with pytest.raises(ToolCallArgError, match="do not pass natural language"): + InspectCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool class callers"]) + with pytest.raises(ToolCallArgError, match="do not pass natural language"): + FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) + + +def test_find_code_symbol_formats_symbol_results(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path)) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") + seen = {} + + def fake_run(cmd, **kwargs): + seen["cmd"] = cmd + seen["cwd"] = kwargs["cwd"] + return nanocode.subprocess.CompletedProcess( + cmd, + 0, + json.dumps( + { + "results": [ + { + "name": "Tool", + "kind": "class", + "rel_path": "nanocode.py", + "start_line": 1292, + "end_line": 1338, + "signature": "class Tool:", + } + ] + } + ), + "", + ) + + monkeypatch.setattr(nanocode.subprocess, "run", fake_run) + + result = FindCodeSymbolTool.make(session, ["Tool", 12]).call() + + assert seen == {"cmd": ["/fake/cymbal", "search", "Tool", "--limit", "12", "--json"], "cwd": str(tmp_path)} + assert "" in result + assert "" in result + assert "class Tool nanocode.py:1291:1338 class Tool:" in result + + +def test_find_code_symbol_clamps_limit(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") + assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", 999]).limit == 80 + assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", 0]).limit == 1 + with pytest.raises(ToolCallArgError, match="limit must be an integer"): + FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", "many"]) + + +def test_inspect_code_symbol_rejects_files_directories_and_dotted_module_paths(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") + (tmp_path / "orion" / "biz" / "handlers" / "syftpp").mkdir(parents=True) + (tmp_path / "code.py").write_text("class Tool:\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + with pytest.raises(ToolCallArgError, match="file or directory"): + InspectCodeSymbolTool.make(session, ["code.py"]) + with pytest.raises(ToolCallArgError, match="file or directory"): + InspectCodeSymbolTool.make(session, ["orion.biz.handlers.syftpp"]) + with pytest.raises(ToolCallArgError, match="module path"): + InspectCodeSymbolTool.make(session, ["pkg.module.symbol"]) + + +def test_inspect_code_formats_investigate_result(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path)) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") + seen = {} + + def fake_run(cmd, **kwargs): + seen["cmd"] = cmd + seen["cwd"] = kwargs["cwd"] + return nanocode.subprocess.CompletedProcess( + cmd, + 0, + json.dumps( + { + "results": { + "result": { + "symbol": { + "name": "Tool", + "kind": "class", + "rel_path": "nanocode.py", + "start_line": 1284, + "end_line": 1285, + "signature": "class Tool:", + }, + "source": "class Tool:\n NAME: ClassVar[str]\n", + "members": [{"name": "tool_schema", "kind": "function", "rel_path": "nanocode.py", "start_line": 1315, "end_line": 1327}], + "refs": [{"name": "Tool", "rel_path": "nanocode.py", "line": 1742}], + "impact": [{"symbol": "Tool", "caller": "ReadTool", "rel_path": "nanocode.py", "line": 1742, "depth": 1}], + "implementors": [{"implementer": "ReadTool", "target": "Tool", "rel_path": "nanocode.py", "line": 1742, "resolved": True}], + } + } + } + ), + "", + ) + + monkeypatch.setattr(nanocode.subprocess, "run", fake_run) + + result = InspectCodeSymbolTool.make(session, ["Tool"]).call() + + assert seen == {"cmd": ["/fake/cymbal", "investigate", "Tool", "--json"], "cwd": str(tmp_path)} + assert "" in result + assert 'Line numbers are 0-based and match Read/ReplaceRange ranges.' in result + assert "* symbol: class Tool nanocode.py:1283:1285 class Tool:" in result + assert " 1283 |class Tool:" in result + assert "" in result + assert "function tool_schema nanocode.py:1314:1327" in result + assert "" in result + assert "Tool nanocode.py:1741" in result + assert "" in result + assert "ReadTool nanocode.py:1741 symbol=Tool" in result + assert "" in result + assert "ReadTool nanocode.py:1741 target=Tool" in result + + +def test_outline_code_file_formats_file_outline(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path)) + filepath = tmp_path / "code.py" + filepath.write_text("class Tool:\n pass\n", encoding="utf-8") + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") + seen = {} + + def fake_run(cmd, **kwargs): + seen["cmd"] = cmd + seen["cwd"] = kwargs["cwd"] + return nanocode.subprocess.CompletedProcess( + cmd, + 0, + json.dumps( + { + "results": [ + { + "name": "Tool", + "kind": "class", + "rel_path": "code.py", + "start_line": 1, + "end_line": 2, + "signature": "class Tool:", + } + ] + } + ), + "", + ) + + monkeypatch.setattr(nanocode.subprocess, "run", fake_run) + + result = OutlineCodeFileTool.make(session, ["code.py"]).call() + + assert seen == {"cmd": ["/fake/cymbal", "outline", str(filepath), "--json"], "cwd": str(tmp_path)} + assert "" in result + assert "" in result + assert "class Tool code.py:0:2 class Tool:" in result + + +def test_outline_code_file_rejects_directories_and_symbols(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") + (tmp_path / "pkg").mkdir() + session = Session(cwd=str(tmp_path)) + + with pytest.raises(ToolCallArgError, match="existing file"): + OutlineCodeFileTool.make(session, ["pkg"]) + with pytest.raises(ToolCallArgError, match="existing file"): + OutlineCodeFileTool.make(session, ["Tool"]) diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 843911f..2efc275 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -372,11 +372,9 @@ def test_agent_loop_command_completer_matches_slash_commands(): model_completions = list(nanocode.CommandCompleter(models=["qwen3", "deepseek"]).get_completions(Document("/model q"), CompleteEvent(completion_requested=True))) plan_completions = list(completer.get_completions(Document("/plan "), CompleteEvent(completion_requested=True))) api_completions = list(completer.get_completions(Document("/api r"), CompleteEvent(completion_requested=True))) - codegraph_completions = list(completer.get_completions(Document("/codegraph s"), CompleteEvent(completion_requested=True))) reason_payload_completions = list(completer.get_completions(Document("/reason-payload rea"), CompleteEvent(completion_requested=True))) assert "/help" in [completion.text for completion in slash_completions] - assert "/codegraph" in [completion.text for completion in slash_completions] assert "/api" in [completion.text for completion in slash_completions] assert "/reason-payload" in [completion.text for completion in slash_completions] assert "/plan" in [completion.text for completion in slash_completions] @@ -388,7 +386,6 @@ def test_agent_loop_command_completer_matches_slash_commands(): assert [completion.text for completion in model_completions] == ["qwen3"] assert [completion.text for completion in plan_completions] == ["on", "off"] assert [completion.text for completion in api_completions] == ["responses"] - assert [completion.text for completion in codegraph_completions] == ["status", "sync"] assert [completion.text for completion in reason_payload_completions] == ["reasoning", "reasoning_effort"] From 62849d135a47d2940e5c86c17aa840a6b769a420 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 10:57:57 -0700 Subject: [PATCH 074/144] bump version to 0.4.1 --- CHANGELOG.md | 2 +- nanocode.py | 2 +- pyproject.toml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 614301e..f256a32 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## 0.4.0 - 2026-05-19 +## 0.4.1 - 2026-05-19 ### Added - Added indexed code inspection tools for symbol lookup, symbol investigation, and file outlines when the local index is available. diff --git a/nanocode.py b/nanocode.py index 9a4a5d5..711644c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -54,7 +54,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.0" +__version__ = "0.4.1" JsonValue: TypeAlias = Any diff --git a/pyproject.toml b/pyproject.toml index fc73e0b..ec8571a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.0" +version = "0.4.1" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" From fd095a1b4493bea8f044ca9f7533e26856997ac0 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 11:06:35 -0700 Subject: [PATCH 075/144] improve observe memory guidance --- nanocode.py | 27 ++++++++++++++++++++++----- tests/test_nanocode_agent.py | 13 +++++++++++++ 2 files changed, 35 insertions(+), 5 deletions(-) diff --git a/nanocode.py b/nanocode.py index 711644c..dc19664 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3754,6 +3754,7 @@ def _state_tool_schema(name: str) -> Json: If there is no Goal and the request is a Tracked task: - set a Goal - if enough context is known, also set a short Plan or call the first useful readonly tools +- for root-cause work, set work_mode=investigate and use hypotheses to track competing explanations If there is a Goal but no Plan: - set a short Plan @@ -4144,7 +4145,9 @@ def _state_tool_schema(name: str) -> Json: --- Output --- Use function tools only. -Prefer explicit keep/forget decisions. Omitted results are compacted by default. +Prefer explicit KEEP/FORGET decisions. Omitted results are compacted by default. +Known/hypothesis entries from tool results should cite SOURCE tr.N keys. +Path-only or vague facts do not replace raw results; KEEP the raw result or record a SOURCE-backed, decision-useful conclusion before forgetting/omitting it. YOUR OUTPUT: """ @@ -4155,11 +4158,11 @@ def _state_tool_schema(name: str) -> Json: Job: - Reduce Unreduced Raw Tool Results before ACT continues. -- Prefer declaring keep or forget for each result you reviewed. -- keep only raw results that affect the next ACT frontier: target selection, edit choice, verification, error repair, or completion. -- forget routine success, duplicate listings, no-match searches, superseded results, and ruled-out branches. Forget preserves logs and Recall. +- Prefer declaring KEEP or FORGET for each result you reviewed. +- KEEP only raw results that affect the next ACT frontier: target selection, edit choice, verification, error repair, or completion. +- FORGET routine success, duplicate listings, no-match searches, superseded results, and ruled-out branches. Forget preserves logs and Recall. - If you omit a tr.N key, nanocode compacts it by default; use omission only for unimportant results. -- Before forgetting an important conclusion, preserve it with known, hypothesis, or stable_knowledge. +- Before compacting or forgetting an important conclusion, preserve it with SOURCE-backed known, hypothesis, or stable_knowledge. - Do not update Plan, Verify, or Goal. Allowed tools: keep, forget, known, hypothesis, stable_knowledge. @@ -6960,10 +6963,24 @@ def _handle_observe_response( self.tool_context.compact_observed(observed_blocks) self._mark_memory_checkpoint(observed_counter) self.observe_feedback_errors = [] + self._warn_weak_observe_memory(ctx.actions) self._emit_tool_context_update(kept_keys, forgotten_keys, on_message) self._promote_required_verification(ctx) return AgentRunResult() + def _warn_weak_observe_memory(self, actions: list[Json]) -> None: + if any(_json_str(action.get("type")) in {"keep", "forget", "hypothesis", "stable_knowledge"} for action in actions): + return + known_actions = [action for action in actions if _json_str(action.get("type")) == "known"] + if not known_actions: + return + for action in known_actions: + for raw in _json_list(action.get("items")): + item = KnownItem.from_json(raw) + if item is not None and KnownItem.source_of(item): + return + self._remember_observe_error(self._warning("weak observe memory: known facts need source tr.N or keep/forget coverage.", "use source-backed known/hypothesis or keep important raw results.")) + def _forget_tool_result_error(self, actions: list[Json]) -> str: keys = ToolResultContext.forget_result_keys_from_actions(actions) if not any(_json_str(action.get("type")) == "forget" for action in actions): diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index e6903ff..4950fdc 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -488,6 +488,7 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path, monkeypatch) assert "call needed tools, then answer with assistant text and stop" in prompt assert "do not create Goal, Plan, Known, or Verify just to report the result" in prompt assert "record Verify only after edits, explicit checks, or correctness-sensitive work" in prompt + assert "for root-cause work, set work_mode=investigate and use hypotheses" in prompt assert "Tracked tasks are complete only after goal.complete=true is set" in prompt assert "InspectCodeSymbol" not in prompt assert "OutlineCodeFile" not in prompt @@ -1002,6 +1003,18 @@ def test_observe_known_source_compacts_result_key_by_default(tmp_path): assert agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter) == [] +def test_observe_warns_on_weak_known_without_source_or_coverage(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.mode = nanocode.AgentMode.OBSERVE + agent.tool_context.latest = ['- ok tool=Read args=["a"] key=tr.1\n output:\na'] + + agent.handle_response({"actions": [{"type": "known", "items": ["a exists"]}]}) + + assert agent.mode == nanocode.AgentMode.ACT + assert any("weak observe memory" in error for error in agent.observe_feedback_errors) + assert agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter) == [] + + def test_kept_tool_results_respect_char_budget(tmp_path, monkeypatch): agent = Agent(Session(cwd=str(tmp_path))) agent.mode = nanocode.AgentMode.OBSERVE From ff9079fbadb53d7a0613e005a195f5a2f0ce9b65 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 11:09:59 -0700 Subject: [PATCH 076/144] bump version to 0.4.2 --- CHANGELOG.md | 2 +- nanocode.py | 2 +- pyproject.toml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index f256a32..a56973b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## 0.4.1 - 2026-05-19 +## 0.4.2 - 2026-05-19 ### Added - Added indexed code inspection tools for symbol lookup, symbol investigation, and file outlines when the local index is available. diff --git a/nanocode.py b/nanocode.py index dc19664..3592137 100644 --- a/nanocode.py +++ b/nanocode.py @@ -54,7 +54,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.1" +__version__ = "0.4.2" JsonValue: TypeAlias = Any diff --git a/pyproject.toml b/pyproject.toml index ec8571a..a0e2a8c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.1" +version = "0.4.2" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" From b7ef190a640cbe5db0850439e4793148f034a2e9 Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 20:12:30 -0700 Subject: [PATCH 077/144] refactor: remove thin wrappers and dead status helper --- nanocode.py | 56 +++++++++++-------------------------- tests/test_nanocode_loop.py | 12 +++++--- 2 files changed, 24 insertions(+), 44 deletions(-) diff --git a/nanocode.py b/nanocode.py index 3592137..5eb8aab 100644 --- a/nanocode.py +++ b/nanocode.py @@ -486,41 +486,29 @@ class ProviderConfig: @classmethod def from_dict(cls, data: Json) -> "ProviderConfig": defaults = cls() + api = Config.str(data, "api", defaults.api) + reasoning = Config.str(data, "reasoning", defaults.reasoning) + chat_reasoning = Config.str(data, "chat_reasoning", defaults.chat_reasoning) + if api not in ("chat", "responses", "auto"): + raise ConfigError("config provider.api must be one of: chat, responses, auto") + if reasoning not in REASONING_CHOICES: + raise ConfigError("config provider.reasoning must be one of: " + ", ".join(REASONING_CHOICES)) + if chat_reasoning not in CHAT_REASONING_CHOICES: + raise ConfigError("config provider.chat_reasoning must be one of: " + ", ".join(CHAT_REASONING_CHOICES)) return cls( url=Config.str(data, "url", defaults.url), key=Config.str(data, "key", defaults.key), model=Config.str(data, "model", defaults.model), - api=cls._api(data, defaults.api), + api=api, available_models=Config.str_tuple(data, "available_models"), temperature=Config.float(data, "temperature", defaults.temperature), - reasoning=cls._reasoning(data, defaults.reasoning), - chat_reasoning=cls._chat_reasoning(data, defaults.chat_reasoning), + reasoning=reasoning, + chat_reasoning=chat_reasoning, stream=Config.bool(data, "stream", defaults.stream), timeout=Config.int(data, "timeout", defaults.timeout), first_token_timeout=Config.int(data, "first_token_timeout", defaults.first_token_timeout), ) - @classmethod - def _api(cls, data: Json, default: str) -> str: - value = Config.str(data, "api", default) - if value not in ("chat", "responses", "auto"): - raise ConfigError("config provider.api must be one of: chat, responses, auto") - return value - - @classmethod - def _reasoning(cls, data: Json, default: str) -> str: - value = Config.str(data, "reasoning", default) - if value not in REASONING_CHOICES: - raise ConfigError("config provider.reasoning must be one of: " + ", ".join(REASONING_CHOICES)) - return value - - @classmethod - def _chat_reasoning(cls, data: Json, default: str) -> str: - value = Config.str(data, "chat_reasoning", default) - if value not in CHAT_REASONING_CHOICES: - raise ConfigError("config provider.chat_reasoning must be one of: " + ", ".join(CHAT_REASONING_CHOICES)) - return value - def resolved_chat_reasoning(self) -> str: if self.chat_reasoning != "auto": return self.chat_reasoning @@ -1475,10 +1463,7 @@ def append_recent(self, blocks: list[str], *, max_index_items: int, checkpoint: self.prune_recent(max_index_items=max_index_items, checkpoint=checkpoint) def prune_recent(self, *, max_index_items: int, checkpoint: int) -> None: - def compact_if_observed(block: str) -> str: - return block if self._needs_reduction(block, checkpoint) else self.compact_block(block) - - self.recent = [compact_if_observed(block) for block in self.recent] + self.recent = [block if self._needs_reduction(block, checkpoint) else self.compact_block(block) for block in self.recent] while len(self.current_timeline_blocks()) > max_index_items: index = next((i for i, block in enumerate(self.recent) if not self._needs_reduction(block, checkpoint)), -1) if index < 0: @@ -1530,9 +1515,6 @@ def unreduced_blocks(self, checkpoint: int) -> list[str]: def raw_context_chars(self, checkpoint: int) -> int: return len("\n\n".join(self.unreduced_recent_blocks(checkpoint) + self.latest_raw_blocks())) - def visible_counter(self) -> int: - return self.max_counter(self.recent + self.latest) - @classmethod def _needs_reduction(cls, block: str, checkpoint: int) -> bool: return cls.is_full_block(block) and cls.result_counter(block) > checkpoint @@ -5889,7 +5871,7 @@ def _format_environment(self) -> str: "- arch: " + self.session.arch, "- cwd: " + self.session.cwd, ] - if self._inspect_code_available(): + if _cymbal_available(): lines.append( "- inspect_code_hint: Use FindCodeSymbol for symbol/prefix candidates (case-insensitive, optional limit default 20 max 80), InspectCodeSymbol for chosen symbols, and OutlineCodeFile for known file structure. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." ) @@ -5931,13 +5913,10 @@ def _system_prompt(self, template: str | None = None, *, tools: Iterable[ToolCla def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> tuple[ToolClass, ...]: tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) - if self._inspect_code_available(): + if _cymbal_available(): return tool_classes return tuple(tool for tool in tool_classes if tool not in (FindCodeSymbolTool, OutlineCodeFileTool, InspectCodeSymbolTool)) - def _inspect_code_available(self) -> bool: - return _cymbal_available() - def _discovery_prompt_hint(self, tool_classes: Iterable[ToolClass]) -> str: if FindCodeSymbolTool not in tool_classes and OutlineCodeFileTool not in tool_classes and InspectCodeSymbolTool not in tool_classes: return "Use Search/List/LineCount when path, symbol, range, or target is unknown." @@ -6369,7 +6348,7 @@ def _goal_changes_task(self, actions: list[Json]) -> bool: ) def _mark_memory_checkpoint(self, counter: int = 0) -> None: - checkpoint = counter or self.tool_context.visible_counter() or self.session.state.tool_result_counter + checkpoint = counter or self.tool_context.max_counter(self.tool_context.recent + self.tool_context.latest) or self.session.state.tool_result_counter self.blackboard.memory_checkpoint_tool_result_counter = max(self.blackboard.memory_checkpoint_tool_result_counter, checkpoint) def _has_memory_update_action(self, actions: list[Json]) -> bool: @@ -7808,9 +7787,6 @@ def elapsed(self) -> float: def is_running(self) -> bool: return self.thread is not None - def snapshot(self, turn_elapsed: float = 0.0) -> str: - return "".join(text for _, text in self._fragments(turn_elapsed, now=time.monotonic(), show_sweep=False, show_elapsed=False)) - def resume(self) -> None: if self.thread is not None or not sys.stderr.isatty(): return diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 2efc275..32153fd 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -15,6 +15,10 @@ def make_session(tmp_path, *, model: str = "", compact_at: int = 50, yolo: bool return Session(cwd=str(tmp_path), config=Config.from_dict(data), settings=RuntimeSettings.from_dict(data, yolo=yolo, plan_mode=plan_mode)) +def _status_text(bar: StatusBar) -> str: + return "".join(text for _, text in bar._fragments(0.0, now=time.monotonic(), show_sweep=False, show_elapsed=False)) + + def test_session_reports_missing_required_config(tmp_path): session = Session(cwd=str(tmp_path)) @@ -158,7 +162,7 @@ def test_status_bar_text_has_visible_sweep_marker(tmp_path): assert "turn:1.2s" in text assert all(style.startswith("#") for style, _ in fragments) assert len({style for style, _ in fragments}) > 3 - snapshot = bar.snapshot() + snapshot = _status_text(bar) assert snapshot == "model (medium) | ctx:0/9 | tool:3 | tok:last:42 sess:1k" assert ">" not in snapshot @@ -194,7 +198,7 @@ def test_status_bar_shows_active_modes(tmp_path): session = make_session(tmp_path, model="provider/model", yolo=True, plan_mode=True) bar = StatusBar(session) - assert bar.snapshot() == "model (medium) | yolo | plan | ctx:0/50 | tool:0 | tok:last:- sess:-" + assert _status_text(bar) == "model (medium) | yolo | plan | ctx:0/50 | tool:0 | tok:last:- sess:-" def test_status_bar_shows_recent_status_notice(tmp_path): @@ -203,11 +207,11 @@ def test_status_bar_shows_recent_status_notice(tmp_path): session.state.status_notice_until = time.monotonic() + 5 bar = StatusBar(session) - assert bar.snapshot().endswith(" | err:format") + assert _status_text(bar).endswith(" | err:format") session.state.status_notice_until = 0 - assert "err:format" not in bar.snapshot() + assert "err:format" not in _status_text(bar) def test_agent_loop_highlights_only_diff_previews(tmp_path): From 1b364684c8bc907f4c28bb17e13497d45c82954c Mon Sep 17 00:00:00 2001 From: hit9 Date: Tue, 19 May 2026 21:33:19 -0700 Subject: [PATCH 078/144] refactor: remove more thin wrappers --- nanocode.py | 73 +++++++++--------------------------- tests/test_nanocode_agent.py | 7 +--- 2 files changed, 20 insertions(+), 60 deletions(-) diff --git a/nanocode.py b/nanocode.py index 5eb8aab..30afde5 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1006,15 +1006,10 @@ def append_conversation(self, item: ConversationItem) -> None: def project_key(self) -> str: cwd = os.path.realpath(self.cwd) - basename = self._safe_path_name(os.path.basename(cwd.rstrip(os.sep)) or "root") + basename = re.sub(r"[^A-Za-z0-9_.-]+", "-", os.path.basename(cwd.rstrip(os.sep)) or "root").strip(".-") or "project" digest = hashlib.sha1(cwd.encode("utf-8")).hexdigest()[:10] return basename + "-" + digest - @staticmethod - def _safe_path_name(value: str) -> str: - value = re.sub(r"[^A-Za-z0-9_.-]+", "-", value).strip(".-") - return value or "project" - @staticmethod def _new_session_id() -> str: return datetime.now().strftime("%Y%m%d-%H%M%S") + "-" + str(os.getpid()) + "-" + uuid.uuid4().hex[:8] @@ -1250,10 +1245,6 @@ def _cymbal_available() -> bool: return bool(shutil.which("cymbal")) -def _cymbal_status_label() -> str: - return "available" if _cymbal_available() else "not installed" - - def _json_value_schema(depth: int = 3) -> Json: values: list[Json] = [{"type": "string"}, {"type": "number"}, {"type": "boolean"}, {"type": "null"}] if depth > 0: @@ -1452,16 +1443,11 @@ def bound_kept(self, *, max_chars: int, max_block_chars: int) -> None: def append_latest(self, executions: list[ToolCallExecution], *, max_index_items: int, checkpoint: int) -> None: if not executions: return - self.append_recent(self.latest, max_index_items=max_index_items, checkpoint=checkpoint) + if self.latest: + self.recent.extend(self.latest) self.latest = [self.format_execution(execution) for execution in executions] self.prune_recent(max_index_items=max_index_items, checkpoint=checkpoint) - def append_recent(self, blocks: list[str], *, max_index_items: int, checkpoint: int) -> None: - if not blocks: - return - self.recent.extend(blocks) - self.prune_recent(max_index_items=max_index_items, checkpoint=checkpoint) - def prune_recent(self, *, max_index_items: int, checkpoint: int) -> None: self.recent = [block if self._needs_reduction(block, checkpoint) else self.compact_block(block) for block in self.recent] while len(self.current_timeline_blocks()) > max_index_items: @@ -2429,6 +2415,13 @@ def format_symbol_search(cls, items: list[Json]) -> list[str]: return lines +def _cymbal_json_results(stdout: str) -> list[Json]: + try: + return [_json_dict(item) for item in _json_list(_json_dict(json.loads(stdout)).get("results"))] + except json.JSONDecodeError: + return [] + + @dataclass class FindCodeSymbolTool(Tool): NAME: ClassVar[str] = "FindCodeSymbol" @@ -2494,7 +2487,7 @@ def call(self) -> str: def _format(self, exit_code: int, stdout: str, stderr: str) -> str: lines = ["", "* exit_code: " + str(exit_code)] - if items := self._symbol_results(stdout): + if items := _cymbal_json_results(stdout): lines.extend(CymbalResultFormatter.format_symbol_search(items)) elif stdout: lines.extend(["", stdout.rstrip("\n"), ""]) @@ -2503,14 +2496,6 @@ def _format(self, exit_code: int, stdout: str, stderr: str) -> str: lines.append("") return "\n".join(lines) - @staticmethod - def _symbol_results(stdout: str) -> list[Json]: - try: - return [_json_dict(item) for item in _json_list(_json_dict(json.loads(stdout)).get("results"))] - except json.JSONDecodeError: - return [] - - @dataclass class InspectCodeSymbolTool(Tool): NAME: ClassVar[str] = "InspectCodeSymbol" @@ -2652,7 +2637,7 @@ def call(self) -> str: def _format(self, exit_code: int, stdout: str, stderr: str) -> str: lines = ["", "* exit_code: " + str(exit_code)] - if items := self._outline_results(stdout): + if items := _cymbal_json_results(stdout): lines.extend(CymbalResultFormatter.format_outline(items)) elif stdout: lines.extend(["", stdout.rstrip("\n"), ""]) @@ -2661,14 +2646,6 @@ def _format(self, exit_code: int, stdout: str, stderr: str) -> str: lines.append("") return "\n".join(lines) - @staticmethod - def _outline_results(stdout: str) -> list[Json]: - try: - return [_json_dict(item) for item in _json_list(_json_dict(json.loads(stdout)).get("results"))] - except json.JSONDecodeError: - return [] - - @dataclass class EditTool(Tool): NAME: ClassVar[str] = "Edit" @@ -5285,10 +5262,10 @@ def _format_state_report( self._append_state_section(lines, " Plan", self._format_plan_rows()) hypotheses = [item.format() for item in current.hypotheses] if hypotheses != before_hypotheses: - self._append_state_section(lines, " Hypotheses", self._format_hypothesis_rows()) + self._append_state_section(lines, " Hypotheses", self._format_rows(current.hypotheses, lambda index, item: f" {index}. {self._compact(item.format())}")) known = [KnownItem.format_item(item) for item in current.known] if known != before_known: - self._append_state_section(lines, " Known", self._format_known_rows()) + self._append_state_section(lines, " Known", self._format_rows(current.known, lambda index, item: f" {index}. {self._compact(KnownItem.format_item(item))}")) user_rules = self.session.state.user_rules.format() if user_rules != before_user_rules: self._append_state_section(lines, " User_Rules updated") @@ -5304,12 +5281,6 @@ def render(index: int, item: PlanItem) -> list[str]: return self._format_rows(self.blackboard.plan, render) - def _format_known_rows(self) -> list[str]: - return self._format_rows(self.blackboard.known, lambda index, item: " " + str(index) + ". " + self._compact(KnownItem.format_item(item))) - - def _format_hypothesis_rows(self) -> list[str]: - return self._format_rows(self.blackboard.hypotheses, lambda index, item: " " + str(index) + ". " + self._compact(item.format())) - def _format_rows(self, items: list[Any], render: Callable[[int, Any], str | list[str]]) -> list[str]: if not items: return [" (empty)"] @@ -6138,15 +6109,11 @@ def _remember_agent_error(self, text: str) -> None: def _remember_observe_error(self, text: str) -> None: self._remember_feedback_error(self.observe_feedback_errors, text) - @staticmethod - def _feedback(level: str, text: str, rule: str = "") -> str: - return level + " blocked: " + text + ((" Next: " + rule) if rule else "") - def _error(self, text: str, rule: str = "") -> str: - return self._feedback("Error", text, rule) + return "Error blocked: " + text + ((" Next: " + rule) if rule else "") def _warning(self, text: str, rule: str = "") -> str: - return self._feedback("Warning", text, rule) + return "Warning blocked: " + text + ((" Next: " + rule) if rule else "") def _warn_agent(self, text: str, rule: str = "") -> None: self._remember_agent_error(self._warning(text, rule)) @@ -7549,7 +7516,7 @@ def _status(self, args: str) -> str: + session.settings.context_budget, "conversation: " + str(len(session.state.conversation)) + "/" + str(session.settings.compact_at), "tool_calls: turn=" + str(session.state.turn_tool_calls) + " session=" + str(session.state.session_tool_calls), - "tools: cymbal=" + _cymbal_status_label(), + "tools: cymbal=" + ("available" if _cymbal_available() else "not installed"), "tokens: last=" + _format_count(session.state.last_total_tokens) + " session=" + _format_count(session.state.session_total_tokens), "models:", model_usage, @@ -7842,7 +7809,7 @@ def _format_line(self, turn_elapsed: float, *, now: float, show_elapsed: bool) - if show_elapsed: parts.append(f"turn:{turn_elapsed:.1f}s") if session.state.current_model_call_started_at > 0: - activity = self._activity_label(session.state.current_model_call_activity) + activity = {"compact": "compacting", "observe": "observing"}.get(session.state.current_model_call_activity, "working") if session.state.current_model_call_has_content: activity += "*" elapsed = max(0.0, now - session.state.current_model_call_started_at) @@ -7855,10 +7822,6 @@ def _format_line(self, turn_elapsed: float, *, now: float, show_elapsed: bool) - parts.append(session.state.status_notice) return " | ".join(parts) - @staticmethod - def _activity_label(activity: str) -> str: - return {"compact": "compacting", "observe": "observing"}.get(activity, "working") - def _sweep_fragments(self, text: str, now: float) -> list[tuple[str, str]]: if not text: return [("", "")] diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 4950fdc..a3faf4e 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1087,11 +1087,8 @@ def test_agent_tool_result_index_has_count_limit(tmp_path, monkeypatch): _set_context_budget(monkeypatch, agent, index_items=2) for index in range(4): - agent.tool_context.append_recent( - ['- ok tool=Read args=["' + str(index) + '"] key=tr.' + str(index + 1) + "\n output:\n" + ("x" * 20)], - max_index_items=agent.context_budget().index_items, - checkpoint=999, - ) + agent.tool_context.recent.append('- ok tool=Read args=["' + str(index) + '"] key=tr.' + str(index + 1) + "\n output:\n" + ("x" * 20)) + agent.tool_context.prune_recent(max_index_items=agent.context_budget().index_items, checkpoint=999) recent = _blocks_text(agent.tool_context.recent) assert "recall=tr.1" not in recent From 7d125598dbf9895317ccb076cb26a760e5405870 Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 06:10:32 -0700 Subject: [PATCH 079/144] refactor: reduce agent and provider special cases --- nanocode.py | 86 +++++++++++++++++++++--------------- tests/test_nanocode_agent.py | 6 +-- 2 files changed, 54 insertions(+), 38 deletions(-) diff --git a/nanocode.py b/nanocode.py index 30afde5..aebda32 100644 --- a/nanocode.py +++ b/nanocode.py @@ -409,6 +409,15 @@ def source_result_keys(self) -> set[str]: keys.update(key for item in self.hypotheses for key in item.source if key.startswith("tr.")) return keys + def protected_result_sources(self) -> dict[str, str]: + return { + key: "active hypothesis" + for item in self.hypotheses + if item.status == HypothesisStatus.ACTIVE + for key in item.source + if key.startswith("tr.") + } + @dataclass(frozen=True) class ChatReasoningRule: @@ -450,22 +459,23 @@ class ProviderProfile: } -ALIYUN_THINKING_BUDGET_BY_EFFORT = { - "minimal": 256, - "low": 1024, - "medium": 4096, - "high": 8192, - "xhigh": 16384, - "max": 16384, -} - -DEEPSEEK_REASONING_EFFORT_BY_EFFORT = { - "minimal": "high", - "low": "high", - "medium": "high", - "high": "high", - "xhigh": "max", - "max": "max", +CHAT_REASONING_EFFORT_VALUES: dict[str, dict[str, str | int]] = { + "thinking": { + "minimal": "high", + "low": "high", + "medium": "high", + "high": "high", + "xhigh": "max", + "max": "max", + }, + "enable_thinking": { + "minimal": 256, + "low": 1024, + "medium": 4096, + "high": 8192, + "xhigh": 16384, + "max": 16384, + }, } @@ -1273,6 +1283,7 @@ class Tool: DESCRIPTION: ClassVar[tuple[str, ...]] = () SIGNATURE: ClassVar[str] EXAMPLE: ClassVar[tuple[str, ...]] = () + PARAM_NAMES: ClassVar[tuple[str, ...]] = () EFFECT: ClassVar[ToolEffect] = ToolEffect.OTHER REQUIRES_CONFIRMATION: ClassVar[bool | None] = None @@ -2973,6 +2984,7 @@ class ReplaceRangeEdit: @dataclass class ReplaceRangeTool(Tool): NAME: ClassVar[str] = "ReplaceRange" + PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "ranges") EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Replace one or more small Read-backed [start,end) ranges in an existing file; best when exact line ranges are known or target text is not unique.", @@ -4388,11 +4400,12 @@ def _chat_completion_params( if chat_reasoning == "thinking": extra_body["thinking"] = {"type": "enabled" if reasoning_enabled else "disabled"} if reasoning_enabled: - params["reasoning_effort"] = DEEPSEEK_REASONING_EFFORT_BY_EFFORT.get(self._reasoning_effort(config), "high") + params["reasoning_effort"] = CHAT_REASONING_EFFORT_VALUES["thinking"].get(self._reasoning_effort(config), "high") if chat_reasoning == "enable_thinking": extra_body["enable_thinking"] = reasoning_enabled if reasoning_enabled: - extra_body["thinking_budget"] = ALIYUN_THINKING_BUDGET_BY_EFFORT.get(self._reasoning_effort(config), ALIYUN_THINKING_BUDGET_BY_EFFORT["medium"]) + values = CHAT_REASONING_EFFORT_VALUES["enable_thinking"] + extra_body["thinking_budget"] = values.get(self._reasoning_effort(config), values["medium"]) if extra_body: params["extra_body"] = extra_body return params @@ -5772,7 +5785,7 @@ class Agent: MAX_COMPLETED_GOAL_TOOL_RESULTS: ClassVar[int] = 50 RECENT_EDITS: ClassVar[int] = 20 RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." - RULE_CLOSE_SOURCE: ClassVar[str] = "close the hypothesis before forgetting its source." + RULE_CLOSE_SOURCE: ClassVar[str] = "close or update state that depends on the result before forgetting its source." RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after edit failures prefer ReplaceRange after Read." RULE_GOAL_PLAN_FIRST: ClassVar[str] = "set goal and a short plan before mutating tools or verify." RULE_VERIFY_DIRECTLY: ClassVar[str] = 'run verification tools, then report verify status="passed"|"failed"|"blocked".' @@ -6377,9 +6390,8 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: ) if execution.error_type is not None and issubclass(execution.error_type, ToolCallArgError): detail = self._format_tool_arg_error(execution) - rule = self.RULE_TOOL_SIGNATURE - if execution.call.name in {EditTool.NAME, PatchFileTool.NAME, ReplaceRangeTool.NAME}: - rule = self.RULE_EDIT_SIGNATURE + tool_class = TOOL_REGISTRY.get(execution.call.name) + rule = self.RULE_EDIT_SIGNATURE if tool_class is not None and tool_class.EFFECT == ToolEffect.EDIT else self.RULE_TOOL_SIGNATURE self._remember_agent_error( self._error( "tool call args invalid: " + _format_tool_call_summary(execution.call) + " -> " + detail + ".", @@ -6417,7 +6429,7 @@ def _format_tool_arg_error(self, execution: ToolCallExecution) -> str: return execution.output match = re.search(r"\(([^)]*)\)", tool_class.SIGNATURE) value = match.group(1) if match else "" - params = ["filepath", "ranges"] if call.name == ReplaceRangeTool.NAME else [] + params = list(tool_class.PARAM_NAMES) if not params and value and not any(token in value for token in "[]*") and "..." not in value: params = [part.strip().split("=", 1)[0].strip() for part in value.split(",") if part.strip()] if not params or len(call.args) == len(params): @@ -6546,10 +6558,8 @@ def _investigate_completion_error(self) -> str: else "investigate completion requires a confirmed hypothesis" ) - def _forget_active_hypothesis_error(self, actions: list[Json]) -> str: - forgotten = set(ToolResultContext.forget_result_keys_from_actions(actions)) - if not forgotten: - return "" + @staticmethod + def _released_result_sources_from_actions(actions: list[Json]) -> set[str]: released = set() for action in actions: values = _json_list(action.get("items")) if _json_str(action.get("type")) == "hypothesis" else [] @@ -6557,9 +6567,15 @@ def _forget_active_hypothesis_error(self, actions: list[Json]) -> str: item = Hypothesis.from_json(raw) if item is not None and item.status != HypothesisStatus.ACTIVE: released.update(key for key in item.source if key.startswith("tr.")) - protected = {key for item in self.blackboard.hypotheses if item.status == HypothesisStatus.ACTIVE for key in item.source if key.startswith("tr.")} - conflict = sorted((forgotten & protected) - released) - return "active hypothesis source: " + ", ".join(conflict) if conflict else "" + return released + + def _forget_protected_result_error(self, actions: list[Json]) -> str: + forgotten = set(ToolResultContext.forget_result_keys_from_actions(actions)) + if not forgotten: + return "" + protected = self.blackboard.protected_result_sources() + conflict = sorted((forgotten & set(protected)) - self._released_result_sources_from_actions(actions)) + return "protected source: " + ", ".join(key + " (" + protected[key] + ")" for key in conflict) if conflict else "" def _repeated_tool_retry_error(self, tool_calls: list[JsonValue]) -> str: if self.failed_tool_call_key is None or self.failed_tool_call_count < 2: @@ -6952,14 +6968,14 @@ def _gate_forget_actions( "Retrying: forget only visible tool result keys.", "ToolResult_Gate: " + forget_error + ".", ) - forget_hypothesis_error = self._forget_active_hypothesis_error(actions) - if forget_hypothesis_error: + forget_protected_error = self._forget_protected_result_error(actions) + if forget_protected_error: return self._reject_result( remember_error, on_message, - self._error("forget conflicts with active hypothesis: " + forget_hypothesis_error + ".", self.RULE_CLOSE_SOURCE), - "Retrying: close hypothesis before forgetting its source result.", - "ToolResult_Gate: " + forget_hypothesis_error + ".", + self._error("forget conflicts with protected result source: " + forget_protected_error + ".", self.RULE_CLOSE_SOURCE), + "Retrying: close dependent state before forgetting its source result.", + "ToolResult_Gate: " + forget_protected_error + ".", ) return None diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index a3faf4e..c27ee4f 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -785,8 +785,8 @@ def test_forget_rejects_active_hypothesis_source(tmp_path): assert result.done is False assert "tr.1" in _blocks_text(agent.tool_context.kept_results) - assert any("active hypothesis source: tr.1" in error for error in agent.agent_feedback_errors) - assert messages == ["ToolResult_Gate: active hypothesis source: tr.1."] + assert any("protected source: tr.1 (active hypothesis)" in error for error in agent.agent_feedback_errors) + assert messages == ["ToolResult_Gate: protected source: tr.1 (active hypothesis)."] def test_forget_allows_source_when_hypothesis_is_closed_same_response(tmp_path): @@ -1892,7 +1892,7 @@ def test_agent_request_auto_detects_chat_reasoning_from_provider_url(tmp_path, m assert payloads[0]["reasoning_effort"] == "max" assert payloads[1]["reasoning"] == {"effort": "high"} assert payloads[2]["enable_thinking"] is True - assert payloads[2]["thinking_budget"] == nanocode.ALIYUN_THINKING_BUDGET_BY_EFFORT["high"] + assert payloads[2]["thinking_budget"] == nanocode.CHAT_REASONING_EFFORT_VALUES["enable_thinking"]["high"] assert payloads[3]["thinking"] == {"type": "enabled"} assert payloads[3]["reasoning_effort"] == "max" assert payloads[4] == {"model": "glm-5.1", "messages": [{"role": "system", "content": "system"}, {"role": "user", "content": "user"}], "stream": False} From 6df2bc805d5a13d1150f4c4fdb20b4c929dee735 Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 06:41:05 -0700 Subject: [PATCH 080/144] refactor: remove stable knowledge state --- design.md | 8 +-- nanocode.py | 120 ++++++----------------------------- tests/test_nanocode_agent.py | 50 --------------- 3 files changed, 22 insertions(+), 156 deletions(-) diff --git a/design.md b/design.md index 05adb60..30fd88b 100644 --- a/design.md +++ b/design.md @@ -39,7 +39,6 @@ The main task state lives in the blackboard: - plan - hypotheses - known facts: settled facts for the current task -- stable knowledge: rare reusable codebase facts - verification state - recent edits @@ -60,7 +59,7 @@ When the model outputs `goal` with a different current-task goal: - kept tool results are cleared - visible raw tool results are compacted into summaries - full tool logs remain available through `Recall tr.N` -- known and stable knowledge remain available +- known facts remain available ## Context Construction @@ -74,7 +73,7 @@ ACT mode receives a working context: - Latest Tool Results - errors - recent edits -- known and stable knowledge +- known facts - conversation history - latest user request @@ -82,7 +81,7 @@ OBSERVE receives a smaller cleanup context: - latest user request - goal, plan, hypotheses -- known and stable knowledge +- known facts - kept tool results - observe errors - unreduced raw tool results selected from recent/latest storage @@ -111,7 +110,6 @@ ACT user prompt, top -> bottom +--------------------------------------------------+------------------------------+ | Background | compact_at | | - Environment | | -| - Stable Knowledge | | | - User Rules | | | - Conversation History | | +--------------------------------------------------+------------------------------+ diff --git a/nanocode.py b/nanocode.py index aebda32..cd58a3f 100644 --- a/nanocode.py +++ b/nanocode.py @@ -400,7 +400,6 @@ class Blackboard: hypotheses: list[Hypothesis] = field(default_factory=list) known: list[KnownItem] = field(default_factory=list) memory_checkpoint_tool_result_counter: int = 0 - stable_knowledge: dict[str, list[str]] = field(default_factory=dict) verification_required: bool = False verification: Verification = field(default_factory=Verification) @@ -3587,7 +3586,6 @@ def _canonical_tool_name(name: str | None) -> str: "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), "hypothesis": ("Update investigation hypotheses.", {"items": TOOL_HYPOTHESIS_ITEMS_SCHEMA}, ["items"]), "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), - "stable_knowledge": ("Record rare reusable codebase facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "user_rule": ( "Remember an explicit future behavior rule from the user.", {"text": TOOL_STRING_SCHEMA, "message": TOOL_STRING_SCHEMA}, @@ -3652,7 +3650,7 @@ def _state_tool_schema(name: str) -> Json: Avoid Markdown tables, large headings, decorative formatting, and long nested bullets unless the user asks for them. Available state tools: -goal, plan, hypothesis, known, stable_knowledge, user_rule, verify, forget +goal, plan, hypothesis, known, user_rule, verify, forget Available repository tools: { __tool_names__ } @@ -3662,7 +3660,7 @@ def _state_tool_schema(name: str) -> Json: - args: tool arguments PRIORITY -Latest User Request > User Rules > Current Goal > Plan/Known/Stable Knowledge > Conversation History. +Latest User Request > User Rules > Current Goal > Plan/Known > Conversation History. Current Phase: - new: align latest request with current state, or start readonly discovery @@ -3700,9 +3698,6 @@ def _state_tool_schema(name: str) -> Json: - status: { __hypothesis_status_text__ } - each hypothesis should imply a concrete check -Stable Knowledge: -- rare reusable codebase facts: stack, structure, workflow, convention, gotcha - User Rules: - only explicit future-behavior requests from the user @@ -3835,7 +3830,7 @@ def _state_tool_schema(name: str) -> Json: - Use function tools for state updates and readonly repository actions. - Assistant text is optional; never use it instead of the next useful function tool. - PLAN MODE is a tracked planning task; complete it with goal.complete=true. -- Allowed state tools: goal, plan, hypothesis, known, stable_knowledge, verify. +- Allowed state tools: goal, plan, hypothesis, known, verify. - Allowed repository tools: Read, LineCount, List, Search, Recall, and readonly Git. - Repository tool calls require intention and args. - Do not invent fields when a tool schema already fits. @@ -3943,17 +3938,15 @@ def _state_tool_schema(name: str) -> Json: 1. When Current Phase is new, set one concise planning goal and 2-4 discovery steps when enough context is known. 2. Search for owners before reading large files. 3. Prefer support from code, tests, docs, and recent relevant Git history. -4. After tool results, use Latest Tool Results, Unreduced Tool Results, and Kept Tool Results; use known for settled current-task facts and stable_knowledge only for rare reusable codebase facts. -5. Use stable_knowledge sparingly for broadly true technical facts that are not repository-specific. -6. Update plan status as discovery progresses. -7. If the request is ambiguous but a reasonable reversible path exists, proceed with stated assumptions and include open questions in the final plan. -8. Complete with goal.complete=true only when the final proposal is ready. +4. After tool results, use Latest Tool Results, Unreduced Tool Results, and Kept Tool Results; use known for settled current-task facts. +5. Update plan status as discovery progresses. +6. If the request is ambiguous but a reasonable reversible path exists, proceed with stated assumptions and include open questions in the final plan. +7. Complete with goal.complete=true only when the final proposal is ready. FUNCTION TOOL SEMANTICS - goal: initialize or update the planning goal; set work_mode when useful. - plan: update discovery or planning item status. - known: record durable repository findings from discovery. Do not include guesses. -- stable_knowledge: record stable external/technical knowledge. Use sparingly. - assistant text: brief user-facing status update in the latest user language. - repository tools: request readonly discovery. - verify: record only concrete verification status from readonly discovery; put planned checks in the final proposed plan. @@ -3994,9 +3987,6 @@ def _state_tool_schema(name: str) -> Json: Environment: {environment} -Stable Knowledge: -{stable_knowledge} - User Rules: {user_rules} @@ -4101,9 +4091,6 @@ def _state_tool_schema(name: str) -> Json: Known: {known} -Stable Knowledge: -{stable_knowledge} - Kept Tool Results: {kept_tool_results} @@ -4133,10 +4120,10 @@ def _state_tool_schema(name: str) -> Json: - KEEP only raw results that affect the next ACT frontier: target selection, edit choice, verification, error repair, or completion. - FORGET routine success, duplicate listings, no-match searches, superseded results, and ruled-out branches. Forget preserves logs and Recall. - If you omit a tr.N key, nanocode compacts it by default; use omission only for unimportant results. -- Before compacting or forgetting an important conclusion, preserve it with SOURCE-backed known, hypothesis, or stable_knowledge. +- Before compacting or forgetting an important conclusion, preserve it with SOURCE-backed known or hypothesis. - Do not update Plan, Verify, or Goal. -Allowed tools: keep, forget, known, hypothesis, stable_knowledge. +Allowed tools: keep, forget, known, hypothesis. """ @@ -5203,14 +5190,10 @@ def _make_tool(self, call: ParsedToolCall) -> Tool: ############################ -STABLE_KNOWLEDGE_CATEGORIES: tuple[str, ...] = ("stack", "structure", "workflow", "convention", "gotcha") - - class AgentStateUpdater: DISPLAY_LIMIT: ClassVar[int] = 5 COMPACT_DISPLAY_LIMIT: ClassVar[int] = 3 MAX_KNOWN_ITEMS: ClassVar[int] = 500 - MAX_STABLE_KNOWLEDGE_ITEMS_PER_CATEGORY: ClassVar[int] = 30 VERIFY_STATUS_ACTIONS: ClassVar[dict[str, VerificationStatus]] = { "passed": VerificationStatus.DONE, "failed": VerificationStatus.FAILED, @@ -5262,7 +5245,7 @@ def _format_state_report( before_hypotheses: list[str], before_known: list[str], before_user_rules: str, - before_extra_state: tuple[str, dict[str, list[str]]], + before_extra_state: str, ) -> str: current = self.blackboard lines = [] @@ -5320,7 +5303,6 @@ def compact_report(self) -> str: " Known" in self.latest_report and self.blackboard.known, self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100)), ), - ("Stable Knowledge", " Stable_Knowledge" in self.latest_report, [" updated"]), ("Verification", " Verify" in self.latest_report, [" " + self._format_verification()]), ("User Rules", " User_Rules" in self.latest_report, [" updated"]), ) @@ -5523,11 +5505,10 @@ def _known_facts_overlap(self, left: KnownItem | str, right: KnownItem | str) -> def _known_fact_key(self, fact: KnownItem | str) -> str: return re.sub(r"\s+", " ", KnownItem.text_of(fact)).strip(" \t\r\n。.;；").lower() - def _before_extra_state(self) -> tuple[str, dict[str, list[str]]]: - return self.blackboard.verification.format(), {key: list(value) for key, value in self.blackboard.stable_knowledge.items()} + def _before_extra_state(self) -> str: + return self.blackboard.verification.format() def _apply_extra_state(self, actions: list[Json], *, goal_changed: bool, plan_replaced: bool) -> None: - self._apply_stable_knowledge(actions) if goal_changed: self.blackboard.verification_required = False self._reset_stale_verification(actions, goal_changed=goal_changed, plan_replaced=plan_replaced) @@ -5553,38 +5534,13 @@ def _append_state_section(self, lines: list[str], title: str, rows: list[str] | lines.append(title) lines.extend(rows or []) - def _append_extra_state_report(self, lines: list[str], before_extra_state: tuple[str, dict[str, list[str]]]) -> None: - before_verification, before_stable_knowledge = before_extra_state - if self.blackboard.stable_knowledge != before_stable_knowledge: - self._append_state_section(lines, " Stable_Knowledge", self._format_stable_knowledge_rows()) + def _append_extra_state_report(self, lines: list[str], before_extra_state: str) -> None: + before_verification = before_extra_state verification = self.blackboard.verification.format() if verification == before_verification: return self._append_state_section(lines, " Verify " + self._format_verification()) - def _format_stable_knowledge_rows(self) -> list[str]: - knowledge = self.blackboard.stable_knowledge - if not any(knowledge.values()): - return [" (empty)"] - rows = [] - for category in STABLE_KNOWLEDGE_CATEGORIES: - items = knowledge.get(category, []) - if not items: - continue - rows.append(" " + category) - offset = max(0, len(items) - self.DISPLAY_LIMIT) - if offset: - rows.append(" ... " + str(offset) + " older") - for index, item in enumerate(items[offset:], start=offset + 1): - rows.append(" " + str(index) + ". " + self._compact(item)) - return rows - - def _apply_stable_knowledge(self, actions: list[Json]) -> None: - for raw in self._action_items(actions, "stable_knowledge"): - category, fact = self._stable_knowledge_item_from_json(raw) - if fact: - self._add_stable_knowledge_item(category, fact) - @staticmethod def _actions_of_type(actions: list[Json], action_type: str) -> Iterator[Json]: return (action for action in actions if _json_str(action.get("type")) == action_type) @@ -5592,26 +5548,6 @@ def _actions_of_type(actions: list[Json], action_type: str) -> Iterator[Json]: def _action_items(self, actions: list[Json], action_type: str) -> Iterator[JsonValue]: return (raw for action in self._actions_of_type(actions, action_type) for raw in _json_list(action.get("items"))) - def _stable_knowledge_item_from_json(self, value: JsonValue) -> tuple[str, str]: - item = _json_dict(value) - if item: - category = _json_str(item.get("category")) or "gotcha" - fact = (_json_str(item.get("text")) or _json_str(item.get("fact")) or "").strip() - else: - category = "gotcha" - fact = (_json_str(value) or "").strip() - if category not in STABLE_KNOWLEDGE_CATEGORIES: - category = "gotcha" - return category, fact - - def _add_stable_knowledge_item(self, category: str, fact: str) -> None: - knowledge = self.blackboard.stable_knowledge - items = knowledge.setdefault(category, []) - if fact in items: - return - items.append(fact) - del items[: max(0, len(items) - self.MAX_STABLE_KNOWLEDGE_ITEMS_PER_CATEGORY)] - def _format_verification(self) -> str: verification = self.blackboard.verification parts = [verification.status] @@ -5778,9 +5714,9 @@ class Agent: MAX_AGENT_FEEDBACK_ERRORS: ClassVar[int] = 8 MAX_AGENT_FEEDBACK_ERROR_LEN: ClassVar[int] = 220 MODEL_TIMEOUT_RETRY_DELAYS: ClassVar[tuple[int, ...]] = (3, 10, 20, 30, 60, 120) - ACT_ACTION_TYPES: ClassVar[set[str]] = {"goal", "plan", "hypothesis", "known", "stable_knowledge", "tool", "verify", "user_rule", "forget"} + ACT_ACTION_TYPES: ClassVar[set[str]] = {"goal", "plan", "hypothesis", "known", "tool", "verify", "user_rule", "forget"} PLAN_ACTION_TYPES: ClassVar[set[str]] = ACT_ACTION_TYPES - {"user_rule", "forget"} - OBSERVE_ACTION_TYPES: ClassVar[set[str]] = {"keep", "hypothesis", "known", "stable_knowledge", "forget"} + OBSERVE_ACTION_TYPES: ClassVar[set[str]] = {"keep", "hypothesis", "known", "forget"} COMPLETED_PLAN_STATUSES: ClassVar[set[PlanStatus]] = {PlanStatus.DONE, PlanStatus.BLOCKED} MAX_COMPLETED_GOAL_TOOL_RESULTS: ClassVar[int] = 50 RECENT_EDITS: ClassVar[int] = 20 @@ -5832,7 +5768,6 @@ def build_user_prompt(self) -> str: user_rules=self.session.state.user_rules.format(), known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", - stable_knowledge=self._format_stable_knowledge(), tool_result_index=tool_result_index or "(empty)", unreduced_tool_results=unreduced_tool_results or "(empty)", latest_tool_results=latest_tool_results or "(empty)", @@ -5878,7 +5813,6 @@ def build_observe_prompt(self) -> str: plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", - stable_knowledge=self._format_stable_knowledge(), kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", errors="\n".join("- " + error for error in self.observe_feedback_errors) or "(empty)", unreduced_tool_results=unreduced or "(empty)", @@ -5918,20 +5852,6 @@ def _format_user_request(self) -> str: fence = "`" * max(3, max((len(match.group(0)) for match in re.finditer(r"`{3,}", user_request)), default=0) + 1) return fence + "text\n" + user_request + "\n" + fence - def _format_stable_knowledge(self) -> str: - knowledge = self.blackboard.stable_knowledge - if not any(knowledge.values()): - return "(empty)" - lines = [] - for category in STABLE_KNOWLEDGE_CATEGORIES: - items = [item for item in knowledge.get(category, []) if item] - if not items: - continue - lines.append(category + ":") - lines.extend("- " + item for item in items) - lines.append("") - return "\n".join(lines).rstrip() - def request( self, system_prompt: str, @@ -6340,8 +6260,6 @@ def _has_memory_update_action(self, actions: list[Json]) -> bool: return True if action_type == "known" and any(_memory_fact_from_json(raw) for raw in _json_list(action.get("items"))): return True - if action_type == "stable_knowledge" and _json_list(action.get("items")): - return True return False def execute_tool_calls( @@ -6668,12 +6586,12 @@ def _build_response_context(self, response: Json) -> ResponseContext: has_fresh_plan_action=has_fresh_plan_action, has_user_rule_action="user_rule" in action_types, has_edit_tool_call=has_edit_tool_call, - has_state_update_action=bool(action_types & {"goal", "plan", "known", "hypothesis", "stable_knowledge"}), + has_state_update_action=bool(action_types & {"goal", "plan", "known", "hypothesis"}), state_or_work_requested=bool( tool_calls or pending_verify_requested or (assistant_text and actions and not completion_message) - or action_types & {"goal", "plan", "forget", "hypothesis", "known", "stable_knowledge"} + or action_types & {"goal", "plan", "forget", "hypothesis", "known"} ), ) @@ -6931,7 +6849,7 @@ def _handle_observe_response( return AgentRunResult() def _warn_weak_observe_memory(self, actions: list[Json]) -> None: - if any(_json_str(action.get("type")) in {"keep", "forget", "hypothesis", "stable_knowledge"} for action in actions): + if any(_json_str(action.get("type")) in {"keep", "forget", "hypothesis"} for action in actions): return known_actions = [action for action in actions if _json_str(action.get("type")) == "known"] if not known_actions: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index c27ee4f..fb6ff9e 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -403,7 +403,6 @@ def test_observe_prompt_uses_narrow_context(tmp_path): agent.blackboard.plan = [nanocode.PlanItem(id="p1", text="inspect failing path", status=nanocode.PlanStatus.DOING)] agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="cache branch", status=nanocode.HypothesisStatus.ACTIVE, source=("tr.1",))] agent.blackboard.known = ["known fact"] - agent.blackboard.stable_knowledge = {"workflow": ["use pytest"]} agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] agent.recent_edits = ["- sample.py: old edit"] agent.agent_feedback_errors = ["act error"] @@ -418,7 +417,6 @@ def test_observe_prompt_uses_narrow_context(tmp_path): assert "inspect failing path" in prompt assert "cache branch" in prompt assert "known fact" in prompt - assert "use pytest" in prompt assert "selected result" in prompt assert "raw alpha" in prompt assert "Observe Errors" in prompt @@ -2059,52 +2057,6 @@ def test_agent_keeps_latest_500_known_items(tmp_path): assert agent.blackboard.known[-1] == "fact 500" -def test_main_agent_applies_stable_knowledge_action(tmp_path): - session = Session(cwd=str(tmp_path)) - agent = Agent(session) - - agent.apply_response( - { - "actions": [ - {"type": "known", "items": ["Read pyproject.toml."]}, - { - "type": "stable_knowledge", - "items": [ - {"category": "workflow", "text": "Project test command is make test."}, - {"category": "workflow", "text": "Project test command is make test."}, - ], - } - ] - } - ) - - assert agent.blackboard.known == ["Read pyproject.toml."] - assert agent.blackboard.stable_knowledge == {"workflow": ["Project test command is make test."]} - assert " Stable_Knowledge\n" in agent.state_updater.latest_report - assert " workflow\n" in agent.state_updater.latest_report - assert " 1. Project test command is make test." in agent.state_updater.latest_report - - -def test_main_agent_keeps_latest_30_stable_knowledge_items_per_category(tmp_path): - session = Session(cwd=str(tmp_path)) - agent = Agent(session) - - agent.apply_response( - { - "actions": [ - { - "type": "stable_knowledge", - "items": [{"category": "workflow", "text": "stable fact " + str(index)} for index in range(31)], - } - ] - } - ) - - assert len(agent.blackboard.stable_knowledge["workflow"]) == 30 - assert agent.blackboard.stable_knowledge["workflow"][0] == "stable fact 1" - assert agent.blackboard.stable_knowledge["workflow"][-1] == "stable fact 30" - - def test_main_agent_applies_user_rule_and_saves(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) @@ -3164,7 +3116,6 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): agent.blackboard.goal = "read samples" agent.blackboard.plan = [nanocode.PlanItem(text="try answer", status=nanocode.PlanStatus.DONE, context="seeded")] agent.blackboard.known = ["keep this fact"] - agent.blackboard.stable_knowledge = {"workflow": ["Project test command is make test."]} agent.tool_context.latest = ["old tool call"] agent.model_client = FakeModelClient() @@ -3183,7 +3134,6 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert agent.blackboard.goal == "read samples" assert agent.blackboard.plan == [nanocode.PlanItem(text="try answer", status=nanocode.PlanStatus.DONE, context="seeded")] assert agent.blackboard.known == ["keep this fact"] - assert agent.blackboard.stable_knowledge == {"workflow": ["Project test command is make test."]} assert agent.blackboard.verification.status == VerificationStatus.IDLE assert agent.blackboard.goal_reached is False From 5e67cce769c86c76ad3449ff63596374c04f14e7 Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 06:55:59 -0700 Subject: [PATCH 081/144] refactor: trim tool helper code --- nanocode.py | 147 ++++++++++++++++++++++++---------------------------- 1 file changed, 67 insertions(+), 80 deletions(-) diff --git a/nanocode.py b/nanocode.py index cd58a3f..c47c8e5 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1724,6 +1724,17 @@ def _range_fingerprint(content: str) -> str: ############################ +def _numbered_content(content: str, start: int) -> str: + return "".join(f"{start + index:>7} |{line}" for index, line in enumerate(content.splitlines(keepends=True))) + + +def _parse_line_range_token(value: str) -> tuple[int, int]: + match = re.fullmatch(r"\s*(\d+)\s*[-:,]\s*(\d+)\s*", value) + if match is None: + raise ToolCallArgError("invalid range: use a comma token like 0,120") + return _parse_line_range(match.group(1), match.group(2)) + + @dataclass class ReadTool(Tool): NAME: ClassVar[str] = "Read" @@ -1754,13 +1765,6 @@ def cli_args(cls, args: list[JsonValue]) -> list[str]: tokens = [cls.cli_token(args[0])] return tokens + [str(arg) for arg in args[1:]] - @staticmethod - def _parse_line_range_token(value: str) -> tuple[int, int]: - match = re.fullmatch(r"\s*(\d+)\s*[-:,]\s*(\d+)\s*", value) - if match is None: - raise ToolCallArgError("invalid range: use a comma token like 0,120") - return _parse_line_range(match.group(1), match.group(2)) - @classmethod def make(cls, session: Session, args: list[str]) -> Self: if len(args) == 0: @@ -1771,7 +1775,7 @@ def make(cls, session: Session, args: list[str]) -> Self: if len(args) == 1: ranges = [(0, 0)] elif all(re.fullmatch(r"\s*\d+\s*[-:,]\s*\d+\s*", arg) for arg in args[1:]): - ranges = [cls._parse_line_range_token(arg) for arg in args[1:]] + ranges = [_parse_line_range_token(arg) for arg in args[1:]] elif len(args) == 2: raise ToolCallArgError('Read args error: invalid range token; expected ["filepath", "start,end"]. Example: Read("nanocode.py", "2065,2095").') else: @@ -1805,10 +1809,6 @@ def call(self) -> str: lines.append("") return "\n".join(lines) - @staticmethod - def _numbered_content(content: str, start: int) -> str: - return "".join(f"{start + index:>7} |{line}" for index, line in enumerate(content.splitlines(keepends=True))) - def _read_range(self, start: int, end: int) -> tuple[str, int, int, str, bool, int]: target_filepath = self.filepath total_lines = 0 @@ -1870,7 +1870,7 @@ def _format_range_result( indent + "" + note + "", ] ) - lines.extend([indent + "", self._numbered_content(content, start), indent + ""]) + lines.extend([indent + "", _numbered_content(content, start), indent + ""]) return lines @@ -1950,34 +1950,31 @@ def preview(self) -> str: def requires_confirmation(self, session: Session) -> bool: return not session.is_path_in_cwd(self.dirpath) - def _dir_entry_type(self, entry: os.DirEntry[str]) -> str: - if entry.is_symlink(): - return "symlink" - if entry.is_dir(follow_symlinks=False): - return "dir" - if entry.is_file(follow_symlinks=False): - return "file" - return "other" - - def _entry_type_sort_key(self, entry_type: str) -> int: - return {"dir": 0, "file": 1, "symlink": 2, "other": 3}.get(entry_type, 4) - def call(self) -> str: if not os.path.isdir(self.dirpath): raise ToolCallError("not a directory") + sort_order = {"dir": 0, "file": 1, "symlink": 2, "other": 3} entries = [] with os.scandir(self.dirpath) as scan: for entry in scan: if self.glob_pattern and not fnmatch.fnmatch(entry.name, self.glob_pattern): continue + if entry.is_symlink(): + entry_type = "symlink" + elif entry.is_dir(follow_symlinks=False): + entry_type = "dir" + elif entry.is_file(follow_symlinks=False): + entry_type = "file" + else: + entry_type = "other" entries.append( { "name": entry.name, "path": entry.path, - "type": self._dir_entry_type(entry), + "type": entry_type, } ) - entries.sort(key=lambda item: (self._entry_type_sort_key(str(item["type"])), str(item["name"]))) + entries.sort(key=lambda item: (sort_order.get(str(item["type"]), 4), str(item["name"]))) lines = [""] for e in entries: lines.append(f"* ({e['type']}): {os.path.relpath(str(e['path']), self.cwd)}") @@ -2399,7 +2396,7 @@ def format_investigate(cls, result: Json) -> list[str]: lines.append("* symbol: " + cls.symbol_line(symbol)) source = _json_str(result.get("source")) if source and symbol: - lines.extend(["", ReadTool._numbered_content(source, cls.read_start(symbol.get("start_line"))).rstrip("\n"), ""]) + lines.extend(["", _numbered_content(source, cls.read_start(symbol.get("start_line"))).rstrip("\n"), ""]) for label, key in (("members", "members"), ("references", "refs"), ("impact", "impact"), ("implementors", "implementors")): items = [_json_dict(item) for item in _json_list(result.get(key))] if items: @@ -2432,6 +2429,23 @@ def _cymbal_json_results(stdout: str) -> list[Json]: return [] +def _run_cymbal_command(tag: str, cmd: list[str], *, cwd: str, timeout: int, render: Callable[[str], list[str]]) -> str: + try: + proc = subprocess.run(cmd, cwd=cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, env=_plain_command_env()) + exit_code, stdout, stderr = proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr) + except subprocess.TimeoutExpired as error: + exit_code, stdout, stderr = -1, error.stdout or "", (error.stderr or "") + "timeout" + lines = ["<" + tag + ">", "* exit_code: " + str(exit_code)] + if rendered := render(stdout): + lines.extend(rendered) + elif stdout: + lines.extend(["", stdout.rstrip("\n"), ""]) + if stderr: + lines.extend(["", stderr.rstrip("\n"), ""]) + lines.append("") + return "\n".join(lines) + + @dataclass class FindCodeSymbolTool(Tool): NAME: ClassVar[str] = "FindCodeSymbol" @@ -2489,22 +2503,13 @@ def preview(self) -> str: def call(self) -> str: cmd = [self.cymbal_path, "search", self.query, "--limit", str(self.limit), "--json"] - try: - proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) - except subprocess.TimeoutExpired as error: - return self._format(-1, error.stdout or "", (error.stderr or "") + "timeout") - return self._format(proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) - - def _format(self, exit_code: int, stdout: str, stderr: str) -> str: - lines = ["", "* exit_code: " + str(exit_code)] - if items := _cymbal_json_results(stdout): - lines.extend(CymbalResultFormatter.format_symbol_search(items)) - elif stdout: - lines.extend(["", stdout.rstrip("\n"), ""]) - if stderr: - lines.extend(["", stderr.rstrip("\n"), ""]) - lines.append("") - return "\n".join(lines) + return _run_cymbal_command( + "FindCodeSymbolToolResult", + cmd, + cwd=self.cwd, + timeout=self.timeout, + render=lambda stdout: CymbalResultFormatter.format_symbol_search(_cymbal_json_results(stdout)), + ) @dataclass class InspectCodeSymbolTool(Tool): @@ -2564,22 +2569,13 @@ def preview(self) -> str: def call(self) -> str: cmd = [self.cymbal_path, "investigate", self.symbol, "--json"] - try: - proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) - except subprocess.TimeoutExpired as error: - return self._format(-1, error.stdout or "", (error.stderr or "") + "timeout") - return self._format(proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) - - def _format(self, exit_code: int, stdout: str, stderr: str) -> str: - lines = ["", "* exit_code: " + str(exit_code)] - if result := self._investigate_result(stdout): - lines.extend(CymbalResultFormatter.format_investigate(result)) - elif stdout: - lines.extend(["", stdout.rstrip("\n"), ""]) - if stderr: - lines.extend(["", stderr.rstrip("\n"), ""]) - lines.append("") - return "\n".join(lines) + return _run_cymbal_command( + "InspectCodeSymbolToolResult", + cmd, + cwd=self.cwd, + timeout=self.timeout, + render=lambda stdout: CymbalResultFormatter.format_investigate(self._investigate_result(stdout) or {}), + ) @staticmethod def _investigate_result(stdout: str) -> Json | None: @@ -2639,22 +2635,13 @@ def preview(self) -> str: def call(self) -> str: cmd = [self.cymbal_path, "outline", self.filepath, "--json"] - try: - proc = subprocess.run(cmd, cwd=self.cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=self.timeout, env=_plain_command_env()) - except subprocess.TimeoutExpired as error: - return self._format(-1, error.stdout or "", (error.stderr or "") + "timeout") - return self._format(proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr)) - - def _format(self, exit_code: int, stdout: str, stderr: str) -> str: - lines = ["", "* exit_code: " + str(exit_code)] - if items := _cymbal_json_results(stdout): - lines.extend(CymbalResultFormatter.format_outline(items)) - elif stdout: - lines.extend(["", stdout.rstrip("\n"), ""]) - if stderr: - lines.extend(["", stderr.rstrip("\n"), ""]) - lines.append("") - return "\n".join(lines) + return _run_cymbal_command( + "OutlineCodeFileToolResult", + cmd, + cwd=self.cwd, + timeout=self.timeout, + render=lambda stdout: CymbalResultFormatter.format_outline(_cymbal_json_results(stdout)), + ) @dataclass class EditTool(Tool): @@ -3460,7 +3447,7 @@ class ToolResultTool(Tool): @classmethod def make(cls, session: Session, args: list[str]) -> Self: keys = [arg for arg in args if not re.fullmatch(r"\s*\d+\s*[-:,]\s*\d+\s*", arg)] - ranges = [ReadTool._parse_line_range_token(arg) for arg in args if re.fullmatch(r"\s*\d+\s*[-:,]\s*\d+\s*", arg)] + ranges = [_parse_line_range_token(arg) for arg in args if re.fullmatch(r"\s*\d+\s*[-:,]\s*\d+\s*", arg)] return cls(keys=keys, results=session.state.tool_result_store, cwd=session.cwd, ranges=ranges) def preview(self) -> str: @@ -4967,7 +4954,7 @@ def latest_report(cls, executions: list[ToolCallExecution]) -> str: @classmethod def _format_execution(cls, execution: ToolCallExecution) -> str: marker = "[success]" if execution.outcome == "success" else "[failure]" - text = marker + " " + cls._format_call(execution.call) + text = marker + " " + cls.format_call(execution.call) if execution.result_key: text += " -> " + execution.result_key if execution.outcome != "success": @@ -4979,7 +4966,7 @@ def _format_execution(cls, execution: ToolCallExecution) -> str: return text @classmethod - def _format_call(cls, call: ParsedToolCall) -> str: + def format_call(cls, call: ParsedToolCall) -> str: tool_class = TOOL_REGISTRY.get(call.name) tokens = tool_class.cli_args(call.args) if tool_class is not None else [Tool.cli_token(arg) for arg in call.args] return " ".join([call.name] + tokens) @@ -5119,7 +5106,7 @@ def _dedupe_readonly_tool_calls(self, tool_calls: list[JsonValue]) -> list[JsonV def _store_tool_result(self, call: ParsedToolCall, outcome: str, output: str) -> str: self.session.state.tool_result_counter += 1 key = "tr." + str(self.session.state.tool_result_counter) - description = outcome + " " + ToolCallDisplayFormatter._format_call(call) + description = outcome + " " + ToolCallDisplayFormatter.format_call(call) if call.intention: description += " - " + call.intention log_path = self._write_tool_result_log(key, output) From a12505e09fbe15a1166b2f78c84abf7ff669bebc Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 06:57:30 -0700 Subject: [PATCH 082/144] chore: release 0.4.3 --- CHANGELOG.md | 7 +++++++ nanocode.py | 2 +- pyproject.toml | 2 +- 3 files changed, 9 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a56973b..fcf2736 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,12 @@ # Changelog +## 0.4.3 - 2026-05-20 + +### Changed +- Removed stable knowledge state while keeping current-task known facts. +- Extracted shared numbered-content and line-range helpers for tool output/range handling. +- Trimmed thin helper wrappers in List and indexed code-inspection tools. + ## 0.4.2 - 2026-05-19 ### Added diff --git a/nanocode.py b/nanocode.py index c47c8e5..8deff88 100644 --- a/nanocode.py +++ b/nanocode.py @@ -54,7 +54,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.2" +__version__ = "0.4.3" JsonValue: TypeAlias = Any diff --git a/pyproject.toml b/pyproject.toml index a0e2a8c..ee0a6c8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.2" +version = "0.4.3" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" From fde5b883ef50a4b4cc174070b380fbfda2f45cf2 Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 11:14:20 -0700 Subject: [PATCH 083/144] replace cymbal with built-in code index --- CHANGELOG.md | 10 + README.md | 6 +- design.md | 9 +- nanocode.py | 275 +++++++++++------------- pyproject.toml | 3 +- tests/test_nanocode_agent.py | 8 +- tests/test_nanocode_code_index_tools.py | 185 ++++++++++++++++ tests/test_nanocode_commands.py | 17 +- tests/test_nanocode_cymbal_tools.py | 199 ----------------- tests/test_nanocode_loop.py | 13 ++ 10 files changed, 362 insertions(+), 363 deletions(-) create mode 100644 tests/test_nanocode_code_index_tools.py delete mode 100644 tests/test_nanocode_cymbal_tools.py diff --git a/CHANGELOG.md b/CHANGELOG.md index fcf2736..fce6f5f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,15 @@ # Changelog +## 0.4.4 - 2026-05-20 + +### Added +- Added built-in indexed code navigation backed by project data and `/index` for manual init/sync. + +### Changed +- Replaced the external code-navigation CLI integration with the bundled code index API. +- Hid code navigation tools until an index exists, while lightly updating existing indexes at startup. +- Updated status/docs to describe code index availability without exposing dependency-install wording. + ## 0.4.3 - 2026-05-20 ### Changed diff --git a/README.md b/README.md index ed853b7..708eaca 100644 --- a/README.md +++ b/README.md @@ -80,7 +80,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Tools - File: `Read`, `LineCount`, `List`, `Search`. -- Codebase: `FindCodeSymbol`, `InspectCodeSymbol`, and `OutlineCodeFile` when the local `cymbal` CLI is installed. +- Code navigation: `FindCodeSymbol`, `InspectCodeSymbol`, and `OutlineCodeFile` after `/index` builds the project index. - Edit: `Edit`, `ReplaceRange`. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. @@ -89,7 +89,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. - Info: `/help [question]`, `/status`, `/rules`, `/compact`. - Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/reason-payload [value]`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. -- Maintenance: `/clean`. +- Maintenance: `/index`, `/clean`. - Exit: `/exit`, `/quit`. Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/api responses` switches the current provider to Responses format. `/reason` sets `provider.reasoning` to `off` or an effort value; `/reason-payload` controls the Chat-only reasoning payload shape. `/model` lists configured models before discovered ones, then prompts for reasoning. @@ -106,7 +106,7 @@ Run `nanocode --init-config` to create `~/.nanocode/config.toml`. - `/context [low|medium|high]` shows or switches tool-result context budgets; lower budgets reduce token usage and observe overhead. - Session data: debug prompts and tool-result logs are stored under `~/.nanocode/sessions//`. - Old inactive session directories are auto-cleaned after `runtime.auto_clean_recent` (default `1d`; use `off` to disable). `/clean` removes inactive sessions immediately. -- Project data: user rules are stored under `~/.nanocode/projects//`. +- Project data: user rules and code indexes are stored under `~/.nanocode/projects//`. ## Status diff --git a/design.md b/design.md index 30fd88b..068b83a 100644 --- a/design.md +++ b/design.md @@ -88,10 +88,11 @@ OBSERVE receives a smaller cleanup context: OBSERVE reduces tool-result noise before ACT continues. -Optional tools can be environment-gated. For example, `FindCodeSymbol`, -`InspectCodeSymbol`, and `OutlineCodeFile` are shown only when the local -`cymbal` CLI exists. They accept symbol queries or file paths, not -natural-language questions. +Code navigation tools are environment-gated. `FindCodeSymbol`, +`InspectCodeSymbol`, and `OutlineCodeFile` are shown only when the built-in code +index is available. They accept symbol queries or file paths, not +natural-language questions. The index is created explicitly with `/index`; if an +index already exists, startup performs a lightweight incremental update. Context layout: diff --git a/nanocode.py b/nanocode.py index 8deff88..bc93e9c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -12,6 +12,7 @@ import fcntl import fnmatch import hashlib +import importlib import inspect import itertools import json @@ -54,7 +55,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.3" +__version__ = "0.4.4" JsonValue: TypeAlias = Any @@ -966,6 +967,7 @@ class RuntimeState: session_tool_calls: int = 0 turn_model_calls: int = 0 debug_log_count: int = 0 + code_index_error: str = "" @dataclass @@ -1250,10 +1252,6 @@ def _function_tool_schema(name: str, description: str, parameters: Json) -> Json return {"type": "function", "function": {"name": name, "description": description, "parameters": parameters}} -def _cymbal_available() -> bool: - return bool(shutil.which("cymbal")) - - def _json_value_schema(depth: int = 3) -> Json: values: list[Json] = [{"type": "string"}, {"type": "number"}, {"type": "boolean"}, {"type": "null"}] if depth > 0: @@ -2345,103 +2343,87 @@ def call(self) -> str: return self._call_python() -class CymbalResultFormatter: - MAX_OUTLINE_ITEMS: ClassVar[int] = 160 - MAX_SEARCH_ITEMS: ClassVar[int] = 80 +def _code_index_module() -> Any | None: + try: + return importlib.import_module("code_symbol_index") + except ImportError: + return None - @staticmethod - def read_start(value: JsonValue) -> int: - try: - return max(0, int(value) - 1) - except (TypeError, ValueError): - return 0 - @classmethod - def location(cls, item: Json) -> str: - path = _json_str(item.get("rel_path")) or _json_str(item.get("file")) or "?" - start_value = item.get("start_line", item.get("line")) - if start_value is None: - return path - start = cls.read_start(start_value) - end_value = item.get("end_line") - if end_value is None: - return path + ":" + str(start) - try: - end = max(start, int(end_value)) - except (TypeError, ValueError): - end = start - return path + ":" + str(start) + ":" + str(end) +def _code_index_db_path(session: Session) -> str: + return os.path.join(session.project_dir(), "code-symbol-index", "index.sqlite") - @classmethod - def symbol_line(cls, item: Json) -> str: - name = _json_str(item.get("name")) or _json_str(item.get("implementer")) or _json_str(item.get("caller")) or _json_str(item.get("symbol")) or "(unknown)" - kind = _json_str(item.get("kind")) - extras = [] - if _json_str(item.get("caller")) and _json_str(item.get("symbol")): - extras.append("symbol=" + str(item["symbol"])) - if _json_str(item.get("target")): - extras.append("target=" + str(item["target"])) - if _json_str(item.get("signature")): - extras.append(str(item["signature"])) - if item.get("resolved") is False: - extras.append("unresolved") - return " ".join(part for part in (kind, name, cls.location(item), " ".join(extras)) if part) - @classmethod - def format_investigate(cls, result: Json) -> list[str]: - lines: list[str] = [] - symbol = _json_dict(result.get("symbol")) - if symbol: - lines.append('Line numbers are 0-based and match Read/ReplaceRange ranges.') - lines.append("* symbol: " + cls.symbol_line(symbol)) - source = _json_str(result.get("source")) - if source and symbol: - lines.extend(["", _numbered_content(source, cls.read_start(symbol.get("start_line"))).rstrip("\n"), ""]) - for label, key in (("members", "members"), ("references", "refs"), ("impact", "impact"), ("implementors", "implementors")): - items = [_json_dict(item) for item in _json_list(result.get(key))] - if items: - lines.extend(["<" + label + ">", *(cls.symbol_line(item) for item in items[:50]), ""]) - return lines +def _code_index_repository(session: Session, *, create_index: bool = False) -> Any: + module = _code_index_module() + if module is None: + raise ToolCallError("code index is unavailable") + db_path = _code_index_db_path(session) + if create_index: + os.makedirs(os.path.dirname(db_path), exist_ok=True) + return module.Repository(session.cwd, db_path=db_path, create_index=create_index) - @classmethod - def format_outline(cls, items: list[Json]) -> list[str]: - lines = ['Line numbers are 0-based and match Read/ReplaceRange ranges.', ""] - lines.extend(cls.symbol_line(item) for item in items[: cls.MAX_OUTLINE_ITEMS]) - if len(items) > cls.MAX_OUTLINE_ITEMS: - lines.append("... " + str(len(items) - cls.MAX_OUTLINE_ITEMS) + " more") - lines.append("") - return lines - @classmethod - def format_symbol_search(cls, items: list[Json]) -> list[str]: - lines = ['Line numbers are 0-based and match Read/ReplaceRange ranges.', ""] - lines.extend(cls.symbol_line(item) for item in items[: cls.MAX_SEARCH_ITEMS]) - if len(items) > cls.MAX_SEARCH_ITEMS: - lines.append("... " + str(len(items) - cls.MAX_SEARCH_ITEMS) + " more") - lines.append("") - return lines +def _code_index_status(session: Session, *, check: bool = False) -> tuple[str, str]: + module = _code_index_module() + if module is None: + return "unavailable", "" + try: + status = module.status(session.cwd, db_path=_code_index_db_path(session), check=check, format="object") + except Exception as error: + return "error", str(error) + return str(getattr(status, "status", "error")), str(getattr(status, "message", None) or getattr(status, "reason", None) or "") + +def _code_index_available(session: Session) -> bool: + status, message = _code_index_status(session) + session.state.code_index_error = message if status == "error" else "" + return status in {"ready", "stale"} -def _cymbal_json_results(stdout: str) -> list[Json]: + +def _code_index_update_existing(session: Session) -> None: + status, _message = _code_index_status(session) + if status not in {"ready", "stale"}: + return try: - return [_json_dict(item) for item in _json_list(_json_dict(json.loads(stdout)).get("results"))] - except json.JSONDecodeError: - return [] + _code_index_repository(session).update() + session.state.code_index_error = "" + except Exception as error: + session.state.code_index_error = str(error) -def _run_cymbal_command(tag: str, cmd: list[str], *, cwd: str, timeout: int, render: Callable[[str], list[str]]) -> str: +def _code_index_sync(session: Session) -> str: + before, _message = _code_index_status(session) try: - proc = subprocess.run(cmd, cwd=cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout, env=_plain_command_env()) - exit_code, stdout, stderr = proc.returncode, _clean_terminal_output(proc.stdout), _clean_terminal_output(proc.stderr) - except subprocess.TimeoutExpired as error: - exit_code, stdout, stderr = -1, error.stdout or "", (error.stderr or "") + "timeout" - lines = ["<" + tag + ">", "* exit_code: " + str(exit_code)] - if rendered := render(stdout): - lines.extend(rendered) - elif stdout: - lines.extend(["", stdout.rstrip("\n"), ""]) - if stderr: - lines.extend(["", stderr.rstrip("\n"), ""]) + _code_index_repository(session, create_index=True).refresh() + except Exception as error: + session.state.code_index_error = str(error) + return "code_index: error\n" + str(error) + session.state.code_index_error = "" + status, message = _code_index_status(session) + lines = ["code_index: " + ("initialized" if before == "missing" else "synced"), "status: " + status, "path: " + _code_index_db_path(session)] + if message: + lines.append("note: " + message) + return "\n".join(lines) + + +def _code_index_update(session: Session, filepath: str) -> None: + if _code_index_module() is None or not session.is_path_in_cwd(filepath): + return + status, _message = _code_index_status(session) + if status == "missing": + return + try: + _code_index_repository(session).update([filepath]) + session.state.code_index_error = "" + except Exception as error: + session.state.code_index_error = str(error) + + +def _format_code_index_result(tag: str, text: str) -> str: + lines = ["<" + tag + ">"] + if text.strip(): + lines.append(text.rstrip("\n")) lines.append("") return "\n".join(lines) @@ -2463,9 +2445,7 @@ class FindCodeSymbolTool(Tool): query: str = "" limit: int = DEFAULT_LIMIT - cymbal_path: str = "" - cwd: str = "" - timeout: int = 60 + session: Session | None = None @classmethod def tool_schema(cls) -> Json: @@ -2493,23 +2473,18 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: limit = min(cls.MAX_LIMIT, max(1, int(args[1]))) except (TypeError, ValueError): raise ToolCallArgError("limit must be an integer") - cymbal_path = shutil.which("cymbal") - if not cymbal_path: - raise ToolCallError("cymbal not found") - return cls(query=query, limit=limit, cymbal_path=cymbal_path, cwd=session.cwd, timeout=session.settings.shell_timeout) + if not _code_index_available(session): + raise ToolCallError("code index is not available") + return cls(query=query, limit=limit, session=session) def preview(self) -> str: return "FindCodeSymbol(" + json.dumps(self.query, ensure_ascii=False) + ")" def call(self) -> str: - cmd = [self.cymbal_path, "search", self.query, "--limit", str(self.limit), "--json"] - return _run_cymbal_command( - "FindCodeSymbolToolResult", - cmd, - cwd=self.cwd, - timeout=self.timeout, - render=lambda stdout: CymbalResultFormatter.format_symbol_search(_cymbal_json_results(stdout)), - ) + if self.session is None: + raise ToolCallError("missing session") + text = _code_index_repository(self.session).search_text(self.query, limit=self.limit) + return _format_code_index_result("FindCodeSymbolToolResult", text) @dataclass class InspectCodeSymbolTool(Tool): @@ -2529,9 +2504,7 @@ class InspectCodeSymbolTool(Tool): ) symbol: str = "" - cymbal_path: str = "" - cwd: str = "" - timeout: int = 60 + session: Session | None = None @classmethod def tool_schema(cls) -> Json: @@ -2551,9 +2524,8 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: symbol = str(args[0]).strip() if not symbol: raise ToolCallArgError("symbol cannot be empty") - cymbal_path = shutil.which("cymbal") - if not cymbal_path: - raise ToolCallError("cymbal not found") + if not _code_index_available(session): + raise ToolCallError("code index is not available") path_target = session.resolve_path(symbol) dotted_path = session.resolve_path(symbol.replace(".", os.sep)) if "." in symbol and os.sep not in symbol else "" if os.path.exists(path_target) or (dotted_path and os.path.exists(dotted_path)): @@ -2562,29 +2534,15 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: raise ToolCallArgError("symbol must be one symbol, Class.member, or symbol prefix; do not pass natural language") if "." in symbol and not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?", symbol): raise ToolCallArgError("symbol looks like a module path; use List/Search/Read for modules/packages, or pass a specific symbol") - return cls(symbol=symbol, cymbal_path=cymbal_path, cwd=session.cwd, timeout=session.settings.shell_timeout) + return cls(symbol=symbol, session=session) def preview(self) -> str: return "InspectCodeSymbol(" + json.dumps(self.symbol, ensure_ascii=False) + ")" def call(self) -> str: - cmd = [self.cymbal_path, "investigate", self.symbol, "--json"] - return _run_cymbal_command( - "InspectCodeSymbolToolResult", - cmd, - cwd=self.cwd, - timeout=self.timeout, - render=lambda stdout: CymbalResultFormatter.format_investigate(self._investigate_result(stdout) or {}), - ) - - @staticmethod - def _investigate_result(stdout: str) -> Json | None: - try: - data = _json_dict(json.loads(stdout)) - except json.JSONDecodeError: - return None - result = _json_dict(_json_dict(data.get("results")).get("result")) - return result or None + if self.session is None: + raise ToolCallError("missing session") + return _format_code_index_result("InspectCodeSymbolToolResult", _code_index_repository(self.session).inspect_text(self.symbol)) @dataclass @@ -2600,9 +2558,7 @@ class OutlineCodeFileTool(Tool): EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["nanocode.py"]',) filepath: str = "" - cymbal_path: str = "" - cwd: str = "" - timeout: int = 60 + session: Session | None = None @classmethod def tool_schema(cls) -> Json: @@ -2622,26 +2578,21 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: filepath = session.resolve_path(str(args[0]).strip()) if not os.path.isfile(filepath): raise ToolCallArgError("filepath must be an existing file; directories and symbols are not supported") - cymbal_path = shutil.which("cymbal") - if not cymbal_path: - raise ToolCallError("cymbal not found") - return cls(filepath=filepath, cymbal_path=cymbal_path, cwd=session.cwd, timeout=session.settings.shell_timeout) + if not _code_index_available(session): + raise ToolCallError("code index is not available") + return cls(filepath=filepath, session=session) def requires_confirmation(self, session: Session) -> bool: return not session.is_path_in_cwd(self.filepath) def preview(self) -> str: - return "OutlineCodeFile(" + json.dumps(os.path.relpath(self.filepath, self.cwd), ensure_ascii=False) + ")" + cwd = self.session.cwd if self.session is not None else os.getcwd() + return "OutlineCodeFile(" + json.dumps(os.path.relpath(self.filepath, cwd), ensure_ascii=False) + ")" def call(self) -> str: - cmd = [self.cymbal_path, "outline", self.filepath, "--json"] - return _run_cymbal_command( - "OutlineCodeFileToolResult", - cmd, - cwd=self.cwd, - timeout=self.timeout, - render=lambda stdout: CymbalResultFormatter.format_outline(_cymbal_json_results(stdout)), - ) + if self.session is None: + raise ToolCallError("missing session") + return _format_code_index_result("OutlineCodeFileToolResult", _code_index_repository(self.session).outline_text(self.filepath)) @dataclass class EditTool(Tool): @@ -5777,7 +5728,7 @@ def _format_environment(self) -> str: "- arch: " + self.session.arch, "- cwd: " + self.session.cwd, ] - if _cymbal_available(): + if _code_index_available(self.session): lines.append( "- inspect_code_hint: Use FindCodeSymbol for symbol/prefix candidates (case-insensitive, optional limit default 20 max 80), InspectCodeSymbol for chosen symbols, and OutlineCodeFile for known file structure. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." ) @@ -5818,7 +5769,7 @@ def _system_prompt(self, template: str | None = None, *, tools: Iterable[ToolCla def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> tuple[ToolClass, ...]: tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) - if _cymbal_available(): + if _code_index_available(self.session): return tool_classes return tuple(tool for tool in tool_classes if tool not in (FindCodeSymbolTool, OutlineCodeFileTool, InspectCodeSymbolTool)) @@ -6307,6 +6258,8 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: self.blackboard.verification_required = True self.blackboard.task_code = TaskCode.VERIFYING self._remember_recent_edit(execution) + if execution.call.args: + _code_index_update(self.session, self.session.resolve_path(str(execution.call.args[0]))) def _remember_tool_failure(self, execution: ToolCallExecution) -> None: if execution.outcome != "failure": @@ -7116,6 +7069,7 @@ class CommandSpec: CommandSpec("/provider", "Show or switch provider", "Config", "/provider [name]"), CommandSpec("/plan", "Toggle plan mode or ask for a readonly plan", "Config", "/plan [on|off|question]"), CommandSpec("/yolo", "Toggle yolo mode (skip confirmations)", "Config", "/yolo"), + CommandSpec("/index", "Initialize or sync code index", "Maintenance", "/index"), CommandSpec("/clean", "Clean inactive session directories", "Maintenance", "/clean"), CommandSpec("/exit", "Exit nanocode", "Control", "/exit"), CommandSpec("/quit", "Exit nanocode", "Control", "/quit"), @@ -7415,6 +7369,13 @@ def _status(self, args: str) -> str: else " (empty)" ) verification_status = blackboard.verification.status + code_index_status, code_index_message = _code_index_status(session) + if session.state.code_index_error: + code_index_status = "error" + code_index_message = session.state.code_index_error + elif code_index_status in {"missing", "stale"}: + code_index_message = (code_index_message + "; " if code_index_message else "") + "run /index" + code_index = code_index_status + (": " + _shorten(code_index_message, 80) if code_index_message else "") return "\n".join( [ "provider: " + session.config.active_provider, @@ -7437,7 +7398,7 @@ def _status(self, args: str) -> str: + session.settings.context_budget, "conversation: " + str(len(session.state.conversation)) + "/" + str(session.settings.compact_at), "tool_calls: turn=" + str(session.state.turn_tool_calls) + " session=" + str(session.state.session_tool_calls), - "tools: cymbal=" + ("available" if _cymbal_available() else "not installed"), + "tools: code_index=" + code_index, "tokens: last=" + _format_count(session.state.last_total_tokens) + " session=" + _format_count(session.state.session_total_tokens), "models:", model_usage, @@ -7452,6 +7413,11 @@ def _compact(self, args: str) -> str: return "Usage: /compact" return self._with_status(self._compact_history) + def _index(self, args: str) -> str: + if args: + return "Usage: /index" + return self._with_status(lambda: _code_index_sync(self.agent.session)) + def _context(self, args: str) -> str: value = args.strip() if value: @@ -7857,6 +7823,7 @@ def run(self) -> int: seconds = RuntimeSettings.clean_retention_seconds(self.agent.session.settings.auto_clean_recent) if seconds > 0: SessionCleaner(self.agent.session).clean(older_than_seconds=seconds) + self._sync_existing_code_index() dispatcher = CommandDispatcher( self.agent, run_agent=self._run_agent, @@ -8570,6 +8537,9 @@ def _emit(self, message: str) -> None: self._with_status_paused(lambda: self._print_message(message)) def _print_welcome(self) -> None: + index_status, _index_message = _code_index_status(self.agent.session) + index_tip = [("ansibrightblack", " tip: "), ("ansicyan", "/index"), ("ansiwhite", " initializes indexed code tools\n")] if index_status == "missing" else [] + plain_tip = " tip: /index initializes indexed code tools\n" if index_status == "missing" else "" self._emit_segments( [("bold ansicyan", "nanocode"), ("ansiwhite", " - AI coding assistant\n")] + [ @@ -8585,14 +8555,19 @@ def _print_welcome(self) -> None: ("ansiwhite", " cancels, "), ("ansicyan", "c-d"), ("ansiwhite", " exits\n\n"), - ], + ] + + index_tip, "nanocode - AI coding assistant\n" " /help [question] for help or source-aware questions\n" " /status for current session state;\n" - " during work: enter queues, c-c cancels, c-d exits\n", + " during work: enter queues, c-c cancels, c-d exits\n" + + plain_tip, end="", ) + def _sync_existing_code_index(self) -> None: + _code_index_update_existing(self.agent.session) + def _wait_confirm(self, prompt: str, *, default: bool) -> ConfirmationResult: self._discard_pending_tty_input() suffix = "[Y/n/reason]" if default else "[y/N/reason]" diff --git a/pyproject.toml b/pyproject.toml index ee0a6c8..6d5f4da 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.3" +version = "0.4.4" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" @@ -27,6 +27,7 @@ classifiers = [ "Topic :: Terminals", ] dependencies = [ + "code-symbol-index>=0.1.3", "openai>=2.37.0", "prompt-toolkit>=3.0", "socksio>=1.0.0", diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index fb6ff9e..349b568 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -473,7 +473,7 @@ def test_act_prompt_tells_model_to_reply_to_pending_feedback_first(tmp_path): def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") + monkeypatch.setattr(nanocode, "_code_index_available", lambda session: False) agent = Agent(Session(cwd=str(tmp_path))) prompt = agent._system_prompt() @@ -496,8 +496,8 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path, monkeypatch) def test_inspect_code_tools_is_hidden_until_available(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_available", lambda session: False) agent = Agent(Session(cwd=str(tmp_path))) - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] @@ -510,8 +510,8 @@ def test_inspect_code_tools_is_hidden_until_available(tmp_path, monkeypatch): def test_inspect_code_tools_is_visible_when_available(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_available", lambda session: True) agent = Agent(Session(cwd=str(tmp_path))) - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] @@ -526,7 +526,7 @@ def test_inspect_code_tools_is_visible_when_available(tmp_path, monkeypatch): assert "Use FindCodeSymbol for symbol/prefix candidates" in prompt assert "InspectCodeSymbol for chosen symbols" in prompt assert "OutlineCodeFile for known file structure" in prompt - assert "cymbal" not in prompt + assert "code-symbol-index" not in prompt assert "case-insensitive" in prompt assert "optional limit default 20 max 80" in prompt assert "Do not pass natural language" in prompt diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py new file mode 100644 index 0000000..6d11254 --- /dev/null +++ b/tests/test_nanocode_code_index_tools.py @@ -0,0 +1,185 @@ +from types import SimpleNamespace + +import nanocode +import pytest + +from nanocode import FindCodeSymbolTool, InspectCodeSymbolTool, OutlineCodeFileTool, Session, ToolCallArgError, ToolCallError + + +class FakeRepository: + events = [] + status = "ready" + refresh_status = None + + def __init__(self, root, *, db_path=None, create_index=False): + self.root = root + self.db_path = db_path + self.create_index = create_index + self.events.append(("repo", root, db_path, create_index)) + + def refresh(self): + self.events.append(("refresh", self.root, self.db_path)) + if self.refresh_status is not None: + type(self).status = self.refresh_status + return self + + def update(self, paths=None): + self.events.append(("update", tuple(paths or ()), self.root, self.db_path)) + return self + + def search_text(self, query, *, limit): + self.events.append(("search_text", query, limit, self.root, self.db_path)) + return "query: " + query + "\ncount: 1\nsymbol Tool nanocode.py:10:20" + + def inspect_text(self, symbol): + self.events.append(("inspect_text", symbol, self.root, self.db_path)) + return "symbol:\n name: " + symbol + "\nsource:\n status: full" + + def outline_text(self, filepath): + self.events.append(("outline_text", filepath, self.root, self.db_path)) + return "file: " + filepath + "\noutline:\n class Tool 0:2 class Tool:" + + +def fake_code_index_module(status="ready", *, refresh_status=None): + FakeRepository.status = status + FakeRepository.refresh_status = refresh_status + + def status_fn(root, *, db_path=None, check=False, format="object"): + status = FakeRepository.status + FakeRepository.events.append(("status", root, db_path, check, format)) + return SimpleNamespace(status=status, reason="index not initialized" if status == "missing" else "", message="") + + return SimpleNamespace(Repository=FakeRepository, status=status_fn) + + +@pytest.fixture(autouse=True) +def reset_fake_repository(): + FakeRepository.events = [] + FakeRepository.status = "ready" + FakeRepository.refresh_status = None + + +def test_inspect_code_requires_code_index(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_module", lambda: None) + + with pytest.raises(ToolCallError, match="code index is not available"): + InspectCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool"]) + + +def test_code_index_schema_accepts_expected_args(): + for tool in (InspectCodeSymbolTool, OutlineCodeFileTool): + args_schema = tool.tool_schema()["function"]["parameters"]["properties"]["args"] + assert args_schema["minItems"] == 1 + assert args_schema["maxItems"] == 1 + assert args_schema["items"]["type"] == "string" + args_schema = FindCodeSymbolTool.tool_schema()["function"]["parameters"]["properties"]["args"] + assert args_schema["minItems"] == 1 + assert args_schema["maxItems"] == 2 + assert args_schema["items"]["type"] == ["string", "number"] + + +def test_inspect_code_rejects_natural_language(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + + with pytest.raises(ToolCallArgError, match="do not pass natural language"): + InspectCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool class callers"]) + with pytest.raises(ToolCallArgError, match="do not pass natural language"): + FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) + + +def test_code_index_missing_is_not_initialized_implicitly(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module("missing")) + + with pytest.raises(ToolCallError, match="code index is not available"): + FindCodeSymbolTool.make(session, ["Tool"]) + + assert not [event for event in FakeRepository.events if event[0] in {"repo", "refresh"}] + + +def test_code_index_sync_initializes_missing_index_in_project_data(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) + module = fake_code_index_module("missing", refresh_status="ready") + monkeypatch.setattr(nanocode, "_code_index_module", lambda: module) + + result = nanocode._code_index_sync(session) + + db_path = str(tmp_path / "data" / "projects" / session.project_key() / "code-symbol-index" / "index.sqlite") + assert ("repo", str(tmp_path), db_path, True) in FakeRepository.events + assert ("refresh", str(tmp_path), db_path) in FakeRepository.events + assert result == "code_index: initialized\nstatus: ready\npath: " + db_path + + +def test_code_index_update_existing_syncs_ready_index_only(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module("ready")) + + nanocode._code_index_update_existing(session) + + assert ("update", tuple(), str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events + + +def test_find_code_symbol_uses_search_text(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + + result = FindCodeSymbolTool.make(session, ["Tool", 12]).call() + + db_path = str(tmp_path / "data" / "projects" / session.project_key() / "code-symbol-index" / "index.sqlite") + assert ("search_text", "Tool", 12, str(tmp_path), db_path) in FakeRepository.events + assert result == "\nquery: Tool\ncount: 1\nsymbol Tool nanocode.py:10:20\n" + + +def test_find_code_symbol_clamps_limit(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", 999]).limit == 80 + assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", 0]).limit == 1 + with pytest.raises(ToolCallArgError, match="limit must be an integer"): + FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", "many"]) + + +def test_inspect_code_symbol_rejects_files_directories_and_dotted_module_paths(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + (tmp_path / "orion" / "biz" / "handlers" / "syftpp").mkdir(parents=True) + (tmp_path / "code.py").write_text("class Tool:\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + with pytest.raises(ToolCallArgError, match="file or directory"): + InspectCodeSymbolTool.make(session, ["code.py"]) + with pytest.raises(ToolCallArgError, match="file or directory"): + InspectCodeSymbolTool.make(session, ["orion.biz.handlers.syftpp"]) + with pytest.raises(ToolCallArgError, match="module path"): + InspectCodeSymbolTool.make(session, ["pkg.module.symbol"]) + + +def test_inspect_code_symbol_uses_inspect_text(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path)) + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + + result = InspectCodeSymbolTool.make(session, ["Tool"]).call() + + assert ("inspect_text", "Tool", str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events + assert result == "\nsymbol:\n name: Tool\nsource:\n status: full\n" + + +def test_outline_code_file_uses_outline_text(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path)) + filepath = tmp_path / "code.py" + filepath.write_text("class Tool:\n pass\n", encoding="utf-8") + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + + result = OutlineCodeFileTool.make(session, ["code.py"]).call() + + assert ("outline_text", str(filepath), str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events + assert result == "\nfile: " + str(filepath) + "\noutline:\n class Tool 0:2 class Tool:\n" + + +def test_outline_code_file_rejects_directories_and_symbols(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + (tmp_path / "pkg").mkdir() + session = Session(cwd=str(tmp_path)) + + with pytest.raises(ToolCallArgError, match="existing file"): + OutlineCodeFileTool.make(session, ["pkg"]) + with pytest.raises(ToolCallArgError, match="existing file"): + OutlineCodeFileTool.make(session, ["Tool"]) diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 42e43b8..fdd4aff 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -86,7 +86,8 @@ def test_command_dispatcher_updates_config_and_auto_compacts(tmp_path): assert exit_result.status == CommandStatus.EXIT -def test_status_reports_tokens_in_human_readable_format(tmp_path): +def test_status_reports_tokens_in_human_readable_format(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_status", lambda session: ("unavailable", "")) session = make_session(tmp_path, model="model") session.state.last_total_tokens = 1200 session.state.session_total_tokens = 2_345_678 @@ -103,11 +104,23 @@ def test_status_reports_tokens_in_human_readable_format(tmp_path): assert "models:" in result.message assert "model: calls=2 tokens=2m" in result.message assert "tool_calls: turn=0 session=0" in result.message - assert "tools: cymbal=" in result.message + assert "tools: code_index=unavailable" in result.message assert "task: done" in result.message assert "blackboard" not in result.message +def test_index_command_syncs_code_index(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_sync", lambda session: "code_index: synced") + dispatcher = CommandDispatcher(Agent(make_session(tmp_path))) + + result = dispatcher.dispatch("/index") + usage_result = dispatcher.dispatch("/index extra") + + assert result.status == CommandStatus.HANDLED + assert result.message == "code_index: synced" + assert usage_result.message == "Usage: /index" + + def test_set_command_shows_and_validates_runtime_config(tmp_path): session = make_session(tmp_path, stream=True) dispatcher = CommandDispatcher(Agent(session)) diff --git a/tests/test_nanocode_cymbal_tools.py b/tests/test_nanocode_cymbal_tools.py deleted file mode 100644 index bae4703..0000000 --- a/tests/test_nanocode_cymbal_tools.py +++ /dev/null @@ -1,199 +0,0 @@ -import json - -import nanocode -import pytest - -from nanocode import FindCodeSymbolTool, InspectCodeSymbolTool, OutlineCodeFileTool, Session, ToolCallArgError, ToolCallError - - -def test_inspect_code_requires_cymbal(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") - - with pytest.raises(ToolCallError, match="cymbal not found"): - InspectCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool"]) - - -def test_inspect_code_schema_accepts_only_one_target_arg(): - for tool in (InspectCodeSymbolTool, OutlineCodeFileTool): - args_schema = tool.tool_schema()["function"]["parameters"]["properties"]["args"] - assert args_schema["minItems"] == 1 - assert args_schema["maxItems"] == 1 - assert args_schema["items"]["type"] == "string" - args_schema = FindCodeSymbolTool.tool_schema()["function"]["parameters"]["properties"]["args"] - assert args_schema["minItems"] == 1 - assert args_schema["maxItems"] == 2 - assert args_schema["items"]["type"] == ["string", "number"] - - -def test_inspect_code_rejects_natural_language(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") - - with pytest.raises(ToolCallArgError, match="do not pass natural language"): - InspectCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool class callers"]) - with pytest.raises(ToolCallArgError, match="do not pass natural language"): - FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) - - -def test_find_code_symbol_formats_symbol_results(tmp_path, monkeypatch): - session = Session(cwd=str(tmp_path)) - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") - seen = {} - - def fake_run(cmd, **kwargs): - seen["cmd"] = cmd - seen["cwd"] = kwargs["cwd"] - return nanocode.subprocess.CompletedProcess( - cmd, - 0, - json.dumps( - { - "results": [ - { - "name": "Tool", - "kind": "class", - "rel_path": "nanocode.py", - "start_line": 1292, - "end_line": 1338, - "signature": "class Tool:", - } - ] - } - ), - "", - ) - - monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - - result = FindCodeSymbolTool.make(session, ["Tool", 12]).call() - - assert seen == {"cmd": ["/fake/cymbal", "search", "Tool", "--limit", "12", "--json"], "cwd": str(tmp_path)} - assert "" in result - assert "" in result - assert "class Tool nanocode.py:1291:1338 class Tool:" in result - - -def test_find_code_symbol_clamps_limit(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") - assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", 999]).limit == 80 - assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", 0]).limit == 1 - with pytest.raises(ToolCallArgError, match="limit must be an integer"): - FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", "many"]) - - -def test_inspect_code_symbol_rejects_files_directories_and_dotted_module_paths(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") - (tmp_path / "orion" / "biz" / "handlers" / "syftpp").mkdir(parents=True) - (tmp_path / "code.py").write_text("class Tool:\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - with pytest.raises(ToolCallArgError, match="file or directory"): - InspectCodeSymbolTool.make(session, ["code.py"]) - with pytest.raises(ToolCallArgError, match="file or directory"): - InspectCodeSymbolTool.make(session, ["orion.biz.handlers.syftpp"]) - with pytest.raises(ToolCallArgError, match="module path"): - InspectCodeSymbolTool.make(session, ["pkg.module.symbol"]) - - -def test_inspect_code_formats_investigate_result(tmp_path, monkeypatch): - session = Session(cwd=str(tmp_path)) - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") - seen = {} - - def fake_run(cmd, **kwargs): - seen["cmd"] = cmd - seen["cwd"] = kwargs["cwd"] - return nanocode.subprocess.CompletedProcess( - cmd, - 0, - json.dumps( - { - "results": { - "result": { - "symbol": { - "name": "Tool", - "kind": "class", - "rel_path": "nanocode.py", - "start_line": 1284, - "end_line": 1285, - "signature": "class Tool:", - }, - "source": "class Tool:\n NAME: ClassVar[str]\n", - "members": [{"name": "tool_schema", "kind": "function", "rel_path": "nanocode.py", "start_line": 1315, "end_line": 1327}], - "refs": [{"name": "Tool", "rel_path": "nanocode.py", "line": 1742}], - "impact": [{"symbol": "Tool", "caller": "ReadTool", "rel_path": "nanocode.py", "line": 1742, "depth": 1}], - "implementors": [{"implementer": "ReadTool", "target": "Tool", "rel_path": "nanocode.py", "line": 1742, "resolved": True}], - } - } - } - ), - "", - ) - - monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - - result = InspectCodeSymbolTool.make(session, ["Tool"]).call() - - assert seen == {"cmd": ["/fake/cymbal", "investigate", "Tool", "--json"], "cwd": str(tmp_path)} - assert "" in result - assert 'Line numbers are 0-based and match Read/ReplaceRange ranges.' in result - assert "* symbol: class Tool nanocode.py:1283:1285 class Tool:" in result - assert " 1283 |class Tool:" in result - assert "" in result - assert "function tool_schema nanocode.py:1314:1327" in result - assert "" in result - assert "Tool nanocode.py:1741" in result - assert "" in result - assert "ReadTool nanocode.py:1741 symbol=Tool" in result - assert "" in result - assert "ReadTool nanocode.py:1741 target=Tool" in result - - -def test_outline_code_file_formats_file_outline(tmp_path, monkeypatch): - session = Session(cwd=str(tmp_path)) - filepath = tmp_path / "code.py" - filepath.write_text("class Tool:\n pass\n", encoding="utf-8") - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") - seen = {} - - def fake_run(cmd, **kwargs): - seen["cmd"] = cmd - seen["cwd"] = kwargs["cwd"] - return nanocode.subprocess.CompletedProcess( - cmd, - 0, - json.dumps( - { - "results": [ - { - "name": "Tool", - "kind": "class", - "rel_path": "code.py", - "start_line": 1, - "end_line": 2, - "signature": "class Tool:", - } - ] - } - ), - "", - ) - - monkeypatch.setattr(nanocode.subprocess, "run", fake_run) - - result = OutlineCodeFileTool.make(session, ["code.py"]).call() - - assert seen == {"cmd": ["/fake/cymbal", "outline", str(filepath), "--json"], "cwd": str(tmp_path)} - assert "" in result - assert "" in result - assert "class Tool code.py:0:2 class Tool:" in result - - -def test_outline_code_file_rejects_directories_and_symbols(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/fake/cymbal" if name == "cymbal" else "") - (tmp_path / "pkg").mkdir() - session = Session(cwd=str(tmp_path)) - - with pytest.raises(ToolCallArgError, match="existing file"): - OutlineCodeFileTool.make(session, ["pkg"]) - with pytest.raises(ToolCallArgError, match="existing file"): - OutlineCodeFileTool.make(session, ["Tool"]) diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 32153fd..bced0be 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -532,6 +532,19 @@ def run(self, user_input, *, confirm=None, on_auto_approve=None, on_message=None assert loop.agent.runs == ["hello"] +def test_agent_loop_welcome_suggests_index_when_missing(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_status", lambda session: ("missing", "")) + + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + + outputs = [] + AgentLoop(FakeAgent(), input_fn=lambda prompt: "", output_fn=outputs.append)._print_welcome() + + assert any("tip: /index initializes indexed code tools" in output for output in outputs) + + def test_agent_loop_consumes_queued_input_before_prompt(tmp_path): class FakeAgent: def __init__(self): From d6bb5e7eaec8887bbca01aa033d43828fbd00e4c Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 11:23:20 -0700 Subject: [PATCH 084/144] support force rebuilding code index --- README.md | 2 +- design.md | 5 +++-- nanocode.py | 18 ++++++++++++------ tests/test_nanocode_code_index_tools.py | 15 +++++++++++++++ tests/test_nanocode_commands.py | 8 ++++++-- 5 files changed, 37 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 708eaca..44695da 100644 --- a/README.md +++ b/README.md @@ -89,7 +89,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. - Info: `/help [question]`, `/status`, `/rules`, `/compact`. - Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/reason-payload [value]`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. -- Maintenance: `/index`, `/clean`. +- Maintenance: `/index [force]`, `/clean`. - Exit: `/exit`, `/quit`. Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/api responses` switches the current provider to Responses format. `/reason` sets `provider.reasoning` to `off` or an effort value; `/reason-payload` controls the Chat-only reasoning payload shape. `/model` lists configured models before discovered ones, then prompts for reasoning. diff --git a/design.md b/design.md index 068b83a..07779a5 100644 --- a/design.md +++ b/design.md @@ -91,8 +91,9 @@ OBSERVE reduces tool-result noise before ACT continues. Code navigation tools are environment-gated. `FindCodeSymbol`, `InspectCodeSymbol`, and `OutlineCodeFile` are shown only when the built-in code index is available. They accept symbol queries or file paths, not -natural-language questions. The index is created explicitly with `/index`; if an -index already exists, startup performs a lightweight incremental update. +natural-language questions. The index is created explicitly with `/index`, +rebuilt with `/index force`, and lightly updated at startup when it already +exists. Context layout: diff --git a/nanocode.py b/nanocode.py index bc93e9c..583774b 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2392,8 +2392,12 @@ def _code_index_update_existing(session: Session) -> None: session.state.code_index_error = str(error) -def _code_index_sync(session: Session) -> str: +def _code_index_sync(session: Session, *, force: bool = False) -> str: before, _message = _code_index_status(session) + if force: + if _code_index_module() is None: + return "code_index: error\ncode index is unavailable" + shutil.rmtree(os.path.dirname(_code_index_db_path(session)), ignore_errors=True) try: _code_index_repository(session, create_index=True).refresh() except Exception as error: @@ -2401,7 +2405,8 @@ def _code_index_sync(session: Session) -> str: return "code_index: error\n" + str(error) session.state.code_index_error = "" status, message = _code_index_status(session) - lines = ["code_index: " + ("initialized" if before == "missing" else "synced"), "status: " + status, "path: " + _code_index_db_path(session)] + action = "rebuilt" if force else ("initialized" if before == "missing" else "synced") + lines = ["code_index: " + action, "status: " + status, "path: " + _code_index_db_path(session)] if message: lines.append("note: " + message) return "\n".join(lines) @@ -7069,7 +7074,7 @@ class CommandSpec: CommandSpec("/provider", "Show or switch provider", "Config", "/provider [name]"), CommandSpec("/plan", "Toggle plan mode or ask for a readonly plan", "Config", "/plan [on|off|question]"), CommandSpec("/yolo", "Toggle yolo mode (skip confirmations)", "Config", "/yolo"), - CommandSpec("/index", "Initialize or sync code index", "Maintenance", "/index"), + CommandSpec("/index", "Initialize, sync, or rebuild code index", "Maintenance", "/index [force]"), CommandSpec("/clean", "Clean inactive session directories", "Maintenance", "/clean"), CommandSpec("/exit", "Exit nanocode", "Control", "/exit"), CommandSpec("/quit", "Exit nanocode", "Control", "/quit"), @@ -7414,9 +7419,10 @@ def _compact(self, args: str) -> str: return self._with_status(self._compact_history) def _index(self, args: str) -> str: - if args: - return "Usage: /index" - return self._with_status(lambda: _code_index_sync(self.agent.session)) + value = args.strip() + if value not in {"", "force"}: + return "Usage: /index [force]" + return self._with_status(lambda: _code_index_sync(self.agent.session, force=value == "force")) def _context(self, args: str) -> str: value = args.strip() diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index 6d11254..7e7e095 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -110,6 +110,21 @@ def test_code_index_sync_initializes_missing_index_in_project_data(tmp_path, mon assert result == "code_index: initialized\nstatus: ready\npath: " + db_path +def test_code_index_force_rebuild_removes_project_index_dir(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) + module = fake_code_index_module("ready") + monkeypatch.setattr(nanocode, "_code_index_module", lambda: module) + index_dir = tmp_path / "data" / "projects" / session.project_key() / "code-symbol-index" + index_dir.mkdir(parents=True) + (index_dir / "old.sqlite").write_text("old", encoding="utf-8") + + result = nanocode._code_index_sync(session, force=True) + + assert not (index_dir / "old.sqlite").exists() + assert ("repo", str(tmp_path), nanocode._code_index_db_path(session), True) in FakeRepository.events + assert result == "code_index: rebuilt\nstatus: ready\npath: " + nanocode._code_index_db_path(session) + + def test_code_index_update_existing_syncs_ready_index_only(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module("ready")) diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index fdd4aff..ac1b45b 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -110,15 +110,19 @@ def test_status_reports_tokens_in_human_readable_format(tmp_path, monkeypatch): def test_index_command_syncs_code_index(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode, "_code_index_sync", lambda session: "code_index: synced") + calls = [] + monkeypatch.setattr(nanocode, "_code_index_sync", lambda session, *, force=False: calls.append(force) or "code_index: synced") dispatcher = CommandDispatcher(Agent(make_session(tmp_path))) result = dispatcher.dispatch("/index") + force_result = dispatcher.dispatch("/index force") usage_result = dispatcher.dispatch("/index extra") assert result.status == CommandStatus.HANDLED assert result.message == "code_index: synced" - assert usage_result.message == "Usage: /index" + assert force_result.message == "code_index: synced" + assert calls == [False, True] + assert usage_result.message == "Usage: /index [force]" def test_set_command_shows_and_validates_runtime_config(tmp_path): From 027d153af5ffbb3e044f188ecbb016bc94ff211c Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 11:34:34 -0700 Subject: [PATCH 085/144] show code index progress without blocking startup --- nanocode.py | 29 ++++++++++++++++++++----- pyproject.toml | 2 +- tests/test_nanocode_code_index_tools.py | 18 ++++++++++----- tests/test_nanocode_loop.py | 28 +++++++++++++++++++++++- 4 files changed, 64 insertions(+), 13 deletions(-) diff --git a/nanocode.py b/nanocode.py index 583774b..ff6c371 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2386,12 +2386,22 @@ def _code_index_update_existing(session: Session) -> None: if status not in {"ready", "stale"}: return try: - _code_index_repository(session).update() + _code_index_repository(session).update(progress=_code_index_progress(session)) session.state.code_index_error = "" except Exception as error: session.state.code_index_error = str(error) +def _code_index_progress(session: Session) -> Callable[..., None]: + def update(event: str, *, done: int = 0, total: int = 0, **_kwargs: object) -> None: + phase = {"scan": "scan", "start": "parse", "file": "parse", "finish": "done"}.get(event, event) + suffix = (" " + str(done) + "/" + str(total)) if total > 0 else "" + session.state.status_notice = "index:" + phase + suffix + session.state.status_notice_until = time.monotonic() + 30 + + return update + + def _code_index_sync(session: Session, *, force: bool = False) -> str: before, _message = _code_index_status(session) if force: @@ -2399,11 +2409,13 @@ def _code_index_sync(session: Session, *, force: bool = False) -> str: return "code_index: error\ncode index is unavailable" shutil.rmtree(os.path.dirname(_code_index_db_path(session)), ignore_errors=True) try: - _code_index_repository(session, create_index=True).refresh() + _code_index_repository(session, create_index=True).refresh(progress=_code_index_progress(session)) except Exception as error: session.state.code_index_error = str(error) return "code_index: error\n" + str(error) session.state.code_index_error = "" + session.state.status_notice = "index:done" + session.state.status_notice_until = time.monotonic() + 2 status, message = _code_index_status(session) action = "rebuilt" if force else ("initialized" if before == "missing" else "synced") lines = ["code_index: " + action, "status: " + status, "path: " + _code_index_db_path(session)] @@ -7699,6 +7711,8 @@ def _format_line(self, turn_elapsed: float, *, now: float, show_elapsed: bool) - rate = session.state.last_model_call_rate token_summary = "last:" + last_tokens + " sess:" + session_tokens parts = [model + " (" + reasoning + ")" + modes, "ctx:" + context, "tool:" + str(session.state.turn_tool_calls), "tok:" + token_summary] + if session.state.status_notice and session.state.status_notice_until > now: + parts.insert(1, session.state.status_notice) if show_elapsed: parts.append(f"turn:{turn_elapsed:.1f}s") if session.state.current_model_call_started_at > 0: @@ -7711,8 +7725,6 @@ def _format_line(self, turn_elapsed: float, *, now: float, show_elapsed: bool) - parts.append(activity + "(" + str(session.state.turn_model_calls) + "):" + f"{elapsed:.1f}s") if rate > 0: parts[3] += " " + _format_count(int(rate)) + "t/s" - if session.state.status_notice and session.state.status_notice_until > now: - parts.append(session.state.status_notice) return " | ".join(parts) def _sweep_fragments(self, text: str, now: float) -> list[tuple[str, str]]: @@ -7819,6 +7831,7 @@ def __init__( self._runtime_ui_stop = threading.Event() self._tool_live_preview_lock = threading.Lock() self._tool_live_preview_text = "" + self._startup_index_thread: threading.Thread | None = None self._exit_after_current_turn = False if self.prompt_session is None and input_fn is input and sys.stdin.isatty(): self.prompt_session = self._make_prompt_session() @@ -7829,7 +7842,7 @@ def run(self) -> int: seconds = RuntimeSettings.clean_retention_seconds(self.agent.session.settings.auto_clean_recent) if seconds > 0: SessionCleaner(self.agent.session).clean(older_than_seconds=seconds) - self._sync_existing_code_index() + self._start_existing_code_index_sync() dispatcher = CommandDispatcher( self.agent, run_agent=self._run_agent, @@ -8574,6 +8587,12 @@ def _print_welcome(self) -> None: def _sync_existing_code_index(self) -> None: _code_index_update_existing(self.agent.session) + def _start_existing_code_index_sync(self) -> None: + if self._startup_index_thread is not None or _code_index_status(self.agent.session)[0] not in {"ready", "stale"}: + return + self._startup_index_thread = threading.Thread(target=self._sync_existing_code_index, daemon=True) + self._startup_index_thread.start() + def _wait_confirm(self, prompt: str, *, default: bool) -> ConfirmationResult: self._discard_pending_tty_input() suffix = "[Y/n/reason]" if default else "[y/N/reason]" diff --git a/pyproject.toml b/pyproject.toml index 6d5f4da..e303e87 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,7 +27,7 @@ classifiers = [ "Topic :: Terminals", ] dependencies = [ - "code-symbol-index>=0.1.3", + "code-symbol-index>=0.1.4", "openai>=2.37.0", "prompt-toolkit>=3.0", "socksio>=1.0.0", diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index 7e7e095..42978ab 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -17,14 +17,18 @@ def __init__(self, root, *, db_path=None, create_index=False): self.create_index = create_index self.events.append(("repo", root, db_path, create_index)) - def refresh(self): - self.events.append(("refresh", self.root, self.db_path)) + def refresh(self, *, progress=None): + self.events.append(("refresh", self.root, self.db_path, progress is not None)) + if progress is not None: + progress("scan") + progress("start", done=0, total=2) + progress("file", done=1, total=2, path="code.py") if self.refresh_status is not None: type(self).status = self.refresh_status return self - def update(self, paths=None): - self.events.append(("update", tuple(paths or ()), self.root, self.db_path)) + def update(self, paths=None, *, progress=None): + self.events.append(("update", tuple(paths or ()), self.root, self.db_path, progress is not None)) return self def search_text(self, query, *, limit): @@ -106,7 +110,8 @@ def test_code_index_sync_initializes_missing_index_in_project_data(tmp_path, mon db_path = str(tmp_path / "data" / "projects" / session.project_key() / "code-symbol-index" / "index.sqlite") assert ("repo", str(tmp_path), db_path, True) in FakeRepository.events - assert ("refresh", str(tmp_path), db_path) in FakeRepository.events + assert ("refresh", str(tmp_path), db_path, True) in FakeRepository.events + assert session.state.status_notice == "index:done" assert result == "code_index: initialized\nstatus: ready\npath: " + db_path @@ -122,6 +127,7 @@ def test_code_index_force_rebuild_removes_project_index_dir(tmp_path, monkeypatc assert not (index_dir / "old.sqlite").exists() assert ("repo", str(tmp_path), nanocode._code_index_db_path(session), True) in FakeRepository.events + assert ("refresh", str(tmp_path), nanocode._code_index_db_path(session), True) in FakeRepository.events assert result == "code_index: rebuilt\nstatus: ready\npath: " + nanocode._code_index_db_path(session) @@ -131,7 +137,7 @@ def test_code_index_update_existing_syncs_ready_index_only(tmp_path, monkeypatch nanocode._code_index_update_existing(session) - assert ("update", tuple(), str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events + assert ("update", tuple(), str(tmp_path), nanocode._code_index_db_path(session), True) in FakeRepository.events def test_find_code_symbol_uses_search_text(tmp_path, monkeypatch): diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index bced0be..9138211 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -207,7 +207,7 @@ def test_status_bar_shows_recent_status_notice(tmp_path): session.state.status_notice_until = time.monotonic() + 5 bar = StatusBar(session) - assert _status_text(bar).endswith(" | err:format") + assert "model (medium) | err:format | ctx:" in _status_text(bar) session.state.status_notice_until = 0 @@ -545,6 +545,32 @@ def __init__(self): assert any("tip: /index initializes indexed code tools" in output for output in outputs) +def test_agent_loop_starts_existing_index_sync_in_background(tmp_path, monkeypatch): + started = [] + monkeypatch.setattr(nanocode, "_code_index_status", lambda session: ("ready", "")) + + class FakeThread: + def __init__(self, *, target, daemon): + self.target = target + self.daemon = daemon + + def start(self): + started.append((self.target, self.daemon)) + + class FakeAgent: + def __init__(self): + self.session = make_session(tmp_path, model="model") + self.blackboard = Blackboard() + + monkeypatch.setattr(nanocode.threading, "Thread", FakeThread) + outputs = [] + loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "/exit", output_fn=outputs.append) + + assert loop.run() == 0 + assert len(started) == 1 + assert started[0][1] is True + + def test_agent_loop_consumes_queued_input_before_prompt(tmp_path): class FakeAgent: def __init__(self): From a8fee945032315609a0cfb619325c47af9a93966 Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 19:39:05 -0700 Subject: [PATCH 086/144] Sync existing code index before prompt --- nanocode.py | 95 +++++++++++++++++-------- tests/test_nanocode_code_index_tools.py | 9 ++- tests/test_nanocode_loop.py | 23 +++--- 3 files changed, 84 insertions(+), 43 deletions(-) diff --git a/nanocode.py b/nanocode.py index ff6c371..23731f1 100644 --- a/nanocode.py +++ b/nanocode.py @@ -981,6 +981,7 @@ class Session: settings: RuntimeSettings = field(default_factory=RuntimeSettings) state: RuntimeState = field(default_factory=RuntimeState) session_id: str = field(default_factory=lambda: Session._new_session_id()) + code_index_repository: Any | None = None @classmethod def from_config_file(cls, *, path: str | None = None, yolo: bool = False, plan_mode: bool = False, debug: bool = False) -> "Session": @@ -2355,13 +2356,18 @@ def _code_index_db_path(session: Session) -> str: def _code_index_repository(session: Session, *, create_index: bool = False) -> Any: + if not create_index and session.code_index_repository is not None: + return session.code_index_repository module = _code_index_module() if module is None: raise ToolCallError("code index is unavailable") db_path = _code_index_db_path(session) if create_index: os.makedirs(os.path.dirname(db_path), exist_ok=True) - return module.Repository(session.cwd, db_path=db_path, create_index=create_index) + repository = module.Repository(session.cwd, db_path=db_path, create_index=create_index) + if not create_index: + session.code_index_repository = repository + return repository def _code_index_status(session: Session, *, check: bool = False) -> tuple[str, str]: @@ -2381,41 +2387,53 @@ def _code_index_available(session: Session) -> bool: return status in {"ready", "stale"} -def _code_index_update_existing(session: Session) -> None: - status, _message = _code_index_status(session) - if status not in {"ready", "stale"}: - return - try: - _code_index_repository(session).update(progress=_code_index_progress(session)) - session.state.code_index_error = "" - except Exception as error: - session.state.code_index_error = str(error) +def _set_code_index_notice(session: Session, event: str, *, done: int = 0, total: int = 0, seconds: int = 30) -> None: + phase = {"scan": "scan", "start": "parse", "file": "parse", "finish": "done"}.get(event, event) + suffix = (" " + str(done) + "/" + str(total)) if total > 0 else "" + session.state.status_notice = "index:" + phase + suffix + session.state.status_notice_until = time.monotonic() + seconds def _code_index_progress(session: Session) -> Callable[..., None]: def update(event: str, *, done: int = 0, total: int = 0, **_kwargs: object) -> None: - phase = {"scan": "scan", "start": "parse", "file": "parse", "finish": "done"}.get(event, event) - suffix = (" " + str(done) + "/" + str(total)) if total > 0 else "" - session.state.status_notice = "index:" + phase + suffix - session.state.status_notice_until = time.monotonic() + 30 + _set_code_index_notice(session, event, done=done, total=total) return update +def _code_index_sync_existing(session: Session, progress: Callable[..., None] | None = None) -> bool: + status, _message = _code_index_status(session) + if status not in {"ready", "stale"}: + return False + try: + repository = _code_index_repository(session) + repository.update(progress=progress or _code_index_progress(session)) + session.code_index_repository = repository + session.state.code_index_error = "" + _set_code_index_notice(session, "done", seconds=2) + except Exception as error: + session.code_index_repository = None + session.state.code_index_error = str(error) + return True + + def _code_index_sync(session: Session, *, force: bool = False) -> str: before, _message = _code_index_status(session) if force: if _code_index_module() is None: return "code_index: error\ncode index is unavailable" + session.code_index_repository = None shutil.rmtree(os.path.dirname(_code_index_db_path(session)), ignore_errors=True) try: - _code_index_repository(session, create_index=True).refresh(progress=_code_index_progress(session)) + repository = _code_index_repository(session, create_index=True) + repository.refresh(progress=_code_index_progress(session)) + session.code_index_repository = repository except Exception as error: + session.code_index_repository = None session.state.code_index_error = str(error) return "code_index: error\n" + str(error) session.state.code_index_error = "" - session.state.status_notice = "index:done" - session.state.status_notice_until = time.monotonic() + 2 + _set_code_index_notice(session, "done", seconds=2) status, message = _code_index_status(session) action = "rebuilt" if force else ("initialized" if before == "missing" else "synced") lines = ["code_index: " + action, "status: " + status, "path: " + _code_index_db_path(session)] @@ -7831,7 +7849,6 @@ def __init__( self._runtime_ui_stop = threading.Event() self._tool_live_preview_lock = threading.Lock() self._tool_live_preview_text = "" - self._startup_index_thread: threading.Thread | None = None self._exit_after_current_turn = False if self.prompt_session is None and input_fn is input and sys.stdin.isatty(): self.prompt_session = self._make_prompt_session() @@ -7842,7 +7859,7 @@ def run(self) -> int: seconds = RuntimeSettings.clean_retention_seconds(self.agent.session.settings.auto_clean_recent) if seconds > 0: SessionCleaner(self.agent.session).clean(older_than_seconds=seconds) - self._start_existing_code_index_sync() + self._sync_existing_code_index_before_prompt() dispatcher = CommandDispatcher( self.agent, run_agent=self._run_agent, @@ -7890,6 +7907,37 @@ def _prompt(self) -> str: labels.append("plan") return "[" + ",".join(labels) + "] > " if labels else "> " + def _sync_existing_code_index_before_prompt(self) -> None: + def progress(event: str, *, done: int = 0, total: int = 0, **_kwargs: object) -> None: + _set_code_index_notice(self.agent.session, event, done=done, total=total) + if self.output_fn is not print or not sys.stderr.isatty(): + return + phase = {"scan": "scan", "start": "parse", "file": "parse", "finish": "done"}.get(event, event) + self.status_bar.output.write_raw("\r") + self.status_bar.output.erase_end_of_line() + print_formatted_text(FormattedText(self._index_progress_fragments(phase, done, total)), output=self.status_bar.output, end="", flush=True) + + attempted = _code_index_sync_existing(self.agent.session, progress=progress) + if not attempted or self.output_fn is not print or not sys.stderr.isatty(): + return + self.status_bar.output.write_raw("\r") + self.status_bar.output.erase_end_of_line() + status = "error" if self.agent.session.state.code_index_error else "sync done" + print_formatted_text(FormattedText(self._index_progress_fragments(status, 1, 1)), output=self.status_bar.output, end="\n", flush=True) + self.status_bar.rendered = False + + def _index_progress_fragments(self, phase: str, done: int, total: int) -> list[tuple[str, str]]: + width = 18 + if total > 0: + filled = min(width, max(0, int(width * done / max(total, 1)))) + bar = "#" * filled + "-" * (width - filled) + count = " " + str(done) + "/" + str(total) + else: + bar = "-" * width + count = "" + style = "ansired" if phase == "error" else "ansicyan" + return [("ansibrightblack", " index "), (style, phase), ("ansibrightblack", " [" + bar + "]" + count)] + def _read_input(self, prompt: str) -> str: if self.prompt_session is None: return self.input_fn(prompt) @@ -8584,15 +8632,6 @@ def _print_welcome(self) -> None: end="", ) - def _sync_existing_code_index(self) -> None: - _code_index_update_existing(self.agent.session) - - def _start_existing_code_index_sync(self) -> None: - if self._startup_index_thread is not None or _code_index_status(self.agent.session)[0] not in {"ready", "stale"}: - return - self._startup_index_thread = threading.Thread(target=self._sync_existing_code_index, daemon=True) - self._startup_index_thread.start() - def _wait_confirm(self, prompt: str, *, default: bool) -> ConfirmationResult: self._discard_pending_tty_input() suffix = "[Y/n/reason]" if default else "[y/N/reason]" diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index 42978ab..229abc2 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -29,6 +29,9 @@ def refresh(self, *, progress=None): def update(self, paths=None, *, progress=None): self.events.append(("update", tuple(paths or ()), self.root, self.db_path, progress is not None)) + if progress is not None: + progress("scan") + progress("finish", done=1, total=1) return self def search_text(self, query, *, limit): @@ -131,13 +134,15 @@ def test_code_index_force_rebuild_removes_project_index_dir(tmp_path, monkeypatc assert result == "code_index: rebuilt\nstatus: ready\npath: " + nanocode._code_index_db_path(session) -def test_code_index_update_existing_syncs_ready_index_only(tmp_path, monkeypatch): +def test_code_index_sync_existing_updates_ready_index_and_caches_repository(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module("ready")) - nanocode._code_index_update_existing(session) + assert nanocode._code_index_sync_existing(session) is True assert ("update", tuple(), str(tmp_path), nanocode._code_index_db_path(session), True) in FakeRepository.events + assert isinstance(session.code_index_repository, FakeRepository) + assert session.state.status_notice == "index:done" def test_find_code_symbol_uses_search_text(tmp_path, monkeypatch): diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 9138211..bfe617a 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -545,30 +545,27 @@ def __init__(self): assert any("tip: /index initializes indexed code tools" in output for output in outputs) -def test_agent_loop_starts_existing_index_sync_in_background(tmp_path, monkeypatch): - started = [] - monkeypatch.setattr(nanocode, "_code_index_status", lambda session: ("ready", "")) +def test_agent_loop_syncs_existing_index_before_prompt(tmp_path, monkeypatch): + synced = [] - class FakeThread: - def __init__(self, *, target, daemon): - self.target = target - self.daemon = daemon - - def start(self): - started.append((self.target, self.daemon)) + def sync_existing(session, *, progress=None): + synced.append(progress is not None) + if progress is not None: + progress("file", done=1, total=2) + return True class FakeAgent: def __init__(self): self.session = make_session(tmp_path, model="model") self.blackboard = Blackboard() - monkeypatch.setattr(nanocode.threading, "Thread", FakeThread) + monkeypatch.setattr(nanocode, "_code_index_sync_existing", sync_existing) outputs = [] loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "/exit", output_fn=outputs.append) assert loop.run() == 0 - assert len(started) == 1 - assert started[0][1] is True + assert synced == [True] + assert loop.agent.session.state.status_notice == "index:parse 1/2" def test_agent_loop_consumes_queued_input_before_prompt(tmp_path): From 9a575282eeea88a52482d7dfc3c2d7cdbef83bc0 Mon Sep 17 00:00:00 2001 From: hit9 Date: Wed, 20 May 2026 22:44:09 -0700 Subject: [PATCH 087/144] Use async refresh for existing code index --- nanocode.py | 75 ++++++++++++++----------- pyproject.toml | 2 +- tests/test_nanocode_code_index_tools.py | 24 ++++++-- tests/test_nanocode_loop.py | 12 ++-- 4 files changed, 67 insertions(+), 46 deletions(-) diff --git a/nanocode.py b/nanocode.py index 23731f1..ac08e55 100644 --- a/nanocode.py +++ b/nanocode.py @@ -968,6 +968,8 @@ class RuntimeState: turn_model_calls: int = 0 debug_log_count: int = 0 code_index_error: str = "" + code_index_refreshing: bool = False + code_index_reload_needed: bool = False @dataclass @@ -2392,6 +2394,7 @@ def _set_code_index_notice(session: Session, event: str, *, done: int = 0, total suffix = (" " + str(done) + "/" + str(total)) if total > 0 else "" session.state.status_notice = "index:" + phase + suffix session.state.status_notice_until = time.monotonic() + seconds + session.state.code_index_refreshing = phase not in {"done", "error"} def _code_index_progress(session: Session) -> Callable[..., None]: @@ -2401,20 +2404,43 @@ def update(event: str, *, done: int = 0, total: int = 0, **_kwargs: object) -> N return update -def _code_index_sync_existing(session: Session, progress: Callable[..., None] | None = None) -> bool: +def _code_index_refresh_existing_async(session: Session, progress: Callable[..., None] | None = None) -> bool: status, _message = _code_index_status(session) if status not in {"ready", "stale"}: return False + module = _code_index_module() + if module is None: + return False + session.code_index_repository = None + session.state.code_index_error = "" + session.state.code_index_refreshing = True + session.state.code_index_reload_needed = False + callback = progress or _code_index_progress(session) + + def refresh_progress(event: str, *, done: int = 0, total: int = 0, **kwargs: object) -> None: + callback(event, done=done, total=total, **kwargs) + if {"finish": "done", "done": "done"}.get(event, event) == "done": + session.state.code_index_reload_needed = True + try: - repository = _code_index_repository(session) - repository.update(progress=progress or _code_index_progress(session)) - session.code_index_repository = repository + module.refresh_async(session.cwd, db_path=_code_index_db_path(session), progress=refresh_progress) + except Exception as error: + session.state.code_index_refreshing = False + session.state.code_index_reload_needed = False + session.state.code_index_error = str(error) + return True + + +def _code_index_reload_if_ready(session: Session) -> None: + if not session.state.code_index_reload_needed or session.state.code_index_refreshing: + return + try: + _code_index_repository(session) session.state.code_index_error = "" - _set_code_index_notice(session, "done", seconds=2) except Exception as error: session.code_index_repository = None session.state.code_index_error = str(error) - return True + session.state.code_index_reload_needed = False def _code_index_sync(session: Session, *, force: bool = False) -> str: @@ -2428,6 +2454,7 @@ def _code_index_sync(session: Session, *, force: bool = False) -> str: repository = _code_index_repository(session, create_index=True) repository.refresh(progress=_code_index_progress(session)) session.code_index_repository = repository + session.state.code_index_reload_needed = False except Exception as error: session.code_index_repository = None session.state.code_index_error = str(error) @@ -7408,6 +7435,9 @@ def _status(self, args: str) -> str: if session.state.code_index_error: code_index_status = "error" code_index_message = session.state.code_index_error + elif session.state.code_index_refreshing: + code_index_status = "syncing" + code_index_message = session.state.status_notice.removeprefix("index:") elif code_index_status in {"missing", "stale"}: code_index_message = (code_index_message + "; " if code_index_message else "") + "run /index" code_index = code_index_status + (": " + _shorten(code_index_message, 80) if code_index_message else "") @@ -7859,7 +7889,7 @@ def run(self) -> int: seconds = RuntimeSettings.clean_retention_seconds(self.agent.session.settings.auto_clean_recent) if seconds > 0: SessionCleaner(self.agent.session).clean(older_than_seconds=seconds) - self._sync_existing_code_index_before_prompt() + self._start_existing_code_index_refresh() dispatcher = CommandDispatcher( self.agent, run_agent=self._run_agent, @@ -7869,6 +7899,7 @@ def run(self) -> int: select_provider=self._select_provider, ) while True: + _code_index_reload_if_ready(self.agent.session) if self._exit_after_current_turn: return 0 try: @@ -7886,6 +7917,7 @@ def run(self) -> int: continue if not user_input: continue + _code_index_reload_if_ready(self.agent.session) try: result = dispatcher.dispatch(user_input) except Exception as error: @@ -7907,36 +7939,11 @@ def _prompt(self) -> str: labels.append("plan") return "[" + ",".join(labels) + "] > " if labels else "> " - def _sync_existing_code_index_before_prompt(self) -> None: + def _start_existing_code_index_refresh(self) -> None: def progress(event: str, *, done: int = 0, total: int = 0, **_kwargs: object) -> None: _set_code_index_notice(self.agent.session, event, done=done, total=total) - if self.output_fn is not print or not sys.stderr.isatty(): - return - phase = {"scan": "scan", "start": "parse", "file": "parse", "finish": "done"}.get(event, event) - self.status_bar.output.write_raw("\r") - self.status_bar.output.erase_end_of_line() - print_formatted_text(FormattedText(self._index_progress_fragments(phase, done, total)), output=self.status_bar.output, end="", flush=True) - attempted = _code_index_sync_existing(self.agent.session, progress=progress) - if not attempted or self.output_fn is not print or not sys.stderr.isatty(): - return - self.status_bar.output.write_raw("\r") - self.status_bar.output.erase_end_of_line() - status = "error" if self.agent.session.state.code_index_error else "sync done" - print_formatted_text(FormattedText(self._index_progress_fragments(status, 1, 1)), output=self.status_bar.output, end="\n", flush=True) - self.status_bar.rendered = False - - def _index_progress_fragments(self, phase: str, done: int, total: int) -> list[tuple[str, str]]: - width = 18 - if total > 0: - filled = min(width, max(0, int(width * done / max(total, 1)))) - bar = "#" * filled + "-" * (width - filled) - count = " " + str(done) + "/" + str(total) - else: - bar = "-" * width - count = "" - style = "ansired" if phase == "error" else "ansicyan" - return [("ansibrightblack", " index "), (style, phase), ("ansibrightblack", " [" + bar + "]" + count)] + _code_index_refresh_existing_async(self.agent.session, progress=progress) def _read_input(self, prompt: str) -> str: if self.prompt_session is None: diff --git a/pyproject.toml b/pyproject.toml index e303e87..f926fa8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,7 +27,7 @@ classifiers = [ "Topic :: Terminals", ] dependencies = [ - "code-symbol-index>=0.1.4", + "code-symbol-index>=0.1.6", "openai>=2.37.0", "prompt-toolkit>=3.0", "socksio>=1.0.0", diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index 229abc2..f1bc19a 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -56,7 +56,14 @@ def status_fn(root, *, db_path=None, check=False, format="object"): FakeRepository.events.append(("status", root, db_path, check, format)) return SimpleNamespace(status=status, reason="index not initialized" if status == "missing" else "", message="") - return SimpleNamespace(Repository=FakeRepository, status=status_fn) + def refresh_async(root, *, db_path=None, progress=None, **kwargs): + FakeRepository.events.append(("refresh_async", root, db_path, progress is not None, kwargs)) + if progress is not None: + progress("scan") + progress("finish", done=1, total=1) + return SimpleNamespace() + + return SimpleNamespace(Repository=FakeRepository, refresh_async=refresh_async, status=status_fn) @pytest.fixture(autouse=True) @@ -134,15 +141,22 @@ def test_code_index_force_rebuild_removes_project_index_dir(tmp_path, monkeypatc assert result == "code_index: rebuilt\nstatus: ready\npath: " + nanocode._code_index_db_path(session) -def test_code_index_sync_existing_updates_ready_index_and_caches_repository(tmp_path, monkeypatch): +def test_code_index_refresh_existing_async_starts_for_ready_index(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module("ready")) - assert nanocode._code_index_sync_existing(session) is True + assert nanocode._code_index_refresh_existing_async(session) is True + + assert ("refresh_async", str(tmp_path), nanocode._code_index_db_path(session), True, {}) in FakeRepository.events + assert session.code_index_repository is None + assert session.state.status_notice == "index:done 1/1" + assert session.state.code_index_refreshing is False + assert session.state.code_index_reload_needed is True + + nanocode._code_index_reload_if_ready(session) - assert ("update", tuple(), str(tmp_path), nanocode._code_index_db_path(session), True) in FakeRepository.events assert isinstance(session.code_index_repository, FakeRepository) - assert session.state.status_notice == "index:done" + assert session.state.code_index_reload_needed is False def test_find_code_symbol_uses_search_text(tmp_path, monkeypatch): diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index bfe617a..cf770eb 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -545,11 +545,11 @@ def __init__(self): assert any("tip: /index initializes indexed code tools" in output for output in outputs) -def test_agent_loop_syncs_existing_index_before_prompt(tmp_path, monkeypatch): - synced = [] +def test_agent_loop_starts_existing_index_refresh_async(tmp_path, monkeypatch): + refreshed = [] - def sync_existing(session, *, progress=None): - synced.append(progress is not None) + def refresh_existing(session, *, progress=None): + refreshed.append(progress is not None) if progress is not None: progress("file", done=1, total=2) return True @@ -559,12 +559,12 @@ def __init__(self): self.session = make_session(tmp_path, model="model") self.blackboard = Blackboard() - monkeypatch.setattr(nanocode, "_code_index_sync_existing", sync_existing) + monkeypatch.setattr(nanocode, "_code_index_refresh_existing_async", refresh_existing) outputs = [] loop = AgentLoop(FakeAgent(), input_fn=lambda prompt: "/exit", output_fn=outputs.append) assert loop.run() == 0 - assert synced == [True] + assert refreshed == [True] assert loop.agent.session.state.status_notice == "index:parse 1/2" From 2df7ca6ea88fca5f2421cf96cc45e00be187e0b7 Mon Sep 17 00:00:00 2001 From: hit9 Date: Thu, 21 May 2026 19:52:59 -0700 Subject: [PATCH 088/144] Release 0.4.5 with code index 0.1.7 support --- CHANGELOG.md | 7 ++ nanocode.py | 143 ++++++++++++++++++------ pyproject.toml | 4 +- tests/test_nanocode_agent.py | 9 +- tests/test_nanocode_code_index_tools.py | 54 +++++---- tests/test_nanocode_commands.py | 2 +- 6 files changed, 151 insertions(+), 68 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fce6f5f..e588004 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,12 @@ # Changelog +## 0.4.5 - 2026-05-21 + +### Changed +- Updated the built-in code index integration for `code-symbol-index` 0.1.7. +- Added indexed symbol filters for kind, path, and exact matching. +- Added file-local symbol outlines and bounded pending-index details in `/status`. + ## 0.4.4 - 2026-05-20 ### Added diff --git a/nanocode.py b/nanocode.py index ac08e55..521437d 100644 --- a/nanocode.py +++ b/nanocode.py @@ -55,7 +55,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.4" +__version__ = "0.4.5" JsonValue: TypeAlias = Any @@ -2377,10 +2377,25 @@ def _code_index_status(session: Session, *, check: bool = False) -> tuple[str, s if module is None: return "unavailable", "" try: - status = module.status(session.cwd, db_path=_code_index_db_path(session), check=check, format="object") + status = module.status(session.cwd, db_path=_code_index_db_path(session), check=check, max_pending_files=20, format="object") except Exception as error: return "error", str(error) - return str(getattr(status, "status", "error")), str(getattr(status, "message", None) or getattr(status, "reason", None) or "") + message = str(getattr(status, "message", None) or getattr(status, "reason", None) or "") + pending = _code_index_pending_message(getattr(status, "pending_changes", None), getattr(status, "pending_files", ())) + if pending: + message = (message + "; " if message else "") + pending + return str(getattr(status, "status", "error")), message + + +def _code_index_pending_message(changes: Any, files: Any) -> str: + if not changes: + return "" + message = "pending " + str(changes) + if isinstance(files, (list, tuple)) and files: + sample = ", ".join(str(item) for item in files[:3]) + message += " (" + sample + ("..." if len(files) > 3 else "") + ")" + return message + def _code_index_available(session: Session) -> bool: @@ -2497,16 +2512,24 @@ class FindCodeSymbolTool(Tool): MAX_LIMIT: ClassVar[int] = 80 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Find indexed symbols by one name or prefix; results rank exact, prefix, then fuzzy matches.", + "Find indexed symbols by one name or prefix, including top-level constants, variables, and dictionary keys when indexed.", "Returns candidate name, kind, language, 0-based file/range, and signature.", - "Optional limit controls max returned symbols; default 20, max 80.", + "Optional options object: limit (default 20, max 80), kind, path, exact_only.", + "Query may use A|B|C as non-regex OR shorthand.", "Input must be one symbol-like token, not natural language or literal text patterns.", ) - SIGNATURE: ClassVar[str] = "FindCodeSymbol(query[, limit]) -> FindCodeSymbolToolResult" - EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["Tool"]', 'Example args: ["tool_schema"]', 'Example args: ["Tool", 40]') + SIGNATURE: ClassVar[str] = "FindCodeSymbol(query[, options]) -> FindCodeSymbolToolResult" + EXAMPLE: ClassVar[tuple[str, ...]] = ( + 'Example args: ["Tool"]', + 'Example args: ["tool_schema", {"kind":"function","exact_only":true}]', + 'Example args: ["Agent", {"path":"nanocode.py","limit":40}]', + ) query: str = "" limit: int = DEFAULT_LIMIT + kind: str = "" + path: str = "" + exact_only: bool = False session: Session | None = None @classmethod @@ -2516,38 +2539,56 @@ def tool_schema(cls) -> Json: "type": "array", "minItems": 1, "maxItems": 2, - "items": {"type": ["string", "number"], "description": "Symbol name/prefix, then optional max result count."}, + "items": {"type": ["string", "object"], "description": "Symbol name/prefix, then optional {limit, kind, path, exact_only} filters."}, } return schema @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: if not 1 <= len(args) <= 2: - raise ToolCallArgError("requires args: query[, limit]") + raise ToolCallArgError("requires args: query[, options]") query = str(args[0]).strip() if not query: raise ToolCallArgError("query cannot be empty") if re.search(r"\s", query): raise ToolCallArgError("query must be one symbol name or prefix; do not pass natural language") limit = cls.DEFAULT_LIMIT + kind = "" + path = "" + exact_only = False if len(args) == 2: + options = _json_dict(args[1]) + if not options: + raise ToolCallArgError("options must be an object: {limit, kind, path, exact_only}") try: - limit = min(cls.MAX_LIMIT, max(1, int(args[1]))) + limit = min(cls.MAX_LIMIT, max(1, int(options.get("limit", cls.DEFAULT_LIMIT)))) except (TypeError, ValueError): raise ToolCallArgError("limit must be an integer") + kind = str(options.get("kind") or "").strip() + path = str(options.get("path") or "").strip() + exact_only = options.get("exact_only") is True if not _code_index_available(session): raise ToolCallError("code index is not available") - return cls(query=query, limit=limit, session=session) + return cls(query=query, limit=limit, kind=kind, path=path, exact_only=exact_only, session=session) def preview(self) -> str: - return "FindCodeSymbol(" + json.dumps(self.query, ensure_ascii=False) + ")" + options = {key: value for key, value in (("limit", self.limit), ("kind", self.kind), ("path", self.path), ("exact_only", self.exact_only)) if value} + args = [self.query] + ([options] if options != {"limit": self.DEFAULT_LIMIT} else []) + return "FindCodeSymbol(" + ", ".join(json.dumps(arg, ensure_ascii=False) for arg in args) + ")" def call(self) -> str: if self.session is None: raise ToolCallError("missing session") - text = _code_index_repository(self.session).search_text(self.query, limit=self.limit) + text = _code_index_repository(self.session).search_text( + self.query, + limit=self.limit, + kind=self.kind or None, + path=self.path or None, + exact_only=self.exact_only, + ) return _format_code_index_result("FindCodeSymbolToolResult", text) + @dataclass class InspectCodeSymbolTool(Tool): NAME: ClassVar[str] = "InspectCodeSymbol" @@ -2555,17 +2596,23 @@ class InspectCodeSymbolTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Inspect one indexed symbol, Class.member, or symbol prefix.", "Returns line-numbered source plus members, references, shallow impact/callers, and implementors when available.", + "Includes import summaries when indexed.", + "Optional options object: kind, path, exact_only.", "Use it to understand a class/function/API and nearby relationships from the index.", "Symbol matching is case-insensitive; returned line numbers are 0-based.", "Not for files, directories, module paths, natural language, or literal text patterns.", ) - SIGNATURE: ClassVar[str] = "InspectCodeSymbol(symbol) -> InspectCodeSymbolToolResult" + SIGNATURE: ClassVar[str] = "InspectCodeSymbol(symbol[, options]) -> InspectCodeSymbolToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["Tool"]', 'Example args: ["Agent.run"]', + 'Example args: ["Tool", {"path":"nanocode.py","exact_only":true}]', ) symbol: str = "" + kind: str = "" + path: str = "" + exact_only: bool = False session: Session | None = None @classmethod @@ -2574,15 +2621,15 @@ def tool_schema(cls) -> Json: schema["function"]["parameters"]["properties"]["args"] = { "type": "array", "minItems": 1, - "maxItems": 1, - "items": {"type": "string", "description": "One symbol, Class.member, or symbol prefix."}, + "maxItems": 2, + "items": {"type": ["string", "object"], "description": "Symbol/Class.member/prefix, then optional {kind, path, exact_only} filters."}, } return schema @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: - if len(args) != 1: - raise ToolCallArgError("requires args: symbol") + if not 1 <= len(args) <= 2: + raise ToolCallArgError("requires args: symbol[, options]") symbol = str(args[0]).strip() if not symbol: raise ToolCallArgError("symbol cannot be empty") @@ -2596,15 +2643,32 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: raise ToolCallArgError("symbol must be one symbol, Class.member, or symbol prefix; do not pass natural language") if "." in symbol and not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?", symbol): raise ToolCallArgError("symbol looks like a module path; use List/Search/Read for modules/packages, or pass a specific symbol") - return cls(symbol=symbol, session=session) + options = _json_dict(args[1]) if len(args) == 2 else {} + if len(args) == 2 and not options: + raise ToolCallArgError("options must be an object: {kind, path, exact_only}") + return cls( + symbol=symbol, + kind=str(options.get("kind") or "").strip(), + path=str(options.get("path") or "").strip(), + exact_only=options.get("exact_only") is True, + session=session, + ) def preview(self) -> str: - return "InspectCodeSymbol(" + json.dumps(self.symbol, ensure_ascii=False) + ")" + options = {key: value for key, value in (("kind", self.kind), ("path", self.path), ("exact_only", self.exact_only)) if value} + args = [self.symbol] + ([options] if options else []) + return "InspectCodeSymbol(" + ", ".join(json.dumps(arg, ensure_ascii=False) for arg in args) + ")" def call(self) -> str: if self.session is None: raise ToolCallError("missing session") - return _format_code_index_result("InspectCodeSymbolToolResult", _code_index_repository(self.session).inspect_text(self.symbol)) + text = _code_index_repository(self.session).inspect_text( + self.symbol, + kind=self.kind or None, + path=self.path or None, + exact_only=self.exact_only, + ) + return _format_code_index_result("InspectCodeSymbolToolResult", text) @dataclass @@ -2613,13 +2677,15 @@ class OutlineCodeFileTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Outline indexed symbols in one file.", - "Pass a file path only; directories and symbols are not supported.", + "Pass a file path, and optionally a symbol name/prefix to narrow the outline.", + "Directories and bare symbols are not supported as the first argument.", "Returns classes, functions, methods, kinds, signatures, and 0-based locations.", ) - SIGNATURE: ClassVar[str] = "OutlineCodeFile(filepath) -> OutlineCodeFileToolResult" - EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["nanocode.py"]',) + SIGNATURE: ClassVar[str] = "OutlineCodeFile(filepath[, symbol]) -> OutlineCodeFileToolResult" + EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["nanocode.py"]', 'Example args: ["nanocode.py", "Tool"]') filepath: str = "" + symbol: str = "" session: Session | None = None @classmethod @@ -2628,33 +2694,38 @@ def tool_schema(cls) -> Json: schema["function"]["parameters"]["properties"]["args"] = { "type": "array", "minItems": 1, - "maxItems": 1, - "items": {"type": "string", "description": "One file path."}, + "maxItems": 2, + "items": {"type": "string", "description": "File path, then optional symbol name/prefix."}, } return schema @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: - if len(args) != 1: - raise ToolCallArgError("requires args: filepath") + if not 1 <= len(args) <= 2: + raise ToolCallArgError("requires args: filepath[, symbol]") filepath = session.resolve_path(str(args[0]).strip()) if not os.path.isfile(filepath): raise ToolCallArgError("filepath must be an existing file; directories and symbols are not supported") + symbol = str(args[1]).strip() if len(args) == 2 else "" + if re.search(r"\s", symbol): + raise ToolCallArgError("symbol must be one symbol name or prefix") if not _code_index_available(session): raise ToolCallError("code index is not available") - return cls(filepath=filepath, session=session) + return cls(filepath=filepath, symbol=symbol, session=session) def requires_confirmation(self, session: Session) -> bool: return not session.is_path_in_cwd(self.filepath) def preview(self) -> str: cwd = self.session.cwd if self.session is not None else os.getcwd() - return "OutlineCodeFile(" + json.dumps(os.path.relpath(self.filepath, cwd), ensure_ascii=False) + ")" + args = [os.path.relpath(self.filepath, cwd)] + ([self.symbol] if self.symbol else []) + return "OutlineCodeFile(" + ", ".join(json.dumps(arg, ensure_ascii=False) for arg in args) + ")" def call(self) -> str: if self.session is None: raise ToolCallError("missing session") - return _format_code_index_result("OutlineCodeFileToolResult", _code_index_repository(self.session).outline_text(self.filepath)) + return _format_code_index_result("OutlineCodeFileToolResult", _code_index_repository(self.session).outline_text(self.filepath, symbol=self.symbol or None)) + @dataclass class EditTool(Tool): @@ -5792,7 +5863,7 @@ def _format_environment(self) -> str: ] if _code_index_available(self.session): lines.append( - "- inspect_code_hint: Use FindCodeSymbol for symbol/prefix candidates (case-insensitive, optional limit default 20 max 80), InspectCodeSymbol for chosen symbols, and OutlineCodeFile for known file structure. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." + "- inspect_code_hint: Use FindCodeSymbol for symbol/prefix candidates (optional kind/path/exact_only/limit filters), InspectCodeSymbol for chosen symbols, and OutlineCodeFile for known file structure or file-local symbol outlines. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." ) return "\n".join(lines) @@ -5840,9 +5911,9 @@ def _discovery_prompt_hint(self, tool_classes: Iterable[ToolClass]) -> str: return "Use Search/List/LineCount when path, symbol, range, or target is unknown." return ( "For structural code discovery, prefer indexed code tools before Search/Read.\n" - "- Use FindCodeSymbol for symbol candidates by name or prefix.\n" - "- Use InspectCodeSymbol for line-numbered source, members, references, and implementors of one symbol.\n" - "- Use OutlineCodeFile for a file-level symbol outline.\n" + "- Use FindCodeSymbol for symbol candidates by name/prefix with optional kind/path/exact_only filters.\n" + "- Use InspectCodeSymbol for line-numbered source, imports, members, references, and implementors of one symbol.\n" + "- Use OutlineCodeFile for file-level or file-local symbol outlines.\n" "- Use Search for exact literal text, config, comments, logs, or when no useful path/symbol guess exists.\n" "- Use List/LineCount when path shape or file size is unknown." ) @@ -7431,7 +7502,7 @@ def _status(self, args: str) -> str: else " (empty)" ) verification_status = blackboard.verification.status - code_index_status, code_index_message = _code_index_status(session) + code_index_status, code_index_message = _code_index_status(session, check=True) if session.state.code_index_error: code_index_status = "error" code_index_message = session.state.code_index_error diff --git a/pyproject.toml b/pyproject.toml index f926fa8..ff2b4ba 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.4" +version = "0.4.5" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" @@ -27,7 +27,7 @@ classifiers = [ "Topic :: Terminals", ] dependencies = [ - "code-symbol-index>=0.1.6", + "code-symbol-index>=0.1.7", "openai>=2.37.0", "prompt-toolkit>=3.0", "socksio>=1.0.0", diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 349b568..3413275 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -520,15 +520,14 @@ def test_inspect_code_tools_is_visible_when_available(tmp_path, monkeypatch): assert "OutlineCodeFile" in tool_names system_prompt = agent._system_prompt() assert "prefer indexed code tools before Search/Read" in system_prompt - assert "Use FindCodeSymbol for symbol candidates by name or prefix" in system_prompt - assert "Use InspectCodeSymbol for line-numbered source, members, references, and implementors" in system_prompt + assert "Use FindCodeSymbol for symbol candidates by name/prefix with optional kind/path/exact_only filters" in system_prompt + assert "Use InspectCodeSymbol for line-numbered source, imports, members, references, and implementors" in system_prompt prompt = agent.build_user_prompt() assert "Use FindCodeSymbol for symbol/prefix candidates" in prompt assert "InspectCodeSymbol for chosen symbols" in prompt - assert "OutlineCodeFile for known file structure" in prompt + assert "OutlineCodeFile for known file structure or file-local symbol outlines" in prompt assert "code-symbol-index" not in prompt - assert "case-insensitive" in prompt - assert "optional limit default 20 max 80" in prompt + assert "kind/path/exact_only/limit filters" in prompt assert "Do not pass natural language" in prompt assert "Use Search/Read for text, config, logs, commands, and exact ranges" in prompt diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index f1bc19a..b819b0f 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -34,16 +34,16 @@ def update(self, paths=None, *, progress=None): progress("finish", done=1, total=1) return self - def search_text(self, query, *, limit): - self.events.append(("search_text", query, limit, self.root, self.db_path)) + def search_text(self, query, *, kind=None, path=None, exact_only=False, limit=20): + self.events.append(("search_text", query, kind, path, exact_only, limit, self.root, self.db_path)) return "query: " + query + "\ncount: 1\nsymbol Tool nanocode.py:10:20" - def inspect_text(self, symbol): - self.events.append(("inspect_text", symbol, self.root, self.db_path)) + def inspect_text(self, symbol, *, kind=None, path=None, exact_only=False): + self.events.append(("inspect_text", symbol, kind, path, exact_only, self.root, self.db_path)) return "symbol:\n name: " + symbol + "\nsource:\n status: full" - def outline_text(self, filepath): - self.events.append(("outline_text", filepath, self.root, self.db_path)) + def outline_text(self, filepath, *, symbol=None): + self.events.append(("outline_text", filepath, symbol, self.root, self.db_path)) return "file: " + filepath + "\noutline:\n class Tool 0:2 class Tool:" @@ -51,9 +51,9 @@ def fake_code_index_module(status="ready", *, refresh_status=None): FakeRepository.status = status FakeRepository.refresh_status = refresh_status - def status_fn(root, *, db_path=None, check=False, format="object"): + def status_fn(root, *, db_path=None, check=False, max_pending_files=50, format="object"): status = FakeRepository.status - FakeRepository.events.append(("status", root, db_path, check, format)) + FakeRepository.events.append(("status", root, db_path, check, max_pending_files, format)) return SimpleNamespace(status=status, reason="index not initialized" if status == "missing" else "", message="") def refresh_async(root, *, db_path=None, progress=None, **kwargs): @@ -81,15 +81,10 @@ def test_inspect_code_requires_code_index(tmp_path, monkeypatch): def test_code_index_schema_accepts_expected_args(): - for tool in (InspectCodeSymbolTool, OutlineCodeFileTool): + for tool in (FindCodeSymbolTool, InspectCodeSymbolTool, OutlineCodeFileTool): args_schema = tool.tool_schema()["function"]["parameters"]["properties"]["args"] assert args_schema["minItems"] == 1 - assert args_schema["maxItems"] == 1 - assert args_schema["items"]["type"] == "string" - args_schema = FindCodeSymbolTool.tool_schema()["function"]["parameters"]["properties"]["args"] - assert args_schema["minItems"] == 1 - assert args_schema["maxItems"] == 2 - assert args_schema["items"]["type"] == ["string", "number"] + assert args_schema["maxItems"] == 2 def test_inspect_code_rejects_natural_language(tmp_path, monkeypatch): @@ -111,6 +106,17 @@ def test_code_index_missing_is_not_initialized_implicitly(tmp_path, monkeypatch) assert not [event for event in FakeRepository.events if event[0] in {"repo", "refresh"}] +def test_code_index_status_formats_checked_pending_files(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) + + def status_fn(root, *, db_path=None, check=False, max_pending_files=50, format="object"): + return SimpleNamespace(status="stale", reason="", message="", pending_changes=5, pending_files=("a.py", "b.py", "c.py", "d.py")) + + monkeypatch.setattr(nanocode, "_code_index_module", lambda: SimpleNamespace(status=status_fn)) + + assert nanocode._code_index_status(session, check=True) == ("stale", "pending 5 (a.py, b.py, c.py...)") + + def test_code_index_sync_initializes_missing_index_in_project_data(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) module = fake_code_index_module("missing", refresh_status="ready") @@ -163,19 +169,19 @@ def test_find_code_symbol_uses_search_text(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) - result = FindCodeSymbolTool.make(session, ["Tool", 12]).call() + result = FindCodeSymbolTool.make(session, ["Tool", {"limit": 12, "kind": "class", "path": "nanocode.py", "exact_only": True}]).call() db_path = str(tmp_path / "data" / "projects" / session.project_key() / "code-symbol-index" / "index.sqlite") - assert ("search_text", "Tool", 12, str(tmp_path), db_path) in FakeRepository.events + assert ("search_text", "Tool", "class", "nanocode.py", True, 12, str(tmp_path), db_path) in FakeRepository.events assert result == "\nquery: Tool\ncount: 1\nsymbol Tool nanocode.py:10:20\n" def test_find_code_symbol_clamps_limit(tmp_path, monkeypatch): monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) - assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", 999]).limit == 80 - assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", 0]).limit == 1 + assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", {"limit": 999}]).limit == 80 + assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", {"limit": 0}]).limit == 1 with pytest.raises(ToolCallArgError, match="limit must be an integer"): - FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", "many"]) + FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", {"limit": "many"}]) def test_inspect_code_symbol_rejects_files_directories_and_dotted_module_paths(tmp_path, monkeypatch): @@ -196,9 +202,9 @@ def test_inspect_code_symbol_uses_inspect_text(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path)) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) - result = InspectCodeSymbolTool.make(session, ["Tool"]).call() + result = InspectCodeSymbolTool.make(session, ["Tool", {"path": "nanocode.py", "exact_only": True}]).call() - assert ("inspect_text", "Tool", str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events + assert ("inspect_text", "Tool", None, "nanocode.py", True, str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events assert result == "\nsymbol:\n name: Tool\nsource:\n status: full\n" @@ -208,9 +214,9 @@ def test_outline_code_file_uses_outline_text(tmp_path, monkeypatch): filepath.write_text("class Tool:\n pass\n", encoding="utf-8") monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) - result = OutlineCodeFileTool.make(session, ["code.py"]).call() + result = OutlineCodeFileTool.make(session, ["code.py", "Tool"]).call() - assert ("outline_text", str(filepath), str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events + assert ("outline_text", str(filepath), "Tool", str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events assert result == "\nfile: " + str(filepath) + "\noutline:\n class Tool 0:2 class Tool:\n" diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index ac1b45b..0d36fbe 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -87,7 +87,7 @@ def test_command_dispatcher_updates_config_and_auto_compacts(tmp_path): def test_status_reports_tokens_in_human_readable_format(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode, "_code_index_status", lambda session: ("unavailable", "")) + monkeypatch.setattr(nanocode, "_code_index_status", lambda session, *, check=False: ("unavailable", "")) session = make_session(tmp_path, model="model") session.state.last_total_tokens = 1200 session.state.session_total_tokens = 2_345_678 From f827c3129ab3c2f89bc1118c3d4c14e16b8b9da4 Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 03:02:05 -0700 Subject: [PATCH 089/144] Replace legacy edit tools with anchored EditFile --- README.md | 2 +- nanocode.py | 731 ++++------------------ tests/test_nanocode_agent.py | 71 ++- tests/test_nanocode_edit_file_tool.py | 153 +++++ tests/test_nanocode_edit_tool.py | 129 ---- tests/test_nanocode_loop.py | 4 +- tests/test_nanocode_patch_file_tool.py | 163 ----- tests/test_nanocode_read_tool.py | 48 +- tests/test_nanocode_replace_range_tool.py | 389 ------------ tests/test_nanocode_search_tool.py | 22 +- 10 files changed, 360 insertions(+), 1352 deletions(-) create mode 100644 tests/test_nanocode_edit_file_tool.py delete mode 100644 tests/test_nanocode_edit_tool.py delete mode 100644 tests/test_nanocode_patch_file_tool.py delete mode 100644 tests/test_nanocode_replace_range_tool.py diff --git a/README.md b/README.md index 44695da..31d8503 100644 --- a/README.md +++ b/README.md @@ -81,7 +81,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. - File: `Read`, `LineCount`, `List`, `Search`. - Code navigation: `FindCodeSymbol`, `InspectCodeSymbol`, and `OutlineCodeFile` after `/index` builds the project index. -- Edit: `Edit`, `ReplaceRange`. +- Edit: `CreateFile`, `EditFile`. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. diff --git a/nanocode.py b/nanocode.py index 521437d..fae7800 100644 --- a/nanocode.py +++ b/nanocode.py @@ -367,7 +367,8 @@ def load(cls, path: str) -> "UserRules": def add(self, rule: str) -> bool: rule = self._clean_rule(rule) - if not rule or rule in self._rules(): + rules = {item for line in self.content.splitlines() if (item := self._clean_rule(line)) and not item.startswith("#")} + if not rule or rule in rules: return False prefix = "# User Rules\n\n" if not self.content.strip() else self.content.rstrip() + "\n" self.content = prefix + "- " + rule @@ -381,9 +382,6 @@ def save(self, path: str) -> None: def format(self, indent: str = "") -> str: return _format_lines((self.content.strip() or "(empty)").splitlines(), indent) - def _rules(self) -> set[str]: - return {rule for line in self.content.splitlines() if (rule := self._clean_rule(line)) and not rule.startswith("#")} - @staticmethod def _clean_rule(rule: str) -> str: rule = " ".join(rule.strip().split()) @@ -815,128 +813,6 @@ class AgentRunResult: value: JsonValue = None -class RangeFingerprintStore: - MAX_ENTRIES: ClassVar[int] = 200 - - @dataclass - class Entry: - fingerprint: str - filepath: str - start: int - end: int - content: str - - @dataclass - class Resolved: - start: int - end: int - fingerprint: str - relocated_from: tuple[int, int] | None = None - - def __init__(self): - self._entries: list[RangeFingerprintStore.Entry] = [] - - def remember(self, *, filepath: str, start: int, end: int, content: str) -> str: - fingerprint = _range_fingerprint(content) - entry = self.Entry(fingerprint=fingerprint, filepath=os.path.realpath(filepath), start=start, end=end, content=content) - if entry not in self._entries: - self._entries.append(entry) - del self._entries[: max(0, len(self._entries) - self.MAX_ENTRIES)] - return fingerprint - - def clear(self) -> None: - self._entries = [] - - def __len__(self) -> int: - return len(self._entries) - - def resolve(self, lines: list[str], *, filepath: str, start: int, end: int, fingerprint: str) -> Resolved: - resolved_start = min(start, len(lines)) - resolved_end = len(lines) if end == 0 else min(end, len(lines)) - resolved_end = max(resolved_end, resolved_start) - current = "".join(lines[resolved_start:resolved_end]) - current_fingerprint = _range_fingerprint(current) - if current_fingerprint == fingerprint: - return self.Resolved(start=resolved_start, end=resolved_end, fingerprint=current_fingerprint) - - for content in self._candidate_contents( - filepath=filepath, - start=resolved_start, - end=resolved_end, - fingerprint=fingerprint, - ): - if _range_fingerprint(content) == current_fingerprint: - return self.Resolved(start=resolved_start, end=resolved_end, fingerprint=current_fingerprint) - - matches = self._find_matches(lines, filepath=filepath, start=resolved_start, end=resolved_end, fingerprint=fingerprint) - message = ( - f"fingerprint mismatch for range {start}:{end}: expected {fingerprint}, current {current_fingerprint}; " - f"call Read(filepath, {start}, {end}) and reuse that range fingerprint" - ) - other_ranges = self._ranges_for_fingerprint(filepath=filepath, fingerprint=fingerprint) - if other_ranges: - message += "; this fingerprint was cached for range(s): " + ", ".join(f"{range_start}:{range_end}" for range_start, range_end in other_ranges) - if not matches: - raise ToolCallError(message) - if len(matches) > 1: - raise ToolCallError(message + "; cached range matched multiple locations") - relocated_start, relocated_end = matches[0] - return self.Resolved( - start=relocated_start, - end=relocated_end, - fingerprint=_range_fingerprint("".join(lines[relocated_start:relocated_end])), - relocated_from=(resolved_start, resolved_end), - ) - - def _find_matches(self, lines: list[str], *, filepath: str, start: int, end: int, fingerprint: str) -> list[tuple[int, int]]: - contents = [content for content in self._candidate_contents(filepath=filepath, start=start, end=end, fingerprint=fingerprint) if content] - - matches = [] - for content in contents: - expected = content.splitlines(keepends=True) - if not expected: - continue - last_start = len(lines) - len(expected) - for position in range(max(0, last_start + 1)): - if lines[position : position + len(expected)] == expected: - matches.append((position, position + len(expected))) - if len(matches) > 1: - return matches - return matches - - def _candidate_contents(self, *, filepath: str, start: int, end: int, fingerprint: str) -> list[str]: - filepath = os.path.realpath(filepath) - contents: list[str] = [] - for entry in self._entries: - if entry.fingerprint != fingerprint or entry.filepath != filepath: - continue - if start == end: - entry_lines = entry.content.splitlines(keepends=True) - cached_end = entry.start + len(entry_lines) - if entry.start <= start <= cached_end: - contents.append("") - continue - entry_lines = entry.content.splitlines(keepends=True) - cached_end = entry.start + len(entry_lines) - if start < entry.start or end > cached_end: - continue - candidate = "".join(entry_lines[start - entry.start : end - entry.start]) - if candidate not in contents: - contents.append(candidate) - return contents - - def _ranges_for_fingerprint(self, *, filepath: str, fingerprint: str) -> list[tuple[int, int]]: - filepath = os.path.realpath(filepath) - ranges = [] - for entry in self._entries: - if entry.fingerprint != fingerprint or entry.filepath != filepath: - continue - item = (entry.start, entry.end) - if item not in ranges: - ranges.append(item) - return ranges - - @dataclass class RuntimeState: debug_prompt_count: int = 0 @@ -960,7 +836,6 @@ class RuntimeState: pending_user_feedback: str = "" conversation: list[ConversationItem] = field(default_factory=list) user_rules: UserRules = field(default_factory=UserRules) - range_fingerprints: RangeFingerprintStore = field(default_factory=RangeFingerprintStore) tool_result_store: dict[str, ToolResultItem] = field(default_factory=dict) tool_result_counter: int = 0 turn_tool_calls: int = 0 @@ -1716,7 +1591,7 @@ def _parse_line_range(start_arg: str, end_arg: str) -> tuple[int, int]: return start, end -def _range_fingerprint(content: str) -> str: +def _line_hash(content: str) -> str: return hashlib.blake2s(content.encode("utf-8"), digest_size=3).hexdigest() @@ -1726,7 +1601,7 @@ def _range_fingerprint(content: str) -> str: def _numbered_content(content: str, start: int) -> str: - return "".join(f"{start + index:>7} |{line}" for index, line in enumerate(content.splitlines(keepends=True))) + return "".join(f"{start + index}:{_line_hash(line)}|{line}" for index, line in enumerate(content.splitlines(keepends=True))) def _parse_line_range_token(value: str) -> tuple[int, int]: @@ -1744,9 +1619,9 @@ class ReadTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Read a single known UTF-8 file; pass multiple 0-based start,end ranges for it.", "Each range returns at most 600 lines.", - 'Content is line-numbered as "line |code"; edit text starts immediately after "|".', + 'Content is hashline-numbered as "line:hash|code"; EditFile anchors use "line:hash" and code starts after "|".', ) - SIGNATURE: ClassVar[str] = "Read(filepath[, range_token...]) -> ReadToolResult" + SIGNATURE: ClassVar[str] = "Read(filepath[, range_token...]) -> ReadToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["code.py", "0,80", "160,220"]', 'Example args: ["code.py"]', @@ -1757,7 +1632,6 @@ class ReadTool(Tool): end: int = 0 ranges: list[tuple[int, int]] = field(default_factory=list) cwd: str = "" - range_fingerprints: RangeFingerprintStore = field(default_factory=RangeFingerprintStore) @classmethod def cli_args(cls, args: list[JsonValue]) -> list[str]: @@ -1782,7 +1656,7 @@ def make(cls, session: Session, args: list[str]) -> Self: else: raise ToolCallArgError('Read args error: for multiple ranges use comma tokens. Example: Read("nanocode.py", "0,40", "200,260").') start, end = ranges[0] - return cls(filepath=filepath, start=start, end=end, ranges=ranges, cwd=session.cwd, range_fingerprints=session.state.range_fingerprints) + return cls(filepath=filepath, start=start, end=end, ranges=ranges, cwd=session.cwd) def requires_confirmation(self, session: Session) -> bool: return not session.is_path_in_cwd(self.filepath) @@ -1797,20 +1671,20 @@ def call(self) -> str: if len(self.ranges) > 1: lines = ["", " " + str(len(self.ranges)) + ""] for start, end in self.ranges: - content, returned_end, fingerprint_end, fingerprint, truncated, total_lines = self._read_range(start, end) + content, returned_end, range_end, truncated, total_lines = self._read_range(start, end) lines.append(" ") - lines.extend(self._format_range_result(start, returned_end, fingerprint_end, fingerprint, truncated, total_lines, content, indent=" ")) + lines.extend(self._format_range_result(start, returned_end, range_end, truncated, total_lines, content, indent=" ")) lines.append(" ") lines.append("") return "\n".join(lines) - content, returned_end, fingerprint_end, fingerprint, truncated, total_lines = self._read_range(self.start, self.end) + content, returned_end, range_end, truncated, total_lines = self._read_range(self.start, self.end) lines = [""] - lines.extend(self._format_range_result(self.start, returned_end, fingerprint_end, fingerprint, truncated, total_lines, content, indent=" ")) + lines.extend(self._format_range_result(self.start, returned_end, range_end, truncated, total_lines, content, indent=" ")) lines.append("") return "\n".join(lines) - def _read_range(self, start: int, end: int) -> tuple[str, int, int, str, bool, int]: + def _read_range(self, start: int, end: int) -> tuple[str, int, int, bool, int]: target_filepath = self.filepath total_lines = 0 selected_lines = [] @@ -1833,21 +1707,14 @@ def _read_range(self, start: int, end: int) -> tuple[str, int, int, str, bool, i truncated = True content = "".join(selected_lines) returned_end = start + len(selected_lines) - fingerprint_end = returned_end if truncated else end - fingerprint = self.range_fingerprints.remember( - filepath=target_filepath, - start=start, - end=fingerprint_end, - content=content, - ) - return content, returned_end, fingerprint_end, fingerprint, truncated, total_lines + range_end = returned_end if truncated else end + return content, returned_end, range_end, truncated, total_lines def _format_range_result( self, start: int, returned_end: int, - fingerprint_end: int, - fingerprint: str, + range_end: int, truncated: bool, total_lines: int, content: str, @@ -1855,9 +1722,8 @@ def _format_range_result( indent: str, ) -> list[str]: lines = [ - indent + "" + str(start) + ":" + str(fingerprint_end) + "", - indent + "" + fingerprint + "", - indent + 'Line prefixes are display-only; code starts immediately after "|".', + indent + "" + str(start) + ":" + str(range_end) + "", + indent + 'Line prefixes are display-only; EditFile anchors use "line:hash"; code starts immediately after "|".', ] if truncated: note = ( @@ -1871,7 +1737,7 @@ def _format_range_result( indent + "" + note + "", ] ) - lines.extend([indent + "", _numbered_content(content, start), indent + ""]) + lines.extend([indent + "", _numbered_content(content, start), indent + ""]) return lines @@ -2381,23 +2247,17 @@ def _code_index_status(session: Session, *, check: bool = False) -> tuple[str, s except Exception as error: return "error", str(error) message = str(getattr(status, "message", None) or getattr(status, "reason", None) or "") - pending = _code_index_pending_message(getattr(status, "pending_changes", None), getattr(status, "pending_files", ())) - if pending: + changes = getattr(status, "pending_changes", None) + files = getattr(status, "pending_files", ()) + if changes: + pending = "pending " + str(changes) + if isinstance(files, (list, tuple)) and files: + sample = ", ".join(str(item) for item in files[:3]) + pending += " (" + sample + ("..." if len(files) > 3 else "") + ")" message = (message + "; " if message else "") + pending return str(getattr(status, "status", "error")), message -def _code_index_pending_message(changes: Any, files: Any) -> str: - if not changes: - return "" - message = "pending " + str(changes) - if isinstance(files, (list, tuple)) and files: - sample = ", ".join(str(item) for item in files[:3]) - message += " (" + sample + ("..." if len(files) > 3 else "") + ")" - return message - - - def _code_index_available(session: Session) -> bool: status, message = _code_index_status(session) session.state.code_index_error = message if status == "error" else "" @@ -2727,263 +2587,6 @@ def call(self) -> str: return _format_code_index_result("OutlineCodeFileToolResult", _code_index_repository(self.session).outline_text(self.filepath, symbol=self.symbol or None)) -@dataclass -class EditTool(Tool): - NAME: ClassVar[str] = "Edit" - EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT - DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Replace/delete exact literal text in an existing file; default requires one unique match, optional 'all' replaces every match.", - "Returns changed path plus replacement count or created=true.", - "If the target is structural or line ranges are clearer, use ReplaceRange.", - ) - SIGNATURE: ClassVar[str] = "Edit(filepath, find, replace[, all]) -> EditToolResult" - EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["code.py", "old text", "new text"]', 'Example all args: ["code.py", "old", "new", "all"]') - - filepath: str = "" - find: str = "" - replace: str = "" - replace_all: bool = False - cwd: str = "" - - @classmethod - def cli_args(cls, args: list[str]) -> list[str]: - return [cls.cli_token(args[0])] if args else [] - - @classmethod - def make(cls, session: Session, args: list[str]) -> Self: - if len(args) not in (3, 4): - raise ToolCallArgError( - "Edit args error: got " - + str(len(args)) - + ' args; expected ["filepath", "find", "replace", optional "all"]. Example: Edit("nanocode.py", "old text", "new text").' - ) - if len(args) == 4 and str(args[3]) != "all": - raise ToolCallArgError('Edit fourth arg must be exactly "all"') - find = str(args[1]) - return cls(filepath=session.resolve_path(args[0]), find=find, replace=str(args[2]), replace_all=len(args) == 4, cwd=session.cwd) - - def preview(self) -> str: - label = f'Edit({self.filepath}, find="{self.find}")' - try: - with open(self.filepath, "r", encoding="utf-8") as f: - content = f.read() - except FileNotFoundError: - if self.find == "": - return _make_unified_diff("", self.replace, self.filepath) or label - return label + "\n# preview unavailable: file does not exist; use empty find to create" - except OSError as error: - return label + "\n# preview unavailable: " + str(error) - if self.find == "": - return label + "\n# preview unavailable: empty find creates missing files only" - if self.find not in content: - return label - replacements = content.count(self.find) - if replacements != 1 and not self.replace_all: - return label + '\n# preview unavailable: target `find` text matched multiple times; pass "all" to replace all matches or use ReplaceRange' - return _make_unified_diff(content, content.replace(self.find, self.replace, -1 if self.replace_all else 1), self.filepath) or label - - def call(self) -> str: - created = False - try: - with open(self.filepath, "r", encoding="utf-8") as f: - content = f.read() - except FileNotFoundError: - if self.find != "": - raise ToolCallError("file does not exist; use empty find to create") - content = "" - created = True - if self.find == "" and not created: - raise ToolCallError("empty find creates missing files only") - if self.find not in content: - raise ToolCallError("target `find` text not found") - replacements = content.count(self.find) - if replacements != 1 and not self.replace_all: - raise ToolCallError('target `find` text matched multiple times; pass "all" to replace all matches or use ReplaceRange') - - with open(self.filepath, "w", encoding="utf-8") as f: - f.write(content.replace(self.find, self.replace, -1 if self.replace_all else 1)) - - lines = [ - "", - f"* path: {os.path.relpath(self.filepath, self.cwd)}", - ] - if created: - lines.append("* created: true") - else: - lines.append(f"* replacements: {replacements}") - lines.append("") - return "\n".join(lines) - - -@dataclass -class PatchFileHunk: - old: list[str] - new: list[str] - alt_old: list[str] - alt_new: list[str] - - -@dataclass -class PatchFileTool(Tool): - NAME: ClassVar[str] = "PatchFile" - EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT - DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Apply a small single-file unified-diff-style patch for coordinated multi-location edits.", - "Returns changed path and applied hunk count.", - "Inside hunks, every line should start with space, -, or +; indented context copied without the extra marker is tolerated.", - "Context lines must be exact file text, without Read display prefixes.", - "Each hunk must include enough unchanged context to match exactly once; all hunks must apply or nothing is written.", - ) - SIGNATURE: ClassVar[str] = "PatchFile(filepath, patch) -> PatchFileToolResult" - EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Example args: ["code.py", "@@\\n old\\n-old_call()\\n+new_call()\\n next\\n"]', - ) - - filepath: str = "" - patch: str = "" - cwd: str = "" - - @classmethod - def cli_args(cls, args: list[str]) -> list[str]: - if len(args) < 2: - return [cls.cli_token(arg) for arg in args] - return [cls.cli_token(args[0]), cls.cli_content_summary(args[1])] - - @classmethod - def make(cls, session: Session, args: list[str]) -> Self: - if len(args) != 2: - raise ToolCallArgError('requires exactly 2 args: filepath, patch. Example: PatchFile("code.py", "@@\\n old\\n-new\\n+new\\n")') - return cls(filepath=session.resolve_path(args[0]), patch=str(args[1]), cwd=session.cwd) - - def preview(self) -> str: - label = f"PatchFile({self.filepath})" - try: - original, new_content, _ = self._preview() - except (OSError, ToolCallError) as error: - return label + "\n# preview unavailable: " + str(error) - return _make_unified_diff(original, new_content, self.filepath) or label - - def preview_error(self) -> str: - try: - self._preview() - except (OSError, ToolCallError) as error: - return str(error) - return "" - - def call(self) -> str: - original, new_content, replacements = self._preview() - if new_content == original: - raise ToolCallError("patch produced no changes") - with open(self.filepath, "w", encoding="utf-8") as f: - f.write(new_content) - return "\n".join( - [ - "", - f"* path: {os.path.relpath(self.filepath, self.cwd)}", - f"* hunks: {len(replacements)}", - "", - ] - ) - - def _preview(self) -> tuple[str, str, list[tuple[int, int, list[str]]]]: - with open(self.filepath, "r", encoding="utf-8") as f: - original = f.read() - lines = original.splitlines(keepends=True) - replacements = [ - (start, start + len(old), new) - for index, hunk in enumerate(self._parse_patch(), start=1) - for old, new in [self._select_hunk_variant(lines, hunk, index)] - for start in [self._match_hunk(lines, old, index)] - ] - return original, "".join(self._patched_lines(lines, replacements)), replacements - - def _parse_patch(self) -> list[PatchFileHunk]: - hunks: list[PatchFileHunk] = [] - current: PatchFileHunk | None = None - for raw_line in self.patch.splitlines(keepends=True): - if raw_line.startswith("\\ No newline at end of file"): - continue - if raw_line.startswith("@@"): - if current is not None and not current.old and not current.new: - continue - current = PatchFileHunk(old=[], new=[], alt_old=[], alt_new=[]) - hunks.append(current) - continue - if current is None: - if raw_line.startswith(("---", "+++", "diff --git ", "index ", "new file mode ", "deleted file mode ", "similarity index ", "rename from ", "rename to ")): - continue - if raw_line.strip(): - raise ToolCallError("patch content before first hunk") - continue - if not raw_line: - continue - prefix, text = raw_line[0], raw_line[1:] - if prefix == " ": - current.old.append(text) - current.new.append(text) - current.alt_old.append(raw_line) - current.alt_new.append(raw_line) - elif prefix == "-": - current.old.append(text) - current.alt_old.append(text) - elif prefix == "+": - current.new.append(text) - current.alt_new.append(" " + text) - else: - raise ToolCallError("invalid patch hunk line prefix: " + repr(prefix)) - if not hunks: - raise ToolCallError("patch has no hunks") - for index, hunk in enumerate(hunks, start=1): - if not hunk.old: - raise ToolCallError(f"hunk {index} has no context or removed lines") - return hunks - - def _select_hunk_variant(self, lines: list[str], hunk: PatchFileHunk, index: int) -> tuple[list[str], list[str]]: - if self._hunk_matches(lines, hunk.old): - return hunk.old, hunk.new - if (hunk.alt_old != hunk.old or hunk.alt_new != hunk.new) and self._hunk_matches(lines, hunk.alt_old): - return hunk.alt_old, hunk.alt_new - raise ToolCallError(f"hunk {index} context did not match; first old line: {self._line_preview(hunk.old[0])}") - - @staticmethod - def _hunk_matches(lines: list[str], old: list[str]) -> bool: - limit = len(lines) - len(old) - return any(lines[start : start + len(old)] == old for start in range(max(0, limit + 1))) - - @classmethod - def _match_hunk(cls, lines: list[str], old: list[str], index: int) -> int: - matches = [] - limit = len(lines) - len(old) - for start in range(max(0, limit + 1)): - if lines[start : start + len(old)] == old: - matches.append(start) - if len(matches) > 1: - raise ToolCallError(f"hunk {index} context matched multiple locations") - return matches[0] - - @staticmethod - def _line_preview(line: str) -> str: - return repr(line.rstrip("\n"))[:120] - - @staticmethod - def _patched_lines(lines: list[str], replacements: list[tuple[int, int, list[str]]]) -> list[str]: - output: list[str] = [] - cursor = 0 - for start, end, replacement in sorted(replacements, key=lambda item: item[0]): - if start < cursor: - overlap = cursor - start - if overlap > len(replacement) or output[-overlap:] != replacement[:overlap]: - raise ToolCallError("patch hunks overlap") - output.extend(replacement[overlap:]) - cursor = max(cursor, end) - continue - output.extend(lines[cursor:start]) - output.extend(replacement) - cursor = end - output.extend(lines[cursor:]) - return output - - @dataclass class CreateFileTool(Tool): NAME: ClassVar[str] = "CreateFile" @@ -2991,7 +2594,7 @@ class CreateFileTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Create a new UTF-8 file with short initial content; target file must not exist.", "Returns changed path and created=true.", - "For substantial new files, create only a small skeleton first, then grow it with focused ReplaceRange edits.", + "For substantial new files, create only a small skeleton first, then grow it with focused EditFile edits.", ) SIGNATURE: ClassVar[str] = "CreateFile(filepath, content) -> CreateFileToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["new.py", "minimal content\\n"]',) @@ -3042,88 +2645,71 @@ def call(self) -> str: @dataclass -class ReplaceRangeEdit: - start: int - end: int - fingerprint: str - before_context: str - after_context: str +class EditFileEdit: + op: str + start: str + end: str content: str @dataclass -class ReplaceRangeTool(Tool): - NAME: ClassVar[str] = "ReplaceRange" - PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "ranges") +class EditFileTool(Tool): + NAME: ClassVar[str] = "EditFile" + PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "edits") EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Replace one or more small Read-backed [start,end) ranges in an existing file; best when exact line ranges are known or target text is not unique.", - "Returns changed path plus resolved ranges, fingerprints, and relocation info when applicable.", - "Pass ranges as [[start,end,fingerprint,before_context,after_context,content], ...].", - "Pass exact before_context and after_context when known; empty boundary context is allowed for non-empty replacements.", - "Content is only the replacement for that range; do not include boundary lines.", - ) - SIGNATURE: ClassVar[str] = ( - "ReplaceRange(filepath, [[start,end,fingerprint,before_context,after_context,content], ...]) -> ReplaceRangeToolResult" + 'Edit an existing UTF-8 file using Read anchors of the form "line:hash".', + "Supports replace, delete, insert_before, and insert_after edits; all anchors are verified before writing.", + "All edits apply atomically or nothing is written.", + "Returns changed path plus applied edit count.", ) + SIGNATURE: ClassVar[str] = "EditFile(filepath, [{op,start,end,content}, ...]) -> EditFileToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Single range: ["code.py", [["10", "12", "a1b2c3", "before\\n", "after\\n", "replacement\\n"]]]', - 'Two ranges: ["code.py", [["10", "12", "a1b2c3", "before\\n", "after\\n", "replacement\\n"], ["20", "20", "d4e5f6", "prev\\n", "next\\n", "inserted\\n"]]]', + 'Replace: ["code.py", [{"op":"replace","start":"10:a1b2c3","end":"12:d4e5f6","content":"new lines\\n"}]]', + 'Insert: ["code.py", [{"op":"insert_after","start":"20:abc123","content":"new line\\n"}]]', ) filepath: str = "" - start: int = 0 - end: int = 0 - fingerprint: str = "" - before_context: str = "" - after_context: str = "" - content: str = "" - edits: list[ReplaceRangeEdit] = field(default_factory=list) + edits: list[EditFileEdit] = field(default_factory=list) cwd: str = "" - range_fingerprints: RangeFingerprintStore = field(default_factory=RangeFingerprintStore) @classmethod def cli_args(cls, args: list[str]) -> list[str]: if len(args) == 2: - ranges = _json_list(args[1]) - if ranges: - return [cls.cli_token(args[0]), str(len(ranges)) + " ranges"] + edits = _json_list(args[1]) + if edits: + return [cls.cli_token(args[0]), str(len(edits)) + " edits"] return [cls.cli_token(arg) for arg in args] @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: if len(args) != 2: - raise ToolCallArgError("requires args: filepath, ranges") - ranges = _json_list(args[1]) - if not ranges: - raise ToolCallArgError("ranges cannot be empty") - return cls._from_edits(session, filepath=str(args[0]), edits=[cls._edit_from_args(_json_list(item)) for item in ranges]) + raise ToolCallArgError("requires args: filepath, edits") + edits = _json_list(args[1]) + if not edits: + raise ToolCallArgError("edits cannot be empty") + return cls(filepath=session.resolve_path(str(args[0])), edits=[cls._edit_from_json(item) for item in edits], cwd=session.cwd) @staticmethod - def _edit_from_args(args: list[JsonValue]) -> ReplaceRangeEdit: - if len(args) != 6: - raise ToolCallArgError("range requires exactly 6 args: start, end, fingerprint, before_context, after_context, content") - start, end = _parse_line_range(str(args[0]), str(args[1])) - fingerprint = str(args[2]) - if not fingerprint and (start != 0 or end != 0): - raise ToolCallArgError("fingerprint cannot be empty") - return ReplaceRangeEdit(start=start, end=end, fingerprint=fingerprint, before_context=str(args[3]), after_context=str(args[4]), content=str(args[5])) - - @classmethod - def _from_edits(cls, session: Session, *, filepath: str, edits: list[ReplaceRangeEdit]) -> Self: - first = edits[0] - return cls( - filepath=session.resolve_path(filepath), - start=first.start, - end=first.end, - fingerprint=first.fingerprint, - before_context=first.before_context, - after_context=first.after_context, - content=first.content, - edits=edits, - cwd=session.cwd, - range_fingerprints=session.state.range_fingerprints, - ) + def _edit_from_json(value: JsonValue) -> EditFileEdit: + item = _json_dict(value) + if not item: + raise ToolCallArgError("each edit must be an object") + op = str(item.get("op") or "").strip() + if op not in {"replace", "delete", "insert_before", "insert_after"}: + raise ToolCallArgError("edit op must be replace, delete, insert_before, or insert_after") + start = str(item.get("start") or "").strip() + end = str(item.get("end") or "").strip() + content = str(item.get("content") or "") + if not start: + raise ToolCallArgError("edit start anchor is required") + if op in {"replace", "delete"} and not end: + raise ToolCallArgError("replace/delete edits require end anchor") + if op in {"insert_before", "insert_after"} and end: + raise ToolCallArgError("insert edits use start anchor only") + if op in {"replace", "insert_before", "insert_after"} and "content" not in item: + raise ToolCallArgError("edit content is required") + return EditFileEdit(op=op, start=start, end=end, content=content) def preview(self) -> str: label = self._label() @@ -3131,18 +2717,7 @@ def preview(self) -> str: original, new_content, _ = self._preview() except (OSError, ToolCallError) as error: return label + "\n# preview unavailable: " + str(error) - warning = self._preview_warning() - diff = _make_unified_diff(original, new_content, self.filepath) or label - return (warning + "\n" if warning else "") + diff - - def _preview_warning(self) -> str: - if len(self.edits) != 1: - return "" - if self.start == 0 and self.end == 0 and not os.path.exists(self.filepath): - return "" - if self.end == 0 or self.end - self.start > 20: - return "# warning: broad range replacement; prefer smaller semantic ranges" - return "" + return _make_unified_diff(original, new_content, self.filepath) or label def preview_error(self) -> str: try: @@ -3152,102 +2727,72 @@ def preview_error(self) -> str: return "" def call(self) -> str: - created = not os.path.exists(self.filepath) original, new_content, replacements = self._preview() if new_content == original: - raise ToolCallError("range replacement produced no changes") + raise ToolCallError("edits produced no changes") with open(self.filepath, "w", encoding="utf-8") as f: f.write(new_content) - relpath = os.path.relpath(self.filepath, self.cwd) - if len(replacements) == 1: - resolved, _ = replacements[0] - lines = [ - "", - f"* path: {relpath}", - f"* range: {resolved.start}:{resolved.end}", - f"* fingerprint: {resolved.fingerprint}", - ] - if created: - lines.append("* created: true") - if resolved.relocated_from: - old_start, old_end = resolved.relocated_from - lines.append(f"* relocated_from: {old_start}:{old_end}") - lines.append("") - return "\n".join(lines) - lines = [ - "", + "", f"* path: {relpath}", - f"* replacements: {len(replacements)}", + f"* edits: {len(replacements)}", ] - for index, (resolved, _) in enumerate(replacements, start=1): - lines.append(f"* range[{index}]: {resolved.start}:{resolved.end}") - lines.append(f"* fingerprint[{index}]: {resolved.fingerprint}") - if resolved.relocated_from: - old_start, old_end = resolved.relocated_from - lines.append(f"* relocated_from[{index}]: {old_start}:{old_end}") - lines.append("") + lines.extend(f"* range[{index}]: {start}:{end}" for index, (start, end, _) in enumerate(replacements, start=1)) + lines.append("") return "\n".join(lines) - def _preview(self) -> tuple[str, str, list[tuple[RangeFingerprintStore.Resolved, list[str]]]]: - file_missing = False + def _preview(self) -> tuple[str, str, list[tuple[int, int, list[str]]]]: try: with open(self.filepath, "r", encoding="utf-8") as f: original = f.read() except FileNotFoundError: - file_missing = True - original = "" + raise ToolCallError("file does not exist; use CreateFile for new files") lines = original.splitlines(keepends=True) replacements = [] for edit in self.edits: - if file_missing: - if len(self.edits) != 1 or edit.start != 0 or edit.end != 0 or edit.fingerprint or edit.before_context or edit.after_context: - raise ToolCallError('file does not exist; use ReplaceRange(filepath, [["0", "0", "", "", "", content]]) to create') - resolved = RangeFingerprintStore.Resolved(start=0, end=0, fingerprint=_range_fingerprint("")) + start = self._resolve_anchor(lines, edit.start) + if edit.op in {"replace", "delete"}: + end = self._resolve_anchor(lines, edit.end) + if end < start: + raise ToolCallError("edit end anchor must be at or after start anchor") + slice_start, slice_end = start, end + 1 else: - resolved = self.range_fingerprints.resolve( - lines, - filepath=self.filepath, - start=edit.start, - end=edit.end, - fingerprint=edit.fingerprint, - ) - replacement = self._replacement_lines(edit.content, has_following_line=resolved.end < len(lines)) - self._validate_boundary_context(lines, resolved, edit, replacement) - replacements.append((resolved, replacement)) + slice_start = start if edit.op == "insert_before" else start + 1 + slice_end = slice_start + replacement = [] if edit.op == "delete" else self._replacement_lines(edit.content, has_following_line=slice_end < len(lines)) + replacements.append((slice_start, slice_end, replacement)) self._reject_overlapping_ranges(replacements) new_lines = list(lines) - for resolved, replacement in sorted(replacements, key=lambda item: item[0].start, reverse=True): - new_lines[resolved.start : resolved.end] = replacement + for start, end, replacement in sorted(replacements, key=lambda item: item[0], reverse=True): + new_lines[start:end] = replacement return original, "".join(new_lines), replacements def _label(self) -> str: - if len(self.edits) <= 1: - return f"ReplaceRange({self.filepath}, {self.start}, {self.end}, {self.fingerprint})" - return f"ReplaceRange({self.filepath}, {len(self.edits)} ranges)" + return f"EditFile({self.filepath}, {len(self.edits)} edits)" @staticmethod - def _reject_overlapping_ranges(replacements: list[tuple[RangeFingerprintStore.Resolved, list[str]]]) -> None: - previous: RangeFingerprintStore.Resolved | None = None - for resolved, _ in sorted(replacements, key=lambda item: item[0].start): - if previous is not None and resolved.start < previous.end: - raise ToolCallError(f"range replacements overlap: {previous.start}:{previous.end} and {resolved.start}:{resolved.end}") - previous = resolved + def _resolve_anchor(lines: list[str], anchor: str) -> int: + anchor = anchor.split("|", 1)[0].strip() + match = re.fullmatch(r"(\d+):([0-9a-fA-F]{6})", anchor) + if match is None: + raise ToolCallError('invalid anchor; use "line:hash" copied from Read output') + index = int(match.group(1)) + if index >= len(lines): + raise ToolCallError("anchor line is out of range; Read the target range again") + expected = match.group(2).lower() + current = _line_hash(lines[index]) + if current != expected: + raise ToolCallError(f"stale anchor {anchor}; current hash is {current}; Read the target range again") + return index @staticmethod - def _validate_boundary_context(lines: list[str], resolved: RangeFingerprintStore.Resolved, edit: ReplaceRangeEdit, replacement: list[str]) -> None: - before_context = "" if resolved.start == 0 else lines[resolved.start - 1] - after_context = "" if resolved.end >= len(lines) else lines[resolved.end] - inserting = resolved.start == resolved.end - if edit.before_context != before_context and (edit.before_context or inserting): - raise ToolCallError("before_context mismatch; Read the target range with one line before and retry") - if edit.after_context != after_context and (edit.after_context or inserting): - raise ToolCallError("after_context mismatch; Read the target range with one line after and retry") - if before_context and replacement and replacement[0] == before_context: - raise ToolCallError("content includes before_context; expand start or remove the boundary line from content") - if after_context and replacement and replacement[-1] == after_context: - raise ToolCallError("content includes after_context; expand end or remove the boundary line from content") + def _reject_overlapping_ranges(replacements: list[tuple[int, int, list[str]]]) -> None: + previous: tuple[int, int] | None = None + for start, end, _ in sorted(replacements, key=lambda item: item[0]): + if previous is not None and (start < previous[1] or (start == previous[0] and end == previous[1])): + raise ToolCallError(f"edits overlap or share an insertion point: {previous[0]}:{previous[1]} and {start}:{end}") + previous = (start, end) @staticmethod def _replacement_lines(content: str, *, has_following_line: bool) -> list[str]: @@ -3281,13 +2826,8 @@ class BashTool(Tool): def cli_args(cls, args: list[str]) -> list[str]: if not args: return [] - return [cls._cli_command_arg(args[0])] - - @staticmethod - def _cli_command_arg(value: str) -> str: - if "\n" in value: - return Tool.cli_content_summary(value) - return _shorten(" ".join(value.split()), 120) + command = str(args[0]) + return [Tool.cli_content_summary(command) if "\n" in command else _shorten(" ".join(command.split()), 120)] @classmethod def make(cls, session: Session, args: list[str]) -> Self: @@ -3585,9 +3125,7 @@ def _content(self, item: ToolResultItem) -> str: InspectCodeSymbolTool.NAME: InspectCodeSymbolTool, SearchTool.NAME: SearchTool, CreateFileTool.NAME: CreateFileTool, - EditTool.NAME: EditTool, - PatchFileTool.NAME: PatchFileTool, - ReplaceRangeTool.NAME: ReplaceRangeTool, + EditFileTool.NAME: EditFileTool, BashTool.NAME: BashTool, GitTool.NAME: GitTool, ToolResultTool.NAME: ToolResultTool, @@ -3840,19 +3378,17 @@ def _state_tool_schema(name: str) -> Json: { __discovery_hint__ } Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. -Read line prefixes are display-only; edit text starts immediately after "|". +Read line prefixes are display-only; EditFile anchors use "line:hash"; edit text starts immediately after "|". Stop discovery once the next edit/check is clear. Editing rules: - make one small coherent change per edit action -- new file: create a minimal skeleton first, then grow with focused ReplaceRange chunks +- new file: create a minimal skeleton first, then grow with focused EditFile chunks - existing file: inspect the exact target before editing - never rewrite a large file in one action -- use Edit only for one tiny exact literal block that appears once -- use ReplaceRange after Read for ranges, repeated text, insertions, and structural edits -- use ReplaceRange(filepath, ranges) for several known independent ranges in one file -- use PatchFile for coordinated multi-location edits in one file; copy context exactly and keep patches small +- use EditFile after Read for replacements, deletions, insertions, repeated text, and coordinated multi-location edits +- copy EditFile anchors exactly from Read output; if an anchor is stale, Read the target range again VERIFICATION Verification strength: @@ -3884,7 +3420,7 @@ def _state_tool_schema(name: str) -> Json: Bash is for shell semantics: tests/builds, explicit commands, and fast Unix text-tool pipelines with find, sed, awk, perl, xargs, or grep. Prefer dedicated tools when they give cleaner structured repo access. Mechanical shell edits are allowed; verify afterward with Git diff, Read, tests, or another focused check. -For complex code changes, prefer ReplaceRange or PatchFile over shell rewrites. +For code changes, prefer CreateFile for new files and EditFile for existing files over shell rewrites. Git is for status, diff, history, and changed files. Recall fetches stored result keys; batch distinct keys and recall each needed key at most once. @@ -5239,7 +4775,7 @@ def parse_tool_call(self, value: JsonValue) -> ParsedToolCall: name = _canonical_tool_name(name) intention = _json_str(item.get("intention")) or "" raw_args = _json_list(item.get("args")) - args: list[JsonValue] = list(raw_args) if name == ReplaceRangeTool.NAME else [_json_str(arg) or "" for arg in raw_args] + args: list[JsonValue] = list(raw_args) if name == EditFileTool.NAME else [_json_str(arg) or "" for arg in raw_args] return ParsedToolCall(name=name, intention=intention, args=args) def _invalid_tool_call(self, value: JsonValue) -> ParsedToolCall: @@ -5793,11 +5329,11 @@ class Agent: RECENT_EDITS: ClassVar[int] = 20 RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." RULE_CLOSE_SOURCE: ClassVar[str] = "close or update state that depends on the result before forgetting its source." - RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after edit failures prefer ReplaceRange after Read." + RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after edit failures Read the target range again and use fresh EditFile anchors." RULE_GOAL_PLAN_FIRST: ClassVar[str] = "set goal and a short plan before mutating tools or verify." RULE_VERIFY_DIRECTLY: ClassVar[str] = 'run verification tools, then report verify status="passed"|"failed"|"blocked".' RULE_TOOL_SIGNATURE: ClassVar[str] = "use the tool signature exactly." - RULE_EDIT_SIGNATURE: ClassVar[str] = "use ReplaceRange for read ranges or repeated text, and use the exact tool signature." + RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile with anchors copied from Read output, and use the exact tool signature." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked verification only when blocker=user." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." @@ -6737,7 +6273,7 @@ def keep(action: Json) -> bool: def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: if ( not (self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) - and self._latest_successful_bash_result() + and any(execution.call.name == BashTool.NAME and execution.outcome == "success" for execution in self.tool_runner.latest_executions) and ctx.tool_calls and not ctx.assistant_text and not ctx.has_goal_action @@ -6772,9 +6308,6 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N self._warn_agent("changed Goal without replacing Plan.", "replace Plan when the task scope changes.") return False - def _latest_successful_bash_result(self) -> bool: - return any(execution.call.name == BashTool.NAME and execution.outcome == "success" for execution in self.tool_runner.latest_executions) - def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback | None) -> None: if on_message is not None and self.state_updater.latest_report: report = self.state_updater.compact_report() @@ -7046,8 +6579,6 @@ def run( checkpoint=self.blackboard.memory_checkpoint_tool_result_counter, ) self._prune_tool_result_store() - # Range fingerprints are tied to previously read file content; require a fresh read before later edits. - self.session.state.range_fingerprints.clear() self.mode = AgentMode.ACT self.session.state.turn_tool_calls = 0 self.session.state.turn_model_calls = 0 @@ -8940,28 +8471,6 @@ def _make_unified_diff(old_content: str, new_content: str, filepath: str) -> str ) -TERMINAL_ESCAPE_RE = re.compile(r"\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])") - - -def _plain_command_env() -> dict[str, str]: - env = os.environ.copy() - env.update({"CI": "1", "NO_COLOR": "1", "TERM": "dumb"}) - return env - - -def _clean_terminal_output(text: str) -> str: - lines = [] - for raw_line in TERMINAL_ESCAPE_RE.sub("", text.replace("\r", "\n")).splitlines(): - line = raw_line.rstrip() - if re.search(r"\b\d{1,3}%$", line) and ("█" in line or "░" in line): - continue - if lines and line == lines[-1]: - continue - if line or (lines and lines[-1]): - lines.append(line) - return "\n".join(lines).strip("\n") - - def _format_process_result(tag: str, exit_code: int, stdout: str, stderr: str) -> str: lines = [f"<{tag}>", f"* exit_code: {exit_code}"] if stdout: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 3413275..78786d8 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1,4 +1,5 @@ import os +import re from dataclasses import replace import nanocode @@ -34,6 +35,11 @@ def _set_context_budget(monkeypatch, agent, **overrides): monkeypatch.setitem(nanocode.CONTEXT_BUDGETS, "medium", replace(nanocode.CONTEXT_BUDGETS["medium"], **overrides)) +def _read_anchors(session: Session, filepath: str) -> list[str]: + result = nanocode.ReadTool.make(session, [filepath]).call() + return re.findall(r"^(\d+:[0-9a-f]{6})\|", result, re.MULTILINE) + + def _session( tmp_path, *, @@ -229,11 +235,12 @@ def test_agent_does_not_dedupe_same_batch_edit_tool_calls(tmp_path): path.write_text("old\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) agent = Agent(session) + anchor = _read_anchors(session, "sample.txt")[0] agent.execute_tool_calls( [ - {"name": "Edit", "intention": "first edit", "args": ["sample.txt", "old", "new"]}, - {"name": "Edit", "intention": "second edit", "args": ["sample.txt", "old", "new"]}, + {"name": "EditFile", "intention": "first edit", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, + {"name": "EditFile", "intention": "second edit", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, ], confirm=lambda call, tool: True, ) @@ -623,11 +630,12 @@ def test_planless_successful_bash_allows_tracked_task_before_more_tools(tmp_path def test_edit_tool_without_goal_or_plan_warns(tmp_path): (tmp_path / "sample.txt").write_text("old\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) + anchor = _read_anchors(agent.session, "sample.txt")[0] result = agent.handle_response( { "actions": [ - {"type": "tool", "name": "Edit", "intention": "edit sample", "args": ["sample.txt", "old", "new"]} + {"type": "tool", "name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]} ] }, confirm=lambda call, tool: True, @@ -2514,14 +2522,15 @@ def test_agent_execute_tool_calls_requests_confirmation_for_edit_tools(tmp_path) session = Session(cwd=str(tmp_path)) agent = Agent(session) confirmations = [] + anchor = _read_anchors(session, "sample.txt")[0] latest = agent.execute_tool_calls( - [{"name": "Edit", "intention": "edit sample", "args": ["sample.txt", "old", "new"]}], + [{"name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], confirm=lambda call, tool: confirmations.append((call.executed, tool.preview())) or False, ) assert confirmations - assert confirmations[0][0] == 'Edit("sample.txt", "old", "new")' + assert confirmations[0][0].startswith('EditFile("sample.txt", ') assert "-old" in confirmations[0][1] assert "+new" in confirmations[0][1] assert "Cancelled: user refused" in latest @@ -2533,9 +2542,10 @@ def test_agent_execute_tool_calls_records_refusal_reason(tmp_path): path.write_text("old\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) agent = Agent(session) + anchor = _read_anchors(session, "sample.txt")[0] latest = agent.execute_tool_calls( - [{"name": "Edit", "intention": "edit sample", "args": ["sample.txt", "old", "new"]}], + [{"name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], confirm=lambda call, tool: "please inspect tests first", ) @@ -2552,10 +2562,11 @@ def test_agent_execute_tool_calls_stops_batch_after_refusal(tmp_path): path.write_text("old\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) agent = Agent(session) + anchor = _read_anchors(session, "sample.txt")[0] latest = agent.execute_tool_calls( [ - {"name": "Edit", "intention": "edit sample", "args": ["sample.txt", "old", "new"]}, + {"name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, {"name": "Bash", "intention": "should not run", "args": ["touch should-not-exist"]}, ], confirm=lambda call, tool: "use English question", @@ -2563,7 +2574,7 @@ def test_agent_execute_tool_calls_stops_batch_after_refusal(tmp_path): assert "Cancelled: user refused: use English question" in latest assert "Bash" not in latest - assert [execution.call.name for execution in agent.tool_runner.latest_executions] == ["Edit"] + assert [execution.call.name for execution in agent.tool_runner.latest_executions] == ["EditFile"] assert path.read_text(encoding="utf-8") == "old\n" assert not (tmp_path / "should-not-exist").exists() @@ -2601,12 +2612,12 @@ def test_agent_execute_tool_calls_rejects_failed_preview_before_confirmation(tmp confirmations = [] latest = agent.execute_tool_calls( - [{"name": "ReplaceRange", "intention": "edit stale range", "args": ["sample.txt", [["0", "1", "bad", "", "", "new"]]]}], + [{"name": "EditFile", "intention": "edit stale range", "args": ["sample.txt", [{"op": "replace", "start": "0:abcdef", "end": "0:abcdef", "content": "new\n"}]]}], confirm=lambda call, tool: confirmations.append((call.executed, tool.preview())) or True, ) assert confirmations == [] - assert "ToolCallError: preview unavailable: fingerprint mismatch" in latest + assert "ToolCallError: preview unavailable: stale anchor" in latest assert path.read_text(encoding="utf-8") == "old\n" @@ -2640,11 +2651,11 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) - latest = agent.execute_tool_calls([{"name": "ReplaceRange", "intention": "bad edit", "args": ["sample.txt", "0", "1", "abc", "", ""]}]) + latest = agent.execute_tool_calls([{"name": "EditFile", "intention": "bad edit", "args": ["sample.txt", "0", "1"]}]) - assert "ToolCallError: requires args: filepath, ranges" in latest - assert "got 6 args, expected 2, extra: 4" in agent.agent_feedback_errors[0] - assert "use ReplaceRange for read ranges" in agent.agent_feedback_errors[0] + assert "ToolCallError: requires args: filepath, edits" in latest + assert "got 3 args, expected 2, extra: 1" in agent.agent_feedback_errors[0] + assert "use EditFile with anchors copied from Read output" in agent.agent_feedback_errors[0] def test_tool_arg_error_does_not_force_observe(tmp_path): @@ -2734,16 +2745,17 @@ def test_agent_execute_tool_calls_shows_auto_approval_in_yolo_mode(tmp_path): agent = Agent(session) confirmations = [] auto_approvals = [] + anchor = _read_anchors(session, "sample.txt")[0] latest = agent.execute_tool_calls( - [{"name": "Edit", "intention": "edit sample", "args": ["sample.txt", "old", "new"]}], + [{"name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], confirm=lambda call, tool: confirmations.append(call.executed) or False, on_auto_approve=lambda call, tool: auto_approvals.append((call.executed, tool.preview())), ) assert confirmations == [] assert auto_approvals - assert auto_approvals[0][0] == 'Edit("sample.txt", "old", "new")' + assert auto_approvals[0][0].startswith('EditFile("sample.txt", ') assert "-old" in auto_approvals[0][1] assert "+new" in auto_approvals[0][1] assert latest.startswith("- ok") @@ -2861,9 +2873,10 @@ def test_agent_plan_mode_rejects_mutating_tool_before_execution(tmp_path): agent = Agent(_session(tmp_path, plan_mode=True, debug=True)) _seed_plan(agent, "plan change") messages = [] + anchor = _read_anchors(agent.session, "sample.txt")[0] result = agent.handle_response( - {"actions": [{"type": "tool", "name": "Edit", "intention": "change sample", "args": ["sample.txt", "old", "new"]}]}, + {"actions": [{"type": "tool", "name": "EditFile", "intention": "change sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}]}, confirm=lambda call, tool: True, on_message=messages.append, ) @@ -2871,7 +2884,7 @@ def test_agent_plan_mode_rejects_mutating_tool_before_execution(tmp_path): assert result.done is False assert path.read_text(encoding="utf-8") == "old\n" assert agent.tool_runner.latest_executions == [] - assert messages == ['PlanMode_Gate: plan mode allows readonly discovery only; blocked tool=Edit args=["sample.txt","old","new"].'] + assert messages and messages[0].startswith("PlanMode_Gate: plan mode allows readonly discovery only; blocked tool=EditFile") def test_agent_plan_mode_rejects_invalid_action_instead_of_completing(tmp_path): @@ -2891,16 +2904,25 @@ def test_agent_normalizes_direct_repo_tool_action_type(tmp_path): agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "change sample") messages = [] + anchor = _read_anchors(agent.session, "sample.txt")[0] result = agent.handle_response( - {"actions": [{"type": "Edit", "intention": "change sample", "args": ["sample.txt", "old", "new"]}]}, + { + "actions": [ + { + "type": "EditFile", + "intention": "change sample", + "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]], + } + ] + }, confirm=lambda call, tool: True, on_message=messages.append, ) assert result.done is False assert path.read_text(encoding="utf-8") == "new\n" - assert agent.tool_runner.latest_executions[0].call.name == "Edit" + assert agent.tool_runner.latest_executions[0].call.name == "EditFile" assert not any("Protocol_Gate" in message for message in messages) @@ -2980,6 +3002,8 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): def test_agent_run_executes_edit_tool_and_requires_verification(tmp_path): (tmp_path / "sample.txt").write_text("old\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + anchor = _read_anchors(session, "sample.txt")[0] class FakeModelClient: def __init__(self): @@ -2990,9 +3014,9 @@ def __init__(self): {"type": "goal", "text": "change sample", "complete": False}, { "type": "tool", - "name": "Edit", + "name": "EditFile", "intention": "change sample text", - "args": ["sample.txt", "old", "new"], + "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]], }, ] }, @@ -3004,7 +3028,6 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return self.responses.pop(0) - session = Session(cwd=str(tmp_path)) agent = Agent(session) _seed_plan(agent, "change sample") agent.model_client = FakeModelClient() @@ -3013,7 +3036,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): response = agent.run("change sample", confirm=lambda call, tool: True, on_message=messages.append) assert response["actions"][-1]["message_for_complete"] == "done" - assert any(message.startswith("[success] Edit sample.txt") for message in messages) + assert any(message.startswith("[success] EditFile sample.txt 1 edits") for message in messages) assert not any(message.startswith("State Updated") for message in messages) assert any("edited files need verification before completion" in error for error in agent.agent_feedback_errors) assert (tmp_path / "sample.txt").read_text(encoding="utf-8") == "new\n" diff --git a/tests/test_nanocode_edit_file_tool.py b/tests/test_nanocode_edit_file_tool.py new file mode 100644 index 0000000..af934be --- /dev/null +++ b/tests/test_nanocode_edit_file_tool.py @@ -0,0 +1,153 @@ +import re + +import pytest + +from nanocode import Agent, EditFileTool, ReadTool, Session, ToolCallError + + +def _anchors(read_result: str) -> list[str]: + return re.findall(r"^(\d+:[0-9a-f]{6})\|", read_result, re.MULTILINE) + + +def _read_anchors(session: Session, filepath: str, range_token: str = "0,0") -> list[str]: + args = [filepath] if range_token == "0,0" else [filepath, range_token] + return _anchors(ReadTool.make(session, args).call()) + + +def test_edit_file_replaces_range_from_read_anchors(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + anchors = _read_anchors(session, "sample.txt") + + tool = EditFileTool.make(session, ["sample.txt", [{"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}]]) + display = tool.preview() + result = tool.call() + + assert tool.requires_confirmation(session) is True + assert "-beta\n" in display + assert "+BETA\n" in display + assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" + assert result == "\n".join( + [ + "", + "* path: sample.txt", + "* edits: 1", + "* range[1]: 1:2", + "", + ] + ) + + +def test_edit_file_accepts_full_hashline_anchor(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + read_result = ReadTool.make(session, ["sample.txt"]).call() + full_hashline = next(line for line in read_result.splitlines() if line.endswith("|beta")) + + EditFileTool.make(session, ["sample.txt", [{"op": "replace", "start": full_hashline, "end": full_hashline, "content": "BETA\n"}]]).call() + + assert path.read_text(encoding="utf-8") == "alpha\nBETA\n" + + +def test_edit_file_inserts_and_deletes_atomically(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\ndelta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + anchors = _read_anchors(session, "sample.txt") + + result = EditFileTool.make( + session, + [ + "sample.txt", + [ + {"op": "insert_after", "start": anchors[0], "content": "inserted\n"}, + {"op": "delete", "start": anchors[2], "end": anchors[2], "content": ""}, + {"op": "replace", "start": anchors[3], "end": anchors[3], "content": "DELTA\n"}, + ], + ], + ).call() + + assert "* edits: 3" in result + assert path.read_text(encoding="utf-8") == "alpha\ninserted\nbeta\nDELTA\n" + + +def test_edit_file_rejects_stale_anchor_without_writing(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + anchors = _read_anchors(session, "sample.txt") + path.write_text("alpha\nchanged\n", encoding="utf-8") + + tool = EditFileTool.make(session, ["sample.txt", [{"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}]]) + + assert "stale anchor" in tool.preview() + with pytest.raises(ToolCallError, match="stale anchor"): + tool.call() + assert path.read_text(encoding="utf-8") == "alpha\nchanged\n" + + +def test_edit_file_rejects_overlapping_edits_without_writing(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + anchors = _read_anchors(session, "sample.txt") + + tool = EditFileTool.make( + session, + [ + "sample.txt", + [ + {"op": "replace", "start": anchors[0], "end": anchors[1], "content": "AB\n"}, + {"op": "replace", "start": anchors[1], "end": anchors[2], "content": "BG\n"}, + ], + ], + ) + + with pytest.raises(ToolCallError, match="overlap"): + tool.call() + assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" + + +def test_edit_file_rejects_missing_files(tmp_path): + session = Session(cwd=str(tmp_path)) + tool = EditFileTool.make(session, ["missing.txt", [{"op": "insert_after", "start": "0:abcdef", "content": "alpha\n"}]]) + + assert "use CreateFile" in tool.preview() + with pytest.raises(ToolCallError, match="use CreateFile"): + tool.call() + + +def test_edit_file_rejects_wrong_arg_shape(tmp_path): + session = Session(cwd=str(tmp_path)) + + with pytest.raises(ToolCallError, match="requires args: filepath, edits"): + EditFileTool.make(session, []) + with pytest.raises(ToolCallError, match="edits cannot be empty"): + EditFileTool.make(session, ["sample.txt", []]) + with pytest.raises(ToolCallError, match="edit op must be"): + EditFileTool.make(session, ["sample.txt", [{"op": "move", "start": "0:abcdef"}]]) + + +def test_agent_executes_edit_file_with_structured_args(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + anchors = _read_anchors(session, "sample.txt") + agent = Agent(session) + + latest = agent.execute_tool_calls( + [ + { + "name": "EditFile", + "intention": "replace beta", + "args": ["sample.txt", [{"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}]], + } + ], + confirm=lambda call, tool: True, + ) + + assert path.read_text(encoding="utf-8") == "alpha\nBETA\n" + assert "" in latest + assert agent.blackboard.verification_required is True diff --git a/tests/test_nanocode_edit_tool.py b/tests/test_nanocode_edit_tool.py deleted file mode 100644 index e709328..0000000 --- a/tests/test_nanocode_edit_tool.py +++ /dev/null @@ -1,129 +0,0 @@ -import pytest - -from nanocode import EditTool, Session, ToolCallError - - -def test_edit_tool_replaces_unique_exact_match(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = EditTool.make(session, ["sample.txt", "beta", "BETA"]) - display = tool.preview() - result = tool.call() - - assert tool.requires_confirmation(session) is True - assert "-beta\n" in display - assert "+BETA\n" in display - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - assert result == "\n".join( - [ - "", - "* path: sample.txt", - "* replacements: 1", - "", - ] - ) - - -def test_edit_tool_rejects_repeated_find_text(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\nbeta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = EditTool.make(session, ["sample.txt", "beta", "BETA"]) - - assert 'pass "all"' in tool.preview() - with pytest.raises(ToolCallError, match="matched multiple times"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\nbeta\nbeta\n" - - -def test_edit_tool_replaces_all_exact_matches_when_requested(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\nbeta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = EditTool.make(session, ["sample.txt", "beta", "BETA", "all"]) - display = tool.preview() - result = tool.call() - - assert display.count("-beta") == 2 - assert display.count("+BETA") == 2 - assert path.read_text(encoding="utf-8") == "alpha\nBETA\nBETA\n" - assert result == "\n".join( - [ - "", - "* path: sample.txt", - "* replacements: 2", - "", - ] - ) - - -def test_edit_tool_raises_when_find_text_is_missing(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = EditTool.make(session, ["sample.txt", "missing", "replacement"]) - - with pytest.raises(ToolCallError, match="target `find` text not found"): - tool.call() - - -def test_edit_tool_creates_missing_file_with_empty_find(tmp_path): - path = tmp_path / "created.txt" - session = Session(cwd=str(tmp_path)) - - tool = EditTool.make(session, ["created.txt", "", "alpha\n"]) - display = tool.preview() - result = tool.call() - - assert "+alpha\n" in display - assert path.read_text(encoding="utf-8") == "alpha\n" - assert result == "\n".join( - [ - "", - "* path: created.txt", - "* created: true", - "", - ] - ) - - -def test_edit_tool_rejects_wrong_arg_count_with_actionable_error(tmp_path): - session = Session(cwd=str(tmp_path)) - - with pytest.raises(ToolCallError, match=r'Edit args error: got 0 args; expected \["filepath", "find", "replace", optional "all"\]'): - EditTool.make(session, []) - - -def test_edit_tool_rejects_invalid_fourth_arg(tmp_path): - session = Session(cwd=str(tmp_path)) - - with pytest.raises(ToolCallError, match='fourth arg must be exactly "all"'): - EditTool.make(session, ["sample.txt", "beta", "BETA", "first"]) - - -def test_edit_tool_rejects_empty_find_text_for_existing_file(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = EditTool.make(session, ["sample.txt", "", "replacement"]) - - assert "empty find creates missing files only" in tool.preview() - with pytest.raises(ToolCallError, match="empty find creates missing files only"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\n" - - -def test_edit_tool_display_falls_back_when_find_text_is_missing(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = EditTool.make(session, ["sample.txt", "missing", "replacement"]) - - assert tool.preview() == f'Edit({path}, find="missing")' diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index cf770eb..0467c34 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -354,12 +354,12 @@ def preview(self): outputs = [] loop = AgentLoop(FakeAgent(), output_fn=outputs.append) - call = ParsedToolCall(name="Edit", intention="edit sample", args=["sample.txt", "old", "new"]) + call = ParsedToolCall(name="EditFile", intention="edit sample", args=["sample.txt", [{"op": "replace", "start": "0:abcdef", "end": "0:abcdef", "content": "new\n"}]]) loop._show_auto_tool_call(call, FakeTool()) assert any("Auto Tool Call | auto approved" in output for output in outputs) - assert any('Run Edit("sample.txt", "old", "new")' in output for output in outputs) + assert any('Run EditFile("sample.txt", ' in output for output in outputs) assert any("Why edit sample" in output for output in outputs) assert any("Preview\npreview" in output for output in outputs) diff --git a/tests/test_nanocode_patch_file_tool.py b/tests/test_nanocode_patch_file_tool.py deleted file mode 100644 index 713d36c..0000000 --- a/tests/test_nanocode_patch_file_tool.py +++ /dev/null @@ -1,163 +0,0 @@ -import pytest - -from nanocode import Agent, PatchFileTool, Session, ToolCallError - - -def test_patch_file_tool_applies_single_hunk(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = PatchFileTool.make(session, ["sample.txt", "@@\n alpha\n-beta\n+BETA\n gamma\n"]) - display = tool.preview() - result = tool.call() - - assert tool.requires_confirmation(session) is True - assert "-beta\n" in display - assert "+BETA\n" in display - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - assert result == "\n".join( - [ - "", - "* path: sample.txt", - "* hunks: 1", - "", - ] - ) - - -def test_patch_file_tool_accepts_common_diff_headers(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - patch = """diff --git a/sample.txt b/sample.txt -index 1111111..2222222 100644 ---- a/sample.txt -+++ b/sample.txt -@@ -1,3 +1,3 @@ - alpha --beta -+BETA - gamma -""" - - PatchFileTool.make(session, ["sample.txt", patch]).call() - - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - - -def test_patch_file_tool_applies_multiple_hunks_atomically(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\ndelta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - PatchFileTool.make( - session, - [ - "sample.txt", - "@@\n alpha\n-beta\n+BETA\n gamma\n@@\n gamma\n-delta\n+DELTA\n", - ], - ).call() - - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\nDELTA\n" - - -def test_patch_file_tool_ignores_duplicate_empty_hunk_markers(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - PatchFileTool.make(session, ["sample.txt", "@@\n@@\n alpha\n-beta\n+BETA\n gamma\n"]).call() - - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - - -def test_patch_file_tool_accepts_indented_context_without_extra_marker(tmp_path): - path = tmp_path / "sample.py" - path.write_text("def run():\n while True:\n if done:\n return 0\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - PatchFileTool.make( - session, - [ - "sample.py", - '@@\n while True:\n if done:\n+ print("done")\n return 0\n', - ], - ).call() - - assert path.read_text(encoding="utf-8") == 'def run():\n while True:\n if done:\n print("done")\n return 0\n' - - -def test_patch_file_tool_rejects_context_mismatch_without_writing(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = PatchFileTool.make(session, ["sample.txt", "@@\n alpha\n-missing\n+MISSING\n gamma\n"]) - - assert "hunk 1 context did not match" in tool.preview() - assert "first old line: 'alpha'" in tool.preview() - with pytest.raises(ToolCallError, match="hunk 1 context did not match"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" - - -def test_patch_file_tool_rejects_ambiguous_context_without_writing(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\nalpha\nbeta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = PatchFileTool.make(session, ["sample.txt", "@@\n alpha\n-beta\n+BETA\n"]) - - with pytest.raises(ToolCallError, match="matched multiple locations"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\nbeta\nalpha\nbeta\n" - - -def test_patch_file_tool_rejects_overlapping_hunks_without_writing(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = PatchFileTool.make( - session, - [ - "sample.txt", - "@@\n alpha\n-beta\n+BETA\n@@\n-beta\n-gamma\n+GAMMA\n", - ], - ) - - with pytest.raises(ToolCallError, match="overlap"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" - - -def test_patch_file_tool_rejects_malformed_patch(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - with pytest.raises(ToolCallError, match="patch content before first hunk"): - PatchFileTool.make(session, ["sample.txt", "alpha\n"]).call() - - -def test_agent_executes_patch_file_and_requires_verification(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - agent = Agent(session) - - latest = agent.execute_tool_calls( - [ - { - "name": "PatchFile", - "intention": "patch sample", - "args": ["sample.txt", "@@\n alpha\n-beta\n+BETA\n gamma\n"], - } - ], - confirm=lambda call, tool: True, - ) - - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - assert "" in latest - assert agent.blackboard.verification_required is True diff --git a/tests/test_nanocode_read_tool.py b/tests/test_nanocode_read_tool.py index 241c918..ed5063d 100644 --- a/tests/test_nanocode_read_tool.py +++ b/tests/test_nanocode_read_tool.py @@ -4,6 +4,10 @@ from nanocode import ReadTool, Session, ToolCallError +def _hashline(index: int, text: str) -> str: + return f"{index}:{nanocode._line_hash(text)}|{text}" + + def test_read_tool_reads_requested_line_range(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") @@ -15,10 +19,10 @@ def test_read_tool_reads_requested_line_range(tmp_path): assert tool.requires_confirmation(session) is False assert result.startswith("") assert "1:3" in result - assert "" in result - assert "" in result - assert " 1 |beta\n 2 |gamma\n" in result - assert " 0 |alpha" not in result + assert "" not in result + assert "" in result + assert _hashline(1, "beta\n") + _hashline(2, "gamma\n") in result + assert "|alpha" not in result def test_read_tool_rejects_empty_args_with_actionable_error(tmp_path): @@ -49,10 +53,10 @@ def test_read_tool_reads_multiple_line_range_tokens(tmp_path): assert "1:2, 3:5" in tool.preview() assert "1:2" in result assert "3:5" in result - assert " 1 |one\n" in result - assert " 3 |three\n 4 |four\n" in result - assert " 0 |zero" not in result - assert " 2 |two" not in result + assert _hashline(1, "one\n") in result + assert _hashline(3, "three\n") + _hashline(4, "four\n") in result + assert "|zero" not in result + assert "|two" not in result def test_read_tool_reads_colon_and_comma_range_tokens(tmp_path): @@ -67,10 +71,10 @@ def test_read_tool_reads_colon_and_comma_range_tokens(tmp_path): assert "1:2, 3:5" in tool.preview() assert "1:2" in result assert "3:5" in result - assert " 1 |one\n" in result - assert " 3 |three\n 4 |four\n" in result - assert " 0 |zero" not in result - assert " 2 |two" not in result + assert _hashline(1, "one\n") in result + assert _hashline(3, "three\n") + _hashline(4, "four\n") in result + assert "|zero" not in result + assert "|two" not in result def test_read_tool_reads_to_eof_when_end_is_zero(tmp_path): @@ -80,8 +84,8 @@ def test_read_tool_reads_to_eof_when_end_is_zero(tmp_path): result = ReadTool.make(session, ["sample.txt", "1,0"]).call() - assert " 1 |beta\n 2 |gamma\n" in result - assert " 0 |alpha" not in result + assert _hashline(1, "beta\n") + _hashline(2, "gamma\n") in result + assert "|alpha" not in result def test_read_tool_allows_omitted_range_for_full_file_read(tmp_path): @@ -95,7 +99,7 @@ def test_read_tool_allows_omitted_range_for_full_file_read(tmp_path): assert tool.start == 0 assert tool.end == 0 assert "0:0" in result - assert " 0 |alpha\n 1 |beta\n" in result + assert _hashline(0, "alpha\n") + _hashline(1, "beta\n") in result def test_read_tool_reads_range_token_when_numeric_filenames_exist(tmp_path): @@ -109,7 +113,7 @@ def test_read_tool_reads_range_token_when_numeric_filenames_exist(tmp_path): assert tool.ranges == [(1, 3)] assert "1:3" in result - assert " 1 |one\n 2 |two\n" in result + assert _hashline(1, "one\n") + _hashline(2, "two\n") in result assert "numeric filename" not in result @@ -125,8 +129,8 @@ def test_read_tool_truncates_full_file_reads_after_600_lines(tmp_path): assert "605" in result assert "Read returned 600 lines from 0:600 of 605 total lines" in result assert "Use Search to locate relevant text or Read smaller ranges in batches." in result - assert " 599 |line-0599\n" in result - assert " 600 |line-0600\n" not in result + assert _hashline(599, "line-0599\n") in result + assert "|line-0600" not in result def test_read_tool_truncates_large_bounded_ranges_after_600_lines(tmp_path): @@ -140,8 +144,8 @@ def test_read_tool_truncates_large_bounded_ranges_after_600_lines(tmp_path): assert "true" in result assert "700" in result assert "Read returned 600 lines from 10:610 of 700 total lines" in result - assert " 609 |line-0609\n" in result - assert " 610 |line-0610\n" not in result + assert _hashline(609, "line-0609\n") in result + assert "|line-0610" not in result def test_read_tool_bounded_read_stops_at_end(tmp_path, monkeypatch): @@ -174,7 +178,7 @@ def tracking_open(*args, **kwargs): result = ReadTool.make(session, ["sample.txt", "1,3"]).call() - assert " 1 |one\n 2 |two\n" in result + assert _hashline(1, "one\n") + _hashline(2, "two\n") in result assert "three" not in result assert lines_read == ["zero\n", "one\n", "two\n"] @@ -187,7 +191,7 @@ def test_read_tool_clamps_out_of_bounds_range(tmp_path): result = ReadTool.make(session, ["sample.txt", "10,20"]).call() assert "alpha" not in result - assert " \n\n " in result + assert " \n\n " in result def test_read_tool_rejects_non_integer_range(tmp_path): diff --git a/tests/test_nanocode_replace_range_tool.py b/tests/test_nanocode_replace_range_tool.py deleted file mode 100644 index 3d8b159..0000000 --- a/tests/test_nanocode_replace_range_tool.py +++ /dev/null @@ -1,389 +0,0 @@ -import pytest - -from nanocode import Agent, RangeFingerprintStore, ReadTool, ReplaceRangeTool, Session, ToolCallError - - -def _fingerprint(read_result: str) -> str: - return read_result.split("", 1)[1].split("", 1)[0] - - -def _replace_args(filepath: str, start: int, end: int, fingerprint: str, before: str, after: str, content: str) -> list[object]: - return [filepath, [[str(start), str(end), fingerprint, before, after, content]]] - - -def test_replace_range_tool_replaces_range_when_fingerprint_matches(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\n")) - display = tool.preview() - result = tool.call() - - assert ReplaceRangeTool.NAME == "ReplaceRange" - assert tool.requires_confirmation(session) is True - assert display.startswith("--- ") - assert "-beta\n" in display - assert "+BETA\n" in display - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - assert result == "\n".join( - [ - "", - "* path: sample.txt", - "* range: 1:2", - f"* fingerprint: {fingerprint}", - "", - ] - ) - - -def test_replace_range_tool_rejects_before_context_mismatch(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "wrong\n", "gamma\n", "BETA\n")) - - assert "# preview unavailable: before_context mismatch" in tool.preview() - with pytest.raises(ToolCallError, match="before_context mismatch"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" - - -def test_replace_range_tool_rejects_after_context_mismatch(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "wrong\n", "BETA\n")) - - assert "# preview unavailable: after_context mismatch" in tool.preview() - with pytest.raises(ToolCallError, match="after_context mismatch"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" - - -def test_replace_range_tool_allows_empty_boundary_context_for_non_empty_range(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - - ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "", "", "BETA\n")).call() - - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - - -def test_replace_range_tool_rejects_content_that_repeats_boundary_context(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - - before_tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "alpha\nBETA\n")) - after_tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\ngamma\n")) - - assert "# preview unavailable: content includes before_context" in before_tool.preview() - assert "# preview unavailable: content includes after_context" in after_tool.preview() - - -def test_replace_range_tool_creates_missing_file_with_empty_zero_range(tmp_path): - path = tmp_path / "created.txt" - session = Session(cwd=str(tmp_path)) - - tool = ReplaceRangeTool.make(session, _replace_args("created.txt", 0, 0, "", "", "", "alpha\n")) - display = tool.preview() - result = tool.call() - - assert "+alpha\n" in display - assert path.read_text(encoding="utf-8") == "alpha\n" - assert result == "\n".join( - [ - "", - "* path: created.txt", - "* range: 0:0", - f"* fingerprint: {RangeFingerprintStore().remember(filepath=str(path), start=0, end=0, content='')}", - "* created: true", - "", - ] - ) - - -def test_replace_range_tool_warns_for_broad_preview_ranges(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("".join("line " + str(index) + "\n" for index in range(25)), encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "0,25"]).call()) - - display = ReplaceRangeTool.make(session, _replace_args("sample.txt", 0, 25, fingerprint, "", "", "replacement\n")).preview() - - assert display.startswith("# warning: broad range replacement; prefer smaller semantic ranges\n--- ") - - -def test_replace_range_tool_accepts_public_batch_ranges(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\ndelta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - beta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - delta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "3,4"]).call()) - - result = ReplaceRangeTool.make( - session, - [ - "sample.txt", - [ - ["1", "2", beta_fingerprint, "alpha\n", "gamma\n", "BETA\n"], - ["3", "4", delta_fingerprint, "gamma\n", "", "DELTA\n"], - ], - ], - ).call() - - assert "* replacements: 2" in result - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\nDELTA\n" - - -def test_agent_executes_replace_range_batch_args(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\ndelta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - beta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - delta_fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "3,4"]).call()) - agent = Agent(session) - - latest = agent.execute_tool_calls( - [ - { - "name": "ReplaceRange", - "intention": "replace two ranges", - "args": [ - "sample.txt", - [ - ["1", "2", beta_fingerprint, "alpha\n", "gamma\n", "BETA\n"], - ["3", "4", delta_fingerprint, "gamma\n", "", "DELTA\n"], - ], - ], - }, - ], - confirm=lambda call, tool: True, - ) - - assert "* replacements: 2" in latest - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\nDELTA\n" - - -def test_replace_range_tool_adds_line_break_before_following_content(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - - ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA")).call() - - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - - -def test_replace_range_tool_relocates_cached_fingerprint_after_line_shift(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "2,3"]).call()) - path.write_text("zero\nalpha\nbeta\ngamma\n", encoding="utf-8") - - result = ReplaceRangeTool.make(session, _replace_args("sample.txt", 2, 3, fingerprint, "beta\n", "", "GAMMA\n")).call() - - assert path.read_text(encoding="utf-8") == "zero\nalpha\nbeta\nGAMMA\n" - assert "* range: 3:4" in result - assert "* relocated_from: 2:3" in result - - -def test_replace_range_tool_rejects_ambiguous_cached_relocation(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - path.write_text("zero\nalpha\nbeta\nbeta\ngamma\n", encoding="utf-8") - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\n")) - - with pytest.raises(ToolCallError, match="cached range matched multiple locations"): - tool.call() - assert path.read_text(encoding="utf-8") == "zero\nalpha\nbeta\nbeta\ngamma\n" - - -def test_replace_range_tool_accepts_full_file_fingerprint_for_partial_range(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt"]).call()) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\n")) - display = tool.preview() - result = tool.call() - - assert display.startswith("--- ") - assert "# preview unavailable" not in display - assert "-beta\n" in display - assert "+BETA\n" in display - assert "* range: 1:2" in result - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - - -def test_replace_range_tool_reports_fingerprint_cached_range(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "0,3"]).call()) - path.write_text("alpha\nBETA\ngamma\n", encoding="utf-8") - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\n")) - - display = tool.preview() - assert "this fingerprint was cached for range(s): 0:3" in display - with pytest.raises(ToolCallError, match=r"cached for range\(s\): 0:3"): - tool.call() - - -def test_replace_range_tool_rejects_fingerprint_mismatch(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, "bad", "alpha\n", "", "BETA\n")) - - display = tool.preview() - - assert display.startswith("ReplaceRange(") - assert "# preview unavailable: fingerprint mismatch" in display - assert "current " in display - assert "call Read(filepath, 1, 2)" in display - with pytest.raises(ToolCallError, match=r"call Read\(filepath, 1, 2\)"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\nbeta\n" - - -def test_replace_range_cache_is_bounded(tmp_path): - session = Session(cwd=str(tmp_path)) - store = session.state.range_fingerprints - - for index in range(RangeFingerprintStore.MAX_ENTRIES + 5): - store.remember(filepath=str(tmp_path / "sample.txt"), start=index, end=index + 1, content="line " + str(index)) - - assert len(store) == RangeFingerprintStore.MAX_ENTRIES - - -def test_replace_range_cache_survives_goal_rewording(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - - Agent(session).apply_response({"actions": [{"type": "goal", "text": "new goal"}]}) - - ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "gamma\n", "BETA\n")).call() - - assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" - - -def test_replace_range_cache_survives_cancel_until_next_run(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - agent = Agent(session) - - agent.cancel_current_goal() - - assert len(session.state.range_fingerprints) == 1 - - class FakeModelClient: - def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): - return {"actions": [], "_assistant_text": "done"} - - agent.model_client = FakeModelClient() - agent.run("next task") - - assert len(session.state.range_fingerprints) == 0 - - -def test_replace_range_cache_clears_when_new_main_run_starts(tmp_path): - class FakeModelClient: - def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): - return {"actions": [], "_assistant_text": "done"} - - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - agent = Agent(session) - agent.model_client = FakeModelClient() - - agent.run("new task") - - assert len(session.state.range_fingerprints) == 0 - - -def test_replace_range_tool_replaces_to_eof_when_end_is_zero(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,0"]).call()) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 0, fingerprint, "alpha\n", "", "tail\n")) - result = tool.call() - - assert path.read_text(encoding="utf-8") == "alpha\ntail\n" - assert "* range: 1:3" in result - - -def test_replace_range_tool_inserts_when_start_equals_end(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,1"]).call()) - - ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 1, fingerprint, "alpha\n", "gamma\n", "beta\n")).call() - - assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n" - - -def test_replace_range_tool_requires_boundary_context_for_insert_range(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,1"]).call()) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 1, fingerprint, "", "", "beta\n")) - - assert "# preview unavailable: before_context mismatch" in tool.preview() - with pytest.raises(ToolCallError, match="before_context mismatch"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\ngamma\n" - - -def test_replace_range_tool_accepts_wide_fingerprint_for_empty_insert_range_with_context(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt"]).call()) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 1, fingerprint, "alpha\n", "beta\n", "INSERT\n")) - result = tool.call() - - assert "* range: 1:1" in result - assert path.read_text(encoding="utf-8") == "alpha\nINSERT\nbeta\ngamma\n" - - -def test_replace_range_tool_rejects_no_change(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("alpha\nbeta\n", encoding="utf-8") - session = Session(cwd=str(tmp_path)) - fingerprint = _fingerprint(ReadTool.make(session, ["sample.txt", "1,2"]).call()) - - tool = ReplaceRangeTool.make(session, _replace_args("sample.txt", 1, 2, fingerprint, "alpha\n", "", "beta\n")) - - with pytest.raises(ToolCallError, match="range replacement produced no changes"): - tool.call() - assert path.read_text(encoding="utf-8") == "alpha\nbeta\n" diff --git a/tests/test_nanocode_search_tool.py b/tests/test_nanocode_search_tool.py index a7b43ac..cebd0ef 100644 --- a/tests/test_nanocode_search_tool.py +++ b/tests/test_nanocode_search_tool.py @@ -40,23 +40,23 @@ def test_search_tool_rejects_many_plain_args_without_explicit_path(tmp_path): session = Session(cwd=str(tmp_path)) with pytest.raises(ToolCallError, match="requires 1 to 4 args"): - SearchTool.make(session, ["class Edit", "class Bash", "class Search", "class Read", "class ReplaceRange"]) + SearchTool.make(session, ["class EditFile", "class Bash", "class Search", "class Read", "class CreateFile"]) def test_search_tool_treats_second_plain_arg_as_path(tmp_path): path = tmp_path / "sample.py" - path.write_text("class EditTool:\nclass BashTool:\n", encoding="utf-8") + path.write_text("class EditFileTool:\nclass BashTool:\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = SearchTool.make(session, ["class Edit|class Bash", "sample.py"]) + tool = SearchTool.make(session, ["class EditFile|class Bash", "sample.py"]) - assert tool.pattern == "class Edit|class Bash" + assert tool.pattern == "class EditFile|class Bash" assert tool.target_path == str(path) def test_search_tool_accepts_explicit_path_option_with_regex_and_context(tmp_path, monkeypatch): path = tmp_path / "nanocode.py" - path.write_text("class EditTool:\nclass BashTool:\n", encoding="utf-8") + path.write_text("class EditFileTool:\nclass BashTool:\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") @@ -65,16 +65,16 @@ def test_search_tool_accepts_explicit_path_option_with_regex_and_context(tmp_pat assert tool.target_path == str(path) assert tool.context_lines == 0 - assert "* nanocode.py:1: class EditTool:" in result + assert "* nanocode.py:1: class EditFileTool:" in result assert "* nanocode.py:2: class BashTool:" in result def test_search_tool_accepts_explicit_path_option_as_second_arg(tmp_path): path = tmp_path / "nanocode.py" - path.write_text("class EditTool:\nclass BashTool:\n", encoding="utf-8") + path.write_text("class EditFileTool:\nclass BashTool:\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = SearchTool.make(session, ["class Edit", "path=nanocode.py"]) + tool = SearchTool.make(session, ["class EditFile", "path=nanocode.py"]) assert tool.target_path == str(path) assert tool.context_lines == SearchTool.CONTEXT_LINES @@ -82,12 +82,12 @@ def test_search_tool_accepts_explicit_path_option_as_second_arg(tmp_path): def test_search_tool_accepts_explicit_path_option_with_multiple_terms(tmp_path): path = tmp_path / "nanocode.py" - path.write_text("class EditTool:\nclass BashTool:\n", encoding="utf-8") + path.write_text("class EditFileTool:\nclass BashTool:\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = SearchTool.make(session, ["class Edit", "class Bash", "path=nanocode.py"]) + tool = SearchTool.make(session, ["class EditFile", "class Bash", "path=nanocode.py"]) - assert tool.pattern == "class Edit|class Bash" + assert tool.pattern == "class EditFile|class Bash" assert tool.target_path == str(path) From 0b2b9b5142170b9eb653b45fc976da4e357b92de Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 03:52:10 -0700 Subject: [PATCH 090/144] Improve Search anchors and EditFile guidance --- README.md | 2 + nanocode.py | 77 ++++++++++++++++++++++++------ tests/test_nanocode_agent.py | 13 ++++- tests/test_nanocode_search_tool.py | 68 ++++++++++++++++---------- 4 files changed, 117 insertions(+), 43 deletions(-) diff --git a/README.md b/README.md index 31d8503..f9513c8 100644 --- a/README.md +++ b/README.md @@ -85,6 +85,8 @@ nanocode currently targets macOS and Linux. Windows is not supported. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. +`Search` and `Read` both return 0-based `line:hash|code` anchors for `EditFile`. For broad mechanical text replacement, shell text pipelines are acceptable when followed by a focused diff or test. + ## Commands - Info: `/help [question]`, `/status`, `/rules`, `/compact`. diff --git a/nanocode.py b/nanocode.py index fae7800..311da79 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1601,7 +1601,15 @@ def _line_hash(content: str) -> str: def _numbered_content(content: str, start: int) -> str: - return "".join(f"{start + index}:{_line_hash(line)}|{line}" for index, line in enumerate(content.splitlines(keepends=True))) + return "".join(_numbered_line(start + index, line) for index, line in enumerate(content.splitlines(keepends=True))) + + +def _numbered_line(index: int, line: str) -> str: + return f"{index}:{_line_hash(line)}|{line}" + + +def _numbered_line_preview(index: int, line: str, max_chars: int = 300) -> str: + return f"{index}:{_line_hash(line)}|{line.removesuffix(chr(10))[:max_chars]}" def _parse_line_range_token(value: str) -> tuple[int, int]: @@ -1860,7 +1868,7 @@ class SearchTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Case-insensitive regex search before Read; use A|B|C for alternatives and \\n for multiline matches.", - "Returns matching file paths, 0-based line numbers, matched lines, and requested context lines.", + 'Returns matching file paths, matched lines, and 0-based context lines as "line:hash|code" anchors usable by EditFile.', "For exact text, escape regex metacharacters like braces, parens, dots, stars, and brackets.", "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py, set context=N for 0..30 lines; omitted path defaults to current directory.", "Second positional arg is always path, third positional arg is always glob; with path=, extra leading positional args are joined as regex alternatives.", @@ -2068,7 +2076,7 @@ def _read_match_context(self, path: str, line_number: int) -> list[tuple[int, st if lineno > end: break if lineno >= start: - context.append((lineno, line.rstrip("\n")[:300])) + context.append((lineno - 1, line)) except OSError: return [] return context @@ -2076,12 +2084,14 @@ def _read_match_context(self, path: str, line_number: int) -> list[tuple[int, st def _format_result(self, engine: str, matches: list[Match], truncated: bool) -> str: lines = [""] lines.append(f"* engine: {engine}") + if matches: + lines.append('Context lines are 0-based "line:hash|code"; use "line:hash" as EditFile anchors.') if matches: for match in matches: lines.append(f"* {self._relpath(match.path)}:{match.line_number}: {match.text}") - for lineno, text in match.context: - marker = ">" if lineno == match.line_number else " " - lines.append(f" {marker} {lineno}: {text}") + for index, line in match.context: + marker = ">" if index == match.line_number - 1 else " " + lines.append(f" {marker} {_numbered_line_preview(index, line)}") else: lines.append("No matches.") if truncated: @@ -2658,7 +2668,7 @@ class EditFileTool(Tool): PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "edits") EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - 'Edit an existing UTF-8 file using Read anchors of the form "line:hash".', + 'Edit an existing UTF-8 file using Search or Read anchors of the form "line:hash".', "Supports replace, delete, insert_before, and insert_after edits; all anchors are verified before writing.", "All edits apply atomically or nothing is written.", "Returns changed path plus applied edit count.", @@ -3315,6 +3325,7 @@ def _state_tool_schema(name: str) -> Json: - inspect visible results before deciding the next action - OBSERVE owns keep/forget cleanup - preserve useful conclusions in goal, plan, known, hypothesis, or verify; forget noise when it no longer helps +- do not let old gate feedback dominate once fresh tool results answer the next step WORKFLOW Classify the latest request as Chat, One-shot, or Tracked task before deciding state tools. @@ -3339,6 +3350,7 @@ def _state_tool_schema(name: str) -> Json: - execute the next useful frontier - batch independent searches, reads, recalls, and checks - serialize only when later arguments depend on earlier results +- when in verifying phase after edits, prefer the smallest relevant check over more broad reading Prefer useful tool calls over state-only turns. Pair state updates with the next frontier tool call when tool arguments are already known. @@ -3378,17 +3390,20 @@ def _state_tool_schema(name: str) -> Json: { __discovery_hint__ } Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. -Read line prefixes are display-only; EditFile anchors use "line:hash"; edit text starts immediately after "|". +Search and Read context lines are hashline-numbered as "line:hash|code". +EditFile anchors use the "line:hash" part; edit text starts immediately after "|". Stop discovery once the next edit/check is clear. Editing rules: -- make one small coherent change per edit action +- make one coherent change per edit action - new file: create a minimal skeleton first, then grow with focused EditFile chunks - existing file: inspect the exact target before editing - never rewrite a large file in one action -- use EditFile after Read for replacements, deletions, insertions, repeated text, and coordinated multi-location edits -- copy EditFile anchors exactly from Read output; if an anchor is stale, Read the target range again +- Search can provide EditFile anchors for small localized edits; use Read when you need fuller context +- use medium EditFile batches: usually one file or one logical block with several related edits +- split when the JSON becomes large, anchors come from unrelated areas, or a previous edit failed +- copy EditFile anchors exactly from Search/Read output; if an anchor is stale, Search/Read the target again VERIFICATION Verification strength: @@ -3419,7 +3434,7 @@ def _state_tool_schema(name: str) -> Json: Prefer dedicated tools for precise file reads/searches and structured edits. Bash is for shell semantics: tests/builds, explicit commands, and fast Unix text-tool pipelines with find, sed, awk, perl, xargs, or grep. Prefer dedicated tools when they give cleaner structured repo access. -Mechanical shell edits are allowed; verify afterward with Git diff, Read, tests, or another focused check. +Mechanical literal rename/replacement across known files may use shell text pipelines when faster and clearer; verify afterward with Git diff, Search/Read, tests, or another focused check. For code changes, prefer CreateFile for new files and EditFile for existing files over shell rewrites. Git is for status, diff, history, and changed files. @@ -5329,14 +5344,22 @@ class Agent: RECENT_EDITS: ClassVar[int] = 20 RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." RULE_CLOSE_SOURCE: ClassVar[str] = "close or update state that depends on the result before forgetting its source." - RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after edit failures Read the target range again and use fresh EditFile anchors." + RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after EditFile failures use a smaller batch and fresh Search/Read anchors." RULE_GOAL_PLAN_FIRST: ClassVar[str] = "set goal and a short plan before mutating tools or verify." RULE_VERIFY_DIRECTLY: ClassVar[str] = 'run verification tools, then report verify status="passed"|"failed"|"blocked".' RULE_TOOL_SIGNATURE: ClassVar[str] = "use the tool signature exactly." - RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile with anchors copied from Read output, and use the exact tool signature." + RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile with anchors copied from Search/Read output; split oversized batches." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked verification only when blocker=user." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." + RULE_VALID_TOOL_JSON: ClassVar[str] = "rebuild valid function arguments; for EditFile, use one file/logical block and split oversized batches." + STALE_TOOL_FEEDBACK_MARKERS: ClassVar[tuple[str, ...]] = ( + "invalid function/tool response", + "tool call args invalid", + "edit failed:", + "repeated same failed tool call", + "tool call was cancelled", + ) def __init__(self, session: Session): self.session = session @@ -5579,7 +5602,8 @@ def run_stream_loop( def _remember_format_gate(self, format_error: str) -> None: remember_error = self._remember_observe_error if self.mode == AgentMode.OBSERVE else self._remember_agent_error - remember_error(self._format_gate_user_message("Error: invalid function/tool response", format_error) + " Next: " + self.RULE_FUNCTION_TOOLS) + rule = self.RULE_VALID_TOOL_JSON if "invalid tool arguments" in format_error else self.RULE_FUNCTION_TOOLS + remember_error(self._format_gate_user_message("Error: invalid function/tool response", format_error) + " Next: " + rule) def _handle_format_gate(self, response: Json, format_error: str, consecutive_errors: int, on_message: MessageCallback | None) -> None: self._set_status_notice("err:format") @@ -5649,6 +5673,14 @@ def _remember_agent_error(self, text: str) -> None: def _remember_observe_error(self, text: str) -> None: self._remember_feedback_error(self.observe_feedback_errors, text) + def _drop_old_feedback_after_successful_tools(self, checkpoint: int) -> None: + if checkpoint <= 0 or not self.tool_runner.latest_executions: + return + if all(execution.outcome == "success" for execution in self.tool_runner.latest_executions): + self.agent_feedback_errors[:checkpoint] = [ + error for error in self.agent_feedback_errors[:checkpoint] if not any(marker in error for marker in self.STALE_TOOL_FEEDBACK_MARKERS) + ] + def _error(self, text: str, rule: str = "") -> str: return "Error blocked: " + text + ((" Next: " + rule) if rule else "") @@ -5923,6 +5955,19 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: rule, ) ) + if ( + execution.error_type is not None + and issubclass(execution.error_type, ToolCallError) + and not issubclass(execution.error_type, ToolCallArgError) + and (tool_class := TOOL_REGISTRY.get(execution.call.name)) is not None + and tool_class.EFFECT == ToolEffect.EDIT + ): + self._remember_agent_error( + self._error( + "edit failed: " + _format_tool_call_summary(execution.call) + " -> " + _shorten(" ".join(execution.output.split()), 120) + ".", + "use fresh Search/Read anchors; if the edit is large, retry a smaller coherent batch.", + ) + ) if execution.requires_verification: self.blackboard.verification_required = True self.blackboard.task_code = TaskCode.VERIFYING @@ -6640,6 +6685,7 @@ def handle_response( ) -> AgentRunResult: try: ctx = self._build_response_context(response) + feedback_checkpoint = len(self.agent_feedback_errors) DebugTrace.handle_event(self, "handle-start", ctx, response) if self.mode == AgentMode.OBSERVE: return self._handle_observe_response( @@ -6682,6 +6728,7 @@ def handle_response( on_auto_approve=on_auto_approve, on_message=on_message, ): + self._drop_old_feedback_after_successful_tools(feedback_checkpoint) DebugTrace.handle_event(self, "handle-tools", ctx, response) return AgentRunResult() result = self._finish_or_continue(ctx, on_message) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 78786d8..20467d3 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -656,7 +656,7 @@ def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): for name in ("find", "sed", "awk", "perl", "xargs", "grep"): assert name in prompt assert "structured repo access" in prompt - assert "Mechanical shell edits are allowed" in prompt + assert "Mechanical literal rename/replacement" in prompt assert "verify afterward" in prompt @@ -2655,7 +2655,16 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): assert "ToolCallError: requires args: filepath, edits" in latest assert "got 3 args, expected 2, extra: 1" in agent.agent_feedback_errors[0] - assert "use EditFile with anchors copied from Read output" in agent.agent_feedback_errors[0] + assert "use EditFile with anchors copied from Search/Read output" in agent.agent_feedback_errors[0] + + +def test_agent_drops_old_feedback_after_successful_tool_progress(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + agent.agent_feedback_errors = ["Error blocked: tool call args invalid: old bad call."] + + agent.handle_response({"actions": [{"type": "tool", "name": "List", "intention": "inspect root", "args": ["."]}]}) + + assert agent.agent_feedback_errors == [] def test_tool_arg_error_does_not_force_observe(tmp_path): diff --git a/tests/test_nanocode_search_tool.py b/tests/test_nanocode_search_tool.py index cebd0ef..fa2cd03 100644 --- a/tests/test_nanocode_search_tool.py +++ b/tests/test_nanocode_search_tool.py @@ -1,7 +1,9 @@ +import re + import nanocode import pytest -from nanocode import SearchTool, Session, ToolCallError +from nanocode import EditFileTool, SearchTool, Session, ToolCallError def test_search_tool_python_backend_finds_or_patterns_and_applies_glob(tmp_path, monkeypatch): @@ -175,7 +177,21 @@ def test_search_tool_uses_python_when_rg_is_missing(tmp_path, monkeypatch): assert "* engine: python" in result assert "* sample.txt:1: needle" in result - assert " > 1: needle" in result + assert " > 0:" in result and "|needle" in result + + +def test_search_tool_context_anchor_can_drive_edit_file(tmp_path, monkeypatch): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") + + result = SearchTool.make(session, ["beta", "sample.txt", "context=0"]).call() + anchor = re.search(r">\s+(\d+:[0-9a-f]{6})\|beta", result).group(1) + + EditFileTool.make(session, ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "BETA\n"}]]).call() + + assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" def test_search_tool_python_backend_includes_four_context_lines(tmp_path, monkeypatch): @@ -187,15 +203,15 @@ def test_search_tool_python_backend_includes_four_context_lines(tmp_path, monkey result = SearchTool.make(session, ["needle", "sample.txt"]).call() assert "* sample.txt:4: needle" in result - assert " 1: one" in result - assert " 2: two" in result - assert " 3: three" in result - assert " > 4: needle" in result - assert " 5: five" in result - assert " 6: six" in result - assert " 7: seven" in result - assert " 8: eight" in result - assert " 9: nine" not in result + assert " 0:" in result and "|one" in result + assert " 1:" in result and "|two" in result + assert " 2:" in result and "|three" in result + assert " > 3:" in result and "|needle" in result + assert " 4:" in result and "|five" in result + assert " 5:" in result and "|six" in result + assert " 6:" in result and "|seven" in result + assert " 7:" in result and "|eight" in result + assert "|nine" not in result def test_search_tool_python_backend_supports_regex(tmp_path, monkeypatch): @@ -222,13 +238,13 @@ def test_search_tool_supports_context_option_without_glob(tmp_path, monkeypatch) result = SearchTool.make(session, ["needle", "sample.txt", "context=3"]).call() - assert " 1: one" in result - assert " 2: two" in result - assert " 3: three" in result - assert " > 4: needle" in result - assert " 5: five" in result - assert " 6: six" in result - assert " 7: seven" in result + assert " 0:" in result and "|one" in result + assert " 1:" in result and "|two" in result + assert " 2:" in result and "|three" in result + assert " > 3:" in result and "|needle" in result + assert " 4:" in result and "|five" in result + assert " 5:" in result and "|six" in result + assert " 6:" in result and "|seven" in result def test_search_tool_accepts_context_30(tmp_path): @@ -248,11 +264,11 @@ def test_search_tool_supports_numeric_context_option_with_glob(tmp_path, monkeyp result = SearchTool.make(session, ["needle", ".", "*.txt", "2"]).call() assert "* keep.txt:3: needle" in result - assert " 1: zero" in result - assert " 2: one" in result - assert " > 3: needle" in result - assert " 4: three" in result - assert " 5: four" in result + assert " 0:" in result and "|zero" in result + assert " 1:" in result and "|one" in result + assert " > 2:" in result and "|needle" in result + assert " 3:" in result and "|three" in result + assert " 4:" in result and "|four" in result assert "skip.py" not in result @@ -265,7 +281,7 @@ def test_search_tool_supports_glob_and_context_option(tmp_path, monkeypatch): result = SearchTool.make(session, ["needle", ".", "*.txt", "context=1"]).call() assert "* keep.txt:2: needle" in result - assert " > 2: needle" in result + assert " > 1:" in result and "|needle" in result assert "skip.py" not in result @@ -363,8 +379,8 @@ def test_search_tool_supports_multiline_regex(tmp_path, monkeypatch): assert tool.pattern == "@dataclass.*\nclass.*State" assert "* engine: python-multiline" in result assert "* sample.py:1: @dataclass class State" in result - assert " > 1: @dataclass" in result - assert " 2: class State:" in result + assert " > 0:" in result and "|@dataclass" in result + assert " 1:" in result and "|class State:" in result def test_search_tool_rejects_invalid_context(tmp_path): From f8e81fb3498667a4f6ee2130b31aab4944fe7557 Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 04:23:16 -0700 Subject: [PATCH 091/144] Use code-symbol-index 0.1.8 anchors --- README.md | 2 +- nanocode.py | 37 +++++++++++++++++-------- pyproject.toml | 2 +- tests/test_nanocode_agent.py | 6 ++-- tests/test_nanocode_code_index_tools.py | 6 ++-- 5 files changed, 33 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index f9513c8..9ca276f 100644 --- a/README.md +++ b/README.md @@ -85,7 +85,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. -`Search` and `Read` both return 0-based `line:hash|code` anchors for `EditFile`. For broad mechanical text replacement, shell text pipelines are acceptable when followed by a focused diff or test. +`Search`, `Read`, and `InspectCodeSymbol` return 0-based `line:hash|code` anchors for `EditFile`. For broad mechanical text replacement, shell text pipelines are acceptable when followed by a focused diff or test. ## Commands diff --git a/nanocode.py b/nanocode.py index 311da79..15c652c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2465,11 +2465,11 @@ class InspectCodeSymbolTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Inspect one indexed symbol, Class.member, or symbol prefix.", - "Returns line-numbered source plus members, references, shallow impact/callers, and implementors when available.", + 'Returns source as 0-based "line:hash|code" anchors plus members, references, shallow impact/callers, and implementors when available.', "Includes import summaries when indexed.", "Optional options object: kind, path, exact_only.", "Use it to understand a class/function/API and nearby relationships from the index.", - "Symbol matching is case-insensitive; returned line numbers are 0-based.", + "Symbol matching is case-insensitive; source anchors can be used directly with EditFile.", "Not for files, directories, module paths, natural language, or literal text patterns.", ) SIGNATURE: ClassVar[str] = "InspectCodeSymbol(symbol[, options]) -> InspectCodeSymbolToolResult" @@ -2537,6 +2537,7 @@ def call(self) -> str: kind=self.kind or None, path=self.path or None, exact_only=self.exact_only, + anchors=True, ) return _format_code_index_result("InspectCodeSymbolToolResult", text) @@ -2668,7 +2669,7 @@ class EditFileTool(Tool): PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "edits") EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - 'Edit an existing UTF-8 file using Search or Read anchors of the form "line:hash".', + 'Edit an existing UTF-8 file using anchors of the form "line:hash".', "Supports replace, delete, insert_before, and insert_after edits; all anchors are verified before writing.", "All edits apply atomically or nothing is written.", "Returns changed path plus applied edit count.", @@ -2786,7 +2787,7 @@ def _resolve_anchor(lines: list[str], anchor: str) -> int: anchor = anchor.split("|", 1)[0].strip() match = re.fullmatch(r"(\d+):([0-9a-fA-F]{6})", anchor) if match is None: - raise ToolCallError('invalid anchor; use "line:hash" copied from Read output') + raise ToolCallError('invalid anchor; use "line:hash" copied from Search, Read, or InspectCodeSymbol output') index = int(match.group(1)) if index >= len(lines): raise ToolCallError("anchor line is out of range; Read the target range again") @@ -3390,7 +3391,7 @@ def _state_tool_schema(name: str) -> Json: { __discovery_hint__ } Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. -Search and Read context lines are hashline-numbered as "line:hash|code". +{ __edit_anchor_intro__ } EditFile anchors use the "line:hash" part; edit text starts immediately after "|". Stop discovery once the next edit/check is clear. @@ -3400,10 +3401,10 @@ def _state_tool_schema(name: str) -> Json: - new file: create a minimal skeleton first, then grow with focused EditFile chunks - existing file: inspect the exact target before editing - never rewrite a large file in one action -- Search can provide EditFile anchors for small localized edits; use Read when you need fuller context +{ __edit_anchor_rule__ } - use medium EditFile batches: usually one file or one logical block with several related edits - split when the JSON becomes large, anchors come from unrelated areas, or a previous edit failed -- copy EditFile anchors exactly from Search/Read output; if an anchor is stale, Search/Read the target again +- copy EditFile anchors exactly from visible tool output; if an anchor is stale, inspect the target again VERIFICATION Verification strength: @@ -5344,11 +5345,11 @@ class Agent: RECENT_EDITS: ClassVar[int] = 20 RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." RULE_CLOSE_SOURCE: ClassVar[str] = "close or update state that depends on the result before forgetting its source." - RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after EditFile failures use a smaller batch and fresh Search/Read anchors." + RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after EditFile failures use a smaller batch and fresh anchors." RULE_GOAL_PLAN_FIRST: ClassVar[str] = "set goal and a short plan before mutating tools or verify." RULE_VERIFY_DIRECTLY: ClassVar[str] = 'run verification tools, then report verify status="passed"|"failed"|"blocked".' RULE_TOOL_SIGNATURE: ClassVar[str] = "use the tool signature exactly." - RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile with anchors copied from Search/Read output; split oversized batches." + RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile with anchors copied from visible tool output; split oversized batches." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked verification only when blocker=user." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." @@ -5422,7 +5423,7 @@ def _format_environment(self) -> str: ] if _code_index_available(self.session): lines.append( - "- inspect_code_hint: Use FindCodeSymbol for symbol/prefix candidates (optional kind/path/exact_only/limit filters), InspectCodeSymbol for chosen symbols, and OutlineCodeFile for known file structure or file-local symbol outlines. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." + "- inspect_code_hint: Use FindCodeSymbol for symbol/prefix candidates (optional kind/path/exact_only/limit filters), InspectCodeSymbol for chosen symbols and edit anchors, and OutlineCodeFile for known file structure or file-local symbol outlines. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." ) return "\n".join(lines) @@ -5455,6 +5456,8 @@ def _system_prompt(self, template: str | None = None, *, tools: Iterable[ToolCla (template or AGENT_SYSTEM_PROMPT) .replace("{ __tool_names__ }", "|".join(tool.NAME for tool in tool_classes)) .replace("{ __discovery_hint__ }", self._discovery_prompt_hint(tool_classes)) + .replace("{ __edit_anchor_intro__ }", self._edit_anchor_intro(tool_classes)) + .replace("{ __edit_anchor_rule__ }", self._edit_anchor_rule(tool_classes)) .replace("{ __hypothesis_status_text__ }", HYPOTHESIS_STATUS_TEXT) .strip() ) @@ -5471,12 +5474,22 @@ def _discovery_prompt_hint(self, tool_classes: Iterable[ToolClass]) -> str: return ( "For structural code discovery, prefer indexed code tools before Search/Read.\n" "- Use FindCodeSymbol for symbol candidates by name/prefix with optional kind/path/exact_only filters.\n" - "- Use InspectCodeSymbol for line-numbered source, imports, members, references, and implementors of one symbol.\n" + "- Use InspectCodeSymbol for anchored source, imports, members, references, and implementors of one symbol.\n" "- Use OutlineCodeFile for file-level or file-local symbol outlines.\n" "- Use Search for exact literal text, config, comments, logs, or when no useful path/symbol guess exists.\n" "- Use List/LineCount when path shape or file size is unknown." ) + def _edit_anchor_intro(self, tool_classes: Iterable[ToolClass]) -> str: + if InspectCodeSymbolTool in tool_classes: + return 'Search, Read, and InspectCodeSymbol source lines are hashline-numbered as "line:hash|code".' + return 'Search and Read context lines are hashline-numbered as "line:hash|code".' + + def _edit_anchor_rule(self, tool_classes: Iterable[ToolClass]) -> str: + if InspectCodeSymbolTool in tool_classes: + return "- Search can provide anchors for localized edits; InspectCodeSymbol can provide anchors for known symbols; use Read when you need fuller context" + return "- Search can provide anchors for localized edits; use Read when you need fuller context" + def _format_user_request(self) -> str: user_request = self.blackboard.user_input or "(empty)" fence = "`" * max(3, max((len(match.group(0)) for match in re.finditer(r"`{3,}", user_request)), default=0) + 1) @@ -5965,7 +5978,7 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: self._remember_agent_error( self._error( "edit failed: " + _format_tool_call_summary(execution.call) + " -> " + _shorten(" ".join(execution.output.split()), 120) + ".", - "use fresh Search/Read anchors; if the edit is large, retry a smaller coherent batch.", + "use fresh anchors; if the edit is large, retry a smaller coherent batch.", ) ) if execution.requires_verification: diff --git a/pyproject.toml b/pyproject.toml index ff2b4ba..0cdd6e5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,7 +27,7 @@ classifiers = [ "Topic :: Terminals", ] dependencies = [ - "code-symbol-index>=0.1.7", + "code-symbol-index>=0.1.8", "openai>=2.37.0", "prompt-toolkit>=3.0", "socksio>=1.0.0", diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 20467d3..03ca538 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -528,10 +528,10 @@ def test_inspect_code_tools_is_visible_when_available(tmp_path, monkeypatch): system_prompt = agent._system_prompt() assert "prefer indexed code tools before Search/Read" in system_prompt assert "Use FindCodeSymbol for symbol candidates by name/prefix with optional kind/path/exact_only filters" in system_prompt - assert "Use InspectCodeSymbol for line-numbered source, imports, members, references, and implementors" in system_prompt + assert "Use InspectCodeSymbol for anchored source, imports, members, references, and implementors" in system_prompt prompt = agent.build_user_prompt() assert "Use FindCodeSymbol for symbol/prefix candidates" in prompt - assert "InspectCodeSymbol for chosen symbols" in prompt + assert "InspectCodeSymbol for chosen symbols and edit anchors" in prompt assert "OutlineCodeFile for known file structure or file-local symbol outlines" in prompt assert "code-symbol-index" not in prompt assert "kind/path/exact_only/limit filters" in prompt @@ -2655,7 +2655,7 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): assert "ToolCallError: requires args: filepath, edits" in latest assert "got 3 args, expected 2, extra: 1" in agent.agent_feedback_errors[0] - assert "use EditFile with anchors copied from Search/Read output" in agent.agent_feedback_errors[0] + assert "use EditFile with anchors copied from visible tool output" in agent.agent_feedback_errors[0] def test_agent_drops_old_feedback_after_successful_tool_progress(tmp_path): diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index b819b0f..b255833 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -38,8 +38,8 @@ def search_text(self, query, *, kind=None, path=None, exact_only=False, limit=20 self.events.append(("search_text", query, kind, path, exact_only, limit, self.root, self.db_path)) return "query: " + query + "\ncount: 1\nsymbol Tool nanocode.py:10:20" - def inspect_text(self, symbol, *, kind=None, path=None, exact_only=False): - self.events.append(("inspect_text", symbol, kind, path, exact_only, self.root, self.db_path)) + def inspect_text(self, symbol, *, kind=None, path=None, exact_only=False, anchors=False): + self.events.append(("inspect_text", symbol, kind, path, exact_only, anchors, self.root, self.db_path)) return "symbol:\n name: " + symbol + "\nsource:\n status: full" def outline_text(self, filepath, *, symbol=None): @@ -204,7 +204,7 @@ def test_inspect_code_symbol_uses_inspect_text(tmp_path, monkeypatch): result = InspectCodeSymbolTool.make(session, ["Tool", {"path": "nanocode.py", "exact_only": True}]).call() - assert ("inspect_text", "Tool", None, "nanocode.py", True, str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events + assert ("inspect_text", "Tool", None, "nanocode.py", True, True, str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events assert result == "\nsymbol:\n name: Tool\nsource:\n status: full\n" From 5d9006ed3b00c425011f0a532690c822ee9b1365 Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 04:46:30 -0700 Subject: [PATCH 092/144] Fix tool arg preservation and stale feedback cleanup --- nanocode.py | 26 ++++++++++++++++--------- tests/test_nanocode_agent.py | 5 ++++- tests/test_nanocode_code_index_tools.py | 19 +++++++++++++++++- tests/test_nanocode_read_tool.py | 3 ++- 4 files changed, 41 insertions(+), 12 deletions(-) diff --git a/nanocode.py b/nanocode.py index 15c652c..b3b8966 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1247,7 +1247,16 @@ def _bound_tool_output(output: str, *, log_path: str = "", max_chars: int = MAX_ if original_chars <= max_chars: return BoundedToolOutput(output, False, original_lines, original_chars) - header = "[tool result excerpt]\nexcerpted: true\noriginal_lines: " + str(original_lines) + "\noriginal_chars: " + str(original_chars) + "\n" + header = ( + "[tool result excerpt]\n" + "excerpted: true\n" + "note: only an excerpt is visible; use Recall with a line range or Read smaller targeted ranges instead of repeating the same large read.\n" + "original_lines: " + + str(original_lines) + + "\noriginal_chars: " + + str(original_chars) + + "\n" + ) labels = ("\n--- head ---\n", "\n--- middle ---\n", "\n--- tail ---\n") body_budget = max_chars - len(header) - sum(len(label) for label in labels) if body_budget <= 0: @@ -1649,16 +1658,16 @@ def cli_args(cls, args: list[JsonValue]) -> list[str]: return tokens + [str(arg) for arg in args[1:]] @classmethod - def make(cls, session: Session, args: list[str]) -> Self: + def make(cls, session: Session, args: list[JsonValue]) -> Self: if len(args) == 0: raise ToolCallArgError( 'Read args error: got 0 args; expected ["filepath"] or ["filepath", "start,end"]. Example: Read("nanocode.py", "2065,2095"). Do not call Read().' ) - filepath = session.resolve_path(args[0]) + filepath = session.resolve_path(str(args[0])) if len(args) == 1: ranges = [(0, 0)] - elif all(re.fullmatch(r"\s*\d+\s*[-:,]\s*\d+\s*", arg) for arg in args[1:]): - ranges = [_parse_line_range_token(arg) for arg in args[1:]] + elif all(re.fullmatch(r"\s*\d+\s*[-:,]\s*\d+\s*", str(arg)) for arg in args[1:]): + ranges = [_parse_line_range_token(str(arg)) for arg in args[1:]] elif len(args) == 2: raise ToolCallArgError('Read args error: invalid range token; expected ["filepath", "start,end"]. Example: Read("nanocode.py", "2065,2095").') else: @@ -1736,7 +1745,7 @@ def _format_range_result( if truncated: note = ( f"Read returned {returned_end - start} lines from {start}:{returned_end} of {total_lines} total lines. " - "Use Search to locate relevant text or Read smaller ranges in batches." + "Use Search to locate relevant text, Recall with a line range, or Read smaller targeted ranges; do not repeat the same large read." ) lines.extend( [ @@ -4790,9 +4799,7 @@ def parse_tool_call(self, value: JsonValue) -> ParsedToolCall: raise ToolCallArgError('tool action missing required field: name. Use {"type":"tool","name":"Read","intention":"...","args":["path"]}.') name = _canonical_tool_name(name) intention = _json_str(item.get("intention")) or "" - raw_args = _json_list(item.get("args")) - args: list[JsonValue] = list(raw_args) if name == EditFileTool.NAME else [_json_str(arg) or "" for arg in raw_args] - return ParsedToolCall(name=name, intention=intention, args=args) + return ParsedToolCall(name=name, intention=intention, args=list(_json_list(item.get("args")))) def _invalid_tool_call(self, value: JsonValue) -> ParsedToolCall: item = _json_dict(value) @@ -5360,6 +5367,7 @@ class Agent: "edit failed:", "repeated same failed tool call", "tool call was cancelled", + "state update-only turn", ) def __init__(self, session: Session): diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 03ca538..32cb2b3 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2660,7 +2660,10 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): def test_agent_drops_old_feedback_after_successful_tool_progress(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) - agent.agent_feedback_errors = ["Error blocked: tool call args invalid: old bad call."] + agent.agent_feedback_errors = [ + "Error blocked: tool call args invalid: old bad call.", + "Warning blocked: state update-only turn; include frontier tool.", + ] agent.handle_response({"actions": [{"type": "tool", "name": "List", "intention": "inspect root", "args": ["."]}]}) diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index b255833..8042b21 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -3,7 +3,7 @@ import nanocode import pytest -from nanocode import FindCodeSymbolTool, InspectCodeSymbolTool, OutlineCodeFileTool, Session, ToolCallArgError, ToolCallError +from nanocode import Agent, FindCodeSymbolTool, InspectCodeSymbolTool, OutlineCodeFileTool, Session, ToolCallArgError, ToolCallError class FakeRepository: @@ -208,6 +208,23 @@ def test_inspect_code_symbol_uses_inspect_text(tmp_path, monkeypatch): assert result == "\nsymbol:\n name: Tool\nsource:\n status: full\n" +def test_agent_tool_call_preserves_code_index_options_object(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path)) + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + + Agent(session).execute_tool_calls( + [ + { + "name": "InspectCodeSymbol", + "intention": "inspect exact symbol", + "args": ["Tool", {"path": "nanocode.py", "exact_only": True}], + } + ] + ) + + assert ("inspect_text", "Tool", None, "nanocode.py", True, True, str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events + + def test_outline_code_file_uses_outline_text(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path)) filepath = tmp_path / "code.py" diff --git a/tests/test_nanocode_read_tool.py b/tests/test_nanocode_read_tool.py index ed5063d..fa11037 100644 --- a/tests/test_nanocode_read_tool.py +++ b/tests/test_nanocode_read_tool.py @@ -128,7 +128,7 @@ def test_read_tool_truncates_full_file_reads_after_600_lines(tmp_path): assert "true" in result assert "605" in result assert "Read returned 600 lines from 0:600 of 605 total lines" in result - assert "Use Search to locate relevant text or Read smaller ranges in batches." in result + assert "Recall with a line range, or Read smaller targeted ranges" in result assert _hashline(599, "line-0599\n") in result assert "|line-0600" not in result @@ -144,6 +144,7 @@ def test_read_tool_truncates_large_bounded_ranges_after_600_lines(tmp_path): assert "true" in result assert "700" in result assert "Read returned 600 lines from 10:610 of 700 total lines" in result + assert "Recall with a line range, or Read smaller targeted ranges" in result assert _hashline(609, "line-0609\n") in result assert "|line-0610" not in result From da949fea327bc0f00beaf2d562970b9fe99be57e Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 04:58:03 -0700 Subject: [PATCH 093/144] Unify code index inspection tool --- README.md | 4 +- design.md | 11 +- nanocode.py | 303 +++++++++--------------- tests/test_nanocode_agent.py | 27 +-- tests/test_nanocode_code_index_tools.py | 66 +++--- 5 files changed, 164 insertions(+), 247 deletions(-) diff --git a/README.md b/README.md index 9ca276f..c3b68dd 100644 --- a/README.md +++ b/README.md @@ -80,12 +80,12 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Tools - File: `Read`, `LineCount`, `List`, `Search`. -- Code navigation: `FindCodeSymbol`, `InspectCodeSymbol`, and `OutlineCodeFile` after `/index` builds the project index. +- Code navigation: `InspectCode` after `/index` builds the project index. - Edit: `CreateFile`, `EditFile`. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. -`Search`, `Read`, and `InspectCodeSymbol` return 0-based `line:hash|code` anchors for `EditFile`. For broad mechanical text replacement, shell text pipelines are acceptable when followed by a focused diff or test. +`Search`, `Read`, and `InspectCode` mode=inspect return 0-based `line:hash|code` anchors for `EditFile`. For broad mechanical text replacement, shell text pipelines are acceptable when followed by a focused diff or test. ## Commands diff --git a/design.md b/design.md index 07779a5..8627dc7 100644 --- a/design.md +++ b/design.md @@ -88,12 +88,11 @@ OBSERVE receives a smaller cleanup context: OBSERVE reduces tool-result noise before ACT continues. -Code navigation tools are environment-gated. `FindCodeSymbol`, -`InspectCodeSymbol`, and `OutlineCodeFile` are shown only when the built-in code -index is available. They accept symbol queries or file paths, not -natural-language questions. The index is created explicitly with `/index`, -rebuilt with `/index force`, and lightly updated at startup when it already -exists. +The code navigation tool is environment-gated. `InspectCode` is shown only when +the built-in code index is available. It supports `find`, `inspect`, and +`outline` modes for symbol queries or file paths, not natural-language +questions. The index is created explicitly with `/index`, rebuilt with +`/index force`, and lightly updated at startup when it already exists. Context layout: diff --git a/nanocode.py b/nanocode.py index b3b8966..3f0776a 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1175,7 +1175,7 @@ def cli_content_summary(value: str) -> str: @staticmethod def cli_token(value: JsonValue) -> str: - text = str(value) + text = json.dumps(value, ensure_ascii=False, separators=(",", ":")) if isinstance(value, (dict, list)) else str(value) if "\n" in text: return Tool.cli_content_summary(text) text = _shorten(text, 100) @@ -2385,30 +2385,31 @@ def _format_code_index_result(tag: str, text: str) -> str: @dataclass -class FindCodeSymbolTool(Tool): - NAME: ClassVar[str] = "FindCodeSymbol" +class InspectCodeTool(Tool): + NAME: ClassVar[str] = "InspectCode" DEFAULT_LIMIT: ClassVar[int] = 20 MAX_LIMIT: ClassVar[int] = 80 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Find indexed symbols by one name or prefix, including top-level constants, variables, and dictionary keys when indexed.", - "Returns candidate name, kind, language, 0-based file/range, and signature.", - "Optional options object: limit (default 20, max 80), kind, path, exact_only.", - "Query may use A|B|C as non-regex OR shorthand.", - "Input must be one symbol-like token, not natural language or literal text patterns.", + "Use the built-in code index for structural code navigation.", + "Modes: find symbol candidates, inspect one symbol with anchored source, or outline one file.", + "find options: limit, kind, path, exact_only; inspect options: kind, path, exact_only; outline options: symbol.", + "find/inspect targets are symbol names or prefixes, not natural language or literal text; outline target is a file path.", ) - SIGNATURE: ClassVar[str] = "FindCodeSymbol(query[, options]) -> FindCodeSymbolToolResult" + SIGNATURE: ClassVar[str] = "InspectCode(mode, target[, options]) -> InspectCodeToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Example args: ["Tool"]', - 'Example args: ["tool_schema", {"kind":"function","exact_only":true}]', - 'Example args: ["Agent", {"path":"nanocode.py","limit":40}]', + 'Find: ["find", "Tool", {"kind":"class","limit":20}]', + 'Inspect: ["inspect", "Agent.run", {"path":"nanocode.py","exact_only":true}]', + 'Outline: ["outline", "nanocode.py", {"symbol":"Tool"}]', ) - query: str = "" + mode: str = "" + target: str = "" limit: int = DEFAULT_LIMIT kind: str = "" path: str = "" exact_only: bool = False + symbol: str = "" session: Session | None = None @classmethod @@ -2416,195 +2417,113 @@ def tool_schema(cls) -> Json: schema = super().tool_schema() schema["function"]["parameters"]["properties"]["args"] = { "type": "array", - "minItems": 1, - "maxItems": 2, - "items": {"type": ["string", "object"], "description": "Symbol name/prefix, then optional {limit, kind, path, exact_only} filters."}, + "minItems": 2, + "maxItems": 3, + "items": {"type": ["string", "object"], "description": 'mode, target, then optional filters object. mode is "find", "inspect", or "outline".'}, } return schema @classmethod def make(cls, session: Session, args: list[JsonValue]) -> Self: - if not 1 <= len(args) <= 2: - raise ToolCallArgError("requires args: query[, options]") - query = str(args[0]).strip() - if not query: - raise ToolCallArgError("query cannot be empty") - if re.search(r"\s", query): - raise ToolCallArgError("query must be one symbol name or prefix; do not pass natural language") + if not 2 <= len(args) <= 3: + raise ToolCallArgError("requires args: mode, target[, options]") + mode = str(args[0]).strip().lower() + if mode not in {"find", "inspect", "outline"}: + raise ToolCallArgError("mode must be find, inspect, or outline") + target = str(args[1]).strip() + if not target: + raise ToolCallArgError("target cannot be empty") + options = cls._options(args) limit = cls.DEFAULT_LIMIT - kind = "" - path = "" - exact_only = False - if len(args) == 2: - options = _json_dict(args[1]) - if not options: - raise ToolCallArgError("options must be an object: {limit, kind, path, exact_only}") + if mode == "find": + cls._validate_symbolish(target, "query") try: limit = min(cls.MAX_LIMIT, max(1, int(options.get("limit", cls.DEFAULT_LIMIT)))) except (TypeError, ValueError): raise ToolCallArgError("limit must be an integer") - kind = str(options.get("kind") or "").strip() - path = str(options.get("path") or "").strip() - exact_only = options.get("exact_only") is True - if not _code_index_available(session): - raise ToolCallError("code index is not available") - return cls(query=query, limit=limit, kind=kind, path=path, exact_only=exact_only, session=session) - - def preview(self) -> str: - options = {key: value for key, value in (("limit", self.limit), ("kind", self.kind), ("path", self.path), ("exact_only", self.exact_only)) if value} - args = [self.query] + ([options] if options != {"limit": self.DEFAULT_LIMIT} else []) - return "FindCodeSymbol(" + ", ".join(json.dumps(arg, ensure_ascii=False) for arg in args) + ")" - - def call(self) -> str: - if self.session is None: - raise ToolCallError("missing session") - text = _code_index_repository(self.session).search_text( - self.query, - limit=self.limit, - kind=self.kind or None, - path=self.path or None, - exact_only=self.exact_only, - ) - return _format_code_index_result("FindCodeSymbolToolResult", text) - - -@dataclass -class InspectCodeSymbolTool(Tool): - NAME: ClassVar[str] = "InspectCodeSymbol" - EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY - DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Inspect one indexed symbol, Class.member, or symbol prefix.", - 'Returns source as 0-based "line:hash|code" anchors plus members, references, shallow impact/callers, and implementors when available.', - "Includes import summaries when indexed.", - "Optional options object: kind, path, exact_only.", - "Use it to understand a class/function/API and nearby relationships from the index.", - "Symbol matching is case-insensitive; source anchors can be used directly with EditFile.", - "Not for files, directories, module paths, natural language, or literal text patterns.", - ) - SIGNATURE: ClassVar[str] = "InspectCodeSymbol(symbol[, options]) -> InspectCodeSymbolToolResult" - EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Example args: ["Tool"]', - 'Example args: ["Agent.run"]', - 'Example args: ["Tool", {"path":"nanocode.py","exact_only":true}]', - ) - - symbol: str = "" - kind: str = "" - path: str = "" - exact_only: bool = False - session: Session | None = None - - @classmethod - def tool_schema(cls) -> Json: - schema = super().tool_schema() - schema["function"]["parameters"]["properties"]["args"] = { - "type": "array", - "minItems": 1, - "maxItems": 2, - "items": {"type": ["string", "object"], "description": "Symbol/Class.member/prefix, then optional {kind, path, exact_only} filters."}, - } - return schema - - @classmethod - def make(cls, session: Session, args: list[JsonValue]) -> Self: - if not 1 <= len(args) <= 2: - raise ToolCallArgError("requires args: symbol[, options]") - symbol = str(args[0]).strip() - if not symbol: - raise ToolCallArgError("symbol cannot be empty") + elif mode == "inspect": + cls._validate_symbolish(target, "symbol") + path_target = session.resolve_path(target) + dotted_path = session.resolve_path(target.replace(".", os.sep)) if "." in target and os.sep not in target else "" + if os.path.exists(path_target) or (dotted_path and os.path.exists(dotted_path)): + raise ToolCallArgError("inspect target looks like a file or directory; use mode=outline, List, Search, or Read") + if "." in target and not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?", target): + raise ToolCallArgError("symbol looks like a module path; use List/Search/Read for modules/packages, or pass a specific symbol") + else: + filepath = session.resolve_path(target) + if not os.path.isfile(filepath): + raise ToolCallArgError("outline target must be an existing file") + target = filepath + symbol = str(options.get("symbol") or "").strip() + if re.search(r"\s", symbol): + raise ToolCallArgError("outline symbol filter must be one symbol name or prefix") + options["symbol"] = symbol if not _code_index_available(session): raise ToolCallError("code index is not available") - path_target = session.resolve_path(symbol) - dotted_path = session.resolve_path(symbol.replace(".", os.sep)) if "." in symbol and os.sep not in symbol else "" - if os.path.exists(path_target) or (dotted_path and os.path.exists(dotted_path)): - raise ToolCallArgError("symbol target looks like a file or directory; use OutlineCodeFile, List, Search, or Read") - if re.search(r"\s", symbol): - raise ToolCallArgError("symbol must be one symbol, Class.member, or symbol prefix; do not pass natural language") - if "." in symbol and not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?", symbol): - raise ToolCallArgError("symbol looks like a module path; use List/Search/Read for modules/packages, or pass a specific symbol") - options = _json_dict(args[1]) if len(args) == 2 else {} - if len(args) == 2 and not options: - raise ToolCallArgError("options must be an object: {kind, path, exact_only}") return cls( - symbol=symbol, + mode=mode, + target=target, + limit=limit, kind=str(options.get("kind") or "").strip(), path=str(options.get("path") or "").strip(), exact_only=options.get("exact_only") is True, + symbol=str(options.get("symbol") or "").strip(), session=session, ) - def preview(self) -> str: - options = {key: value for key, value in (("kind", self.kind), ("path", self.path), ("exact_only", self.exact_only)) if value} - args = [self.symbol] + ([options] if options else []) - return "InspectCodeSymbol(" + ", ".join(json.dumps(arg, ensure_ascii=False) for arg in args) + ")" - - def call(self) -> str: - if self.session is None: - raise ToolCallError("missing session") - text = _code_index_repository(self.session).inspect_text( - self.symbol, - kind=self.kind or None, - path=self.path or None, - exact_only=self.exact_only, - anchors=True, - ) - return _format_code_index_result("InspectCodeSymbolToolResult", text) - - -@dataclass -class OutlineCodeFileTool(Tool): - NAME: ClassVar[str] = "OutlineCodeFile" - EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY - DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Outline indexed symbols in one file.", - "Pass a file path, and optionally a symbol name/prefix to narrow the outline.", - "Directories and bare symbols are not supported as the first argument.", - "Returns classes, functions, methods, kinds, signatures, and 0-based locations.", - ) - SIGNATURE: ClassVar[str] = "OutlineCodeFile(filepath[, symbol]) -> OutlineCodeFileToolResult" - EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["nanocode.py"]', 'Example args: ["nanocode.py", "Tool"]') - - filepath: str = "" - symbol: str = "" - session: Session | None = None - - @classmethod - def tool_schema(cls) -> Json: - schema = super().tool_schema() - schema["function"]["parameters"]["properties"]["args"] = { - "type": "array", - "minItems": 1, - "maxItems": 2, - "items": {"type": "string", "description": "File path, then optional symbol name/prefix."}, - } - return schema - - @classmethod - def make(cls, session: Session, args: list[JsonValue]) -> Self: - if not 1 <= len(args) <= 2: - raise ToolCallArgError("requires args: filepath[, symbol]") - filepath = session.resolve_path(str(args[0]).strip()) - if not os.path.isfile(filepath): - raise ToolCallArgError("filepath must be an existing file; directories and symbols are not supported") - symbol = str(args[1]).strip() if len(args) == 2 else "" - if re.search(r"\s", symbol): - raise ToolCallArgError("symbol must be one symbol name or prefix") - if not _code_index_available(session): - raise ToolCallError("code index is not available") - return cls(filepath=filepath, symbol=symbol, session=session) + @staticmethod + def _options(args: list[JsonValue]) -> dict[str, JsonValue]: + if len(args) == 2: + return {} + options = _json_dict(args[2]) + if not options: + raise ToolCallArgError("options must be an object") + return options - def requires_confirmation(self, session: Session) -> bool: - return not session.is_path_in_cwd(self.filepath) + @staticmethod + def _validate_symbolish(value: str, label: str) -> None: + if re.search(r"\s", value): + raise ToolCallArgError(label + " must be one symbol name or prefix; do not pass natural language") def preview(self) -> str: - cwd = self.session.cwd if self.session is not None else os.getcwd() - args = [os.path.relpath(self.filepath, cwd)] + ([self.symbol] if self.symbol else []) - return "OutlineCodeFile(" + ", ".join(json.dumps(arg, ensure_ascii=False) for arg in args) + ")" + options = { + key: value + for key, value in ( + ("limit", self.limit if self.mode == "find" and self.limit != self.DEFAULT_LIMIT else 0), + ("kind", self.kind), + ("path", self.path), + ("exact_only", self.exact_only), + ("symbol", self.symbol), + ) + if value + } + target = os.path.relpath(self.target, self.session.cwd) if self.mode == "outline" and self.session is not None else self.target + args: list[JsonValue] = [self.mode, target] + ([options] if options else []) + return "InspectCode(" + ", ".join(json.dumps(arg, ensure_ascii=False) for arg in args) + ")" def call(self) -> str: if self.session is None: raise ToolCallError("missing session") - return _format_code_index_result("OutlineCodeFileToolResult", _code_index_repository(self.session).outline_text(self.filepath, symbol=self.symbol or None)) + repo = _code_index_repository(self.session) + if self.mode == "find": + text = repo.search_text( + self.target, + limit=self.limit, + kind=self.kind or None, + path=self.path or None, + exact_only=self.exact_only, + ) + elif self.mode == "inspect": + text = repo.inspect_text( + self.target, + kind=self.kind or None, + path=self.path or None, + exact_only=self.exact_only, + anchors=True, + ) + else: + text = repo.outline_text(self.target, symbol=self.symbol or None) + return _format_code_index_result("InspectCodeToolResult", "mode: " + self.mode + "\n" + text) @dataclass @@ -2796,7 +2715,7 @@ def _resolve_anchor(lines: list[str], anchor: str) -> int: anchor = anchor.split("|", 1)[0].strip() match = re.fullmatch(r"(\d+):([0-9a-fA-F]{6})", anchor) if match is None: - raise ToolCallError('invalid anchor; use "line:hash" copied from Search, Read, or InspectCodeSymbol output') + raise ToolCallError('invalid anchor; use "line:hash" copied from Search, Read, or InspectCode mode=inspect output') index = int(match.group(1)) if index >= len(lines): raise ToolCallError("anchor line is out of range; Read the target range again") @@ -3140,9 +3059,7 @@ def _content(self, item: ToolResultItem) -> str: ReadTool.NAME: ReadTool, LineCountTool.NAME: LineCountTool, ListTool.NAME: ListTool, - FindCodeSymbolTool.NAME: FindCodeSymbolTool, - OutlineCodeFileTool.NAME: OutlineCodeFileTool, - InspectCodeSymbolTool.NAME: InspectCodeSymbolTool, + InspectCodeTool.NAME: InspectCodeTool, SearchTool.NAME: SearchTool, CreateFileTool.NAME: CreateFileTool, EditFileTool.NAME: EditFileTool, @@ -3154,9 +3071,7 @@ def _content(self, item: ToolResultItem) -> str: ReadTool, LineCountTool, ListTool, - FindCodeSymbolTool, - OutlineCodeFileTool, - InspectCodeSymbolTool, + InspectCodeTool, SearchTool, PlanModeGitTool, ToolResultTool, @@ -5431,7 +5346,7 @@ def _format_environment(self) -> str: ] if _code_index_available(self.session): lines.append( - "- inspect_code_hint: Use FindCodeSymbol for symbol/prefix candidates (optional kind/path/exact_only/limit filters), InspectCodeSymbol for chosen symbols and edit anchors, and OutlineCodeFile for known file structure or file-local symbol outlines. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." + "- inspect_code_hint: Use InspectCode for structural code navigation: mode=find for symbol candidates, mode=inspect for anchored symbol source, mode=outline for file outlines. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." ) return "\n".join(lines) @@ -5474,28 +5389,28 @@ def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> t tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) if _code_index_available(self.session): return tool_classes - return tuple(tool for tool in tool_classes if tool not in (FindCodeSymbolTool, OutlineCodeFileTool, InspectCodeSymbolTool)) + return tuple(tool for tool in tool_classes if tool is not InspectCodeTool) def _discovery_prompt_hint(self, tool_classes: Iterable[ToolClass]) -> str: - if FindCodeSymbolTool not in tool_classes and OutlineCodeFileTool not in tool_classes and InspectCodeSymbolTool not in tool_classes: + if InspectCodeTool not in tool_classes: return "Use Search/List/LineCount when path, symbol, range, or target is unknown." return ( - "For structural code discovery, prefer indexed code tools before Search/Read.\n" - "- Use FindCodeSymbol for symbol candidates by name/prefix with optional kind/path/exact_only filters.\n" - "- Use InspectCodeSymbol for anchored source, imports, members, references, and implementors of one symbol.\n" - "- Use OutlineCodeFile for file-level or file-local symbol outlines.\n" + "For structural code discovery, prefer InspectCode before Search/Read.\n" + "- InspectCode mode=find: symbol candidates by name/prefix with optional kind/path/exact_only/limit filters.\n" + "- InspectCode mode=inspect: anchored source, imports, members, references, and implementors for one symbol.\n" + "- InspectCode mode=outline: file-level or file-local symbol outlines.\n" "- Use Search for exact literal text, config, comments, logs, or when no useful path/symbol guess exists.\n" "- Use List/LineCount when path shape or file size is unknown." ) def _edit_anchor_intro(self, tool_classes: Iterable[ToolClass]) -> str: - if InspectCodeSymbolTool in tool_classes: - return 'Search, Read, and InspectCodeSymbol source lines are hashline-numbered as "line:hash|code".' + if InspectCodeTool in tool_classes: + return 'Search, Read, and InspectCode mode=inspect source lines are hashline-numbered as "line:hash|code".' return 'Search and Read context lines are hashline-numbered as "line:hash|code".' def _edit_anchor_rule(self, tool_classes: Iterable[ToolClass]) -> str: - if InspectCodeSymbolTool in tool_classes: - return "- Search can provide anchors for localized edits; InspectCodeSymbol can provide anchors for known symbols; use Read when you need fuller context" + if InspectCodeTool in tool_classes: + return "- Search can provide anchors for localized edits; InspectCode mode=inspect can provide anchors for known symbols; use Read when you need fuller context" return "- Search can provide anchors for localized edits; use Read when you need fuller context" def _format_user_request(self) -> str: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 32cb2b3..cf86013 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -495,9 +495,7 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path, monkeypatch) assert "record Verify only after edits, explicit checks, or correctness-sensitive work" in prompt assert "for root-cause work, set work_mode=investigate and use hypotheses" in prompt assert "Tracked tasks are complete only after goal.complete=true is set" in prompt - assert "InspectCodeSymbol" not in prompt - assert "OutlineCodeFile" not in prompt - assert "FindCodeSymbol" not in prompt + assert "InspectCode" not in prompt assert "Use Search/List/LineCount when path, symbol, range, or target is unknown" in prompt assert "__discovery_hint__" not in prompt @@ -508,9 +506,7 @@ def test_inspect_code_tools_is_hidden_until_available(tmp_path, monkeypatch): tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] - assert "FindCodeSymbol" not in tool_names - assert "InspectCodeSymbol" not in tool_names - assert "OutlineCodeFile" not in tool_names + assert "InspectCode" not in tool_names prompt = agent.build_user_prompt() assert "- inspect_code:" not in prompt assert "inspect_code_hint" not in prompt @@ -522,19 +518,18 @@ def test_inspect_code_tools_is_visible_when_available(tmp_path, monkeypatch): tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] - assert "FindCodeSymbol" in tool_names - assert "InspectCodeSymbol" in tool_names - assert "OutlineCodeFile" in tool_names + assert "InspectCode" in tool_names system_prompt = agent._system_prompt() - assert "prefer indexed code tools before Search/Read" in system_prompt - assert "Use FindCodeSymbol for symbol candidates by name/prefix with optional kind/path/exact_only filters" in system_prompt - assert "Use InspectCodeSymbol for anchored source, imports, members, references, and implementors" in system_prompt + assert "prefer InspectCode before Search/Read" in system_prompt + assert "InspectCode mode=find" in system_prompt + assert "InspectCode mode=inspect" in system_prompt + assert "InspectCode mode=outline" in system_prompt prompt = agent.build_user_prompt() - assert "Use FindCodeSymbol for symbol/prefix candidates" in prompt - assert "InspectCodeSymbol for chosen symbols and edit anchors" in prompt - assert "OutlineCodeFile for known file structure or file-local symbol outlines" in prompt + assert "Use InspectCode for structural code navigation" in prompt + assert "mode=find for symbol candidates" in prompt + assert "mode=inspect for anchored symbol source" in prompt + assert "mode=outline for file outlines" in prompt assert "code-symbol-index" not in prompt - assert "kind/path/exact_only/limit filters" in prompt assert "Do not pass natural language" in prompt assert "Use Search/Read for text, config, logs, commands, and exact ranges" in prompt diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index 8042b21..d52c77d 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -3,7 +3,7 @@ import nanocode import pytest -from nanocode import Agent, FindCodeSymbolTool, InspectCodeSymbolTool, OutlineCodeFileTool, Session, ToolCallArgError, ToolCallError +from nanocode import Agent, InspectCodeTool, Session, ToolCallArgError, ToolCallError class FakeRepository: @@ -77,23 +77,31 @@ def test_inspect_code_requires_code_index(tmp_path, monkeypatch): monkeypatch.setattr(nanocode, "_code_index_module", lambda: None) with pytest.raises(ToolCallError, match="code index is not available"): - InspectCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool"]) + InspectCodeTool.make(Session(cwd=str(tmp_path)), ["inspect", "Tool"]) def test_code_index_schema_accepts_expected_args(): - for tool in (FindCodeSymbolTool, InspectCodeSymbolTool, OutlineCodeFileTool): - args_schema = tool.tool_schema()["function"]["parameters"]["properties"]["args"] - assert args_schema["minItems"] == 1 - assert args_schema["maxItems"] == 2 + args_schema = InspectCodeTool.tool_schema()["function"]["parameters"]["properties"]["args"] + assert args_schema["minItems"] == 2 + assert args_schema["maxItems"] == 3 def test_inspect_code_rejects_natural_language(tmp_path, monkeypatch): monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) with pytest.raises(ToolCallArgError, match="do not pass natural language"): - InspectCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool class callers"]) + InspectCodeTool.make(Session(cwd=str(tmp_path)), ["inspect", "Tool class callers"]) with pytest.raises(ToolCallArgError, match="do not pass natural language"): - FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool class"]) + InspectCodeTool.make(Session(cwd=str(tmp_path)), ["find", "Tool class"]) + + +def test_inspect_code_rejects_invalid_mode_and_options(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) + + with pytest.raises(ToolCallArgError, match="mode must be find, inspect, or outline"): + InspectCodeTool.make(Session(cwd=str(tmp_path)), ["search", "Tool"]) + with pytest.raises(ToolCallArgError, match="options must be an object"): + InspectCodeTool.make(Session(cwd=str(tmp_path)), ["find", "Tool", "limit=10"]) def test_code_index_missing_is_not_initialized_implicitly(tmp_path, monkeypatch): @@ -101,7 +109,7 @@ def test_code_index_missing_is_not_initialized_implicitly(tmp_path, monkeypatch) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module("missing")) with pytest.raises(ToolCallError, match="code index is not available"): - FindCodeSymbolTool.make(session, ["Tool"]) + InspectCodeTool.make(session, ["find", "Tool"]) assert not [event for event in FakeRepository.events if event[0] in {"repo", "refresh"}] @@ -165,23 +173,23 @@ def test_code_index_refresh_existing_async_starts_for_ready_index(tmp_path, monk assert session.state.code_index_reload_needed is False -def test_find_code_symbol_uses_search_text(tmp_path, monkeypatch): +def test_inspect_code_find_uses_search_text(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) - result = FindCodeSymbolTool.make(session, ["Tool", {"limit": 12, "kind": "class", "path": "nanocode.py", "exact_only": True}]).call() + result = InspectCodeTool.make(session, ["find", "Tool", {"limit": 12, "kind": "class", "path": "nanocode.py", "exact_only": True}]).call() db_path = str(tmp_path / "data" / "projects" / session.project_key() / "code-symbol-index" / "index.sqlite") assert ("search_text", "Tool", "class", "nanocode.py", True, 12, str(tmp_path), db_path) in FakeRepository.events - assert result == "\nquery: Tool\ncount: 1\nsymbol Tool nanocode.py:10:20\n" + assert result == "\nmode: find\nquery: Tool\ncount: 1\nsymbol Tool nanocode.py:10:20\n" -def test_find_code_symbol_clamps_limit(tmp_path, monkeypatch): +def test_inspect_code_find_clamps_limit(tmp_path, monkeypatch): monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) - assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", {"limit": 999}]).limit == 80 - assert FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", {"limit": 0}]).limit == 1 + assert InspectCodeTool.make(Session(cwd=str(tmp_path)), ["find", "Tool", {"limit": 999}]).limit == 80 + assert InspectCodeTool.make(Session(cwd=str(tmp_path)), ["find", "Tool", {"limit": 0}]).limit == 1 with pytest.raises(ToolCallArgError, match="limit must be an integer"): - FindCodeSymbolTool.make(Session(cwd=str(tmp_path)), ["Tool", {"limit": "many"}]) + InspectCodeTool.make(Session(cwd=str(tmp_path)), ["find", "Tool", {"limit": "many"}]) def test_inspect_code_symbol_rejects_files_directories_and_dotted_module_paths(tmp_path, monkeypatch): @@ -191,21 +199,21 @@ def test_inspect_code_symbol_rejects_files_directories_and_dotted_module_paths(t session = Session(cwd=str(tmp_path)) with pytest.raises(ToolCallArgError, match="file or directory"): - InspectCodeSymbolTool.make(session, ["code.py"]) + InspectCodeTool.make(session, ["inspect", "code.py"]) with pytest.raises(ToolCallArgError, match="file or directory"): - InspectCodeSymbolTool.make(session, ["orion.biz.handlers.syftpp"]) + InspectCodeTool.make(session, ["inspect", "orion.biz.handlers.syftpp"]) with pytest.raises(ToolCallArgError, match="module path"): - InspectCodeSymbolTool.make(session, ["pkg.module.symbol"]) + InspectCodeTool.make(session, ["inspect", "pkg.module.symbol"]) -def test_inspect_code_symbol_uses_inspect_text(tmp_path, monkeypatch): +def test_inspect_code_inspect_uses_inspect_text(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path)) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) - result = InspectCodeSymbolTool.make(session, ["Tool", {"path": "nanocode.py", "exact_only": True}]).call() + result = InspectCodeTool.make(session, ["inspect", "Tool", {"path": "nanocode.py", "exact_only": True}]).call() assert ("inspect_text", "Tool", None, "nanocode.py", True, True, str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events - assert result == "\nsymbol:\n name: Tool\nsource:\n status: full\n" + assert result == "\nmode: inspect\nsymbol:\n name: Tool\nsource:\n status: full\n" def test_agent_tool_call_preserves_code_index_options_object(tmp_path, monkeypatch): @@ -215,9 +223,9 @@ def test_agent_tool_call_preserves_code_index_options_object(tmp_path, monkeypat Agent(session).execute_tool_calls( [ { - "name": "InspectCodeSymbol", + "name": "InspectCode", "intention": "inspect exact symbol", - "args": ["Tool", {"path": "nanocode.py", "exact_only": True}], + "args": ["inspect", "Tool", {"path": "nanocode.py", "exact_only": True}], } ] ) @@ -225,16 +233,16 @@ def test_agent_tool_call_preserves_code_index_options_object(tmp_path, monkeypat assert ("inspect_text", "Tool", None, "nanocode.py", True, True, str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events -def test_outline_code_file_uses_outline_text(tmp_path, monkeypatch): +def test_inspect_code_outline_uses_outline_text(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path)) filepath = tmp_path / "code.py" filepath.write_text("class Tool:\n pass\n", encoding="utf-8") monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) - result = OutlineCodeFileTool.make(session, ["code.py", "Tool"]).call() + result = InspectCodeTool.make(session, ["outline", "code.py", {"symbol": "Tool"}]).call() assert ("outline_text", str(filepath), "Tool", str(tmp_path), nanocode._code_index_db_path(session)) in FakeRepository.events - assert result == "\nfile: " + str(filepath) + "\noutline:\n class Tool 0:2 class Tool:\n" + assert result == "\nmode: outline\nfile: " + str(filepath) + "\noutline:\n class Tool 0:2 class Tool:\n" def test_outline_code_file_rejects_directories_and_symbols(tmp_path, monkeypatch): @@ -243,6 +251,6 @@ def test_outline_code_file_rejects_directories_and_symbols(tmp_path, monkeypatch session = Session(cwd=str(tmp_path)) with pytest.raises(ToolCallArgError, match="existing file"): - OutlineCodeFileTool.make(session, ["pkg"]) + InspectCodeTool.make(session, ["outline", "pkg"]) with pytest.raises(ToolCallArgError, match="existing file"): - OutlineCodeFileTool.make(session, ["Tool"]) + InspectCodeTool.make(session, ["outline", "Tool"]) From de06ac634bfc9bf2f5fdfffba60e79701f14b6b4 Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:02:27 -0700 Subject: [PATCH 094/144] Tighten EditFile tool schema --- nanocode.py | 21 +++++++++++++++++++++ tests/test_nanocode_edit_file_tool.py | 10 ++++++++++ 2 files changed, 31 insertions(+) diff --git a/nanocode.py b/nanocode.py index 3f0776a..de098df 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2612,6 +2612,27 @@ class EditFileTool(Tool): edits: list[EditFileEdit] = field(default_factory=list) cwd: str = "" + @classmethod + def tool_schema(cls) -> Json: + schema = super().tool_schema() + edit_schema: Json = _tool_object_schema( + { + "op": {"type": "string", "enum": ["replace", "delete", "insert_before", "insert_after"]}, + "start": {"type": "string", "description": 'Anchor copied from tool output, e.g. "10:a1b2c3".'}, + "end": {"type": "string", "description": "Required for replace/delete; omit for inserts."}, + "content": {"type": "string", "description": "Replacement or inserted text; use empty string for delete."}, + }, + ["op", "start"], + ) + schema["function"]["parameters"]["properties"]["args"] = { + "type": "array", + "minItems": 2, + "maxItems": 2, + "items": {"anyOf": [{"type": "string"}, {"type": "array", "minItems": 1, "items": edit_schema}]}, + "description": 'Exactly two arguments: filepath string, then edits array. Do not pass edits as a JSON string.', + } + return schema + @classmethod def cli_args(cls, args: list[str]) -> list[str]: if len(args) == 2: diff --git a/tests/test_nanocode_edit_file_tool.py b/tests/test_nanocode_edit_file_tool.py index af934be..fd7b357 100644 --- a/tests/test_nanocode_edit_file_tool.py +++ b/tests/test_nanocode_edit_file_tool.py @@ -130,6 +130,16 @@ def test_edit_file_rejects_wrong_arg_shape(tmp_path): EditFileTool.make(session, ["sample.txt", [{"op": "move", "start": "0:abcdef"}]]) +def test_edit_file_schema_describes_two_structured_args(): + args_schema = EditFileTool.tool_schema()["function"]["parameters"]["properties"]["args"] + + assert args_schema["minItems"] == 2 + assert args_schema["maxItems"] == 2 + assert "Do not pass edits as a JSON string" in args_schema["description"] + edit_schema = args_schema["items"]["anyOf"][1]["items"] + assert edit_schema["properties"]["op"]["enum"] == ["replace", "delete", "insert_before", "insert_after"] + + def test_agent_executes_edit_file_with_structured_args(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\n", encoding="utf-8") From d26126e70d9cae68dc0103260130cdd4a6b136db Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:12:14 -0700 Subject: [PATCH 095/144] Preserve streamed tool result batches --- nanocode.py | 22 +++++++++++++----- tests/test_nanocode_agent.py | 43 ++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+), 5 deletions(-) diff --git a/nanocode.py b/nanocode.py index de098df..ce6b81b 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1335,12 +1335,13 @@ def bound_kept(self, *, max_chars: int, max_block_chars: int) -> None: while self.kept_results and len("\n\n".join(self.kept_results)) > max_chars: del self.kept_results[0] - def append_latest(self, executions: list[ToolCallExecution], *, max_index_items: int, checkpoint: int) -> None: + def append_latest(self, executions: list[ToolCallExecution], *, max_index_items: int, checkpoint: int, append: bool = False) -> None: if not executions: return - if self.latest: + if self.latest and not append: self.recent.extend(self.latest) - self.latest = [self.format_execution(execution) for execution in executions] + blocks = [self.format_execution(execution) for execution in executions] + self.latest = [*self.latest, *blocks] if append else blocks self.prune_recent(max_index_items=max_index_items, checkpoint=checkpoint) def prune_recent(self, *, max_index_items: int, checkpoint: int) -> None: @@ -5757,15 +5758,17 @@ def stream_step( committed = False latest_result = AgentRunResult() + streamed_tool_batch_started = False def on_stream_action(action: Json) -> bool: - nonlocal committed, latest_result + nonlocal committed, latest_result, streamed_tool_batch_started committed = True self.stream_stop_requested = False assistant_text = _json_str(action.pop("_assistant_text", None)) or "" response = {"actions": [action]} if assistant_text: response["_assistant_text"] = assistant_text + is_tool = _json_str(action.get("type")) == "tool" invalid_response = self._validate_action_response(response) latest_result = ( self.handle_response( @@ -5773,6 +5776,7 @@ def on_stream_action(action: Json) -> bool: confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message, + append_to_latest=is_tool and streamed_tool_batch_started, ) if invalid_response is None else self._reject_result( @@ -5783,9 +5787,11 @@ def on_stream_action(action: Json) -> bool: "Format_Gate: invalid streamed action.", ) ) + if is_tool: + streamed_tool_batch_started = True if latest_result.done or self.stream_stop_requested: return True - if _json_str(action.get("type")) == "tool" and any(execution.outcome != "success" for execution in self.tool_runner.latest_executions): + if is_tool and any(execution.outcome != "success" for execution in self.tool_runner.latest_executions): return True return self.mode == AgentMode.OBSERVE @@ -5864,12 +5870,14 @@ def execute_tool_calls( *, confirm: ConfirmCallback | None = None, on_auto_approve: ToolDisplayCallback | None = None, + append_to_latest: bool = False, ) -> str: self.tool_runner.execute(tool_calls, confirm=confirm, on_auto_approve=on_auto_approve) self.tool_context.append_latest( self.tool_runner.latest_executions, max_index_items=self.context_budget().index_items, checkpoint=self.blackboard.memory_checkpoint_tool_result_counter, + append=append_to_latest, ) self.session.state.turn_tool_calls += len(self.tool_runner.latest_executions) self.session.state.session_tool_calls += len(self.tool_runner.latest_executions) @@ -6389,6 +6397,7 @@ def _run_tool_actions( confirm: ConfirmCallback | None, on_auto_approve: ToolDisplayCallback | None, on_message: MessageCallback | None, + append_to_latest: bool = False, ) -> bool: if not ctx.tool_calls: return False @@ -6396,6 +6405,7 @@ def _run_tool_actions( ctx.tool_calls, confirm=confirm, on_auto_approve=on_auto_approve, + append_to_latest=append_to_latest, ) if on_message is not None: report = ToolCallDisplayFormatter.latest_report(self.tool_runner.latest_executions) @@ -6639,6 +6649,7 @@ def handle_response( confirm: ConfirmCallback | None = None, on_auto_approve: ToolDisplayCallback | None = None, on_message: MessageCallback | None = None, + append_to_latest: bool = False, ) -> AgentRunResult: try: ctx = self._build_response_context(response) @@ -6684,6 +6695,7 @@ def handle_response( confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message, + append_to_latest=append_to_latest, ): self._drop_old_feedback_after_successful_tools(feedback_checkpoint) DebugTrace.handle_event(self, "handle-tools", ctx, response) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index cf86013..51fb6a6 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -194,6 +194,22 @@ def test_agent_dedupes_same_batch_readonly_tool_calls_keeping_latest(tmp_path): assert "first read" not in latest +def test_agent_can_append_streamed_tool_calls_to_latest_batch(tmp_path): + (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") + (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") + agent = Agent(Session(cwd=str(tmp_path))) + + agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) + agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}], append_to_latest=True) + + latest = _blocks_text(agent.tool_context.latest) + assert "one" in latest + assert "two" in latest + assert 'tool=Read args=["one.txt","0,1"]' in latest + assert 'tool=Read args=["two.txt","0,1"]' in latest + assert agent.tool_context.recent == [] + + def test_agent_does_not_dedupe_nonconsecutive_same_batch_readonly_tool_calls(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\n", encoding="utf-8") @@ -1585,6 +1601,33 @@ def __init__(self, **_kwargs): assert session.state.last_total_tokens == 5 +def test_agent_stream_step_preserves_same_response_tool_batch_in_latest(tmp_path, monkeypatch): + (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") + (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") + + class FakeModelClient: + def request(self, *_args, on_stream_action=None, **_kwargs): + assert on_stream_action is not None + on_stream_action({"type": "tool", "name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}) + on_stream_action({"type": "tool", "name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}) + return {"actions": []} + + agent = Agent(Session(cwd=str(tmp_path))) + agent.model_client = FakeModelClient() + monkeypatch.setattr(agent, "_can_stream_tools", lambda: True) + + result, _response, committed = agent.stream_step() + + latest = _blocks_text(agent.tool_context.latest) + assert result.done is False + assert committed is True + assert "one" in latest + assert "two" in latest + assert 'tool=Read args=["one.txt","0,1"]' in latest + assert 'tool=Read args=["two.txt","0,1"]' in latest + assert agent.tool_context.recent == [] + + def test_agent_request_responses_stream_parses_function_tool_event(tmp_path, monkeypatch): response_calls = [] From 5efa25ac6026b6284629243a5d6242285b52157b Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:17:50 -0700 Subject: [PATCH 096/144] Reduce redundant discovery before edits --- nanocode.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/nanocode.py b/nanocode.py index ce6b81b..bf10f40 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3297,6 +3297,7 @@ def _state_tool_schema(name: str) -> Json: - execute the next useful frontier - batch independent searches, reads, recalls, and checks - serialize only when later arguments depend on earlier results +- if the next edit/check is clear, do it now instead of rereading for confidence - when in verifying phase after edits, prefer the smallest relevant check over more broad reading Prefer useful tool calls over state-only turns. @@ -3341,11 +3342,12 @@ def _state_tool_schema(name: str) -> Json: EditFile anchors use the "line:hash" part; edit text starts immediately after "|". Stop discovery once the next edit/check is clear. +Do not repeat Search/Read/Recall for confidence when visible results already identify target ranges. Editing rules: - make one coherent change per edit action - new file: create a minimal skeleton first, then grow with focused EditFile chunks -- existing file: inspect the exact target before editing +- existing file: use visible anchors when available; inspect only when anchors are missing, stale, or too compressed - never rewrite a large file in one action { __edit_anchor_rule__ } - use medium EditFile batches: usually one file or one logical block with several related edits From e84f6a7e4c297ca7f99aaf51da5ed0ee76ff226d Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:25:41 -0700 Subject: [PATCH 097/144] Clear stale function-tool feedback --- nanocode.py | 4 +++- tests/test_nanocode_agent.py | 1 + 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/nanocode.py b/nanocode.py index bf10f40..450aadf 100644 --- a/nanocode.py +++ b/nanocode.py @@ -5302,6 +5302,7 @@ class Agent: RULE_VALID_TOOL_JSON: ClassVar[str] = "rebuild valid function arguments; for EditFile, use one file/logical block and split oversized batches." STALE_TOOL_FEEDBACK_MARKERS: ClassVar[tuple[str, ...]] = ( "invalid function/tool response", + "invalid function-tool response", "tool call args invalid", "edit failed:", "repeated same failed tool call", @@ -5637,8 +5638,9 @@ def _drop_old_feedback_after_successful_tools(self, checkpoint: int) -> None: if checkpoint <= 0 or not self.tool_runner.latest_executions: return if all(execution.outcome == "success" for execution in self.tool_runner.latest_executions): + markers = tuple(marker.lower() for marker in self.STALE_TOOL_FEEDBACK_MARKERS) self.agent_feedback_errors[:checkpoint] = [ - error for error in self.agent_feedback_errors[:checkpoint] if not any(marker in error for marker in self.STALE_TOOL_FEEDBACK_MARKERS) + error for error in self.agent_feedback_errors[:checkpoint] if not any(marker in error.lower() for marker in markers) ] def _error(self, text: str, rule: str = "") -> str: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 51fb6a6..c853cca 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2699,6 +2699,7 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): def test_agent_drops_old_feedback_after_successful_tool_progress(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.agent_feedback_errors = [ + "Error blocked: Invalid function-tool response: invalid tool arguments.", "Error blocked: tool call args invalid: old bad call.", "Warning blocked: state update-only turn; include frontier tool.", ] From b5e4ec80726047151c3d6dec453355b4472fb73f Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:30:27 -0700 Subject: [PATCH 098/144] Reduce anchor refresh bias before edits --- nanocode.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/nanocode.py b/nanocode.py index 450aadf..c5ac6ec 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1637,7 +1637,7 @@ class ReadTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Read a single known UTF-8 file; pass multiple 0-based start,end ranges for it.", "Each range returns at most 600 lines.", - 'Content is hashline-numbered as "line:hash|code"; EditFile anchors use "line:hash" and code starts after "|".', + 'Content is numbered as "line:hash|code"; use "line:hash" as an EditFile anchor when editing visible lines.', ) SIGNATURE: ClassVar[str] = "Read(filepath[, range_token...]) -> ReadToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( @@ -1687,7 +1687,11 @@ def preview(self) -> str: def call(self) -> str: if len(self.ranges) > 1: - lines = ["", " " + str(len(self.ranges)) + ""] + lines = [ + "", + ' Content lines are "line:hash|code"; EditFile anchors are the "line:hash" part.', + " " + str(len(self.ranges)) + "", + ] for start, end in self.ranges: content, returned_end, range_end, truncated, total_lines = self._read_range(start, end) lines.append(" ") @@ -1697,7 +1701,7 @@ def call(self) -> str: return "\n".join(lines) content, returned_end, range_end, truncated, total_lines = self._read_range(self.start, self.end) - lines = [""] + lines = ["", ' Content lines are "line:hash|code"; EditFile anchors are the "line:hash" part.'] lines.extend(self._format_range_result(self.start, returned_end, range_end, truncated, total_lines, content, indent=" ")) lines.append("") return "\n".join(lines) @@ -1739,10 +1743,7 @@ def _format_range_result( *, indent: str, ) -> list[str]: - lines = [ - indent + "" + str(start) + ":" + str(range_end) + "", - indent + 'Line prefixes are display-only; EditFile anchors use "line:hash"; code starts immediately after "|".', - ] + lines = [indent + "" + str(start) + ":" + str(range_end) + ""] if truncated: note = ( f"Read returned {returned_end - start} lines from {start}:{returned_end} of {total_lines} total lines. " @@ -3339,7 +3340,7 @@ def _state_tool_schema(name: str) -> Json: Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. { __edit_anchor_intro__ } -EditFile anchors use the "line:hash" part; edit text starts immediately after "|". +Visible "line:hash|code" lines already contain EditFile anchors; use the "line:hash" part. Stop discovery once the next edit/check is clear. Do not repeat Search/Read/Recall for confidence when visible results already identify target ranges. @@ -3352,7 +3353,7 @@ def _state_tool_schema(name: str) -> Json: { __edit_anchor_rule__ } - use medium EditFile batches: usually one file or one logical block with several related edits - split when the JSON becomes large, anchors come from unrelated areas, or a previous edit failed -- copy EditFile anchors exactly from visible tool output; if an anchor is stale, inspect the target again +- copy EditFile anchors exactly from visible tool output; reread only after EditFile reports a stale/missing anchor VERIFICATION Verification strength: From 1280e25d97662b68242965fd65de4c93f20b5214 Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:34:59 -0700 Subject: [PATCH 099/144] Clarify EditFile execution timing --- nanocode.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/nanocode.py b/nanocode.py index c5ac6ec..51fda5a 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2599,14 +2599,15 @@ class EditFileTool(Tool): PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "edits") EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - 'Edit an existing UTF-8 file using anchors of the form "line:hash".', - "Supports replace, delete, insert_before, and insert_after edits; all anchors are verified before writing.", - "All edits apply atomically or nothing is written.", + "Edit an existing UTF-8 file once target lines are visible.", + 'Use "line:hash" anchors already shown by Read, Search, or InspectCode.', + "Supports atomic multi-edit batches: replace, delete, insert_before, and insert_after.", + "Reread only if EditFile reports stale or missing anchors.", "Returns changed path plus applied edit count.", ) SIGNATURE: ClassVar[str] = "EditFile(filepath, [{op,start,end,content}, ...]) -> EditFileToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Replace: ["code.py", [{"op":"replace","start":"10:a1b2c3","end":"12:d4e5f6","content":"new lines\\n"}]]', + 'Batch: ["code.py", [{"op":"replace","start":"10:a1b2c3","end":"12:d4e5f6","content":"new lines\\n"},{"op":"delete","start":"20:abc123","end":"20:abc123"}]]', 'Insert: ["code.py", [{"op":"insert_after","start":"20:abc123","content":"new line\\n"}]]', ) From 69a755c53b193d998e9583b4b2767ab697868077 Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:41:14 -0700 Subject: [PATCH 100/144] Reduce edit anchor reread bias --- README.md | 2 +- nanocode.py | 20 ++++++++++---------- tests/test_nanocode_agent.py | 2 +- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index c3b68dd..206f38b 100644 --- a/README.md +++ b/README.md @@ -85,7 +85,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. - Shell: `Bash`, `Git`. - Memory: `Recall` reads stored tool results by key. -`Search`, `Read`, and `InspectCode` mode=inspect return 0-based `line:hash|code` anchors for `EditFile`. For broad mechanical text replacement, shell text pipelines are acceptable when followed by a focused diff or test. +`Search`, `Read`, and `InspectCode` mode=inspect return 0-based `line:hash|code` lines that can be used as edit anchors. For broad mechanical text replacement, shell text pipelines are acceptable when followed by a focused diff or test. ## Commands diff --git a/nanocode.py b/nanocode.py index 51fda5a..35448c3 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1637,7 +1637,7 @@ class ReadTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Read a single known UTF-8 file; pass multiple 0-based start,end ranges for it.", "Each range returns at most 600 lines.", - 'Content is numbered as "line:hash|code"; use "line:hash" as an EditFile anchor when editing visible lines.', + 'Content is numbered as "line:hash|code"; the "line:hash" part is the line anchor.', ) SIGNATURE: ClassVar[str] = "Read(filepath[, range_token...]) -> ReadToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( @@ -1689,7 +1689,7 @@ def call(self) -> str: if len(self.ranges) > 1: lines = [ "", - ' Content lines are "line:hash|code"; EditFile anchors are the "line:hash" part.', + ' Content lines are "line:hash|code"; the "line:hash" part is the line anchor.', " " + str(len(self.ranges)) + "", ] for start, end in self.ranges: @@ -1701,7 +1701,7 @@ def call(self) -> str: return "\n".join(lines) content, returned_end, range_end, truncated, total_lines = self._read_range(self.start, self.end) - lines = ["", ' Content lines are "line:hash|code"; EditFile anchors are the "line:hash" part.'] + lines = ["", ' Content lines are "line:hash|code"; the "line:hash" part is the line anchor.'] lines.extend(self._format_range_result(self.start, returned_end, range_end, truncated, total_lines, content, indent=" ")) lines.append("") return "\n".join(lines) @@ -1879,7 +1879,7 @@ class SearchTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Case-insensitive regex search before Read; use A|B|C for alternatives and \\n for multiline matches.", - 'Returns matching file paths, matched lines, and 0-based context lines as "line:hash|code" anchors usable by EditFile.', + 'Returns matching file paths, matched lines, and 0-based context lines as "line:hash|code".', "For exact text, escape regex metacharacters like braces, parens, dots, stars, and brackets.", "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py, set context=N for 0..30 lines; omitted path defaults to current directory.", "Second positional arg is always path, third positional arg is always glob; with path=, extra leading positional args are joined as regex alternatives.", @@ -2096,7 +2096,7 @@ def _format_result(self, engine: str, matches: list[Match], truncated: bool) -> lines = [""] lines.append(f"* engine: {engine}") if matches: - lines.append('Context lines are 0-based "line:hash|code"; use "line:hash" as EditFile anchors.') + lines.append('Context lines are 0-based "line:hash|code"; the "line:hash" part is the line anchor.') if matches: for match in matches: lines.append(f"* {self._relpath(match.path)}:{match.line_number}: {match.text}") @@ -3341,7 +3341,7 @@ def _state_tool_schema(name: str) -> Json: Use Read only for known paths/ranges or search-narrowed targets. Read small ranges around likely matches. { __edit_anchor_intro__ } -Visible "line:hash|code" lines already contain EditFile anchors; use the "line:hash" part. +Visible "line:hash|code" lines already contain line anchors; use the "line:hash" part. Stop discovery once the next edit/check is clear. Do not repeat Search/Read/Recall for confidence when visible results already identify target ranges. @@ -3354,7 +3354,7 @@ def _state_tool_schema(name: str) -> Json: { __edit_anchor_rule__ } - use medium EditFile batches: usually one file or one logical block with several related edits - split when the JSON becomes large, anchors come from unrelated areas, or a previous edit failed -- copy EditFile anchors exactly from visible tool output; reread only after EditFile reports a stale/missing anchor +- copy line anchors exactly from visible tool output; refresh anchors only after EditFile reports a stale/missing anchor VERIFICATION Verification strength: @@ -5293,11 +5293,11 @@ class Agent: RECENT_EDITS: ClassVar[int] = 20 RULE_VISIBLE_RESULTS: ClassVar[str] = "use visible tool result keys only." RULE_CLOSE_SOURCE: ClassVar[str] = "close or update state that depends on the result before forgetting its source." - RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after EditFile failures use a smaller batch and fresh anchors." + RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after edit failures use a smaller batch and reread only stale ranges." RULE_GOAL_PLAN_FIRST: ClassVar[str] = "set goal and a short plan before mutating tools or verify." RULE_VERIFY_DIRECTLY: ClassVar[str] = 'run verification tools, then report verify status="passed"|"failed"|"blocked".' RULE_TOOL_SIGNATURE: ClassVar[str] = "use the tool signature exactly." - RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile with anchors copied from visible tool output; split oversized batches." + RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile(filepath, edits) with visible line anchors; split oversized batches." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked verification only when blocker=user." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." @@ -5936,7 +5936,7 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: self._remember_agent_error( self._error( "edit failed: " + _format_tool_call_summary(execution.call) + " -> " + _shorten(" ".join(execution.output.split()), 120) + ".", - "use fresh anchors; if the edit is large, retry a smaller coherent batch.", + "reread only stale ranges; if the edit is large, retry a smaller coherent batch.", ) ) if execution.requires_verification: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index c853cca..359fdea 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2693,7 +2693,7 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): assert "ToolCallError: requires args: filepath, edits" in latest assert "got 3 args, expected 2, extra: 1" in agent.agent_feedback_errors[0] - assert "use EditFile with anchors copied from visible tool output" in agent.agent_feedback_errors[0] + assert "use EditFile(filepath, edits) with visible line anchors" in agent.agent_feedback_errors[0] def test_agent_drops_old_feedback_after_successful_tool_progress(tmp_path): From fff4772d6ad8c0c6bd7233cbc7eacca20ae1291b Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:45:18 -0700 Subject: [PATCH 101/144] Tighten edit progress guidance --- nanocode.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index 35448c3..99a82d5 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2599,10 +2599,10 @@ class EditFileTool(Tool): PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "edits") EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Edit an existing UTF-8 file once target lines are visible.", + "Edit an existing UTF-8 file as soon as target lines and replacement text are known.", 'Use "line:hash" anchors already shown by Read, Search, or InspectCode.', "Supports atomic multi-edit batches: replace, delete, insert_before, and insert_after.", - "Reread only if EditFile reports stale or missing anchors.", + "Do not reread visible target lines for confidence; reread only if EditFile reports stale or missing anchors.", "Returns changed path plus applied edit count.", ) SIGNATURE: ClassVar[str] = "EditFile(filepath, [{op,start,end,content}, ...]) -> EditFileToolResult" @@ -3304,6 +3304,7 @@ def _state_tool_schema(name: str) -> Json: Prefer useful tool calls over state-only turns. Pair state updates with the next frontier tool call when tool arguments are already known. +Assistant text is not progress by itself: if you say you will edit/check now, include that tool call in the same response. FORWARD PROGRESS - Advance as far as safely possible in each turn. From 4112fa6c75d4ef756d02fd0396c1d30349ea7a2c Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:50:57 -0700 Subject: [PATCH 102/144] Increase search tool output budget --- nanocode.py | 5 ++++- tests/test_nanocode_agent.py | 13 +++++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/nanocode.py b/nanocode.py index 99a82d5..71de5c9 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1161,6 +1161,7 @@ class Tool: PARAM_NAMES: ClassVar[tuple[str, ...]] = () EFFECT: ClassVar[ToolEffect] = ToolEffect.OTHER REQUIRES_CONFIRMATION: ClassVar[bool | None] = None + OUTPUT_CHARS: ClassVar[int] = MAX_TOOL_OUTPUT_CHARS @classmethod def cli_args(cls, args: list[JsonValue]) -> list[str]: @@ -1872,6 +1873,7 @@ def call(self) -> str: class SearchTool(Tool): NAME: ClassVar[str] = "Search" MAX_MATCHES: ClassVar[int] = 100 + OUTPUT_CHARS: ClassVar[int] = 24_000 MAX_FILE_BYTES: ClassVar[int] = 2_000_000 RG_MAX_FILESIZE: ClassVar[str] = "2M" CONTEXT_LINES: ClassVar[int] = 4 @@ -4697,7 +4699,8 @@ def _store_tool_result(self, call: ParsedToolCall, outcome: str, output: str) -> if call.intention: description += " - " + call.intention log_path = self._write_tool_result_log(key, output) - bounded = _bound_tool_output(output, log_path=log_path) + tool_class = TOOL_REGISTRY.get(call.name) + bounded = _bound_tool_output(output, log_path=log_path, max_chars=tool_class.OUTPUT_CHARS if tool_class is not None else MAX_TOOL_OUTPUT_CHARS) self.session.state.tool_result_store[key] = ToolResultItem( description=description, value=bounded.value, diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 359fdea..37fed44 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -289,6 +289,19 @@ def test_agent_tool_results_are_bounded_and_logged(tmp_path): assert (tmp_path / item.log_path).read_text(encoding="utf-8").startswith("") +def test_search_tool_result_uses_larger_output_budget(tmp_path): + sample = tmp_path / "sample.txt" + sample.write_text("".join(f"needle {'x' * 180} {index}\n" for index in range(200)), encoding="utf-8") + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + + agent.execute_tool_calls([{"name": "Search", "intention": "search large result", "args": ["needle", "sample.txt", "context=0"]}]) + + item = session.state.tool_result_store["tr.1"] + assert item.excerpted is True + assert nanocode.MAX_TOOL_OUTPUT_CHARS < len(item.value) <= nanocode.SearchTool.OUTPUT_CHARS + + def test_agent_keeps_latest_batch_and_unreduced_tool_results(tmp_path, monkeypatch): for name in ["one.txt", "two.txt", "three.txt", "four.txt"]: (tmp_path / name).write_text(name + "\n", encoding="utf-8") From a28a450884793a485c2e0f4b80c7de7fb3fe120a Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 05:53:57 -0700 Subject: [PATCH 103/144] Clarify mechanical rename tool choice --- nanocode.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index 71de5c9..f282303 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3388,8 +3388,8 @@ def _state_tool_schema(name: str) -> Json: Prefer dedicated tools for precise file reads/searches and structured edits. Bash is for shell semantics: tests/builds, explicit commands, and fast Unix text-tool pipelines with find, sed, awk, perl, xargs, or grep. Prefer dedicated tools when they give cleaner structured repo access. -Mechanical literal rename/replacement across known files may use shell text pipelines when faster and clearer; verify afterward with Git diff, Search/Read, tests, or another focused check. -For code changes, prefer CreateFile for new files and EditFile for existing files over shell rewrites. +Mechanical literal rename/replacement across known files should use shell text pipelines when that is faster and clearer than collecting edit anchors; verify afterward with Git diff, Search/Read, tests, or another focused check. +For code changes, prefer CreateFile for new files and EditFile for structured existing-file edits over shell rewrites. Git is for status, diff, history, and changed files. Recall fetches stored result keys; batch distinct keys and recall each needed key at most once. From 216b0fe06fb1c0c78639dc138b8bd3e987d4eb0f Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 23:10:24 -0700 Subject: [PATCH 104/144] List available shell tools dynamically --- nanocode.py | 7 +++++-- tests/test_nanocode_agent.py | 13 +++++++++++-- 2 files changed, 16 insertions(+), 4 deletions(-) diff --git a/nanocode.py b/nanocode.py index f282303..c595fed 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2774,7 +2774,7 @@ class BashTool(Tool): "Run one explicit shell command via bash -lc in cwd.", "Returns exit_code plus stdout/stderr; long output is stored and bounded in context.", "Prefer dedicated tools when they provide structured repo access; use Bash when shell semantics or pipelines are the clearest path.", - "Good Bash uses include tests, builds, and Unix text-tool pipelines with find, sed, awk, perl, xargs, or grep.", + "Good Bash uses include tests, builds, and Unix text-tool pipelines with tools listed in Environment.", "Mechanical shell edits are allowed, but verify afterward with Git diff, Read, tests, or another focused check.", ) SIGNATURE: ClassVar[str] = "Bash(command) -> BashToolResult" @@ -3386,7 +3386,7 @@ def _state_tool_schema(name: str) -> Json: TOOLS Prefer dedicated tools for precise file reads/searches and structured edits. -Bash is for shell semantics: tests/builds, explicit commands, and fast Unix text-tool pipelines with find, sed, awk, perl, xargs, or grep. +Bash is for shell semantics: tests/builds, explicit commands, and fast Unix text-tool pipelines with tools listed in Environment. Prefer dedicated tools when they give cleaner structured repo access. Mechanical literal rename/replacement across known files should use shell text pipelines when that is faster and clearer than collecting edit anchors; verify afterward with Git diff, Search/Read, tests, or another focused check. For code changes, prefer CreateFile for new files and EditFile for structured existing-file edits over shell rewrites. @@ -5375,6 +5375,9 @@ def _format_environment(self) -> str: "- arch: " + self.session.arch, "- cwd: " + self.session.cwd, ] + shell_tools = [name for name in ("find", "rg", "perl", "sed", "awk", "xargs", "grep", "jq") if shutil.which(name)] + if shell_tools: + lines.append("- shell_tools: " + ", ".join(shell_tools)) if _code_index_available(self.session): lines.append( "- inspect_code_hint: Use InspectCode for structural code navigation: mode=find for symbol candidates, mode=inspect for anchored symbol source, mode=outline for file outlines. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 37fed44..191d260 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -677,13 +677,22 @@ def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): prompt = agent._system_prompt() assert "Bash is for shell semantics" in prompt - for name in ("find", "sed", "awk", "perl", "xargs", "grep"): - assert name in prompt + assert "tools listed in Environment" in prompt assert "structured repo access" in prompt assert "Mechanical literal rename/replacement" in prompt assert "verify afterward" in prompt +def test_act_prompt_lists_available_shell_tools_in_environment(tmp_path, monkeypatch): + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/bin/" + name if name in {"rg", "jq"} else None) + agent = Agent(Session(cwd=str(tmp_path))) + + prompt = agent.build_user_prompt() + + assert "- shell_tools: rg, jq" in prompt + assert "- shell_tools: find" not in prompt + + def test_act_prompt_includes_kept_tool_results(tmp_path): (tmp_path / "sample.txt").write_text("alpha unique\n", encoding="utf-8") (tmp_path / "other.txt").write_text("beta unique\n", encoding="utf-8") From 4aea58d026383818d3cc383e62acbeb8d81d5ace Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 23:14:16 -0700 Subject: [PATCH 105/144] Add EditFile replace_all operation --- nanocode.py | 54 +++++++++++++++++++++++---- tests/test_nanocode_edit_file_tool.py | 47 ++++++++++++++++++++++- 2 files changed, 92 insertions(+), 9 deletions(-) diff --git a/nanocode.py b/nanocode.py index c595fed..82c8e2a 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2593,6 +2593,8 @@ class EditFileEdit: start: str end: str content: str + old: str = "" + new: str = "" @dataclass @@ -2603,13 +2605,15 @@ class EditFileTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Edit an existing UTF-8 file as soon as target lines and replacement text are known.", 'Use "line:hash" anchors already shown by Read, Search, or InspectCode.', - "Supports atomic multi-edit batches: replace, delete, insert_before, and insert_after.", + "Supports atomic multi-edit batches: replace, delete, insert_before, insert_after, and replace_all.", + "Use replace_all for literal file-wide text replacement when anchors are unnecessary.", "Do not reread visible target lines for confidence; reread only if EditFile reports stale or missing anchors.", "Returns changed path plus applied edit count.", ) - SIGNATURE: ClassVar[str] = "EditFile(filepath, [{op,start,end,content}, ...]) -> EditFileToolResult" + SIGNATURE: ClassVar[str] = "EditFile(filepath, [{op,start,end,content}|{op:'replace_all',old,new}, ...]) -> EditFileToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Batch: ["code.py", [{"op":"replace","start":"10:a1b2c3","end":"12:d4e5f6","content":"new lines\\n"},{"op":"delete","start":"20:abc123","end":"20:abc123"}]]', + 'Literal replace all: ["code.py", [{"op":"replace_all","old":"OldName","new":"NewName"}]]', 'Insert: ["code.py", [{"op":"insert_after","start":"20:abc123","content":"new line\\n"}]]', ) @@ -2620,7 +2624,7 @@ class EditFileTool(Tool): @classmethod def tool_schema(cls) -> Json: schema = super().tool_schema() - edit_schema: Json = _tool_object_schema( + anchored_edit_schema: Json = _tool_object_schema( { "op": {"type": "string", "enum": ["replace", "delete", "insert_before", "insert_after"]}, "start": {"type": "string", "description": 'Anchor copied from tool output, e.g. "10:a1b2c3".'}, @@ -2629,11 +2633,19 @@ def tool_schema(cls) -> Json: }, ["op", "start"], ) + replace_all_schema: Json = _tool_object_schema( + { + "op": {"type": "string", "enum": ["replace_all"]}, + "old": {"type": "string", "description": "Required for replace_all; literal text to replace."}, + "new": {"type": "string", "description": "Required for replace_all; literal replacement text."}, + }, + ["op", "old", "new"], + ) schema["function"]["parameters"]["properties"]["args"] = { "type": "array", "minItems": 2, "maxItems": 2, - "items": {"anyOf": [{"type": "string"}, {"type": "array", "minItems": 1, "items": edit_schema}]}, + "items": {"anyOf": [{"type": "string"}, {"type": "array", "minItems": 1, "items": {"anyOf": [anchored_edit_schema, replace_all_schema]}}]}, "description": 'Exactly two arguments: filepath string, then edits array. Do not pass edits as a JSON string.', } return schema @@ -2661,11 +2673,21 @@ def _edit_from_json(value: JsonValue) -> EditFileEdit: if not item: raise ToolCallArgError("each edit must be an object") op = str(item.get("op") or "").strip() - if op not in {"replace", "delete", "insert_before", "insert_after"}: - raise ToolCallArgError("edit op must be replace, delete, insert_before, or insert_after") + if op not in {"replace", "delete", "insert_before", "insert_after", "replace_all"}: + raise ToolCallArgError("edit op must be replace, delete, insert_before, insert_after, or replace_all") start = str(item.get("start") or "").strip() end = str(item.get("end") or "").strip() content = str(item.get("content") or "") + old = str(item.get("old") or "") + new = str(item.get("new") or "") + if op == "replace_all": + if "old" not in item or "new" not in item: + raise ToolCallArgError("replace_all requires old and new") + if not old: + raise ToolCallArgError("replace_all old cannot be empty") + if start or end: + raise ToolCallArgError("replace_all does not use anchors") + return EditFileEdit(op=op, start="", end="", content="", old=old, new=new) if not start: raise ToolCallArgError("edit start anchor is required") if op in {"replace", "delete"} and not end: @@ -2703,7 +2725,11 @@ def call(self) -> str: f"* path: {relpath}", f"* edits: {len(replacements)}", ] - lines.extend(f"* range[{index}]: {start}:{end}" for index, (start, end, _) in enumerate(replacements, start=1)) + for index, (start, end, _) in enumerate(replacements, start=1): + if start < 0: + lines.append(f"* replace_all[{index}]: {end} replacements") + else: + lines.append(f"* range[{index}]: {start}:{end}") lines.append("") return "\n".join(lines) @@ -2713,6 +2739,19 @@ def _preview(self) -> tuple[str, str, list[tuple[int, int, list[str]]]]: original = f.read() except FileNotFoundError: raise ToolCallError("file does not exist; use CreateFile for new files") + if any(edit.op == "replace_all" for edit in self.edits): + if any(edit.op != "replace_all" for edit in self.edits): + raise ToolCallError("replace_all cannot be mixed with anchored edits") + new_content = original + replacements = [] + for edit in self.edits: + count = new_content.count(edit.old) + if count == 0: + raise ToolCallError("replace_all old text not found") + new_content = new_content.replace(edit.old, edit.new) + replacements.append((-1, count, [])) + return original, new_content, replacements + lines = original.splitlines(keepends=True) replacements = [] for edit in self.edits: @@ -3352,6 +3391,7 @@ def _state_tool_schema(name: str) -> Json: Editing rules: - make one coherent change per edit action - new file: create a minimal skeleton first, then grow with focused EditFile chunks +- literal file-wide replacement: use EditFile replace_all - existing file: use visible anchors when available; inspect only when anchors are missing, stale, or too compressed - never rewrite a large file in one action { __edit_anchor_rule__ } diff --git a/tests/test_nanocode_edit_file_tool.py b/tests/test_nanocode_edit_file_tool.py index fd7b357..7f78320 100644 --- a/tests/test_nanocode_edit_file_tool.py +++ b/tests/test_nanocode_edit_file_tool.py @@ -73,6 +73,44 @@ def test_edit_file_inserts_and_deletes_atomically(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\ninserted\nbeta\nDELTA\n" +def test_edit_file_replace_all_literal_text_without_anchors(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("OldName alpha\nOldName beta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + tool = EditFileTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "OldName", "new": "NewName"}]]) + display = tool.preview() + result = tool.call() + + assert "-OldName alpha\n" in display + assert "+NewName alpha\n" in display + assert path.read_text(encoding="utf-8") == "NewName alpha\nNewName beta\n" + assert "* edits: 1" in result + assert "* replace_all[1]: 2 replacements" in result + + +def test_edit_file_replace_all_rejects_no_match_or_mixed_edits(tmp_path): + path = tmp_path / "sample.txt" + path.write_text("alpha\nbeta\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + anchors = _read_anchors(session, "sample.txt") + + with pytest.raises(ToolCallError, match="old text not found"): + EditFileTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "missing", "new": "x"}]]).call() + with pytest.raises(ToolCallError, match="cannot be mixed"): + EditFileTool.make( + session, + [ + "sample.txt", + [ + {"op": "replace_all", "old": "alpha", "new": "ALPHA"}, + {"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}, + ], + ], + ).call() + assert path.read_text(encoding="utf-8") == "alpha\nbeta\n" + + def test_edit_file_rejects_stale_anchor_without_writing(tmp_path): path = tmp_path / "sample.txt" path.write_text("alpha\nbeta\n", encoding="utf-8") @@ -128,6 +166,10 @@ def test_edit_file_rejects_wrong_arg_shape(tmp_path): EditFileTool.make(session, ["sample.txt", []]) with pytest.raises(ToolCallError, match="edit op must be"): EditFileTool.make(session, ["sample.txt", [{"op": "move", "start": "0:abcdef"}]]) + with pytest.raises(ToolCallError, match="replace_all requires old and new"): + EditFileTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "alpha"}]]) + with pytest.raises(ToolCallError, match="replace_all old cannot be empty"): + EditFileTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "", "new": "beta"}]]) def test_edit_file_schema_describes_two_structured_args(): @@ -136,8 +178,9 @@ def test_edit_file_schema_describes_two_structured_args(): assert args_schema["minItems"] == 2 assert args_schema["maxItems"] == 2 assert "Do not pass edits as a JSON string" in args_schema["description"] - edit_schema = args_schema["items"]["anyOf"][1]["items"] - assert edit_schema["properties"]["op"]["enum"] == ["replace", "delete", "insert_before", "insert_after"] + edit_schemas = args_schema["items"]["anyOf"][1]["items"]["anyOf"] + assert edit_schemas[0]["properties"]["op"]["enum"] == ["replace", "delete", "insert_before", "insert_after"] + assert edit_schemas[1]["properties"]["op"]["enum"] == ["replace_all"] def test_agent_executes_edit_file_with_structured_args(tmp_path): From 0821ca11c5999ae4976566da8cb57aef3f406fa6 Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 23:21:34 -0700 Subject: [PATCH 106/144] Preserve raw bad function-call arguments --- nanocode.py | 33 +++++++++++++++++++++++++-------- tests/test_nanocode_agent.py | 30 ++++++++++++++++++++++++++++++ 2 files changed, 55 insertions(+), 8 deletions(-) diff --git a/nanocode.py b/nanocode.py index 82c8e2a..b5c932c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -4277,7 +4277,12 @@ def _action_from_function_call(self, name: str, arguments: str) -> Json: try: value = json.loads(arguments or "{}") except Exception as error: - return {"type": name or "invalid_tool_call", "_format_error": "invalid tool arguments: " + str(error)} + tool_name = name or "invalid_tool_call" + return { + "type": tool_name, + "_format_bad_output": arguments, + "_format_error": "invalid tool arguments for " + tool_name + ": " + str(error), + } args = _json_dict(value) if name in TOOL_REGISTRY: return {"type": "tool", "name": name, "intention": _json_str(args.get("intention")) or "", "args": _json_list(args.get("args"))} @@ -4491,7 +4496,10 @@ def _invalid_model_response(self, content: str, reason: str = "expected a functi return { "actions": [], "_format_bad_output": content, - "_format_error": "Invalid function-tool response: " + reason + ". Use the provided function tools. Bad output: " + _shorten(content), + "_format_error": "Invalid function-tool response: " + + reason + + ". Use valid function tool calls with JSON arguments matching the tool schema. Bad output: " + + _shorten(content), } def _message_content(self, result: JsonValue) -> str | None: @@ -6043,21 +6051,30 @@ def _remember_recent_edit(self, execution: ToolCallExecution) -> None: self.recent_edits.append("- " + path + ": " + _shorten(intention, 160)) self.recent_edits = self.recent_edits[-self.RECENT_EDITS :] - def _invalid_action_response(self, response: Json, reason: str) -> Json: + def _invalid_action_response(self, response: Json, reason: str, bad_output: str | None = None) -> Json: + bad_output = bad_output if bad_output is not None else json.dumps(response, ensure_ascii=False) return { "actions": [], - "_format_error": f"Invalid function-tool response: {reason}. Use the provided function tools. Bad output: " - + _shorten(json.dumps(response, ensure_ascii=False)), + "_format_bad_output": bad_output, + "_format_error": f"Invalid function-tool response: {reason}. Use valid function tool calls with JSON arguments matching the tool schema. Bad output: " + + _shorten(bad_output), } def _validate_action_response(self, response: Json) -> Json | None: actions = response.get("actions") if not isinstance(actions, list): return self._invalid_action_response(response, "expected actions array") - action_errors = [_json_str(action.get("_format_error")) for action in (_json_dict(item) for item in actions)] - action_errors = [error for error in action_errors if error] + action_bad_outputs = [] + action_errors = [] + for action in (_json_dict(item) for item in actions): + error = _json_str(action.get("_format_error")) + if error: + action_errors.append(error) + bad_output = _json_str(action.get("_format_bad_output")) + if bad_output: + action_bad_outputs.append(bad_output) if action_errors: - return self._invalid_action_response(response, "; ".join(action_errors)) + return self._invalid_action_response(response, "; ".join(action_errors), "\n".join(action_bad_outputs) or None) extra_keys = sorted(str(key) for key in response.keys() if key not in {"actions", "_assistant_text"} and not str(key).startswith("_format_")) if extra_keys: return self._invalid_action_response(response, "unexpected top-level keys: " + ", ".join(extra_keys)) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 191d260..fb83d1c 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1499,6 +1499,36 @@ def test_agent_request_sends_function_tool_schema_and_parses_tool_call(tmp_path, assert session.state.last_total_tokens == 5 +def test_agent_step_preserves_raw_bad_function_arguments(tmp_path, monkeypatch): + bad_arguments = '{"text":"broken",' + _patch_openai( + monkeypatch, + { + "choices": [ + { + "message": { + "tool_calls": [ + { + "function": { + "name": "goal", + "arguments": bad_arguments, + } + } + ], + } + } + ] + }, + ) + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) + + response = Agent(session).step() + + assert response["_format_bad_output"] == bad_arguments + assert "invalid tool arguments for goal" in response["_format_error"] + assert "Bad output: " + bad_arguments in response["_format_error"] + + def test_agent_accepts_string_plan_items_from_function_call(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) response = {"actions": [{"type": "plan", "mode": "replace", "items": ["Create demo", "Run smoke test"]}]} From e6d00edb085b1cce2a7678d67f84fc7f59c7fa4e Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 14:26:21 +0800 Subject: [PATCH 107/144] minor fix --- nanocode.py | 64 ++++++++++++++++++++++++++--------------------------- 1 file changed, 31 insertions(+), 33 deletions(-) diff --git a/nanocode.py b/nanocode.py index b5c932c..f2de25f 100644 --- a/nanocode.py +++ b/nanocode.py @@ -60,6 +60,7 @@ JsonValue: TypeAlias = Any Json: TypeAlias = dict[str, JsonValue] + ############################ # Errors ############################ @@ -104,14 +105,11 @@ class ConversationItem: role: Role time: datetime = field(default_factory=datetime.now) - def format_ts(self) -> str: - return self.time.strftime("%Y-%m-%d %H:%M:%S") - def format_transcript(self, title: str, content: str, indent: str = "") -> str: quoted = ["> " + line if line else ">" for line in content.splitlines()] if not quoted: quoted = [">"] - return _format_lines([f"#### {title} {self.format_ts()}", *quoted], indent) + return _format_lines([f"#### {title} {self.time.strftime('%Y-%m-%d %H:%M:%S')}", *quoted], indent) @dataclass @@ -408,13 +406,7 @@ def source_result_keys(self) -> set[str]: return keys def protected_result_sources(self) -> dict[str, str]: - return { - key: "active hypothesis" - for item in self.hypotheses - if item.status == HypothesisStatus.ACTIVE - for key in item.source - if key.startswith("tr.") - } + return {key: "active hypothesis" for item in self.hypotheses if item.status == HypothesisStatus.ACTIVE for key in item.source if key.startswith("tr.")} @dataclass(frozen=True) @@ -1203,6 +1195,7 @@ def tool_schema(cls) -> Json: def requires_confirmation(self, session: Session) -> bool: return self.REQUIRES_CONFIRMATION if self.REQUIRES_CONFIRMATION is not None else self.EFFECT == ToolEffect.EDIT + ToolClass: TypeAlias = Type[Tool] @@ -1252,11 +1245,7 @@ def _bound_tool_output(output: str, *, log_path: str = "", max_chars: int = MAX_ "[tool result excerpt]\n" "excerpted: true\n" "note: only an excerpt is visible; use Recall with a line range or Read smaller targeted ranges instead of repeating the same large read.\n" - "original_lines: " - + str(original_lines) - + "\noriginal_chars: " - + str(original_chars) - + "\n" + "original_lines: " + str(original_lines) + "\noriginal_chars: " + str(original_chars) + "\n" ) labels = ("\n--- head ---\n", "\n--- middle ---\n", "\n--- tail ---\n") body_budget = max_chars - len(header) - sum(len(label) for label in labels) @@ -1472,6 +1461,7 @@ def forget_result_keys_from_actions(actions: list[Json]) -> list[str]: keys.extend(key for key in _source_from_json(action) if key.startswith("tr.")) return list(dict.fromkeys(keys)) + ConfirmationResult: TypeAlias = bool | str ConfirmCallback: TypeAlias = Callable[[ParsedToolCall, Tool], ConfirmationResult] ToolDisplayCallback: TypeAlias = Callable[[ParsedToolCall, Tool], None] @@ -2646,7 +2636,7 @@ def tool_schema(cls) -> Json: "minItems": 2, "maxItems": 2, "items": {"anyOf": [{"type": "string"}, {"type": "array", "minItems": 1, "items": {"anyOf": [anchored_edit_schema, replace_all_schema]}}]}, - "description": 'Exactly two arguments: filepath string, then edits array. Do not pass edits as a JSON string.', + "description": "Exactly two arguments: filepath string, then edits array. Do not pass edits as a JSON string.", } return schema @@ -4881,10 +4871,14 @@ def _format_state_report( self._append_state_section(lines, " Plan", self._format_plan_rows()) hypotheses = [item.format() for item in current.hypotheses] if hypotheses != before_hypotheses: - self._append_state_section(lines, " Hypotheses", self._format_rows(current.hypotheses, lambda index, item: f" {index}. {self._compact(item.format())}")) + self._append_state_section( + lines, " Hypotheses", self._format_rows(current.hypotheses, lambda index, item: f" {index}. {self._compact(item.format())}") + ) known = [KnownItem.format_item(item) for item in current.known] if known != before_known: - self._append_state_section(lines, " Known", self._format_rows(current.known, lambda index, item: f" {index}. {self._compact(KnownItem.format_item(item))}")) + self._append_state_section( + lines, " Known", self._format_rows(current.known, lambda index, item: f" {index}. {self._compact(KnownItem.format_item(item))}") + ) user_rules = self.session.state.user_rules.format() if user_rules != before_user_rules: self._append_state_section(lines, " User_Rules updated") @@ -5148,9 +5142,8 @@ def _apply_task_code(self, actions: list[Json]) -> None: return tracked_state = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) if ( - ("goal" in action_types or "plan" in action_types or "hypothesis" in action_types or (tracked_state and "tool" in action_types)) - and not self.blackboard.goal_reached - ): + "goal" in action_types or "plan" in action_types or "hypothesis" in action_types or (tracked_state and "tool" in action_types) + ) and not self.blackboard.goal_reached: self.blackboard.task_code = TaskCode.WORKING def _append_state_section(self, lines: list[str], title: str, rows: list[str] | None = None) -> None: @@ -5810,9 +5803,7 @@ def stream_step( if _json_str(response.get("_format_error")): return AgentRunResult(), response, False return ( - self.handle_response( - response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message - ), + self.handle_response(response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message), response, False, ) @@ -5873,9 +5864,7 @@ def on_stream_action(action: Json) -> bool: if invalid_response is not None: return AgentRunResult(), invalid_response, False return ( - self.handle_response( - response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message - ), + self.handle_response(response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message), response, False, ) @@ -6380,7 +6369,10 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N if ctx.pending_verify_requested: self._warn_agent('ignored verify status="pending".', self.RULE_VERIFY_DIRECTLY) if self.session.state.pending_user_feedback and ctx.goal_will_change: - self._warn_agent("Pending User Feedback is not a new task by default.", "answer it without rewriting Goal unless the user explicitly replaces or cancels the task.") + self._warn_agent( + "Pending User Feedback is not a new task by default.", + "answer it without rewriting Goal unless the user explicitly replaces or cancels the task.", + ) self._drop_goal_rewrite_actions(ctx) if ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested and (ctx.pending_verify_requested or ctx.has_edit_tool_call): self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) @@ -6547,7 +6539,12 @@ def _warn_weak_observe_memory(self, actions: list[Json]) -> None: item = KnownItem.from_json(raw) if item is not None and KnownItem.source_of(item): return - self._remember_observe_error(self._warning("weak observe memory: known facts need source tr.N or keep/forget coverage.", "use source-backed known/hypothesis or keep important raw results.")) + self._remember_observe_error( + self._warning( + "weak observe memory: known facts need source tr.N or keep/forget coverage.", + "use source-backed known/hypothesis or keep important raw results.", + ) + ) def _forget_tool_result_error(self, actions: list[Json]) -> str: keys = ToolResultContext.forget_result_keys_from_actions(actions) @@ -8300,7 +8297,9 @@ def _emit(self, message: str) -> None: def _print_welcome(self) -> None: index_status, _index_message = _code_index_status(self.agent.session) - index_tip = [("ansibrightblack", " tip: "), ("ansicyan", "/index"), ("ansiwhite", " initializes indexed code tools\n")] if index_status == "missing" else [] + index_tip = ( + [("ansibrightblack", " tip: "), ("ansicyan", "/index"), ("ansiwhite", " initializes indexed code tools\n")] if index_status == "missing" else [] + ) plain_tip = " tip: /index initializes indexed code tools\n" if index_status == "missing" else "" self._emit_segments( [("bold ansicyan", "nanocode"), ("ansiwhite", " - AI coding assistant\n")] @@ -8322,8 +8321,7 @@ def _print_welcome(self) -> None: "nanocode - AI coding assistant\n" " /help [question] for help or source-aware questions\n" " /status for current session state;\n" - " during work: enter queues, c-c cancels, c-d exits\n" - + plain_tip, + " during work: enter queues, c-c cancels, c-d exits\n" + plain_tip, end="", ) From f6d82b94928df4ed81efd783a444356ea1db4796 Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 23:39:14 -0700 Subject: [PATCH 108/144] Default Search context to match line only --- nanocode.py | 4 ++-- tests/test_nanocode_search_tool.py | 14 ++++++-------- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/nanocode.py b/nanocode.py index f2de25f..53fb287 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1866,14 +1866,14 @@ class SearchTool(Tool): OUTPUT_CHARS: ClassVar[int] = 24_000 MAX_FILE_BYTES: ClassVar[int] = 2_000_000 RG_MAX_FILESIZE: ClassVar[str] = "2M" - CONTEXT_LINES: ClassVar[int] = 4 + CONTEXT_LINES: ClassVar[int] = 0 MAX_CONTEXT_LINES: ClassVar[int] = 30 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Case-insensitive regex search before Read; use A|B|C for alternatives and \\n for multiline matches.", 'Returns matching file paths, matched lines, and 0-based context lines as "line:hash|code".', "For exact text, escape regex metacharacters like braces, parens, dots, stars, and brackets.", - "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py, set context=N for 0..30 lines; omitted path defaults to current directory.", + "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py, set context=N for 0..30 surrounding lines; omitted context defaults to 0.", "Second positional arg is always path, third positional arg is always glob; with path=, extra leading positional args are joined as regex alternatives.", "Use at most one glob= per Search. For multiple extensions, run multiple Search actions or search path=. without glob.", "Batch multiple Search actions in one turn when checking independent patterns or multiple globs.", diff --git a/tests/test_nanocode_search_tool.py b/tests/test_nanocode_search_tool.py index fa2cd03..595782d 100644 --- a/tests/test_nanocode_search_tool.py +++ b/tests/test_nanocode_search_tool.py @@ -194,7 +194,7 @@ def test_search_tool_context_anchor_can_drive_edit_file(tmp_path, monkeypatch): assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" -def test_search_tool_python_backend_includes_four_context_lines(tmp_path, monkeypatch): +def test_search_tool_python_backend_includes_default_context_lines(tmp_path, monkeypatch): path = tmp_path / "sample.txt" path.write_text("one\ntwo\nthree\nneedle\nfive\nsix\nseven\neight\nnine\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) @@ -203,14 +203,12 @@ def test_search_tool_python_backend_includes_four_context_lines(tmp_path, monkey result = SearchTool.make(session, ["needle", "sample.txt"]).call() assert "* sample.txt:4: needle" in result - assert " 0:" in result and "|one" in result - assert " 1:" in result and "|two" in result - assert " 2:" in result and "|three" in result assert " > 3:" in result and "|needle" in result - assert " 4:" in result and "|five" in result - assert " 5:" in result and "|six" in result - assert " 6:" in result and "|seven" in result - assert " 7:" in result and "|eight" in result + assert "|three" not in result + assert "|five" not in result + assert "|one" not in result + assert "|two" not in result + assert "|six" not in result assert "|nine" not in result From 429053c742e4b93cf5bf710789718d131d359e8b Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 23:44:09 -0700 Subject: [PATCH 109/144] Keep large Search results structured --- nanocode.py | 40 +++++++++++++++++++++++++----- tests/test_nanocode_search_tool.py | 15 +++++++++++ 2 files changed, 49 insertions(+), 6 deletions(-) diff --git a/nanocode.py b/nanocode.py index 53fb287..12d8daf 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1873,7 +1873,8 @@ class SearchTool(Tool): "Case-insensitive regex search before Read; use A|B|C for alternatives and \\n for multiline matches.", 'Returns matching file paths, matched lines, and 0-based context lines as "line:hash|code".', "For exact text, escape regex metacharacters like braces, parens, dots, stars, and brackets.", - "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py, set context=N for 0..30 surrounding lines; omitted context defaults to 0.", + "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py; omitted context defaults to 0.", + "Use context=N only when nearby lines are needed; prefer context=0 for broad searches and renames.", "Second positional arg is always path, third positional arg is always glob; with path=, extra leading positional args are joined as regex alternatives.", "Use at most one glob= per Search. For multiple extensions, run multiple Search actions or search path=. without glob.", "Batch multiple Search actions in one turn when checking independent patterns or multiple globs.", @@ -2084,23 +2085,50 @@ def _read_match_context(self, path: str, line_number: int) -> list[tuple[int, st return [] return context - def _format_result(self, engine: str, matches: list[Match], truncated: bool) -> str: + def _format_result_lines(self, engine: str, matches: list[Match], *, truncated: bool, include_context: bool, context_omitted: bool = False) -> list[str]: lines = [""] lines.append(f"* engine: {engine}") if matches: lines.append('Context lines are 0-based "line:hash|code"; the "line:hash" part is the line anchor.') + if context_omitted: + lines.append("* context_omitted: result too large; rerun with a narrower path or fewer matches for surrounding lines") if matches: for match in matches: lines.append(f"* {self._relpath(match.path)}:{match.line_number}: {match.text}") - for index, line in match.context: - marker = ">" if index == match.line_number - 1 else " " - lines.append(f" {marker} {_numbered_line_preview(index, line)}") + if include_context: + for index, line in match.context: + marker = ">" if index == match.line_number - 1 else " " + lines.append(f" {marker} {_numbered_line_preview(index, line)}") else: lines.append("No matches.") if truncated: lines.append("* truncated: true") lines.append("") - return "\n".join(lines) + return lines + + def _format_result(self, engine: str, matches: list[Match], truncated: bool) -> str: + lines = self._format_result_lines(engine, matches, truncated=truncated, include_context=True) + value = "\n".join(lines) + if len(value) <= self.OUTPUT_CHARS: + return value + if self.context_lines > 0: + lines = self._format_result_lines(engine, matches, truncated=truncated, include_context=False, context_omitted=True) + value = "\n".join(lines) + if len(value) <= self.OUTPUT_CHARS: + return value + + lines = self._format_result_lines(engine, [], truncated=True, include_context=False) + prefix = lines[:2] + suffix = lines[-2:] + body: list[str] = [] + for match in matches: + candidate = [*prefix, *body, f"* {self._relpath(match.path)}:{match.line_number}: {match.text}", *suffix] + if len("\n".join(candidate)) > self.OUTPUT_CHARS: + break + body.append(f"* {self._relpath(match.path)}:{match.line_number}: {match.text}") + if not body and matches: + body.append(_shorten(f"* {self._relpath(matches[0].path)}:{matches[0].line_number}: {matches[0].text}", self.OUTPUT_CHARS // 2)) + return "\n".join([*prefix, *body, *suffix]) def _rg_command(self, rg: str, *, pcre2: bool = False) -> list[str]: cmd = [rg, "--json", "--line-number", "--max-filesize", self.RG_MAX_FILESIZE] diff --git a/tests/test_nanocode_search_tool.py b/tests/test_nanocode_search_tool.py index 595782d..79b64c9 100644 --- a/tests/test_nanocode_search_tool.py +++ b/tests/test_nanocode_search_tool.py @@ -245,6 +245,21 @@ def test_search_tool_supports_context_option_without_glob(tmp_path, monkeypatch) assert " 6:" in result and "|seven" in result +def test_search_tool_omits_context_before_outer_excerpt(tmp_path, monkeypatch): + path = tmp_path / "sample.txt" + path.write_text(("before " + "x" * 300 + "\nneedle\n") * 4, encoding="utf-8") + session = Session(cwd=str(tmp_path)) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") + monkeypatch.setattr(SearchTool, "OUTPUT_CHARS", 700) + + result = SearchTool.make(session, ["needle", "sample.txt", "context=1"]).call() + + assert "* context_omitted:" in result + assert "* sample.txt:2: needle" in result + assert "|before " not in result + assert "[tool result excerpt]" not in result + + def test_search_tool_accepts_context_30(tmp_path): session = Session(cwd=str(tmp_path)) From e18e7a78ce2c4889a5d019a485affe850d13a10f Mon Sep 17 00:00:00 2001 From: hit9 Date: Fri, 22 May 2026 23:48:22 -0700 Subject: [PATCH 110/144] Support multiple tool signatures --- nanocode.py | 44 +++++++++++++++++++++++++++++++++++++------- 1 file changed, 37 insertions(+), 7 deletions(-) diff --git a/nanocode.py b/nanocode.py index 12d8daf..d67ce89 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1148,7 +1148,8 @@ class ToolEffect(StrEnum): class Tool: NAME: ClassVar[str] DESCRIPTION: ClassVar[tuple[str, ...]] = () - SIGNATURE: ClassVar[str] + SIGNATURE: ClassVar[str] = "" + SIGNATURES: ClassVar[tuple[str, ...]] = () EXAMPLE: ClassVar[tuple[str, ...]] = () PARAM_NAMES: ClassVar[tuple[str, ...]] = () EFFECT: ClassVar[ToolEffect] = ToolEffect.OTHER @@ -1178,11 +1179,19 @@ def cli_token(value: JsonValue) -> str: return text return json.dumps(text, ensure_ascii=False) + @classmethod + def signatures(cls) -> tuple[str, ...]: + return cls.SIGNATURES or ((cls.SIGNATURE,) if cls.SIGNATURE else ()) + + @classmethod + def schema_description(cls) -> str: + return " ".join((*cls.DESCRIPTION, *cls.signatures(), *cls.EXAMPLE)) + @classmethod def tool_schema(cls) -> Json: return _function_tool_schema( cls.NAME, - " ".join((*cls.DESCRIPTION, cls.SIGNATURE, *cls.EXAMPLE)), + cls.schema_description(), _tool_object_schema( { "intention": {"type": "string", "description": "Question being answered or concrete outcome needed."}, @@ -1630,7 +1639,10 @@ class ReadTool(Tool): "Each range returns at most 600 lines.", 'Content is numbered as "line:hash|code"; the "line:hash" part is the line anchor.', ) - SIGNATURE: ClassVar[str] = "Read(filepath[, range_token...]) -> ReadToolResult" + SIGNATURES: ClassVar[tuple[str, ...]] = ( + "Read(filepath) -> first 600 lines with line:hash anchors", + "Read(filepath, 'start,end'[, 'start,end'...]) -> selected 0-based ranges with line:hash anchors", + ) EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["code.py", "0,80", "160,220"]', 'Example args: ["code.py"]', @@ -1804,7 +1816,11 @@ class ListTool(Tool): "Returns each immediate entry with type and relative path.", "Batch multiple List actions in one turn when checking several known directories.", ) - SIGNATURE: ClassVar[str] = "List([dirpath][, glob]) -> ListToolResult" + SIGNATURES: ClassVar[tuple[str, ...]] = ( + "List() -> current directory entries", + "List(dirpath) -> one directory entries", + "List(dirpath, glob) -> immediate entries matching glob", + ) EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["src"]', 'Example args: ["src", "*.py"]', "Current dir args: []") dirpath: str = "" @@ -1880,7 +1896,12 @@ class SearchTool(Tool): "Batch multiple Search actions in one turn when checking independent patterns or multiple globs.", "Only options are path=, glob=, context=; escape regex symbols for literal text.", ) - SIGNATURE: ClassVar[str] = "Search(pattern[, path=path][, glob=pattern][, context=N]) -> SearchToolResult" + SIGNATURES: ClassVar[tuple[str, ...]] = ( + "Search(pattern) -> recursive match lines under current directory", + "Search(pattern, path=FILE_OR_DIR) -> recursive match lines under path", + "Search(pattern, path=FILE_OR_DIR, glob=GLOB) -> recursive match lines filtered by glob", + "Search(pattern, path=FILE_OR_DIR, context=N) -> match lines plus N surrounding lines", + ) EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["class .*Tool", "path=nanocode.py", "context=0"]', 'Example args: ["TODO|FIXME", "path=.", "glob=*.py", "context=2"]', @@ -2418,7 +2439,11 @@ class InspectCodeTool(Tool): "find options: limit, kind, path, exact_only; inspect options: kind, path, exact_only; outline options: symbol.", "find/inspect targets are symbol names or prefixes, not natural language or literal text; outline target is a file path.", ) - SIGNATURE: ClassVar[str] = "InspectCode(mode, target[, options]) -> InspectCodeToolResult" + SIGNATURES: ClassVar[tuple[str, ...]] = ( + "InspectCode('find', symbol_prefix[, {limit, kind, path, exact_only}]) -> symbol candidates with file/range", + "InspectCode('inspect', symbol_name[, {kind, path, exact_only}]) -> anchored source, signature, imports, and callers/callees when available", + "InspectCode('outline', filepath[, {symbol}]) -> file outline, or focused outline for one symbol in the file", + ) EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Find: ["find", "Tool", {"kind":"class","limit":20}]', 'Inspect: ["inspect", "Agent.run", {"path":"nanocode.py","exact_only":true}]', @@ -2628,7 +2653,12 @@ class EditFileTool(Tool): "Do not reread visible target lines for confidence; reread only if EditFile reports stale or missing anchors.", "Returns changed path plus applied edit count.", ) - SIGNATURE: ClassVar[str] = "EditFile(filepath, [{op,start,end,content}|{op:'replace_all',old,new}, ...]) -> EditFileToolResult" + SIGNATURES: ClassVar[tuple[str, ...]] = ( + "EditFile(filepath, [{op:'replace', start, end, content}, ...]) -> replace anchored ranges", + "EditFile(filepath, [{op:'delete', start, end}, ...]) -> delete anchored ranges", + "EditFile(filepath, [{op:'insert_before'|'insert_after', start, content}, ...]) -> insert at anchors", + "EditFile(filepath, [{op:'replace_all', old, new}]) -> literal file-wide replacement", + ) EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Batch: ["code.py", [{"op":"replace","start":"10:a1b2c3","end":"12:d4e5f6","content":"new lines\\n"},{"op":"delete","start":"20:abc123","end":"20:abc123"}]]', 'Literal replace all: ["code.py", [{"op":"replace_all","old":"OldName","new":"NewName"}]]', From 0f4bb0aa7262680b6dacd34bf2cee595ea5d6d17 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 00:12:55 -0700 Subject: [PATCH 111/144] Simplify visible agent state and remove plan mode --- README.md | 9 +- nanocode.py | 566 ++++++++------------------------ tests/test_nanocode_agent.py | 149 +++------ tests/test_nanocode_commands.py | 44 +-- tests/test_nanocode_loop.py | 54 +-- 5 files changed, 221 insertions(+), 601 deletions(-) diff --git a/README.md b/README.md index 206f38b..ebe46c3 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ Pre-1.0 note: nanocode is still evolving quickly. Functionality, commands, confi - **Function Tools**: Route model decisions through auditable tools. - **Verified Edits**: Reject stale range edits before they touch files. -- **Autonomous Loop**: Chain reading, editing, running, and verification. +- **Autonomous Loop**: Chain reading, editing, running, and checks. - **Live Telemetry**: Stream tool intent, token use, and status. ## Install @@ -61,7 +61,6 @@ Ask a source-aware question about nanocode itself: CLI arguments: - `--yolo`: Skip tool execution confirmations. -- `--plan`: Plan changes without editing files or running commands. - `--debug`: Write request prompts to the current session directory under `~/.nanocode/sessions/`. - `--config `: Path to config file (default: `~/.nanocode/config.toml`). - `--init-config`: Create a default config file. @@ -90,7 +89,7 @@ nanocode currently targets macOS and Linux. Windows is not supported. ## Commands - Info: `/help [question]`, `/status`, `/rules`, `/compact`. -- Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/reason-payload [value]`, `/provider [name]`, `/plan [on|off|question]`, `/yolo`. +- Config: `/config`, `/set `, `/api [auto|chat|responses]`, `/model [model_name]`, `/reason`, `/reason-payload [value]`, `/provider [name]`, `/yolo`. - Maintenance: `/index [force]`, `/clean`. - Exit: `/exit`, `/quit`. @@ -112,5 +111,5 @@ Run `nanocode --init-config` to create `~/.nanocode/config.toml`. ## Status -- Status bar: active model, reasoning, active yolo/plan modes, conversation context, current-turn tool calls, tokens, elapsed time, and active model-call time. -- `/status`: active provider, model state, session id, runtime state, conversation/tool counters, per-model calls/tokens, task, goal, and verification. +- Status bar: active model, reasoning, active yolo mode, conversation context, current-turn tool calls, tokens, elapsed time, and active model-call time. +- `/status`: active provider, model state, session id, runtime state, conversation/tool counters, per-model calls/tokens, goal, and checks. diff --git a/nanocode.py b/nanocode.py index d67ce89..a8ca01b 100644 --- a/nanocode.py +++ b/nanocode.py @@ -406,7 +406,7 @@ def source_result_keys(self) -> set[str]: return keys def protected_result_sources(self) -> dict[str, str]: - return {key: "active hypothesis" for item in self.hypotheses if item.status == HypothesisStatus.ACTIVE for key in item.source if key.startswith("tr.")} + return {key: "active lead" for item in self.hypotheses if item.status == HypothesisStatus.ACTIVE for key in item.source if key.startswith("tr.")} @dataclass(frozen=True) @@ -579,27 +579,21 @@ class RuntimeSettings: shell_timeout: int = 60 compact_at: int = 50 max_agent_steps: int = 100 - plan_timeout: int = 360 - plan_first_token_timeout: int = 180 auto_clean_recent: str = "1d" context_budget: str = "medium" yolo: bool = False - plan_mode: bool = False debug: bool = False @classmethod - def from_dict(cls, data: Json, *, yolo: bool = False, plan_mode: bool = False, debug: bool = False) -> "RuntimeSettings": + def from_dict(cls, data: Json, *, yolo: bool = False, debug: bool = False) -> "RuntimeSettings": runtime = Config.table(data, "runtime") return cls( shell_timeout=Config.int(runtime, "shell_timeout", 60), compact_at=Config.int(runtime, "compact_at", 50), max_agent_steps=max(1, Config.int(runtime, "max_agent_steps", 100) or 0), - plan_timeout=max(1, Config.int(runtime, "plan_timeout", 360) or 0), - plan_first_token_timeout=max(1, Config.int(runtime, "plan_first_token_timeout", 180) or 0), auto_clean_recent=cls.clean_retention(Config.str(runtime, "auto_clean_recent", "1d")), context_budget=cls.clean_context_budget(Config.str(runtime, "context_budget", "medium")), yolo=yolo or bool(Config.bool(runtime, "yolo", False)), - plan_mode=plan_mode or bool(Config.bool(runtime, "plan_mode", False)), debug=debug, ) @@ -751,13 +745,10 @@ class ConfigFile: shell_timeout = 60 compact_at = 50 max_agent_steps = 100 -plan_timeout = 360 -plan_first_token_timeout = 180 context_budget = "medium" # Automatically delete inactive session directories older than this. Use "off" to disable. auto_clean_recent = "1d" yolo = false -plan_mode = false """ @classmethod @@ -853,12 +844,12 @@ class Session: code_index_repository: Any | None = None @classmethod - def from_config_file(cls, *, path: str | None = None, yolo: bool = False, plan_mode: bool = False, debug: bool = False) -> "Session": - return cls.from_config_data(ConfigFile.load(path), yolo=yolo, plan_mode=plan_mode, debug=debug) + def from_config_file(cls, *, path: str | None = None, yolo: bool = False, debug: bool = False) -> "Session": + return cls.from_config_data(ConfigFile.load(path), yolo=yolo, debug=debug) @classmethod - def from_config_data(cls, data: Json, *, yolo: bool = False, plan_mode: bool = False, debug: bool = False) -> "Session": - session = cls(config=Config.from_dict(data), settings=RuntimeSettings.from_dict(data, yolo=yolo, plan_mode=plan_mode, debug=debug)) + def from_config_data(cls, data: Json, *, yolo: bool = False, debug: bool = False) -> "Session": + session = cls(config=Config.from_dict(data), settings=RuntimeSettings.from_dict(data, yolo=yolo, debug=debug)) session.load_user_rules() return session @@ -1102,7 +1093,6 @@ def handle_event( def _agent_payload(agent: Any) -> Json: return { "mode": agent.mode, - "task_code": agent.blackboard.task_code, "goal": agent.blackboard.goal, "plan_items": len(agent.blackboard.plan), "feedback_tail": agent.agent_feedback_errors[-3:], @@ -3090,15 +3080,6 @@ def call(self) -> str: return _format_process_result("GitToolResult", -1, error.stdout or "", (error.stderr or "") + "timeout") -class PlanModeGitTool(GitTool): - NAME: ClassVar[str] = "Git" - DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Run readonly git commands only: status, diff, log, show, rev-parse, ls-files, grep, blame.", - "Returns exit_code plus stdout/stderr.", - "Pass each git argument separately; optional first arg cwd=path changes repository directory.", - ) - - @dataclass class ToolResultTool(Tool): NAME: ClassVar[str] = "Recall" @@ -3180,15 +3161,6 @@ def _content(self, item: ToolResultItem) -> str: GitTool.NAME: GitTool, ToolResultTool.NAME: ToolResultTool, } -PLAN_MODE_TOOLS: tuple[ToolClass, ...] = ( - ReadTool, - LineCountTool, - ListTool, - InspectCodeTool, - SearchTool, - PlanModeGitTool, - ToolResultTool, -) def _canonical_tool_name(name: str | None) -> str: @@ -3231,17 +3203,16 @@ def _canonical_tool_name(name: str | None) -> str: STATE_TOOL_PARAMS: dict[str, tuple[str, Json, list[str]]] = { "goal": ( - "Set, update, or complete the current goal. Use work_mode=investigate for root-cause/debug work; use message_for_complete for the final user message.", + "Set, update, or complete the current goal. Use message_for_complete for the final user message.", { "text": TOOL_STRING_SCHEMA, - "work_mode": {"type": ["string", "null"], "enum": ["normal", "investigate"]}, "complete": {"type": "boolean"}, "message_for_complete": TOOL_NULLABLE_STRING_SCHEMA, }, ["text", "complete", "message_for_complete"], ), "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), - "hypothesis": ("Update investigation hypotheses.", {"items": TOOL_HYPOTHESIS_ITEMS_SCHEMA}, ["items"]), + "hypothesis": ("Update investigation leads.", {"items": TOOL_HYPOTHESIS_ITEMS_SCHEMA}, ["items"]), "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "user_rule": ( "Remember an explicit future behavior rule from the user.", @@ -3254,7 +3225,7 @@ def _canonical_tool_name(name: str | None) -> str: ["source", "reason"], ), "verify": ( - "Record concrete verification status.", + "Record concrete check status.", { "kind": TOOL_STRING_SCHEMA, "method": TOOL_NULLABLE_STRING_SCHEMA, @@ -3280,7 +3251,7 @@ def _state_tool_schema(name: str) -> Json: COMPACT_TOOL_SCHEMA = _function_tool_schema( "compact", - "Return a compact continuation summary and retained known facts.", + "Return a compact continuation summary and retained facts.", _tool_object_schema( { "summary": TOOL_STRING_SCHEMA, @@ -3298,7 +3269,7 @@ def _state_tool_schema(name: str) -> Json: Use function tools to update state and work on the repository. Assistant text is optional. Do not answer with text when a useful tool call should be made. -Tracked tasks are complete only after goal.complete=true is set. +Multi-step tasks are complete only after goal.complete=true is set. Language rule: all user-facing assistant text MUST use the latest user language. This includes chat text, progress text, pending-feedback replies, direct responses, and message_for_complete. @@ -3317,43 +3288,43 @@ def _state_tool_schema(name: str) -> Json: - args: tool arguments PRIORITY -Latest User Request > User Rules > Current Goal > Plan/Known > Conversation History. - -Current Phase: -- new: align latest request with current state, or start readonly discovery -- working: continue the current goal -- verifying: run or record verification -- done: wait for the next user request +Latest User Request > User Rules > Current Goal > Plan/Facts > Conversation History. -Do not rewrite the Goal when Current Phase is working/verifying unless the user changed the task. Never repeat a previous completion as the answer. +Do not rewrite the Goal unless the user changed the task. TASK SHAPES -Chat: +Simple answer: - direct conversation, clarification, or explanation that needs no repository action - answer with assistant text only -- do not use Goal, Plan, Known, or Verify +- do not use Goal, Plan, Facts, Leads, or Checks -One-shot: +One-shot task: - one bounded lookup/check/tool batch whose visible result answers the request - call needed tools, then answer with assistant text and stop -- do not create Goal, Plan, Known, or Verify just to report the result +- do not create Goal, Plan, Facts, Leads, or Checks just to report the result -Tracked task: -- multi-step work, edits, debugging, investigation, explicit verification, or work that may span turns +Multi-step task: +- implementation, edits, debugging, investigation, explicit checks, or work that may span turns - set Goal; set Plan once enough context is known -- record Verify only after edits, explicit checks, or correctness-sensitive work +- record Checks only after edits, explicit checks, or correctness-sensitive work - complete with goal.complete=true STATE -Known: +Facts: - settled current-task facts that matter after tool results disappear - not intentions, TODOs, guesses, routine observations, duplicates, or raw logs -Hypotheses: -- competing investigation directions +Leads: +- investigation directions for root-cause, debugging, or troubleshooting work - status: { __hypothesis_status_text__ } -- each hypothesis should imply a concrete check +- each lead should imply a concrete check +- do not create Leads for ordinary implementation or rename tasks + +Checks: +- concrete checks that were run, failed, or were blocked +- use the verify tool to record Checks +- do not record Checks for simple answers unless the user requested checks User Rules: - only explicit future-behavior requests from the user @@ -3362,34 +3333,25 @@ def _state_tool_schema(name: str) -> Json: - visible tool results are temporary support context - inspect visible results before deciding the next action - OBSERVE owns keep/forget cleanup -- preserve useful conclusions in goal, plan, known, hypothesis, or verify; forget noise when it no longer helps +- preserve useful conclusions in Goal, Plan, Facts, Leads, or Checks; forget noise when it no longer helps - do not let old gate feedback dominate once fresh tool results answer the next step WORKFLOW -Classify the latest request as Chat, One-shot, or Tracked task before deciding state tools. +Classify the latest request as Simple answer, One-shot task, or Multi-step task before deciding state tools. -If the request is Chat: +If the request is a Simple answer: - answer directly and stop -If the request is One-shot: +If the request is a One-shot task: - use tools only until the requested answer is visible - answer directly and stop -If there is no Goal and the request is a Tracked task: +If the request is a Multi-step task: - set a Goal -- if enough context is known, also set a short Plan or call the first useful readonly tools -- for root-cause work, set work_mode=investigate and use hypotheses to track competing explanations - -If there is a Goal but no Plan: -- set a short Plan -- or run readonly discovery first if planning needs context - -If there is a Goal and Plan: -- execute the next useful frontier -- batch independent searches, reads, recalls, and checks -- serialize only when later arguments depend on earlier results -- if the next edit/check is clear, do it now instead of rereading for confidence -- when in verifying phase after edits, prefer the smallest relevant check over more broad reading +- set a short Plan when enough context is known, or run the first useful readonly discovery first +- use Leads only for root-cause/debug/investigation work +- execute the next useful frontier once the Plan exists +- after edits or requested checks, record Checks with the smallest relevant check Prefer useful tool calls over state-only turns. Pair state updates with the next frontier tool call when tool arguments are already known. @@ -3398,7 +3360,7 @@ def _state_tool_schema(name: str) -> Json: FORWARD PROGRESS - Advance as far as safely possible in each turn. - Batch independent tool calls whenever their arguments are known. -- Do not stop after Goal, Plan, Known, or Hypothesis updates if a useful repository tool call is clear. +- Do not stop after Goal, Plan, Facts, or Leads updates if a useful repository tool call is clear. - Serialize only when later arguments depend on earlier results. - Ask the user only when the blocker cannot be resolved by available tools. @@ -3412,18 +3374,18 @@ def _state_tool_schema(name: str) -> Json: - at most one item may be doing - done context must cite supporting result context - blocked context must name the concrete blocker -- add a verify step only for edits, explicit checks, or correctness-sensitive work +- add a check step only for edits, explicit checks, or correctness-sensitive work -If all Plan items are done/blocked and verification passed/blocked, finish by default. +If all Plan items are done/blocked and Checks passed/blocked, finish by default. To continue tools after that, first reopen the Plan with a todo/doing item explaining why completion is insufficient. INVESTIGATION -Use work_mode=investigate for root-cause analysis, competing explanations, or branch elimination. +Use Leads for root-cause analysis, competing explanations, or branch elimination. Rules: - track plausible directions separately -- mark hypotheses ruled_out when evidence eliminates them -- mark hypotheses confirmed before claiming root cause +- mark leads ruled_out when evidence eliminates them +- mark leads confirmed before claiming root cause - stop investigating when the exact target and next edit/check are clear DISCOVERY AND EDITING @@ -3447,8 +3409,8 @@ def _state_tool_schema(name: str) -> Json: - split when the JSON becomes large, anchors come from unrelated areas, or a previous edit failed - copy line anchors exactly from visible tool output; refresh anchors only after EditFile reports a stale/missing anchor -VERIFICATION -Verification strength: +CHECKS +Check strength: - none: simple answers - light: read/static confirmation - tool: code changes or requested checks @@ -3465,12 +3427,12 @@ def _state_tool_schema(name: str) -> Json: - blocker when blocked Passed context must cite concrete recent tool result context. -Blocked verification must include blocker and context. +Blocked Checks must include blocker and context. -If verification fails, record failed, repair, then verify again. +If a check fails, record failed, repair, then verify again. A test/build run in the same batch as a failed edit does not verify the repaired state. -Do not use pending verification status. -Complete with verify blocked only when blocker=user. +Do not use pending check status. +Complete with blocked Checks only when blocker=user. TOOLS Prefer dedicated tools for precise file reads/searches and structured edits. @@ -3486,165 +3448,6 @@ def _state_tool_schema(name: str) -> Json: Always move the task toward the next useful state. """ -AGENT_PLAN_SYSTEM_PROMPT = """You are nanocode in PLAN MODE. - -You are a planning agent, not an implementation agent. - -OUTPUT PROTOCOL -- Use function tools for state updates and readonly repository actions. -- Assistant text is optional; never use it instead of the next useful function tool. -- PLAN MODE is a tracked planning task; complete it with goal.complete=true. -- Allowed state tools: goal, plan, hypothesis, known, verify. -- Allowed repository tools: Read, LineCount, List, Search, Recall, and readonly Git. -- Repository tool calls require intention and args. -- Do not invent fields when a tool schema already fits. - -MODE BOUNDARIES -- Produce an implementation plan for the latest user request. -- Do not implement, change files, run tests, install packages, run shell commands, or mutate repository state. -- Do not propose non-readonly discovery. -- Do not turn the plan into code unless the user explicitly asked only for a design/code sketch outside the repository. -- If the user asks for implementation while you are in PLAN MODE, plan the implementation; do not perform it. - -LANGUAGE -- Use the latest user language for all user-facing text, including progress and the final proposed plan. -- Preserve code, identifiers, filenames, command names, config keys, API names, and quoted text exactly. -- If the user mixes languages, follow the dominant language of the latest request. -- User-facing text is read in a terminal: keep it plain, concise, direct, and CLI-friendly. -- Avoid Markdown tables, large headings, decorative formatting, and long nested bullets unless the user asks for them. - -READONLY DISCOVERY -- Allowed tools: Read, LineCount, List, Search, Recall. -- Git is allowed only for readonly inspection: status, diff, log, show, rev-parse, ls-files, grep, blame. -- Use only the provided readonly function tools. Do not request any other tools. -- Use the smallest useful discovery batch. -- Prefer targeted Search/Read over broad surveys. -- Prefer reading the owning file and nearby tests over unrelated code. -- Stop discovery as soon as the files, ownership boundaries, approach, risks, and verification path are clear enough. -- Call more readonly tools only when the final proposal would otherwise rely on guesswork. - -PLANNING DOCTRINE -Design before action: -- First clarify what problem is being solved, what must not change, and what success looks like. -- Separate the user's goal from the possible implementation mechanism. -- Prefer a correct direction over a fast but structurally wrong shortcut. -- Think several steps ahead, but only propose the smallest useful step now. - -Fit the existing system: -- Fit the existing architecture before proposing new abstractions. -- Identify current ownership boundaries: modules, layers, public APIs, state owners, side-effect owners, and test owners. -- Respect existing naming, style, dependency direction, error handling, and data flow. -- Do not introduce a new architectural style when a local change fits the current one. - -Begin from concerns: -- Identify relevant functional concerns. -- Identify relevant non-functional concerns when they may affect design: performance, consistency, availability, latency, scalability, compatibility, maintainability, security, debuggability, and migration cost. -- State tradeoffs only when they affect the proposed implementation. -- Scale the depth of design analysis to the risk and scope of the request. - -Keep it simple: -- Prefer the simplest design that preserves correctness and future flexibility. -- Avoid speculative generality. -- Add an abstraction only when it removes real duplication, stabilizes a boundary, hides unavoidable complexity, or enables a known extension. -- Avoid thin pass-through interfaces that add coupling without adding capability. -- Avoid special-case fixes unless the request is itself special-case behavior. -- If two designs are viable, prefer the one with fewer moving parts, clearer ownership, and easier verification. - -Module and layer judgment: -- Decompose top-down for broad changes: subsystem -> module -> file -> symbol. -- For local changes, begin at the owning symbol and expand only as needed. -- Keep modules focused on one topic. -- Keep high-cohesion logic together and low-coupling boundaries explicit. -- Prefer dependency flow from higher-level orchestration toward lower-level capabilities. -- Avoid new cycles; if a cycle is unavoidable, call it out as a risk or propose a smaller split. -- Push unavoidable complexity downward behind a stable boundary when doing so simplifies callers. -- Do not leak internal failure handling, retries, fallback, or compatibility mechanics into unrelated callers. - -Interfaces and contracts: -- For any public or shared interface, identify the contract before proposing changes. -- Check whether the interface should be orthogonal to nearby APIs, whether it overlaps existing behavior, and whether important cases are missing. -- Prefer interfaces that make the common case simple. -- Note idempotency, undefined behavior, validation, error cases, compatibility, and call ordering when relevant. -- Prefer explicit names and explicit state transitions over ambiguous combined operations. -- Preserve backward compatibility unless the user explicitly asks for a breaking change. -- If compatibility may break, propose versioning, migration, adapter behavior, or rollback. - -Data, state, and side effects: -- Identify what data is read, written, derived, cached, emitted, or persisted. -- Keep data model changes minimal and direct. -- Separate calculation from IO when it makes the logic easier to test or reason about. -- Separate data and behavior when behavior should apply to many entities or batches. -- Separate strategy/policy from core model when business rules may vary while the model should stay stable. -- Identify side effects such as filesystem writes, network calls, database writes, cache invalidation, events, logging, metrics, and user-visible output. - -Time, concurrency, and sequencing: -- When behavior spans multiple steps, processes, workers, requests, events, or retries, describe the sequence. -- Identify the driver: user action, request, IO event, queue consumer, cron/timer, test runner, or background worker. -- Call out ordering assumptions, races, idempotency requirements, retry behavior, and compensation paths when relevant. -- For event/signal based designs, avoid circular signal chains and unclear ownership. - -Closed-loop reliability: -- Prefer designs where each module contains its own routine failure handling. -- Prevent errors, retries, fallback, and cleanup responsibilities from leaking across unrelated boundaries. -- Include observability/debuggability when useful: logs, metrics, traces, error messages, assertions, or inspection points. -- Include rollback or migration concerns when a change affects public APIs, persisted data, configuration, deployment, or shared behavior. -- Use redundancy/fallback only when it addresses a real failure mode; keep the added complexity local. - -Verification: -- Scale verification with risk. -- For local changes, propose narrow tests or checks near the touched code. -- For shared contracts, propose broader regression tests. -- For data, migration, compatibility, or concurrency risks, propose targeted edge-case tests. -- Include manual verification only when automated verification is unavailable or insufficient. -- Verification steps must be executable by a coding agent, but you must not run them. - -DISCOVERY STRATEGY -1. When Current Phase is new, set one concise planning goal and 2-4 discovery steps when enough context is known. -2. Search for owners before reading large files. -3. Prefer support from code, tests, docs, and recent relevant Git history. -4. After tool results, use Latest Tool Results, Unreduced Tool Results, and Kept Tool Results; use known for settled current-task facts. -5. Update plan status as discovery progresses. -6. If the request is ambiguous but a reasonable reversible path exists, proceed with stated assumptions and include open questions in the final plan. -7. Complete with goal.complete=true only when the final proposal is ready. - -FUNCTION TOOL SEMANTICS -- goal: initialize or update the planning goal; set work_mode when useful. -- plan: update discovery or planning item status. -- known: record durable repository findings from discovery. Do not include guesses. -- assistant text: brief user-facing status update in the latest user language. -- repository tools: request readonly discovery. -- verify: record only concrete verification status from readonly discovery; put planned checks in the final proposed plan. -- goal: complete the planning task with the final proposed plan. - -FINAL MESSAGE CONTRACT -- The final action must be type="goal" with complete=true. -- message_for_complete must contain exactly one ... block. -- Do not include text before or after the block inside message_for_complete. -- The proposed plan must be concrete and executable by a coding agent. -- The proposed plan must not include implementation output, generated patches, command execution results, or claims that tests were run. - -The block should include these sections, in this order: -1. Goal -2. Current understanding / durable findings -3. Design rationale -4. Touched files and symbols -5. Ordered implementation steps -6. Verification plan -7. Risks, tradeoffs, rollback, and open questions - -FINAL PLAN QUALITY BAR -Before completing, ensure the plan answers: -- What is the smallest correct change? -- Which module owns the change? -- What public contracts or data contracts are affected? -- What state, side effects, or sequencing matter? -- What failure modes should stay closed-loop within the owning module? -- What compatibility or migration concern exists, if any? -- How should the coding agent verify the change? -- What uncertainty remains? - -""" - AGENT_USER_PROMPT_TEMPLATE = """ --- Background --- @@ -3676,29 +3479,7 @@ def _state_tool_schema(name: str) -> Json: Recent Edits: {recent_edits} -Known: -{known} - -Current Phase: -{task_code} - -Work Mode: -{work_mode} - -Goal: -{goal} - -Plan: -{plan} - -Current Focus: -{current_focus} - -Hypotheses: -{hypotheses} - -Verification: -{verification_state} +{state_sections} Blocking Feedback - Fix Before Next Action: {errors} @@ -3715,19 +3496,18 @@ def _state_tool_schema(name: str) -> Json: - Treat it as an interrupt to the current task, not a new task. - After responding, continue the existing Goal/Plan unless the user explicitly replaces or cancels the task. - Do not rewrite Goal/Plan just to answer a side question or acknowledge a correction. -If Current Phase is working or verifying, continue from the existing Goal and Plan unless the user changed the task. -If Current Phase is working and Plan is not empty, do not stop on state-only updates; include tool, verify, or goal. +If a Goal or Plan is present, continue it unless the user changed the task. +If a Plan is present, do not stop on state-only updates; include tool, verify, or goal when useful. Before repeating or broadening tool calls, inspect visible tool results. -If Current Phase is new and visible tool results answer the request, answer with assistant text and stop. -If they already answer a one-shot request, answer directly instead of calling more tools. +If visible tool results already answer a one-shot request, answer directly instead of calling more tools. Otherwise use them to update state, choose the next frontier, or forget noise. --- Output --- Use function tools for task state and repository actions. -Chat: answer with assistant text only. -One-shot with no Goal or Plan: assistant text is the final answer once visible results answer the request. -Tracked task: assistant text is optional; never use it instead of the next useful function tool. Goal completion requires goal.complete=true. +Simple answer: answer with assistant text only. +One-shot task with no Goal or Plan: assistant text is the final answer once visible results answer the request. +Multi-step task: assistant text is optional; never use it instead of the next useful function tool. Goal completion requires goal.complete=true. Language rule: every chat/progress/response text must use the latest user language, including pending-feedback replies and final answers. Do not switch to English when the latest user request is Chinese. Terminal output rule: every chat/progress/response text should be plain, concise, and CLI-friendly. Avoid Markdown tables, large headings, decorative formatting, and long nested bullets unless requested. @@ -3749,10 +3529,10 @@ def _state_tool_schema(name: str) -> Json: Plan: {plan} -Hypotheses: +Leads: {hypotheses} -Known: +Facts: {known} Kept Tool Results: @@ -3768,7 +3548,7 @@ def _state_tool_schema(name: str) -> Json: Use function tools only. Prefer explicit KEEP/FORGET decisions. Omitted results are compacted by default. -Known/hypothesis entries from tool results should cite SOURCE tr.N keys. +Facts/Leads entries from tool results should cite SOURCE tr.N keys. Path-only or vague facts do not replace raw results; KEEP the raw result or record a SOURCE-backed, decision-useful conclusion before forgetting/omitting it. YOUR OUTPUT: @@ -3781,11 +3561,11 @@ def _state_tool_schema(name: str) -> Json: Job: - Reduce Unreduced Raw Tool Results before ACT continues. - Prefer declaring KEEP or FORGET for each result you reviewed. -- KEEP only raw results that affect the next ACT frontier: target selection, edit choice, verification, error repair, or completion. +- KEEP only raw results that affect the next ACT frontier: target selection, edit choice, checks, error repair, or completion. - FORGET routine success, duplicate listings, no-match searches, superseded results, and ruled-out branches. Forget preserves logs and Recall. - If you omit a tr.N key, nanocode compacts it by default; use omission only for unimportant results. -- Before compacting or forgetting an important conclusion, preserve it with SOURCE-backed known or hypothesis. -- Do not update Plan, Verify, or Goal. +- Before compacting or forgetting an important conclusion, preserve it with SOURCE-backed Facts or Leads. +- Do not update Plan, Checks, or Goal. Allowed tools: keep, forget, known, hypothesis. """ @@ -3798,7 +3578,7 @@ def _state_tool_schema(name: str) -> Json: COMPACTOR_PROMPT = """You are nanocode's conversation-history compactor. -Compress conversation history and Known facts so the coding agent can continue later. +Compress conversation history and Facts so the coding agent can continue later. Do not solve the task or add unsupported facts. Use the compact function tool only. @@ -3809,9 +3589,9 @@ def _state_tool_schema(name: str) -> Json: - plan/status - files, paths, symbols, and APIs touched - commands run and outcomes -- known facts and context keys needed later +- facts and context keys needed later - unresolved blockers and open questions -- verification context +- checks context Omit noise: - raw logs @@ -3821,14 +3601,14 @@ def _state_tool_schema(name: str) -> Json: - context values unless needed for continuity Write the shortest complete continuation summary. -Compress Known to concise durable facts. +Compress Facts to concise durable facts. """ COMPACT_USER_PROMPT_TEMPLATE = """ ------------ Known_To_Compact Begin ------------ +----------- Facts_To_Compact Begin ------------ {known} ---------- Known_To_Compact End ---------------- +--------- Facts_To_Compact End ---------------- ----------- Conversation_To_Compact Begin ------ {conversation} @@ -4364,8 +4144,6 @@ def _responses_params( def _request_timeouts(self, config: ProviderConfig, *, activity: str) -> tuple[int, int | None]: timeout = config.timeout if config.timeout is not None else 180 first_token_timeout = config.first_token_timeout if config.first_token_timeout is not None else timeout - if activity == "agent" and self.session.settings.plan_mode: - return self.session.settings.plan_timeout, self.session.settings.plan_first_token_timeout return timeout, first_token_timeout def _mark_stream_output(self, chars: int, seen: bool, *, request_deadline: float, first_token_timeout: int | None) -> bool: @@ -4930,12 +4708,12 @@ def _format_state_report( hypotheses = [item.format() for item in current.hypotheses] if hypotheses != before_hypotheses: self._append_state_section( - lines, " Hypotheses", self._format_rows(current.hypotheses, lambda index, item: f" {index}. {self._compact(item.format())}") + lines, " Leads", self._format_rows(current.hypotheses, lambda index, item: f" {index}. {self._compact(item.format())}") ) known = [KnownItem.format_item(item) for item in current.known] if known != before_known: self._append_state_section( - lines, " Known", self._format_rows(current.known, lambda index, item: f" {index}. {self._compact(KnownItem.format_item(item))}") + lines, " Facts", self._format_rows(current.known, lambda index, item: f" {index}. {self._compact(KnownItem.format_item(item))}") ) user_rules = self.session.state.user_rules.format() if user_rules != before_user_rules: @@ -4969,16 +4747,16 @@ def compact_report(self) -> str: ("Goal", " Goal" in self.latest_report, [" " + self._compact(self.blackboard.goal or "(empty)")]), ("Plan", " Plan" in self.latest_report and self.blackboard.plan, self.latest_compact_plan_rows or self._compact_plan_rows()), ( - "Hypotheses", - " Hypotheses" in self.latest_report and self.blackboard.hypotheses, + "Leads", + " Leads" in self.latest_report and self.blackboard.hypotheses, self._compact_rows(self.blackboard.hypotheses, lambda item: self._compact(item.format(), 100)), ), ( - "Known", - " Known" in self.latest_report and self.blackboard.known, + "Facts", + " Facts" in self.latest_report and self.blackboard.known, self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100)), ), - ("Verification", " Verify" in self.latest_report, [" " + self._format_verification()]), + ("Checks", " Checks" in self.latest_report, [" " + self._format_verification()]), ("User Rules", " User_Rules" in self.latest_report, [" updated"]), ) if changed @@ -5213,7 +4991,7 @@ def _append_extra_state_report(self, lines: list[str], before_extra_state: str) verification = self.blackboard.verification.format() if verification == before_verification: return - self._append_state_section(lines, " Verify " + self._format_verification()) + self._append_state_section(lines, " Checks " + self._format_verification()) @staticmethod def _actions_of_type(actions: list[Json], action_type: str) -> Iterator[Json]: @@ -5389,7 +5167,6 @@ class Agent: MAX_AGENT_FEEDBACK_ERROR_LEN: ClassVar[int] = 220 MODEL_TIMEOUT_RETRY_DELAYS: ClassVar[tuple[int, ...]] = (3, 10, 20, 30, 60, 120) ACT_ACTION_TYPES: ClassVar[set[str]] = {"goal", "plan", "hypothesis", "known", "tool", "verify", "user_rule", "forget"} - PLAN_ACTION_TYPES: ClassVar[set[str]] = ACT_ACTION_TYPES - {"user_rule", "forget"} OBSERVE_ACTION_TYPES: ClassVar[set[str]] = {"keep", "hypothesis", "known", "forget"} COMPLETED_PLAN_STATUSES: ClassVar[set[PlanStatus]] = {PlanStatus.DONE, PlanStatus.BLOCKED} MAX_COMPLETED_GOAL_TOOL_RESULTS: ClassVar[int] = 50 @@ -5398,11 +5175,11 @@ class Agent: RULE_CLOSE_SOURCE: ClassVar[str] = "close or update state that depends on the result before forgetting its source." RULE_CHANGE_FAILED_TOOL: ClassVar[str] = "change args or switch tools; after edit failures use a smaller batch and reread only stale ranges." RULE_GOAL_PLAN_FIRST: ClassVar[str] = "set goal and a short plan before mutating tools or verify." - RULE_VERIFY_DIRECTLY: ClassVar[str] = 'run verification tools, then report verify status="passed"|"failed"|"blocked".' + RULE_VERIFY_DIRECTLY: ClassVar[str] = 'run checks, then report verify status="passed"|"failed"|"blocked".' RULE_TOOL_SIGNATURE: ClassVar[str] = "use the tool signature exactly." RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile(filepath, edits) with visible line anchors; split oversized batches." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." - RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked verification only when blocker=user." + RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked Checks only when blocker=user." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." RULE_VALID_TOOL_JSON: ClassVar[str] = "rebuild valid function arguments; for EditFile, use one file/logical block and split oversized batches." STALE_TOOL_FEEDBACK_MARKERS: ClassVar[tuple[str, ...]] = ( @@ -5450,24 +5227,38 @@ def build_user_prompt(self) -> str: environment=self._format_environment(), conversation_history="\n\n".join(item.format() for item in conversation) if conversation else "(empty)", user_rules=self.session.state.user_rules.format(), - known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", tool_result_index=tool_result_index or "(empty)", unreduced_tool_results=unreduced_tool_results or "(empty)", latest_tool_results=latest_tool_results or "(empty)", - task_code=current.task_code, - work_mode=current.work_mode, - goal=current.goal or "(empty)", - plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", - current_focus=self._format_current_focus(), - hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", - verification_state=current.verification.format(), + state_sections=self._format_state_sections(), errors="\n".join("! " + error for error in self.agent_feedback_errors) or "(empty)", recent_edits="\n".join(self.recent_edits) if self.recent_edits else "(empty)", pending_user_feedback=self.session.state.pending_user_feedback or "(empty)", user_request=self._format_user_request(), ).strip() + def _format_state_sections(self) -> str: + current = self.blackboard + sections: list[str] = [] + + def add(name: str, value: str) -> None: + value = value.strip() + if value: + sections.append(name + ":\n" + value) + + add("Goal", current.goal) + if current.known: + add("Facts", "\n".join(KnownItem.format_item(item) for item in current.known)) + if current.hypotheses: + add("Leads", "\n".join(item.format() for item in current.hypotheses)) + if current.plan: + add("Plan", "\n".join(item.format() for item in current.plan)) + add("Current Focus", self._format_current_focus()) + if current.verification.has_context() or current.verification_required: + add("Checks", current.verification.format() if current.verification.has_context() else "status: required") + return "\n\n".join(sections) if sections else "(empty)" + def _format_environment(self) -> str: lines = [ "- system: " + self.session.system, @@ -5818,10 +5609,7 @@ def _step_prompts(self) -> tuple[str, str, str]: user_prompt = self.build_observe_prompt() activity = "observe" else: - system_prompt = self._system_prompt( - AGENT_PLAN_SYSTEM_PROMPT if self.session.settings.plan_mode else None, - tools=PLAN_MODE_TOOLS if self.session.settings.plan_mode else None, - ) + system_prompt = self._system_prompt() user_prompt = self.build_user_prompt() activity = "agent" return system_prompt, user_prompt, activity @@ -5830,9 +5618,6 @@ def _tool_schemas(self) -> list[Json]: if self.mode == AgentMode.OBSERVE: action_names = self.OBSERVE_ACTION_TYPES tool_classes: Iterable[ToolClass] = () - elif self.session.settings.plan_mode: - action_names = self.PLAN_ACTION_TYPES - {"tool"} - tool_classes = self._available_tool_classes(PLAN_MODE_TOOLS) else: action_names = self.ACT_ACTION_TYPES - {"tool"} tool_classes = self._available_tool_classes() @@ -6204,12 +5989,12 @@ def _is_pending_verify_action(action: Json) -> bool: return _json_str(action.get("type")) == "verify" and _json_str(action.get("status")) == "pending" def _investigate_completion_error(self) -> str: - if self.blackboard.work_mode != WorkMode.INVESTIGATE or not self.blackboard.goal_reached: + if not self.blackboard.goal_reached or not self.blackboard.hypotheses: return "" return ( "" if any(item.status == HypothesisStatus.CONFIRMED for item in self.blackboard.hypotheses) - else "investigate completion requires a confirmed hypothesis" + else "investigation completion requires a confirmed lead" ) @staticmethod @@ -6243,26 +6028,6 @@ def _repeated_tool_retry_error(self, tool_calls: list[JsonValue]) -> str: return "same failed tool call repeated after " + str(self.failed_tool_call_count) + " failures: " + _format_tool_call_summary(call) return "" - def _plan_mode_tool_error(self, tool_calls: list[JsonValue]) -> str: - if not self.session.settings.plan_mode: - return "" - for value in tool_calls: - try: - call = self.tool_runner.parse_tool_call(value) - except ToolCallArgError: - continue - tool_class = TOOL_REGISTRY.get(call.name) - if tool_class is None: - return "plan mode allows registered readonly tools only; blocked " + _format_tool_call_summary(call) - if tool_class.EFFECT == ToolEffect.READONLY: - continue - if tool_class is GitTool: - args = call.args[1:] if call.args and isinstance(call.args[0], str) and call.args[0].startswith("cwd=") else call.args - if args and args[0] in GIT_READONLY_COMMANDS: - continue - return "plan mode allows readonly discovery only; blocked " + _format_tool_call_summary(call) - return "" - def _build_response_context(self, response: Json) -> ResponseContext: raw_actions = self._response_actions(response) assistant_text = _json_str(response.get("_assistant_text")) or "" @@ -6361,7 +6126,7 @@ def _gate_protocol_actions(self, ctx: ResponseContext, on_message: MessageCallba return ( self._gate_action_types( ctx.actions, - allowed=self.PLAN_ACTION_TYPES if self.session.settings.plan_mode else self.ACT_ACTION_TYPES, + allowed=self.ACT_ACTION_TYPES, on_message=on_message, retry_message="Retrying: use a valid agent action.", feedback_message=self._error("this step only accepts agent work actions."), @@ -6380,14 +6145,6 @@ def _gate_tool_actions(self, ctx: ResponseContext, on_message: MessageCallback | "Retrying: change the failed tool call instead of repeating it.", "ToolRetry_Gate: " + repeated_tool_retry_error + ".", ) - plan_mode_tool_error = self._plan_mode_tool_error(ctx.tool_calls) - if plan_mode_tool_error: - return self._reject_agent( - on_message, - self._error(plan_mode_tool_error + ".", "produce a proposed plan without executing mutations."), - "Retrying: plan mode only allows readonly discovery.", - "PlanMode_Gate: " + plan_mode_tool_error + ".", - ) return False def _drop_goal_rewrite_actions(self, ctx: ResponseContext) -> None: @@ -6459,21 +6216,20 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | if ctx.tool_calls and not any(execution.outcome != "success" for execution in self.tool_runner.latest_executions) and self._verification_is_settled(): if self._plan_is_complete(): - self._warn_agent("Plan and verification are complete; continuing tools without reopening Plan.") + self._warn_agent("Plan and Checks are complete; continuing tools without reopening Plan.") elif ctx.plan_was_complete and ctx.verification_was_settled: self._warn_agent("Continuing tools after completed Plan; update Plan if the new work changes scope.") if not ctx.tool_calls and not ctx.plan_was_complete and self._plan_is_complete() and not self.blackboard.goal_reached: if not self._verification_is_settled(): self._warn_agent( - "Plan is complete but verification is not recorded.", - "run checks when files changed or verification was requested.", + "Plan is complete but Checks are not recorded.", + "run checks when files changed or checks were requested.", ) else: - self._warn_agent("Plan and verification are complete; finish with goal.complete=true when no further work is needed.") + self._warn_agent("Plan and Checks are complete; finish with goal.complete=true when no further work is needed.") if ( - not self.session.settings.plan_mode - and ctx.has_state_update_action + ctx.has_state_update_action and self.state_updater.changed and not ctx.goal_was_empty and not ctx.tool_calls @@ -6484,18 +6240,6 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | self._warn_agent("state update-only turn; include frontier tool, verify, or goal when arguments are known.") return None - def _plan_mode_completion_error(self, message: str) -> str: - if not self.session.settings.plan_mode: - return "" - text = message.strip() - if not text.startswith("") or not text.endswith(""): - return "final plan must be wrapped in ..." - if text.count("") != 1 or text.count("") != 1: - return "final plan must contain exactly one proposed_plan block" - if not text.removeprefix("").removesuffix("").strip(): - return "final plan block is empty" - return "" - def _promote_required_verification(self, ctx: ResponseContext) -> None: verification = self.blackboard.verification if not self.blackboard.verification_required or not self.blackboard.goal_reached: @@ -6600,7 +6344,7 @@ def _warn_weak_observe_memory(self, actions: list[Json]) -> None: self._remember_observe_error( self._warning( "weak observe memory: known facts need source tr.N or keep/forget coverage.", - "use source-backed known/hypothesis or keep important raw results.", + "use source-backed Facts/Leads or keep important raw results.", ) ) @@ -6669,11 +6413,11 @@ def _finish_or_continue(self, ctx: ResponseContext, on_message: MessageCallback def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: if self.blackboard.verification.status == VerificationStatus.REQUIRED: if self.blackboard.verification_required: - self._warn_agent("edited files need verification before completion.", self.RULE_VERIFY_DIRECTLY) + self._warn_agent("edited files need Checks before completion.", self.RULE_VERIFY_DIRECTLY) else: - self._warn_agent("verification required before completion.", self.RULE_VERIFY_DIRECTLY) + self._warn_agent("Checks are required before completion.", self.RULE_VERIFY_DIRECTLY) if self.blackboard.verification.status == VerificationStatus.FAILED and self.blackboard.goal_reached: - self._warn_agent("verification failed; fix the reported issue first.") + self._warn_agent("Checks failed; fix the reported issue first.") completion_plan_error = self._completion_plan_error(ctx) if completion_plan_error: return self._reject_completion( @@ -6684,19 +6428,11 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N ) blocked_completion_error = self._blocked_verification_completion_error() if blocked_completion_error: - self._warn_agent("blocked verification completion invalid: " + blocked_completion_error + ".", self.RULE_BLOCKED_BY_USER) + self._warn_agent("blocked Checks completion invalid: " + blocked_completion_error + ".", self.RULE_BLOCKED_BY_USER) investigate_completion_error = self._investigate_completion_error() if investigate_completion_error: - self._warn_agent(investigate_completion_error + ".", "mark a hypothesis confirmed when claiming a root cause.") + self._warn_agent(investigate_completion_error + ".", "mark a lead confirmed when claiming a root cause.") completion_message = (ctx.completion_message or ctx.assistant_text or "Done.") if self.blackboard.goal_reached else "" - plan_mode_completion_error = self._plan_mode_completion_error(completion_message) if self.blackboard.goal_reached else "" - if plan_mode_completion_error: - return self._reject_completion( - on_message, - self._error("invalid plan-mode completion: " + plan_mode_completion_error + ".", "return the proposed plan as the final message."), - "Retrying: finish plan mode with a proposed_plan block.", - "PlanMode_Gate: " + plan_mode_completion_error + ".", - ) return None def run( @@ -6872,7 +6608,6 @@ class CommandSpec: "/reason-payload", "Show or set chat reasoning payload", "Config", "/reason-payload [auto|off|reasoning|reasoning_effort|thinking|enable_thinking]" ), CommandSpec("/provider", "Show or switch provider", "Config", "/provider [name]"), - CommandSpec("/plan", "Toggle plan mode or ask for a readonly plan", "Config", "/plan [on|off|question]"), CommandSpec("/yolo", "Toggle yolo mode (skip confirmations)", "Config", "/yolo"), CommandSpec("/index", "Initialize, sync, or rebuild code index", "Maintenance", "/index [force]"), CommandSpec("/clean", "Clean inactive session directories", "Maintenance", "/clean"), @@ -6899,8 +6634,6 @@ class CommandSpec: "runtime.compact_at": "compact_at", "runtime.shell_timeout": "shell_timeout", "runtime.max_agent_steps": "max_agent_steps", - "runtime.plan_timeout": "plan_timeout", - "runtime.plan_first_token_timeout": "plan_first_token_timeout", "runtime.context_budget": "context_budget", "runtime.yolo": "yolo", } @@ -6920,8 +6653,6 @@ class CommandSpec: "runtime.compact_at", "runtime.shell_timeout", "runtime.max_agent_steps", - "runtime.plan_timeout", - "runtime.plan_first_token_timeout", } CONFIG_SET_USAGE = "Usage: /set " @@ -7132,26 +6863,6 @@ def _yolo(self, args: str) -> str: return self._set("runtime.yolo " + ("off" if current else "on")) return self._set("runtime.yolo " + args) - def _plan(self, args: str) -> str: - text = args.strip() - if not text: - current = self.agent.session.settings.plan_mode - self.agent.session.settings.plan_mode = not current - return "Set plan mode = " + self._format_bool(self.agent.session.settings.plan_mode) - if text in {"on", "off"}: - self.agent.session.settings.plan_mode = text == "on" - return "Set plan mode = " + text - previous = self.agent.session.settings.plan_mode - self.agent.session.settings.plan_mode = True - try: - if self.run_agent is not None: - self.run_agent(text) - else: - self.agent.run(text) - finally: - self.agent.session.settings.plan_mode = previous - return "" - def _rules(self, args: str) -> str: if args: return "Usage: /rules" @@ -7198,8 +6909,6 @@ def _status(self, args: str) -> str: "session: " + session.session_id, "runtime: yolo=" + self._format_bool(session.settings.yolo) - + " plan=" - + self._format_bool(session.settings.plan_mode) + " compact_at=" + str(session.settings.compact_at) + " context_budget=" @@ -7210,9 +6919,8 @@ def _status(self, args: str) -> str: "tokens: last=" + _format_count(session.state.last_total_tokens) + " session=" + _format_count(session.state.session_total_tokens), "models:", model_usage, - "task: " + blackboard.task_code, "goal: " + (blackboard.goal or "(empty)"), - "verification: " + verification_status, + "checks: " + verification_status, ] ) @@ -7290,12 +6998,9 @@ def _config(self, args: str) -> str: "runtime.compact_at: " + str(session.settings.compact_at), "runtime.shell_timeout: " + str(session.settings.shell_timeout), "runtime.max_agent_steps: " + str(session.settings.max_agent_steps), - "runtime.plan_timeout: " + str(session.settings.plan_timeout), - "runtime.plan_first_token_timeout: " + str(session.settings.plan_first_token_timeout), "runtime.context_budget: " + session.settings.context_budget, "runtime.auto_clean_recent: " + session.settings.auto_clean_recent, "runtime.yolo: " + self._format_bool(session.settings.yolo), - "runtime.plan_mode: " + self._format_bool(session.settings.plan_mode), ] ) @@ -7495,7 +7200,7 @@ def _format_line(self, turn_elapsed: float, *, now: float, show_elapsed: bool) - active_model = session.state.current_model_call_label or session.config.provider.model model = active_model.rsplit("/", 1)[-1] or active_model or "(no model)" reasoning = session.state.current_model_call_reasoning_label or (session.config.provider.reasoning) - modes = "".join(" | " + label for label, enabled in (("yolo", session.settings.yolo), ("plan", session.settings.plan_mode)) if enabled) + modes = " | yolo" if session.settings.yolo else "" context = str(len(session.state.conversation)) + "/" + str(session.settings.compact_at) last_tokens = _format_count(session.state.last_total_tokens) session_tokens = _format_count(session.state.session_total_tokens) @@ -7678,8 +7383,6 @@ def _prompt(self) -> str: labels = [] if self.agent.session.settings.yolo: labels.append("yolo") - if self.agent.session.settings.plan_mode: - labels.append("plan") return "[" + ",".join(labels) + "] > " if labels else "> " def _start_existing_code_index_refresh(self) -> None: @@ -8405,12 +8108,20 @@ def _print_message(self, message: str) -> None: if message.startswith( ( "Plan Updated", - "Known Updated", - "Hypotheses Updated", - "Plan + Known Updated", - "Plan + Hypotheses Updated", - "Hypotheses + Known Updated", - "Plan + Hypotheses + Known Updated", + "Facts Updated", + "Leads Updated", + "Checks Updated", + "Plan + Facts Updated", + "Plan + Leads Updated", + "Plan + Checks Updated", + "Leads + Facts Updated", + "Leads + Checks Updated", + "Facts + Checks Updated", + "Plan + Leads + Facts Updated", + "Plan + Facts + Checks Updated", + "Plan + Leads + Checks Updated", + "Leads + Facts + Checks Updated", + "Plan + Leads + Facts + Checks Updated", ) ): self._emit_segments(self._compact_state_segments(message), message) @@ -8559,7 +8270,7 @@ def _compact_state_segments(self, message: str) -> list[tuple[str, str]]: for line in message.splitlines(): if line.endswith("Updated"): segments.append(("bold ansicyan", line + "\n")) - elif line in {"Plan", "Hypotheses", "Known"}: + elif line in {"Plan", "Leads", "Facts", "Checks"}: segments.append(("ansicyan", line + "\n")) elif line.startswith(" ..."): segments.append(("ansibrightblack", line + "\n")) @@ -8702,12 +8413,6 @@ def get_completions(self, document, complete_event): if model.startswith(text): yield Completion(model, start_position=-len(text)) return - if text.startswith("/plan "): - text = text[len("/plan ") :] - for value in ("on", "off"): - if value.startswith(text): - yield Completion(value, start_position=-len(text)) - return if text.startswith("/api "): text = text[len("/api ") :] for value in ("auto", "chat", "responses"): @@ -8780,7 +8485,6 @@ def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description="nanocode: AI coding assistant") parser.add_argument("-v", "--version", action="version", version=__version__) parser.add_argument("--yolo", action="store_true", help="Skip tool execution confirmations") - parser.add_argument("--plan", action="store_true", help="Plan changes without editing or running commands") parser.add_argument("--debug", action="store_true", help="Write request prompts to the current session debug directory") parser.add_argument("--config", default=None, help="Path to config file (default: ~/.nanocode/config.toml)") parser.add_argument("--init-config", action="store_true", help="Create a default config file at --config or ~/.nanocode/config.toml") @@ -8789,7 +8493,7 @@ def main(argv: list[str] | None = None) -> int: config_path, created = ConfigFile.init(args.config) print(("Created config: " if created else "Config already exists: ") + config_path) return 0 - session = Session.from_config_file(path=args.config, yolo=args.yolo, plan_mode=args.plan, debug=args.debug) + session = Session.from_config_file(path=args.config, yolo=args.yolo, debug=args.debug) missing = session.missing_required_config() if missing: print("Missing config: " + ", ".join(missing), file=sys.stderr) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index fb83d1c..12a9b9a 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -53,7 +53,6 @@ def _session( reasoning: str = "", chat_reasoning: str = "", yolo: bool = False, - plan_mode: bool = False, debug: bool = False, api: str = "", ) -> Session: @@ -76,7 +75,7 @@ def _session( return Session( cwd=str(tmp_path), config=nanocode.Config.from_dict(data), - settings=nanocode.RuntimeSettings.from_dict(data, yolo=yolo, plan_mode=plan_mode, debug=debug), + settings=nanocode.RuntimeSettings.from_dict(data, yolo=yolo, debug=debug), ) @@ -298,7 +297,7 @@ def test_search_tool_result_uses_larger_output_budget(tmp_path): agent.execute_tool_calls([{"name": "Search", "intention": "search large result", "args": ["needle", "sample.txt", "context=0"]}]) item = session.state.tool_result_store["tr.1"] - assert item.excerpted is True + assert item.excerpted is False assert nanocode.MAX_TOOL_OUTPUT_CHARS < len(item.value) <= nanocode.SearchTool.OUTPUT_CHARS @@ -515,15 +514,15 @@ def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path, monkeypatch) prompt = agent._system_prompt() assert "TASK SHAPES" in prompt - assert "Chat:" in prompt - assert "One-shot:" in prompt - assert "Tracked task:" in prompt - assert "Classify the latest request as Chat, One-shot, or Tracked task" in prompt + assert "Simple answer:" in prompt + assert "One-shot task:" in prompt + assert "Multi-step task:" in prompt + assert "Classify the latest request as Simple answer, One-shot task, or Multi-step task" in prompt assert "call needed tools, then answer with assistant text and stop" in prompt - assert "do not create Goal, Plan, Known, or Verify just to report the result" in prompt - assert "record Verify only after edits, explicit checks, or correctness-sensitive work" in prompt - assert "for root-cause work, set work_mode=investigate and use hypotheses" in prompt - assert "Tracked tasks are complete only after goal.complete=true is set" in prompt + assert "do not create Goal, Plan, Facts, Leads, or Checks just to report the result" in prompt + assert "record Checks only after edits, explicit checks, or correctness-sensitive work" in prompt + assert "use Leads only for root-cause/debug/investigation work" in prompt + assert "Multi-step tasks are complete only after goal.complete=true is set" in prompt assert "InspectCode" not in prompt assert "Use Search/List/LineCount when path, symbol, range, or target is unknown" in prompt assert "__discovery_hint__" not in prompt @@ -568,10 +567,10 @@ def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_pat prompt = agent.build_user_prompt() - assert "Chat: answer with assistant text only." in prompt - assert "One-shot with no Goal or Plan: assistant text is the final answer" in prompt - assert "If Current Phase is new and visible tool results answer the request" in prompt - assert "Tracked task: assistant text is optional" in prompt + assert "Simple answer: answer with assistant text only." in prompt + assert "One-shot task with no Goal or Plan: assistant text is the final answer" in prompt + assert "If visible tool results already answer a one-shot request" in prompt + assert "Multi-step task: assistant text is optional" in prompt assert "Goal completion requires goal.complete=true" in prompt @@ -591,7 +590,7 @@ def test_one_shot_bash_does_not_require_goal_or_plan(tmp_path): assert result.done is False assert len(agent.tool_runner.latest_executions) == 1 assert agent.blackboard.task_code == nanocode.TaskCode.NEW - assert "Current Phase:\nnew" in agent.build_user_prompt() + assert "Current Phase:" not in agent.build_user_prompt() assert not any("mutating work before" in error for error in agent.agent_feedback_errors) @@ -809,7 +808,7 @@ def test_hypothesis_action_updates_blackboard_and_report(tmp_path): context="feed search", ) ] - assert messages == ["Hypotheses Updated\n 1. [active] h1: admin filtering drops history events [tr.1] context: feed search"] + assert messages == ["Leads Updated\n 1. [active] h1: admin filtering drops history events [tr.1] context: feed search"] def test_forget_rejects_active_hypothesis_source(tmp_path): @@ -823,8 +822,8 @@ def test_forget_rejects_active_hypothesis_source(tmp_path): assert result.done is False assert "tr.1" in _blocks_text(agent.tool_context.kept_results) - assert any("protected source: tr.1 (active hypothesis)" in error for error in agent.agent_feedback_errors) - assert messages == ["ToolResult_Gate: protected source: tr.1 (active hypothesis)."] + assert any("protected source: tr.1 (active lead)" in error for error in agent.agent_feedback_errors) + assert messages == ["ToolResult_Gate: protected source: tr.1 (active lead)."] def test_forget_allows_source_when_hypothesis_is_closed_same_response(tmp_path): @@ -851,7 +850,7 @@ def test_forget_allows_source_when_hypothesis_is_closed_same_response(tmp_path): assert agent.blackboard.hypotheses[0].status == nanocode.HypothesisStatus.RULED_OUT assert "tr.1" not in _blocks_text(agent.tool_context.kept_results) assert messages == [ - "Hypotheses Updated\n 1. [ruled_out] h1: branch ruled out [tr.1]", + "Leads Updated\n 1. [ruled_out] h1: branch ruled out [tr.1]", "Tool Result Context: -tr.1", ] @@ -877,7 +876,7 @@ def test_forget_allows_source_when_hypothesis_is_dropped_same_response(tmp_path) assert agent.blackboard.hypotheses[0].status == nanocode.HypothesisStatus.DROPPED assert "tr.1" not in _blocks_text(agent.tool_context.kept_results) assert messages == [ - "Hypotheses Updated\n 1. [dropped] h1: branch no longer matters [tr.1]", + "Leads Updated\n 1. [dropped] h1: branch no longer matters [tr.1]", "Tool Result Context: -tr.1", ] @@ -1283,16 +1282,6 @@ def test_agent_request_responses_api_omits_reasoning_when_disabled(tmp_path, mon assert "reasoning" not in payload -def test_plan_mode_uses_runtime_plan_timeouts(tmp_path): - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", timeout=12, first_token_timeout=5, plan_mode=True) - session.settings.plan_timeout = 240 - session.settings.plan_first_token_timeout = 80 - client = nanocode.ModelClient(session) - - assert client._request_timeouts(session.config.provider, activity="agent") == (240, 80) - assert client._request_timeouts(session.config.provider, activity="compact") == (12, 5) - - def test_agent_request_retries_model_timeout(tmp_path, monkeypatch): class FakeModelClient: def __init__(self): @@ -2253,16 +2242,16 @@ def test_main_agent_state_updates_are_compact_without_debug(tmp_path): ) report = agent.state_updater.compact_report() - assert report.startswith("Goal + Plan + Known Updated") + assert report.startswith("Goal + Plan + Facts Updated") assert "\nGoal\n inspect project\n" in report assert "\nPlan\n" in report assert " ... 1 older\n 2. [✓ done] Read config\n 3. [◔ doing] Update code\n 4. [○ todo] Run tests" in report - assert "\nKnown\n" in report + assert "\nFacts\n" in report assert " ... 1 older\n 2. fact two\n 3. fact three\n 4. fact four" in report assert "State Updated" not in report -def test_main_agent_compact_report_labels_combined_hypotheses_and_known(tmp_path): +def test_main_agent_compact_report_labels_combined_leads_and_facts(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.apply_response( @@ -2280,10 +2269,10 @@ def test_main_agent_compact_report_labels_combined_hypotheses_and_known(tmp_path report = agent.state_updater.compact_report() assert report == "\n".join( [ - "Hypotheses + Known Updated", - "Hypotheses", + "Leads + Facts Updated", + "Leads", " 1. [active] h1: admin selector starves history mode [tr.2]", - "Known", + "Facts", " 1. [tr.3] feed SSE request path is shared by admin and normal users", ] ) @@ -2357,7 +2346,7 @@ def test_agent_state_report_only_includes_real_plan_and_known_changes(tmp_path): assert " Plan\n" in agent.state_updater.latest_report assert " 1. [○ todo] Inspect file" in agent.state_updater.latest_report - assert " Known\n" in agent.state_updater.latest_report + assert " Facts\n" in agent.state_updater.latest_report assert " 1. Search uses rg." in agent.state_updater.latest_report agent.apply_response(response) @@ -2949,7 +2938,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): response = agent.run("initial task", on_message=messages.append, poll_user_input=lambda: queued_inputs.pop(0) if queued_inputs else None) assert response["actions"][0]["message_for_complete"] == "done" - assert messages == ["Goal Updated\n initial task", "sent: use chinese", "Known Updated\n 1. queued feedback was visible", "done"] + assert messages == ["Goal Updated\n initial task", "sent: use chinese", "Facts Updated\n 1. queued feedback was visible", "done"] assert [item.content for item in agent.session.state.conversation if isinstance(item, nanocode.UserMessage)] == ["initial task", "use chinese"] assert agent.blackboard.user_input == "use chinese" assert "use chinese" not in agent.model_client.user_prompts[0] @@ -2959,39 +2948,8 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert "Latest User Request:" in agent.model_client.user_prompts[1] -def test_agent_plan_mode_tool_gate_allows_only_readonly_tools(tmp_path): - agent = Agent(_session(tmp_path, plan_mode=True)) - - assert agent._plan_mode_tool_error([{"type": "tool", "name": "Read", "args": ["sample.txt"]}]) == "" - assert agent._plan_mode_tool_error([{"type": "tool", "name": "Git", "args": ["status", "--short"]}]) == "" - assert "blocked tool=Bash" in agent._plan_mode_tool_error([{"type": "tool", "name": "Bash", "args": ["echo hi"]}]) - assert "blocked tool=Edit" in agent._plan_mode_tool_error([{"type": "tool", "name": "Edit", "args": ["sample.txt", "old", "new"]}]) - assert "blocked tool=Git" in agent._plan_mode_tool_error([{"type": "tool", "name": "Git", "args": ["commit", "-m", "x"]}]) - assert "blocked tool=Lsp" in agent._plan_mode_tool_error([{"type": "tool", "name": "Lsp", "args": ["symbols"]}]) - - -def test_agent_plan_mode_rejects_mutating_tool_before_execution(tmp_path): - path = tmp_path / "sample.txt" - path.write_text("old\n", encoding="utf-8") - agent = Agent(_session(tmp_path, plan_mode=True, debug=True)) - _seed_plan(agent, "plan change") - messages = [] - anchor = _read_anchors(agent.session, "sample.txt")[0] - - result = agent.handle_response( - {"actions": [{"type": "tool", "name": "EditFile", "intention": "change sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}]}, - confirm=lambda call, tool: True, - on_message=messages.append, - ) - - assert result.done is False - assert path.read_text(encoding="utf-8") == "old\n" - assert agent.tool_runner.latest_executions == [] - assert messages and messages[0].startswith("PlanMode_Gate: plan mode allows readonly discovery only; blocked tool=EditFile") - - -def test_agent_plan_mode_rejects_invalid_action_instead_of_completing(tmp_path): - agent = Agent(_session(tmp_path, plan_mode=True, debug=True)) +def test_agent_rejects_invalid_action_instead_of_completing(tmp_path): + agent = Agent(_session(tmp_path, debug=True)) messages = [] result = agent.handle_response({"actions": [{"type": "invalid", "text": "done"}]}, on_message=messages.append) @@ -3046,33 +3004,6 @@ def test_agent_normalizes_lowercase_repo_tool_names(tmp_path): assert not any("Protocol_Gate" in message for message in messages) -def test_agent_plan_mode_stores_proposed_plan_completion(tmp_path): - agent = Agent(_session(tmp_path, plan_mode=True)) - _seed_plan(agent, "plan change") - message = "\n1. Inspect target.\n2. Patch code.\n3. Run tests.\n" - - result = agent.handle_response({"actions": [{"type": "goal", "text": "plan change", "complete": True, "message_for_complete": message}]}) - - assert result.done is True - assert isinstance(agent.session.state.conversation[-1], nanocode.AssistantMessage) - assert agent.session.state.conversation[-1].content == message - - -def test_agent_plan_mode_requires_proposed_plan_completion_block(tmp_path): - agent = Agent(_session(tmp_path, plan_mode=True, debug=True)) - _seed_plan(agent, "plan change") - messages = [] - - result = agent.handle_response( - {"actions": [{"type": "goal", "text": "plan change", "complete": True, "message_for_complete": "plain plan"}]}, - on_message=messages.append, - ) - - assert result.done is False - assert not agent.session.state.conversation - assert messages == ["PlanMode_Gate: final plan must be wrapped in ...."] - - def test_agent_run_allows_readonly_answer_without_verification(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") @@ -3141,7 +3072,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert response["actions"][-1]["message_for_complete"] == "done" assert any(message.startswith("[success] EditFile sample.txt 1 edits") for message in messages) assert not any(message.startswith("State Updated") for message in messages) - assert any("edited files need verification before completion" in error for error in agent.agent_feedback_errors) + assert any("edited files need Checks before completion" in error for error in agent.agent_feedback_errors) assert (tmp_path / "sample.txt").read_text(encoding="utf-8") == "new\n" assert messages[-1] == "done" @@ -3160,7 +3091,7 @@ def test_agent_warns_but_allows_completion_when_verification_required(tmp_path): assert result.done is True assert messages == ["done"] assert agent.agent_feedback_errors == [ - 'Warning blocked: edited files need verification before completion. Next: run verification tools, then report verify status="passed"|"failed"|"blocked".' + 'Warning blocked: edited files need Checks before completion. Next: run checks, then report verify status="passed"|"failed"|"blocked".' ] @@ -3718,7 +3649,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert response["actions"][-1]["message_for_complete"] == "done" assert len(agent.model_client.user_prompts) == 3 - assert any("Plan is complete but verification is not recorded" in error for error in agent.agent_feedback_errors) + assert any("Plan is complete but Checks are not recorded" in error for error in agent.agent_feedback_errors) assert agent.blackboard.verification.status == VerificationStatus.DONE @@ -3742,8 +3673,8 @@ def test_agent_allows_tool_after_completed_plan_and_verification(tmp_path): assert result.done is False assert len(agent.tool_runner.latest_executions) == 1 assert agent.tool_runner.latest_executions[0].outcome == "success" - assert not any("Completion_Gate: completed plan and verification" in message for message in messages) - assert any("Plan and verification are complete" in error for error in agent.agent_feedback_errors) + assert not any("Completion_Gate: completed plan and Checks" in message for message in messages) + assert any("Plan and Checks are complete" in error for error in agent.agent_feedback_errors) def test_agent_allows_tool_after_reopening_completed_plan_with_context(tmp_path): @@ -3998,10 +3929,10 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert agent.blackboard.plan == [nanocode.PlanItem(id="p1", text="answer", status=nanocode.PlanStatus.DONE, context="answered")] -def test_investigate_completion_without_root_cause_hypothesis_warns(tmp_path): +def test_investigate_completion_without_confirmed_lead_warns(tmp_path): agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "find bug") - agent.blackboard.work_mode = nanocode.WorkMode.INVESTIGATE + agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="bad admin filter", status=nanocode.HypothesisStatus.ACTIVE, source=("tr.1",))] messages = [] result = agent.handle_response( @@ -4016,7 +3947,7 @@ def test_investigate_completion_without_root_cause_hypothesis_warns(tmp_path): assert result.done is True assert agent.blackboard.goal_reached is False - assert any("confirmed hypothesis" in error for error in agent.agent_feedback_errors) + assert any("confirmed lead" in error for error in agent.agent_feedback_errors) assert messages[-1] == "done" result = agent.handle_response( @@ -4069,8 +4000,8 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): result = agent.run("为什么 admin history 不出现") assert result["actions"][-1]["message_for_complete"] == "done" - assert agent.blackboard.work_mode == nanocode.WorkMode.INVESTIGATE - assert "Work Mode:\nnormal" in agent.model_client.user_prompts[0] + assert "Work Mode:" not in agent.model_client.user_prompts[0] + assert "Leads:" not in agent.model_client.user_prompts[0] def test_agent_run_retries_goal_complete_when_plan_done_without_context(tmp_path): diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 0d36fbe..92e4cef 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -100,12 +100,13 @@ def test_status_reports_tokens_in_human_readable_format(tmp_path, monkeypatch): assert "tokens: last=1k session=2m" in result.message assert "model: model api=chat(auto) reasoning=medium(off) stream=on" in result.message assert "session: " + session.session_id in result.message - assert "runtime: yolo=off plan=off compact_at=50" in result.message + assert "runtime: yolo=off compact_at=50" in result.message assert "models:" in result.message assert "model: calls=2 tokens=2m" in result.message assert "tool_calls: turn=0 session=0" in result.message assert "tools: code_index=unavailable" in result.message - assert "task: done" in result.message + assert "task:" not in result.message + assert "checks: idle" in result.message assert "blackboard" not in result.message @@ -172,24 +173,22 @@ def test_config_command_reports_resolved_provider_config(tmp_path): assert "paths.session_dir: " in result.message assert "paths.history: " + str(tmp_path / ".nanocode" / "history") in result.message assert "runtime.max_agent_steps: 100" in result.message - assert "runtime.plan_timeout: 360" in result.message - assert "runtime.plan_first_token_timeout: 180" in result.message assert "runtime.context_budget: medium" in result.message assert "runtime.auto_clean_recent: 1d" in result.message - assert "runtime.plan_mode: off" in result.message + assert "runtime.plan" not in result.message -def test_set_command_updates_plan_timeouts(tmp_path): +def test_plan_runtime_config_keys_are_removed(tmp_path): session = make_session(tmp_path) dispatcher = CommandDispatcher(Agent(session)) timeout_result = dispatcher.dispatch("/set runtime.plan_timeout 240") first_token_result = dispatcher.dispatch("/set runtime.plan_first_token_timeout 80") + mode_result = dispatcher.dispatch("/set runtime.plan_mode on") - assert timeout_result.message == "Set runtime.plan_timeout = 240" - assert first_token_result.message == "Set runtime.plan_first_token_timeout = 80" - assert session.settings.plan_timeout == 240 - assert session.settings.plan_first_token_timeout == 80 + assert timeout_result.message == "Unknown config key: runtime.plan_timeout" + assert first_token_result.message == "Unknown config key: runtime.plan_first_token_timeout" + assert mode_result.message == "Unknown config key: runtime.plan_mode" def test_context_command_shows_and_sets_budget(tmp_path): @@ -212,34 +211,13 @@ def test_context_command_shows_and_sets_budget(tmp_path): assert invalid_result.message == "Usage: /context [low|medium|high]" -def test_plan_command_toggles_plan_mode(tmp_path): +def test_plan_command_is_removed(tmp_path): session = make_session(tmp_path) dispatcher = CommandDispatcher(Agent(session)) - on_result = dispatcher.dispatch("/plan") - off_result = dispatcher.dispatch("/plan off") - unknown_set_result = dispatcher.dispatch("/set runtime.plan_mode on") - - assert on_result.message == "Set plan mode = on" - assert off_result.message == "Set plan mode = off" - assert unknown_set_result.message == "Unknown config key: runtime.plan_mode" - assert session.settings.plan_mode is False - - -def test_plan_command_runs_one_shot_plan_question(tmp_path): - prompts = [] - session = make_session(tmp_path) - - def run_agent(prompt): - prompts.append((prompt, session.settings.plan_mode)) - - dispatcher = CommandDispatcher(Agent(session), run_agent=run_agent) - result = dispatcher.dispatch("/plan how should lsp tools work?") - assert result.message == "" - assert prompts == [("how should lsp tools work?", True)] - assert session.settings.plan_mode is False + assert result.message == "Unknown command: /plan" def test_provider_command_switches_current_provider(tmp_path): diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 0467c34..718ea7c 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -6,13 +6,13 @@ from nanocode import AgentLoop, CommandLexer, Config, ConfigFile, Blackboard, ParsedToolCall, ReferenceFileCompleter, RuntimeSettings, Session, StatusBar, ToolCallDisplayFormatter -def make_session(tmp_path, *, model: str = "", compact_at: int = 50, yolo: bool = False, plan_mode: bool = False) -> Session: +def make_session(tmp_path, *, model: str = "", compact_at: int = 50, yolo: bool = False) -> Session: data = { "provider": {"active": "default", "default": {"model": model}}, "paths": {"data_dir": str(tmp_path / ".nanocode")}, "runtime": {"compact_at": compact_at}, } - return Session(cwd=str(tmp_path), config=Config.from_dict(data), settings=RuntimeSettings.from_dict(data, yolo=yolo, plan_mode=plan_mode)) + return Session(cwd=str(tmp_path), config=Config.from_dict(data), settings=RuntimeSettings.from_dict(data, yolo=yolo)) def _status_text(bar: StatusBar) -> str: @@ -49,13 +49,13 @@ def test_session_loads_user_rules_from_project_file(tmp_path, monkeypatch): assert session.state.user_rules.format() == "# User Rules\n\n- Prompt-only changes do not need tests." -def test_runtime_settings_loads_modes_from_config(): - data = {"runtime": {"yolo": True, "plan_mode": True}} +def test_runtime_settings_loads_yolo_from_config(): + data = {"runtime": {"yolo": True}} settings = RuntimeSettings.from_dict(data) assert settings.yolo is True - assert settings.plan_mode is True + assert not hasattr(settings, "plan_mode") def test_runtime_settings_loads_auto_clean_recent(): @@ -88,12 +88,12 @@ def test_init_config_file_writes_default_toml(tmp_path): assert config["provider"]["default"]["timeout"] == 180 assert config["provider"]["default"]["first_token_timeout"] == 90 assert config["runtime"]["compact_at"] == 50 - assert config["runtime"]["plan_timeout"] == 360 - assert config["runtime"]["plan_first_token_timeout"] == 180 assert config["runtime"]["context_budget"] == "medium" assert config["runtime"]["auto_clean_recent"] == "1d" assert config["runtime"]["yolo"] is False - assert config["runtime"]["plan_mode"] is False + assert "plan_timeout" not in config["runtime"] + assert "plan_first_token_timeout" not in config["runtime"] + assert "plan_mode" not in config["runtime"] def test_main_init_config_uses_config_argument(tmp_path, capsys): @@ -107,6 +107,18 @@ def test_main_init_config_uses_config_argument(tmp_path, capsys): assert "Created config: " + str(config_path) in output.out +def test_main_rejects_plan_argument(capsys): + try: + nanocode.main(["--plan"]) + except SystemExit as error: + assert error.code == 2 + else: + raise AssertionError("--plan should be rejected by argparse") + + output = capsys.readouterr() + assert "unrecognized arguments: --plan" in output.err + + def test_main_loads_config_argument(tmp_path, monkeypatch): config_path = tmp_path / "custom.toml" config_path.write_text( @@ -133,7 +145,7 @@ def fake_run(self): monkeypatch.setattr(nanocode.AgentLoop, "run", fake_run) - result = nanocode.main(["--config", str(config_path), "--plan"]) + result = nanocode.main(["--config", str(config_path)]) assert result == 0 assert sessions[0].config.provider.url == "https://example.test/v1" @@ -141,7 +153,7 @@ def fake_run(self): assert sessions[0].config.provider.model == "custom-model" assert sessions[0].config.provider.available_models == ("custom-model", "other-model") assert sessions[0].config.data_dir == ".custom-nanocode" - assert sessions[0].settings.plan_mode is True + assert not hasattr(sessions[0].settings, "plan_mode") def test_status_bar_text_has_visible_sweep_marker(tmp_path): @@ -195,10 +207,10 @@ def test_status_bar_shows_current_model_call_number(tmp_path): def test_status_bar_shows_active_modes(tmp_path): - session = make_session(tmp_path, model="provider/model", yolo=True, plan_mode=True) + session = make_session(tmp_path, model="provider/model", yolo=True) bar = StatusBar(session) - assert _status_text(bar) == "model (medium) | yolo | plan | ctx:0/50 | tool:0 | tok:last:- sess:-" + assert _status_text(bar) == "model (medium) | yolo | ctx:0/50 | tool:0 | tok:last:- sess:-" def test_status_bar_shows_recent_status_notice(tmp_path): @@ -308,11 +320,11 @@ def __init__(self): loop = AgentLoop(FakeAgent(), output_fn=lambda message: None) - segments = loop._compact_state_segments("Hypotheses + Known Updated\nHypotheses\n 1. h1\nKnown\n 1. fact") + segments = loop._compact_state_segments("Leads + Facts Updated\nLeads\n 1. h1\nFacts\n 1. fact") - assert ("bold ansicyan", "Hypotheses + Known Updated\n") in segments - assert ("ansicyan", "Hypotheses\n") in segments - assert ("ansicyan", "Known\n") in segments + assert ("bold ansicyan", "Leads + Facts Updated\n") in segments + assert ("ansicyan", "Leads\n") in segments + assert ("ansicyan", "Facts\n") in segments def test_agent_loop_cancelled_message_mentions_context_is_kept(tmp_path): @@ -372,23 +384,19 @@ def test_agent_loop_command_completer_matches_slash_commands(): set_key_completions = list(completer.get_completions(Document("/set provider."), CompleteEvent(completion_requested=True))) set_reasoning_completions = list(completer.get_completions(Document("/set provider.reasoning h"), CompleteEvent(completion_requested=True))) set_chat_reasoning_completions = list(completer.get_completions(Document("/set provider.chat_reasoning rea"), CompleteEvent(completion_requested=True))) - set_plan_timeout_completions = list(completer.get_completions(Document("/set runtime.plan_"), CompleteEvent(completion_requested=True))) model_completions = list(nanocode.CommandCompleter(models=["qwen3", "deepseek"]).get_completions(Document("/model q"), CompleteEvent(completion_requested=True))) - plan_completions = list(completer.get_completions(Document("/plan "), CompleteEvent(completion_requested=True))) api_completions = list(completer.get_completions(Document("/api r"), CompleteEvent(completion_requested=True))) reason_payload_completions = list(completer.get_completions(Document("/reason-payload rea"), CompleteEvent(completion_requested=True))) assert "/help" in [completion.text for completion in slash_completions] assert "/api" in [completion.text for completion in slash_completions] assert "/reason-payload" in [completion.text for completion in slash_completions] - assert "/plan" in [completion.text for completion in slash_completions] + assert "/plan" not in [completion.text for completion in slash_completions] assert "/config" in [completion.text for completion in config_completions] assert "provider.reasoning" in [completion.text for completion in set_key_completions] assert [completion.text for completion in set_reasoning_completions] == ["high"] assert [completion.text for completion in set_chat_reasoning_completions] == ["reasoning", "reasoning_effort"] - assert {completion.text for completion in set_plan_timeout_completions} == {"runtime.plan_timeout", "runtime.plan_first_token_timeout"} assert [completion.text for completion in model_completions] == ["qwen3"] - assert [completion.text for completion in plan_completions] == ["on", "off"] assert [completion.text for completion in api_completions] == ["responses"] assert [completion.text for completion in reason_payload_completions] == ["reasoning", "reasoning_effort"] @@ -396,11 +404,11 @@ def test_agent_loop_command_completer_matches_slash_commands(): def test_command_lexer_highlights_known_command_prefix_only(): lexer = CommandLexer() - known = lexer.lex_document(Document("/plan how?"))(0) + removed = lexer.lex_document(Document("/plan how?"))(0) unknown = lexer.lex_document(Document("/somecommand"))(0) spaced = lexer.lex_document(Document(" /plan how?"))(0) - assert known == [("class:command-input", "/plan"), ("", " how?")] + assert removed == [("", "/plan how?")] assert unknown == [("", "/somecommand")] assert spaced == [("", " /plan how?")] From 08d9df9f82e5c40dbf02308e57619e1abd4eaf74 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 00:15:03 -0700 Subject: [PATCH 112/144] ignore .code-symbol-index --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 5a741ba..5bd750d 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,4 @@ __pycache__/ .ruff_cache/ uv.lock .python-version +.code-symbol-index/ From 1ff0c40eb2695d788b8cdc1da00d2decb5be2842 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 00:23:46 -0700 Subject: [PATCH 113/144] Tune observe triggers around referenced tool results --- nanocode.py | 90 +++++++++++++++++++++++++----------- tests/test_nanocode_agent.py | 57 +++++++++++++++++++++++ 2 files changed, 119 insertions(+), 28 deletions(-) diff --git a/nanocode.py b/nanocode.py index a8ca01b..7590721 100644 --- a/nanocode.py +++ b/nanocode.py @@ -405,6 +405,26 @@ def source_result_keys(self) -> set[str]: keys.update(key for item in self.hypotheses for key in item.source if key.startswith("tr.")) return keys + def referenced_result_keys(self) -> set[str]: + keys = set(self.source_result_keys()) + texts = [ + self.goal, + *[KnownItem.text_of(item) for item in self.known], + *[item.text for item in self.hypotheses], + *[item.context for item in self.hypotheses], + *[item.text for item in self.plan], + *[item.context for item in self.plan], + self.verification.goal, + self.verification.kind, + self.verification.method, + *self.verification.criteria, + self.verification.context, + self.verification.blocker, + ] + for text in texts: + keys.update(TOOL_RESULT_KEY_REF_PATTERN.findall(str(text))) + return {key for key in keys if key.startswith("tr.")} + def protected_result_sources(self) -> dict[str, str]: return {key: "active lead" for item in self.hypotheses if item.status == HypothesisStatus.ACTIVE for key in item.source if key.startswith("tr.")} @@ -1366,25 +1386,38 @@ def current_timeline_blocks(self) -> list[str]: blocks.append(self.compact_block(block)) return blocks - def latest_raw_blocks(self) -> list[str]: - return [block for block in self.latest if self.is_full_block(block)] + def latest_raw_blocks(self, *, exclude_keys: set[str] | None = None) -> list[str]: + excluded = exclude_keys or set() + return [block for block in self.latest if self.is_full_block(block) and self.result_key(block) not in excluded] - def unreduced_recent_blocks(self, checkpoint: int) -> list[str]: + def unreduced_recent_blocks(self, checkpoint: int, *, exclude_keys: set[str] | None = None) -> list[str]: + excluded = exclude_keys or set() latest_keys = set(self.blocks_by_key(self.latest)) - return [block for block in self.recent if self.result_key(block) not in latest_keys and self._needs_reduction(block, checkpoint)] + return [ + block + for block in self.recent + for key in [self.result_key(block)] + if key not in latest_keys and key not in excluded and self._needs_reduction(block, checkpoint) + ] - def unreduced_blocks(self, checkpoint: int) -> list[str]: + def unreduced_blocks(self, checkpoint: int, *, exclude_keys: set[str] | None = None) -> list[str]: + excluded = exclude_keys or set() seen: set[str] = set() blocks = [] for block in self.recent + self.latest: key = self.result_key(block) - if key and key not in seen and self._needs_reduction(block, checkpoint): + if key and key not in seen and key not in excluded and self._needs_reduction(block, checkpoint): blocks.append(block) seen.add(key) return blocks - def raw_context_chars(self, checkpoint: int) -> int: - return len("\n\n".join(self.unreduced_recent_blocks(checkpoint) + self.latest_raw_blocks())) + def raw_context_chars(self, checkpoint: int, *, exclude_keys: set[str] | None = None) -> int: + return len( + "\n\n".join( + self.unreduced_recent_blocks(checkpoint, exclude_keys=exclude_keys) + + self.latest_raw_blocks(exclude_keys=exclude_keys) + ) + ) @classmethod def _needs_reduction(cls, block: str, checkpoint: int) -> bool: @@ -3332,8 +3365,9 @@ def _state_tool_schema(name: str) -> Json: Tool Results: - visible tool results are temporary support context - inspect visible results before deciding the next action -- OBSERVE owns keep/forget cleanup -- preserve useful conclusions in Goal, Plan, Facts, Leads, or Checks; forget noise when it no longer helps +- ACT should opportunistically forget raw results after preserving useful conclusions in Goal, Plan, Facts, Leads, or Checks +- forget raw results when they no longer affect target selection, edit anchors, error repair, verification, or completion +- OBSERVE is a fallback reducer for unreferenced raw results, not the only cleanup path - do not let old gate feedback dominate once fresh tool results answer the next step WORKFLOW @@ -3361,6 +3395,7 @@ def _state_tool_schema(name: str) -> Json: - Advance as far as safely possible in each turn. - Batch independent tool calls whenever their arguments are known. - Do not stop after Goal, Plan, Facts, or Leads updates if a useful repository tool call is clear. +- Pair source-backed Facts/Leads/Checks with forget when the cited raw result no longer matters. - Serialize only when later arguments depend on earlier results. - Ask the user only when the blocker cannot be resolved by available tools. @@ -5284,7 +5319,7 @@ def _format_current_focus(self) -> str: def build_observe_prompt(self) -> str: current = self.blackboard - unreduced = "\n\n".join(self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter)) + unreduced = "\n\n".join(self._unreferenced_unreduced_blocks()) return AGENT_OBSERVE_USER_PROMPT_TEMPLATE.format( user_rules=self.session.state.user_rules.format(), goal=current.goal or "(empty)", @@ -5513,7 +5548,7 @@ def _prune_tool_result_store(self) -> None: self.session.state.tool_result_store.pop(key) def _protected_tool_result_keys(self) -> set[str]: - keys = self.blackboard.source_result_keys() + keys = self.blackboard.referenced_result_keys() keys.update(ToolResultContext.blocks_by_key(self.tool_context.kept_results)) return keys @@ -5727,8 +5762,6 @@ def apply_response(self, response: Json) -> list[str]: self.blackboard.hypotheses = [] self.state_updater.apply(response) forgotten = self.tool_context.forget_results(ToolResultContext.forget_result_keys_from_actions(actions)) - if self.mode != AgentMode.OBSERVE and self._has_memory_update_action(actions): - self._mark_memory_checkpoint() return forgotten def _goal_changes_task(self, actions: list[Json]) -> bool: @@ -5746,17 +5779,6 @@ def _mark_memory_checkpoint(self, counter: int = 0) -> None: checkpoint = counter or self.tool_context.max_counter(self.tool_context.recent + self.tool_context.latest) or self.session.state.tool_result_counter self.blackboard.memory_checkpoint_tool_result_counter = max(self.blackboard.memory_checkpoint_tool_result_counter, checkpoint) - def _has_memory_update_action(self, actions: list[Json]) -> bool: - for action in actions: - action_type = _json_str(action.get("type")) - if action_type == "keep" and _source_from_json(action): - return True - if action_type == "hypothesis" and _json_list(action.get("items")): - return True - if action_type == "known" and any(_memory_fact_from_json(raw) for raw in _json_list(action.get("items"))): - return True - return False - def execute_tool_calls( self, tool_calls: list[JsonValue], @@ -5781,7 +5803,7 @@ def execute_tool_calls( return "\n\n".join(self.tool_context.latest) def _should_observe_after_tools(self) -> bool: - pending = self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter) + pending = self._unreferenced_unreduced_blocks() if not pending: return False budget = self.context_budget() @@ -5789,7 +5811,19 @@ def _should_observe_after_tools(self) -> bool: # Very large failures still trigger observe through raw-context pressure. return ( len(pending) >= budget.observe_after_results - or self.tool_context.raw_context_chars(self.blackboard.memory_checkpoint_tool_result_counter) >= budget.raw_chars + or self._unreferenced_raw_context_chars() >= budget.raw_chars + ) + + def _unreferenced_unreduced_blocks(self) -> list[str]: + return self.tool_context.unreduced_blocks( + self.blackboard.memory_checkpoint_tool_result_counter, + exclude_keys=self.blackboard.referenced_result_keys(), + ) + + def _unreferenced_raw_context_chars(self) -> int: + return self.tool_context.raw_context_chars( + self.blackboard.memory_checkpoint_tool_result_counter, + exclude_keys=self.blackboard.referenced_result_keys(), ) def _after_tool_execution(self, execution: ToolCallExecution) -> None: @@ -6311,7 +6345,7 @@ def _handle_observe_response( forget_gate = self._gate_forget_actions(ctx.actions, on_message, self._remember_observe_error) if forget_gate is not None: return forget_gate - observed_blocks = self.tool_context.unreduced_blocks(self.blackboard.memory_checkpoint_tool_result_counter) + observed_blocks = self._unreferenced_unreduced_blocks() observed_counter = ToolResultContext.max_counter(observed_blocks) forgotten_keys = self.apply_response(response) self._emit_state_and_text(ctx, on_message) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 12a9b9a..5d6e09b 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -368,6 +368,46 @@ def test_agent_observes_full_latest_result_when_it_becomes_recent(tmp_path, monk assert "recall=tr.2" in _blocks_text(agent.tool_context.latest) +def test_referenced_unreduced_results_do_not_count_toward_observe_threshold(tmp_path, monkeypatch): + for name in ["one.txt", "two.txt", "three.txt"]: + (tmp_path / name).write_text(name + "\n", encoding="utf-8") + agent = Agent(Session(cwd=str(tmp_path))) + _set_context_budget(monkeypatch, agent, raw_chars=10_000, observe_after_results=2) + + agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) + agent.apply_response({"actions": [{"type": "known", "items": [{"source": ["tr.1"], "text": "one.txt was inspected."}]}]}) + agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}]) + + assert agent.mode == nanocode.AgentMode.ACT + assert agent.blackboard.memory_checkpoint_tool_result_counter == 0 + assert len(agent.tool_context.unreduced_blocks(agent.blackboard.memory_checkpoint_tool_result_counter)) == 2 + assert [nanocode.ToolResultContext.result_key(block) for block in agent._unreferenced_unreduced_blocks()] == ["tr.2"] + + agent.execute_tool_calls([{"name": "Read", "intention": "read three", "args": ["three.txt", "0,1"]}]) + + assert agent.mode == nanocode.AgentMode.OBSERVE + observe_prompt = agent.build_observe_prompt() + observe_raw = observe_prompt.split("Unreduced Raw Tool Results:\n", 1)[1].split("\n--- Output ---", 1)[0] + assert "one.txt" not in observe_raw + assert "two.txt" in observe_raw + assert "three.txt" in observe_raw + + +def test_unsourced_known_does_not_cover_unreduced_result(tmp_path, monkeypatch): + (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") + (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") + agent = Agent(Session(cwd=str(tmp_path))) + _set_context_budget(monkeypatch, agent, raw_chars=10_000, observe_after_results=2) + + agent.execute_tool_calls([{"name": "Read", "intention": "read one", "args": ["one.txt", "0,1"]}]) + agent.apply_response({"actions": [{"type": "known", "items": ["one.txt was inspected."]}]}) + agent.execute_tool_calls([{"name": "Read", "intention": "read two", "args": ["two.txt", "0,1"]}]) + + assert agent.mode == nanocode.AgentMode.OBSERVE + assert agent.blackboard.memory_checkpoint_tool_result_counter == 0 + assert [nanocode.ToolResultContext.result_key(block) for block in agent._unreferenced_unreduced_blocks()] == ["tr.1", "tr.2"] + + def test_agent_act_context_keeps_pending_raw_after_latest_rotates(tmp_path, monkeypatch): (tmp_path / "one.txt").write_text("one\n", encoding="utf-8") (tmp_path / "two.txt").write_text("two\n", encoding="utf-8") @@ -1118,6 +1158,23 @@ def test_agent_tool_result_raw_budget_triggers_observe(tmp_path, monkeypatch): assert "x" * 50 in observe_context +def test_referenced_raw_context_does_not_force_observe(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + _set_context_budget(monkeypatch, agent, raw_chars=10_000, observe_after_results=99) + path = tmp_path / "sample.txt" + path.write_text("x" * 400 + "\n", encoding="utf-8") + + agent.execute_tool_calls([{"name": "Read", "intention": "read sample", "args": ["sample.txt", "0,1"]}]) + agent.apply_response( + {"actions": [{"type": "known", "items": [{"source": ["tr.1"], "text": "sample.txt content was inspected."}]}]} + ) + _set_context_budget(monkeypatch, agent, raw_chars=180, observe_after_results=99) + + assert agent._unreferenced_raw_context_chars() == 0 + assert agent._should_observe_after_tools() is False + + def test_agent_tool_result_index_has_count_limit(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path)) agent = Agent(session) From dae9c1a282fd22402fc5512029ffc06791ba7470 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 00:26:02 -0700 Subject: [PATCH 114/144] Remove unused agent locals --- nanocode.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index 7590721..d121931 100644 --- a/nanocode.py +++ b/nanocode.py @@ -5256,7 +5256,6 @@ def apply_context_budget(self) -> None: def build_user_prompt(self) -> str: tool_result_index, unreduced_tool_results, latest_tool_results = self._format_act_tool_result_context() - current = self.blackboard conversation = self.session.state.conversation return AGENT_USER_PROMPT_TEMPLATE.format( environment=self._format_environment(), @@ -6466,7 +6465,6 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N investigate_completion_error = self._investigate_completion_error() if investigate_completion_error: self._warn_agent(investigate_completion_error + ".", "mark a lead confirmed when claiming a root cause.") - completion_message = (ctx.completion_message or ctx.assistant_text or "Done.") if self.blackboard.goal_reached else "" return None def run( From b700cc3a0d5a0381eae09f65a333ff1e26220b7a Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 00:44:51 -0700 Subject: [PATCH 115/144] Make agent prompt concise and workflow-focused --- nanocode.py | 318 +++++++---------------------------- tests/test_nanocode_agent.py | 99 ++--------- 2 files changed, 69 insertions(+), 348 deletions(-) diff --git a/nanocode.py b/nanocode.py index d121931..3c5b430 100644 --- a/nanocode.py +++ b/nanocode.py @@ -172,7 +172,6 @@ class HypothesisStatus(StrEnum): ALL_HYPOTHESIS_STATUSES = frozenset(HypothesisStatus) -HYPOTHESIS_STATUS_TEXT = ", ".join(status.value for status in HypothesisStatus) @dataclass @@ -1911,6 +1910,7 @@ class SearchTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Case-insensitive regex search before Read; use A|B|C for alternatives and \\n for multiline matches.", 'Returns matching file paths, matched lines, and 0-based context lines as "line:hash|code".', + "Compared with rg/grep in Bash, returns structured bounded results, anchors, and tool-result context keys.", "For exact text, escape regex metacharacters like braces, parens, dots, stars, and brackets.", "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py; omitted context defaults to 0.", "Use context=N only when nearby lines are needed; prefer context=0 for broad searches and renames.", @@ -2883,8 +2883,8 @@ class BashTool(Tool): DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run one explicit shell command via bash -lc in cwd.", "Returns exit_code plus stdout/stderr; long output is stored and bounded in context.", - "Prefer dedicated tools when they provide structured repo access; use Bash when shell semantics or pipelines are the clearest path.", - "Good Bash uses include tests, builds, and Unix text-tool pipelines with tools listed in Environment.", + "Use Bash when shell semantics, tests/builds, or custom Unix text-tool pipelines are the clearest path.", + "rg/grep/sed/awk/perl pipelines in Bash are useful for broad scans, custom filters, and mechanical transforms.", "Mechanical shell edits are allowed, but verify afterward with Git diff, Read, tests, or another focused check.", ) SIGNATURE: ClassVar[str] = "Bash(command) -> BashToolResult" @@ -3245,7 +3245,7 @@ def _canonical_tool_name(name: str | None) -> str: ["text", "complete", "message_for_complete"], ), "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), - "hypothesis": ("Update investigation leads.", {"items": TOOL_HYPOTHESIS_ITEMS_SCHEMA}, ["items"]), + "lead": ("Update investigation leads.", {"items": TOOL_HYPOTHESIS_ITEMS_SCHEMA}, ["items"]), "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "user_rule": ( "Remember an explicit future behavior rule from the user.", @@ -3298,193 +3298,35 @@ def _state_tool_schema(name: str) -> Json: # Agent Prompt ############################ -AGENT_SYSTEM_PROMPT = """You are nanocode, a coding agent. +AGENT_SYSTEM_PROMPT = """You are nanocode, a terminal coding agent. -Use function tools to update state and work on the repository. -Assistant text is optional. Do not answer with text when a useful tool call should be made. -Multi-step tasks are complete only after goal.complete=true is set. +Use assistant text for chat/final answers; use function tools for state/repo work. +Use tool schemas for exact names, capabilities, and arguments. +Use the latest user language. Keep terminal output plain and concise. Preserve literals. +WHEN THE NEXT USEFUL ACTION IS CLEAR, TAKE IT NOW. -Language rule: all user-facing assistant text MUST use the latest user language. -This includes chat text, progress text, pending-feedback replies, direct responses, and message_for_complete. -Do not switch to English when the latest user request is Chinese. Preserve code, identifiers, paths, commands, config keys, API names, and quoted text exactly. -User-facing text is read in a terminal: keep it plain, concise, direct, and CLI-friendly. -Avoid Markdown tables, large headings, decorative formatting, and long nested bullets unless the user asks for them. +Priority: latest user request > blocking feedback > user rules > active state > conversation. +Never repeat an old completion. Do not rewrite Goal unless the user changed the task. -Available state tools: -goal, plan, hypothesis, known, user_rule, verify, forget +Workflow: +- Chat: answer directly; do not create task state. +- One-shot: use only needed tools, then answer and stop; do not create task state just to report. +- Tracked task: for edits/debugging/checks/multi-step work, set Goal, keep a short Plan, act on the current step, record Checks after edits or requested checks, finish with goal.complete=true. -Available repository tools: -{ __tool_names__ } +Current step: +- Choose the smallest useful action from latest request, feedback, visible results, and Plan. +- Batch independent actions; serialize dependent actions; ask only when blocked. +- Do not stop at state-only updates when a useful tool call is clear. -All repository tool calls require: -- intention: the concrete question to answer or outcome to achieve -- args: tool arguments +State: +- Goal/Plan track work. Facts are confirmed. Leads are for investigations. Checks are verification. User Rules are future-behavior requests. +- Save only what matters after results disappear; cite tr.N when result-backed; forget raw results when no longer needed. -PRIORITY -Latest User Request > User Rules > Current Goal > Plan/Facts > Conversation History. - -Never repeat a previous completion as the answer. -Do not rewrite the Goal unless the user changed the task. - -TASK SHAPES -Simple answer: -- direct conversation, clarification, or explanation that needs no repository action -- answer with assistant text only -- do not use Goal, Plan, Facts, Leads, or Checks - -One-shot task: -- one bounded lookup/check/tool batch whose visible result answers the request -- call needed tools, then answer with assistant text and stop -- do not create Goal, Plan, Facts, Leads, or Checks just to report the result - -Multi-step task: -- implementation, edits, debugging, investigation, explicit checks, or work that may span turns -- set Goal; set Plan once enough context is known -- record Checks only after edits, explicit checks, or correctness-sensitive work -- complete with goal.complete=true - -STATE -Facts: -- settled current-task facts that matter after tool results disappear -- not intentions, TODOs, guesses, routine observations, duplicates, or raw logs - -Leads: -- investigation directions for root-cause, debugging, or troubleshooting work -- status: { __hypothesis_status_text__ } -- each lead should imply a concrete check -- do not create Leads for ordinary implementation or rename tasks - -Checks: -- concrete checks that were run, failed, or were blocked -- use the verify tool to record Checks -- do not record Checks for simple answers unless the user requested checks - -User Rules: -- only explicit future-behavior requests from the user - -Tool Results: -- visible tool results are temporary support context -- inspect visible results before deciding the next action -- ACT should opportunistically forget raw results after preserving useful conclusions in Goal, Plan, Facts, Leads, or Checks -- forget raw results when they no longer affect target selection, edit anchors, error repair, verification, or completion -- OBSERVE is a fallback reducer for unreferenced raw results, not the only cleanup path -- do not let old gate feedback dominate once fresh tool results answer the next step - -WORKFLOW -Classify the latest request as Simple answer, One-shot task, or Multi-step task before deciding state tools. - -If the request is a Simple answer: -- answer directly and stop - -If the request is a One-shot task: -- use tools only until the requested answer is visible -- answer directly and stop - -If the request is a Multi-step task: -- set a Goal -- set a short Plan when enough context is known, or run the first useful readonly discovery first -- use Leads only for root-cause/debug/investigation work -- execute the next useful frontier once the Plan exists -- after edits or requested checks, record Checks with the smallest relevant check - -Prefer useful tool calls over state-only turns. -Pair state updates with the next frontier tool call when tool arguments are already known. -Assistant text is not progress by itself: if you say you will edit/check now, include that tool call in the same response. - -FORWARD PROGRESS -- Advance as far as safely possible in each turn. -- Batch independent tool calls whenever their arguments are known. -- Do not stop after Goal, Plan, Facts, or Leads updates if a useful repository tool call is clear. -- Pair source-backed Facts/Leads/Checks with forget when the cited raw result no longer matters. -- Serialize only when later arguments depend on earlier results. -- Ask the user only when the blocker cannot be resolved by available tools. - -PLANNING -Use a Plan only for real multi-step work. -Usually keep it to 2-5 concrete outcome steps. - -Plan rules: -- update only when status, text, context, or order changes -- use patch for small changes; replace only for restructuring -- at most one item may be doing -- done context must cite supporting result context -- blocked context must name the concrete blocker -- add a check step only for edits, explicit checks, or correctness-sensitive work - -If all Plan items are done/blocked and Checks passed/blocked, finish by default. -To continue tools after that, first reopen the Plan with a todo/doing item explaining why completion is insufficient. - -INVESTIGATION -Use Leads for root-cause analysis, competing explanations, or branch elimination. - -Rules: -- track plausible directions separately -- mark leads ruled_out when evidence eliminates them -- mark leads confirmed before claiming root cause -- stop investigating when the exact target and next edit/check are clear - -DISCOVERY AND EDITING -{ __discovery_hint__ } -Use Read only for known paths/ranges or search-narrowed targets. -Read small ranges around likely matches. -{ __edit_anchor_intro__ } -Visible "line:hash|code" lines already contain line anchors; use the "line:hash" part. - -Stop discovery once the next edit/check is clear. -Do not repeat Search/Read/Recall for confidence when visible results already identify target ranges. - -Editing rules: -- make one coherent change per edit action -- new file: create a minimal skeleton first, then grow with focused EditFile chunks -- literal file-wide replacement: use EditFile replace_all -- existing file: use visible anchors when available; inspect only when anchors are missing, stale, or too compressed -- never rewrite a large file in one action -{ __edit_anchor_rule__ } -- use medium EditFile batches: usually one file or one logical block with several related edits -- split when the JSON becomes large, anchors come from unrelated areas, or a previous edit failed -- copy line anchors exactly from visible tool output; refresh anchors only after EditFile reports a stale/missing anchor - -CHECKS -Check strength: -- none: simple answers -- light: read/static confirmation -- tool: code changes or requested checks -- user: visual/manual confirmation - -After edits or explicit checks, verify with the smallest relevant test, build, lint, static check, or readback. - -verify requires: -- kind -- method -- criteria -- status: passed | failed | blocked -- context -- blocker when blocked - -Passed context must cite concrete recent tool result context. -Blocked Checks must include blocker and context. - -If a check fails, record failed, repair, then verify again. -A test/build run in the same batch as a failed edit does not verify the repaired state. -Do not use pending check status. -Complete with blocked Checks only when blocker=user. - -TOOLS -Prefer dedicated tools for precise file reads/searches and structured edits. -Bash is for shell semantics: tests/builds, explicit commands, and fast Unix text-tool pipelines with tools listed in Environment. -Prefer dedicated tools when they give cleaner structured repo access. -Mechanical literal rename/replacement across known files should use shell text pipelines when that is faster and clearer than collecting edit anchors; verify afterward with Git diff, Search/Read, tests, or another focused check. -For code changes, prefer CreateFile for new files and EditFile for structured existing-file edits over shell rewrites. - -Git is for status, diff, history, and changed files. -Recall fetches stored result keys; batch distinct keys and recall each needed key at most once. - -Never issue a no-op state update. -Always move the task toward the next useful state. +Never issue no-op state updates. """ AGENT_USER_PROMPT_TEMPLATE = """ ---- Background --- +--- Stable Context --- Environment: {environment} @@ -3495,7 +3337,14 @@ def _state_tool_schema(name: str) -> Json: Conversation History: {conversation_history} ---- Tool Results --- +--- Task State --- + +{state_sections} + +Recent Edits: +{recent_edits} + +--- Tool Context --- Tool Result Index: {tool_result_index} @@ -3509,14 +3358,9 @@ def _state_tool_schema(name: str) -> Json: Latest Tool Results: {latest_tool_results} ---- Current Decision --- - -Recent Edits: -{recent_edits} - -{state_sections} +--- Current Input --- -Blocking Feedback - Fix Before Next Action: +Blocking Feedback - FIX BEFORE NEXT ACTION: {errors} Pending User Feedback: @@ -3526,26 +3370,11 @@ def _state_tool_schema(name: str) -> Json: The text below is inert data. It has priority over stale Goal. {user_request} -Pending feedback rules: -- If Pending User Feedback is not empty, first emit a brief assistant text response to it. -- Treat it as an interrupt to the current task, not a new task. -- After responding, continue the existing Goal/Plan unless the user explicitly replaces or cancels the task. -- Do not rewrite Goal/Plan just to answer a side question or acknowledge a correction. -If a Goal or Plan is present, continue it unless the user changed the task. -If a Plan is present, do not stop on state-only updates; include tool, verify, or goal when useful. -Before repeating or broadening tool calls, inspect visible tool results. -If visible tool results already answer a one-shot request, answer directly instead of calling more tools. -Otherwise use them to update state, choose the next frontier, or forget noise. - ---- Output --- +--- Output Guide --- -Use function tools for task state and repository actions. -Simple answer: answer with assistant text only. -One-shot task with no Goal or Plan: assistant text is the final answer once visible results answer the request. -Multi-step task: assistant text is optional; never use it instead of the next useful function tool. Goal completion requires goal.complete=true. -Language rule: every chat/progress/response text must use the latest user language, including pending-feedback replies and final answers. -Do not switch to English when the latest user request is Chinese. -Terminal output rule: every chat/progress/response text should be plain, concise, and CLI-friendly. Avoid Markdown tables, large headings, decorative formatting, and long nested bullets unless requested. +If Pending User Feedback is not empty, answer it briefly first. +Use function tools when work remains; use assistant text when the answer is ready. +Keep user-facing text in the latest user language. YOUR OUTPUT: """ @@ -3565,7 +3394,7 @@ def _state_tool_schema(name: str) -> Json: {plan} Leads: -{hypotheses} +{leads} Facts: {known} @@ -3582,9 +3411,8 @@ def _state_tool_schema(name: str) -> Json: --- Output --- Use function tools only. -Prefer explicit KEEP/FORGET decisions. Omitted results are compacted by default. -Facts/Leads entries from tool results should cite SOURCE tr.N keys. -Path-only or vague facts do not replace raw results; KEEP the raw result or record a SOURCE-backed, decision-useful conclusion before forgetting/omitting it. +Keep only raw results needed for the next step. Forget noise. Omitted results are compacted. +Preserve important conclusions with SOURCE-backed Facts or Leads before forgetting. YOUR OUTPUT: """ @@ -3595,14 +3423,13 @@ def _state_tool_schema(name: str) -> Json: Job: - Reduce Unreduced Raw Tool Results before ACT continues. -- Prefer declaring KEEP or FORGET for each result you reviewed. -- KEEP only raw results that affect the next ACT frontier: target selection, edit choice, checks, error repair, or completion. -- FORGET routine success, duplicate listings, no-match searches, superseded results, and ruled-out branches. Forget preserves logs and Recall. -- If you omit a tr.N key, nanocode compacts it by default; use omission only for unimportant results. -- Before compacting or forgetting an important conclusion, preserve it with SOURCE-backed Facts or Leads. +- Keep only raw results needed for the next step. +- Forget routine, duplicate, superseded, or irrelevant results; forgotten results remain recallable. +- Omitted tr.N keys are compacted by default. +- Preserve important conclusions with SOURCE-backed Facts or Leads. - Do not update Plan, Checks, or Goal. -Allowed tools: keep, forget, known, hypothesis. +Allowed tools: keep, forget, known, lead. """ @@ -4936,7 +4763,7 @@ def _apply_known(self, actions: list[Json]) -> None: self._add_known_item(item.text, item.source) def _apply_hypotheses(self, actions: list[Json]) -> None: - for raw in self._action_items(actions, "hypothesis"): + for raw in self._action_items(actions, "lead"): item = Hypothesis.from_json(raw) if item is not None: self._add_hypothesis(item) @@ -5013,7 +4840,7 @@ def _apply_task_code(self, actions: list[Json]) -> None: return tracked_state = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) if ( - "goal" in action_types or "plan" in action_types or "hypothesis" in action_types or (tracked_state and "tool" in action_types) + "goal" in action_types or "plan" in action_types or "lead" in action_types or (tracked_state and "tool" in action_types) ) and not self.blackboard.goal_reached: self.blackboard.task_code = TaskCode.WORKING @@ -5201,8 +5028,8 @@ class Agent: MAX_AGENT_FEEDBACK_ERRORS: ClassVar[int] = 8 MAX_AGENT_FEEDBACK_ERROR_LEN: ClassVar[int] = 220 MODEL_TIMEOUT_RETRY_DELAYS: ClassVar[tuple[int, ...]] = (3, 10, 20, 30, 60, 120) - ACT_ACTION_TYPES: ClassVar[set[str]] = {"goal", "plan", "hypothesis", "known", "tool", "verify", "user_rule", "forget"} - OBSERVE_ACTION_TYPES: ClassVar[set[str]] = {"keep", "hypothesis", "known", "forget"} + ACT_ACTION_TYPES: ClassVar[set[str]] = {"goal", "plan", "lead", "known", "tool", "verify", "user_rule", "forget"} + OBSERVE_ACTION_TYPES: ClassVar[set[str]] = {"keep", "lead", "known", "forget"} COMPLETED_PLAN_STATUSES: ClassVar[set[PlanStatus]] = {PlanStatus.DONE, PlanStatus.BLOCKED} MAX_COMPLETED_GOAL_TOOL_RESULTS: ClassVar[int] = 50 RECENT_EDITS: ClassVar[int] = 20 @@ -5323,7 +5150,7 @@ def build_observe_prompt(self) -> str: user_rules=self.session.state.user_rules.format(), goal=current.goal or "(empty)", plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", - hypotheses="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", + leads="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", errors="\n".join("- " + error for error in self.observe_feedback_errors) or "(empty)", @@ -5331,17 +5158,8 @@ def build_observe_prompt(self) -> str: user_request=self._format_user_request(), ).strip() - def _system_prompt(self, template: str | None = None, *, tools: Iterable[ToolClass] | None = None) -> str: - tool_classes = self._available_tool_classes(tools) - return ( - (template or AGENT_SYSTEM_PROMPT) - .replace("{ __tool_names__ }", "|".join(tool.NAME for tool in tool_classes)) - .replace("{ __discovery_hint__ }", self._discovery_prompt_hint(tool_classes)) - .replace("{ __edit_anchor_intro__ }", self._edit_anchor_intro(tool_classes)) - .replace("{ __edit_anchor_rule__ }", self._edit_anchor_rule(tool_classes)) - .replace("{ __hypothesis_status_text__ }", HYPOTHESIS_STATUS_TEXT) - .strip() - ) + def _system_prompt(self, template: str | None = None) -> str: + return (template or AGENT_SYSTEM_PROMPT).strip() def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> tuple[ToolClass, ...]: tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) @@ -5349,28 +5167,6 @@ def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> t return tool_classes return tuple(tool for tool in tool_classes if tool is not InspectCodeTool) - def _discovery_prompt_hint(self, tool_classes: Iterable[ToolClass]) -> str: - if InspectCodeTool not in tool_classes: - return "Use Search/List/LineCount when path, symbol, range, or target is unknown." - return ( - "For structural code discovery, prefer InspectCode before Search/Read.\n" - "- InspectCode mode=find: symbol candidates by name/prefix with optional kind/path/exact_only/limit filters.\n" - "- InspectCode mode=inspect: anchored source, imports, members, references, and implementors for one symbol.\n" - "- InspectCode mode=outline: file-level or file-local symbol outlines.\n" - "- Use Search for exact literal text, config, comments, logs, or when no useful path/symbol guess exists.\n" - "- Use List/LineCount when path shape or file size is unknown." - ) - - def _edit_anchor_intro(self, tool_classes: Iterable[ToolClass]) -> str: - if InspectCodeTool in tool_classes: - return 'Search, Read, and InspectCode mode=inspect source lines are hashline-numbered as "line:hash|code".' - return 'Search and Read context lines are hashline-numbered as "line:hash|code".' - - def _edit_anchor_rule(self, tool_classes: Iterable[ToolClass]) -> str: - if InspectCodeTool in tool_classes: - return "- Search can provide anchors for localized edits; InspectCode mode=inspect can provide anchors for known symbols; use Read when you need fuller context" - return "- Search can provide anchors for localized edits; use Read when you need fuller context" - def _format_user_request(self) -> str: user_request = self.blackboard.user_input or "(empty)" fence = "`" * max(3, max((len(match.group(0)) for match in re.finditer(r"`{3,}", user_request)), default=0) + 1) @@ -6034,7 +5830,7 @@ def _investigate_completion_error(self) -> str: def _released_result_sources_from_actions(actions: list[Json]) -> set[str]: released = set() for action in actions: - values = _json_list(action.get("items")) if _json_str(action.get("type")) == "hypothesis" else [] + values = _json_list(action.get("items")) if _json_str(action.get("type")) == "lead" else [] for raw in values: item = Hypothesis.from_json(raw) if item is not None and item.status != HypothesisStatus.ACTIVE: @@ -6120,12 +5916,12 @@ def _build_response_context(self, response: Json) -> ResponseContext: has_fresh_plan_action=has_fresh_plan_action, has_user_rule_action="user_rule" in action_types, has_edit_tool_call=has_edit_tool_call, - has_state_update_action=bool(action_types & {"goal", "plan", "known", "hypothesis"}), + has_state_update_action=bool(action_types & {"goal", "plan", "known", "lead"}), state_or_work_requested=bool( tool_calls or pending_verify_requested or (assistant_text and actions and not completion_message) - or action_types & {"goal", "plan", "forget", "hypothesis", "known"} + or action_types & {"goal", "plan", "forget", "lead", "known"} ), ) @@ -6364,7 +6160,7 @@ def _handle_observe_response( return AgentRunResult() def _warn_weak_observe_memory(self, actions: list[Json]) -> None: - if any(_json_str(action.get("type")) in {"keep", "forget", "hypothesis"} for action in actions): + if any(_json_str(action.get("type")) in {"keep", "forget", "lead"} for action in actions): return known_actions = [action for action in actions if _json_str(action.get("type")) == "known"] if not known_actions: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 5d6e09b..8e41d9e 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -533,41 +533,6 @@ def test_act_prompt_uses_first_todo_as_current_focus(tmp_path): assert "Current Focus:\n- [○ todo] edit command handler (id=p2)" in prompt -def test_act_prompt_tells_model_to_reply_to_pending_feedback_first(tmp_path): - agent = Agent(Session(cwd=str(tmp_path))) - agent.session.state.pending_user_feedback = "focus on sed" - - prompt = agent.build_user_prompt() - - assert "Pending User Feedback:\nfocus on sed" in prompt - assert "Pending feedback rules:" in prompt - assert "first emit a brief assistant text response" in prompt - assert "not a new task" in prompt - assert "latest user language" in prompt - assert "pending-feedback replies" in prompt - - -def test_act_prompt_keeps_simple_lookups_out_of_task_flow(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode, "_code_index_available", lambda session: False) - agent = Agent(Session(cwd=str(tmp_path))) - - prompt = agent._system_prompt() - - assert "TASK SHAPES" in prompt - assert "Simple answer:" in prompt - assert "One-shot task:" in prompt - assert "Multi-step task:" in prompt - assert "Classify the latest request as Simple answer, One-shot task, or Multi-step task" in prompt - assert "call needed tools, then answer with assistant text and stop" in prompt - assert "do not create Goal, Plan, Facts, Leads, or Checks just to report the result" in prompt - assert "record Checks only after edits, explicit checks, or correctness-sensitive work" in prompt - assert "use Leads only for root-cause/debug/investigation work" in prompt - assert "Multi-step tasks are complete only after goal.complete=true is set" in prompt - assert "InspectCode" not in prompt - assert "Use Search/List/LineCount when path, symbol, range, or target is unknown" in prompt - assert "__discovery_hint__" not in prompt - - def test_inspect_code_tools_is_hidden_until_available(tmp_path, monkeypatch): monkeypatch.setattr(nanocode, "_code_index_available", lambda session: False) agent = Agent(Session(cwd=str(tmp_path))) @@ -575,9 +540,6 @@ def test_inspect_code_tools_is_hidden_until_available(tmp_path, monkeypatch): tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] assert "InspectCode" not in tool_names - prompt = agent.build_user_prompt() - assert "- inspect_code:" not in prompt - assert "inspect_code_hint" not in prompt def test_inspect_code_tools_is_visible_when_available(tmp_path, monkeypatch): @@ -587,31 +549,6 @@ def test_inspect_code_tools_is_visible_when_available(tmp_path, monkeypatch): tool_names = [schema["function"]["name"] for schema in agent._tool_schemas() if schema.get("type") == "function"] assert "InspectCode" in tool_names - system_prompt = agent._system_prompt() - assert "prefer InspectCode before Search/Read" in system_prompt - assert "InspectCode mode=find" in system_prompt - assert "InspectCode mode=inspect" in system_prompt - assert "InspectCode mode=outline" in system_prompt - prompt = agent.build_user_prompt() - assert "Use InspectCode for structural code navigation" in prompt - assert "mode=find for symbol candidates" in prompt - assert "mode=inspect for anchored symbol source" in prompt - assert "mode=outline for file outlines" in prompt - assert "code-symbol-index" not in prompt - assert "Do not pass natural language" in prompt - assert "Use Search/Read for text, config, logs, commands, and exact ranges" in prompt - - -def test_act_user_prompt_separates_chat_one_shot_and_tracked_task_output(tmp_path): - agent = Agent(Session(cwd=str(tmp_path))) - - prompt = agent.build_user_prompt() - - assert "Simple answer: answer with assistant text only." in prompt - assert "One-shot task with no Goal or Plan: assistant text is the final answer" in prompt - assert "If visible tool results already answer a one-shot request" in prompt - assert "Multi-step task: assistant text is optional" in prompt - assert "Goal completion requires goal.complete=true" in prompt def test_one_shot_bash_does_not_require_goal_or_plan(tmp_path): @@ -710,18 +647,6 @@ def test_edit_tool_without_goal_or_plan_warns(tmp_path): assert any("mutating work before Plan was set" in error for error in agent.agent_feedback_errors) -def test_act_prompt_encourages_unix_text_tools_when_clear(tmp_path): - agent = Agent(Session(cwd=str(tmp_path))) - - prompt = agent._system_prompt() - - assert "Bash is for shell semantics" in prompt - assert "tools listed in Environment" in prompt - assert "structured repo access" in prompt - assert "Mechanical literal rename/replacement" in prompt - assert "verify afterward" in prompt - - def test_act_prompt_lists_available_shell_tools_in_environment(tmp_path, monkeypatch): monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/bin/" + name if name in {"rg", "jq"} else None) agent = Agent(Session(cwd=str(tmp_path))) @@ -813,7 +738,7 @@ def test_forget_removes_kept_tool_result_but_keeps_known_source(tmp_path): assert messages == ["Tool Result Context: -tr.1"] -def test_hypothesis_action_updates_blackboard_and_report(tmp_path): +def test_lead_action_updates_blackboard_and_report(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) _seed_plan(agent, "debug branch") messages = [] @@ -822,7 +747,7 @@ def test_hypothesis_action_updates_blackboard_and_report(tmp_path): { "actions": [ { - "type": "hypothesis", + "type": "lead", "items": [ { "id": "h1", @@ -866,7 +791,7 @@ def test_forget_rejects_active_hypothesis_source(tmp_path): assert messages == ["ToolResult_Gate: protected source: tr.1 (active lead)."] -def test_forget_allows_source_when_hypothesis_is_closed_same_response(tmp_path): +def test_forget_allows_source_when_lead_is_closed_same_response(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) _seed_plan(agent, "debug branch") agent.tool_context.kept_results = ['- ok tool=Read args=["a"] key=tr.1\n output:\na'] @@ -877,7 +802,7 @@ def test_forget_allows_source_when_hypothesis_is_closed_same_response(tmp_path): { "actions": [ { - "type": "hypothesis", + "type": "lead", "items": [{"id": "h1", "text": "branch ruled out", "status": "ruled_out", "source": ["tr.1"]}], }, {"type": "forget", "source": ["tr.1"], "reason": "branch ruled out"}, @@ -895,7 +820,7 @@ def test_forget_allows_source_when_hypothesis_is_closed_same_response(tmp_path): ] -def test_forget_allows_source_when_hypothesis_is_dropped_same_response(tmp_path): +def test_forget_allows_source_when_lead_is_dropped_same_response(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) _seed_plan(agent, "debug branch") agent.tool_context.kept_results = ['- ok tool=Read args=["a"] key=tr.1\n output:\na'] @@ -905,7 +830,7 @@ def test_forget_allows_source_when_hypothesis_is_dropped_same_response(tmp_path) result = agent.handle_response( { "actions": [ - {"type": "hypothesis", "items": [{"id": "h1", "text": "branch no longer matters", "status": "dropped", "source": ["tr.1"]}]}, + {"type": "lead", "items": [{"id": "h1", "text": "branch no longer matters", "status": "dropped", "source": ["tr.1"]}]}, {"type": "forget", "source": ["tr.1"], "reason": "branch no longer matters"}, ] }, @@ -1205,7 +1130,7 @@ def test_tool_result_store_keeps_latest_256_items(tmp_path): assert session.state.tool_result_counter == 257 -def test_tool_result_store_trim_keeps_hypothesis_source_keys(tmp_path): +def test_tool_result_store_trim_keeps_lead_source_keys(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="kept branch", source=("tr.1",))] @@ -1588,10 +1513,10 @@ def test_agent_accepts_string_plan_items_from_function_call(tmp_path): ] -def test_agent_accepts_string_hypothesis_items_from_function_call(tmp_path): +def test_agent_accepts_string_lead_items_from_function_call(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) - agent.apply_response({"actions": [{"type": "hypothesis", "items": ["Admin filter excludes history"]}]}) + agent.apply_response({"actions": [{"type": "lead", "items": ["Admin filter excludes history"]}]}) assert agent.blackboard.hypotheses == [ nanocode.Hypothesis(text="Admin filter excludes history"), @@ -2315,7 +2240,7 @@ def test_main_agent_compact_report_labels_combined_leads_and_facts(tmp_path): { "actions": [ { - "type": "hypothesis", + "type": "lead", "items": [{"id": "h1", "text": "admin selector starves history mode", "status": "active", "source": ["tr.2"]}], }, {"type": "known", "items": [{"fact": "feed SSE request path is shared by admin and normal users", "source": ["tr.3"]}]}, @@ -4011,7 +3936,7 @@ def test_investigate_completion_without_confirmed_lead_warns(tmp_path): { "actions": [ { - "type": "hypothesis", + "type": "lead", "items": [{"id": "h1", "text": "bad admin filter", "status": "confirmed", "source": ["tr.1"]}], }, _verify_passed_action(), @@ -4045,7 +3970,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): "type": "plan", "items": [{"id": "p1", "text": "identify root cause", "status": "done", "context": "reasoned"}], }, - {"type": "hypothesis", "items": [{"id": "h1", "text": "bad filter", "status": "confirmed", "source": ["tr.1"]}]}, + {"type": "lead", "items": [{"id": "h1", "text": "bad filter", "status": "confirmed", "source": ["tr.1"]}]}, _verify_passed_action(), {"type": "goal", "text": "find bug", "complete": True, "message_for_complete": "done"}, ] From 14ed2dde3003661c4ea14975a8ad4e39f581c8c8 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 15:45:32 +0800 Subject: [PATCH 116/144] minor fix --- nanocode.py | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/nanocode.py b/nanocode.py index 3c5b430..f657bc6 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1411,12 +1411,7 @@ def unreduced_blocks(self, checkpoint: int, *, exclude_keys: set[str] | None = N return blocks def raw_context_chars(self, checkpoint: int, *, exclude_keys: set[str] | None = None) -> int: - return len( - "\n\n".join( - self.unreduced_recent_blocks(checkpoint, exclude_keys=exclude_keys) - + self.latest_raw_blocks(exclude_keys=exclude_keys) - ) - ) + return len("\n\n".join(self.unreduced_recent_blocks(checkpoint, exclude_keys=exclude_keys) + self.latest_raw_blocks(exclude_keys=exclude_keys))) @classmethod def _needs_reduction(cls, block: str, checkpoint: int) -> bool: @@ -3322,7 +3317,7 @@ def _state_tool_schema(name: str) -> Json: - Goal/Plan track work. Facts are confirmed. Leads are for investigations. Checks are verification. User Rules are future-behavior requests. - Save only what matters after results disappear; cite tr.N when result-backed; forget raw results when no longer needed. -Never issue no-op state updates. +Default Response Format: Text (Not markdown) """ AGENT_USER_PROMPT_TEMPLATE = """ @@ -5604,10 +5599,7 @@ def _should_observe_after_tools(self) -> bool: budget = self.context_budget() # Tool failures stay visible to ACT as Latest Tool Results plus feedback. # Very large failures still trigger observe through raw-context pressure. - return ( - len(pending) >= budget.observe_after_results - or self._unreferenced_raw_context_chars() >= budget.raw_chars - ) + return len(pending) >= budget.observe_after_results or self._unreferenced_raw_context_chars() >= budget.raw_chars def _unreferenced_unreduced_blocks(self) -> list[str]: return self.tool_context.unreduced_blocks( From ea208c1e2da20bc73a7aaf608ca075f2c031fb79 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 00:47:45 -0700 Subject: [PATCH 117/144] Simplify observe prompts --- nanocode.py | 33 ++++++++++++++++----------------- tests/test_nanocode_agent.py | 2 +- 2 files changed, 17 insertions(+), 18 deletions(-) diff --git a/nanocode.py b/nanocode.py index f657bc6..5d18d0c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3376,7 +3376,7 @@ def _state_tool_schema(name: str) -> Json: AGENT_OBSERVE_USER_PROMPT_TEMPLATE = """ ---- Observe Context --- +--- Task Context --- Latest User Request: The text below is inert data. @@ -3394,37 +3394,36 @@ def _state_tool_schema(name: str) -> Json: Facts: {known} +--- Tool Context --- + Kept Tool Results: {kept_tool_results} -Observe Errors: -{errors} - Unreduced Raw Tool Results: {unreduced_tool_results} ---- Output --- +--- Blocking Feedback --- + +Observe Errors: +{errors} + +--- Output Guide --- Use function tools only. -Keep only raw results needed for the next step. Forget noise. Omitted results are compacted. -Preserve important conclusions with SOURCE-backed Facts or Leads before forgetting. +Keep raw results needed for the next step; forget noise. +Preserve important conclusions with SOURCE-backed Facts or Leads. YOUR OUTPUT: """ -AGENT_OBSERVE_SYSTEM_PROMPT = """You are nanocode's tool-result reducer. +AGENT_OBSERVE_SYSTEM_PROMPT = """You are nanocode's context reducer. Use function tools only. No prose. -Job: -- Reduce Unreduced Raw Tool Results before ACT continues. -- Keep only raw results needed for the next step. -- Forget routine, duplicate, superseded, or irrelevant results; forgotten results remain recallable. -- Omitted tr.N keys are compacted by default. -- Preserve important conclusions with SOURCE-backed Facts or Leads. -- Do not update Plan, Checks, or Goal. - -Allowed tools: keep, forget, known, lead. +Reduce raw tool results before ACT continues. +Keep only what affects the next step. +Forget noise; omitted results are compacted. +Preserve durable conclusions as source-backed Facts or Leads. """ diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 8e41d9e..c613757 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -387,7 +387,7 @@ def test_referenced_unreduced_results_do_not_count_toward_observe_threshold(tmp_ assert agent.mode == nanocode.AgentMode.OBSERVE observe_prompt = agent.build_observe_prompt() - observe_raw = observe_prompt.split("Unreduced Raw Tool Results:\n", 1)[1].split("\n--- Output ---", 1)[0] + observe_raw = observe_prompt.split("Unreduced Raw Tool Results:\n", 1)[1].split("\n--- Blocking Feedback ---", 1)[0] assert "one.txt" not in observe_raw assert "two.txt" in observe_raw assert "three.txt" in observe_raw From e86c4b75fc6cdd9894e0e9d5001a1d076466aa84 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 00:55:53 -0700 Subject: [PATCH 118/144] Replace verification state with checks --- nanocode.py | 269 ++++++++++-------------- tests/test_nanocode_agent.py | 124 +++++------ tests/test_nanocode_create_file_tool.py | 2 +- tests/test_nanocode_edit_file_tool.py | 2 +- 4 files changed, 164 insertions(+), 233 deletions(-) diff --git a/nanocode.py b/nanocode.py index 5d18d0c..71a245a 100644 --- a/nanocode.py +++ b/nanocode.py @@ -152,7 +152,7 @@ def __str__(self) -> str: class TaskCode(StrEnum): NEW = "new" WORKING = "working" - VERIFYING = "verifying" + CHECKING = "checking" DONE = "done" @@ -267,15 +267,15 @@ def from_json(cls, value: JsonValue) -> "Hypothesis | None": ) -class VerificationStatus(StrEnum): +class CheckStatus(StrEnum): IDLE = "idle" REQUIRED = "required" - DONE = "done" + PASSED = "passed" FAILED = "failed" BLOCKED = "blocked" -class VerificationBlocker(StrEnum): +class CheckBlocker(StrEnum): NONE = "" USER = "user" ENVIRONMENT = "environment" @@ -283,30 +283,20 @@ class VerificationBlocker(StrEnum): UNKNOWN = "unknown" -ALL_VERIFICATION_BLOCKERS = frozenset(VerificationBlocker) +ALL_CHECK_BLOCKERS = frozenset(CheckBlocker) @dataclass -class Verification: - goal: str = "" - status: VerificationStatus = VerificationStatus.IDLE - kind: str = "" +class Checks: + status: CheckStatus = CheckStatus.IDLE method: str = "" - criteria: list[str] = field(default_factory=list) context: str = "" - blocker: VerificationBlocker = VerificationBlocker.NONE + blocker: CheckBlocker = CheckBlocker.NONE def format(self, indent: str = "") -> str: lines = ["status: " + self.status] - if self.goal: - lines.append("goal: " + self.goal) - if self.kind: - lines.append("kind: " + self.kind) if self.method: lines.append("method: " + self.method) - if self.criteria: - lines.append("criteria:") - lines.extend("- " + item for item in self.criteria) if self.context: lines.append("context: " + self.context) if self.blocker: @@ -314,16 +304,13 @@ def format(self, indent: str = "") -> str: return _format_lines(lines, indent) def reset(self) -> None: - self.goal = "" - self.status = VerificationStatus.IDLE - self.kind = "" + self.status = CheckStatus.IDLE self.method = "" - self.criteria = [] self.context = "" - self.blocker = VerificationBlocker.NONE + self.blocker = CheckBlocker.NONE def has_context(self) -> bool: - return bool(self.goal or self.kind or self.method or self.criteria or self.context or self.blocker or self.status != VerificationStatus.IDLE) + return bool(self.method or self.context or self.blocker or self.status != CheckStatus.IDLE) @dataclass @@ -396,8 +383,8 @@ class Blackboard: hypotheses: list[Hypothesis] = field(default_factory=list) known: list[KnownItem] = field(default_factory=list) memory_checkpoint_tool_result_counter: int = 0 - verification_required: bool = False - verification: Verification = field(default_factory=Verification) + checks_required: bool = False + checks: Checks = field(default_factory=Checks) def source_result_keys(self) -> set[str]: keys = {key for item in self.known for key in KnownItem.source_of(item) if key.startswith("tr.")} @@ -413,12 +400,9 @@ def referenced_result_keys(self) -> set[str]: *[item.context for item in self.hypotheses], *[item.text for item in self.plan], *[item.context for item in self.plan], - self.verification.goal, - self.verification.kind, - self.verification.method, - *self.verification.criteria, - self.verification.context, - self.verification.blocker, + self.checks.method, + self.checks.context, + self.checks.blocker, ] for text in texts: keys.update(TOOL_RESULT_KEY_REF_PATTERN.findall(str(text))) @@ -1236,7 +1220,7 @@ class ToolCallExecution: error_type: Type[Exception] | None = None result_key: str = "" result_excerpted: bool = False - requires_verification: bool = False + requires_checks: bool = False @dataclass @@ -3255,14 +3239,12 @@ def _canonical_tool_name(name: str | None) -> str: "verify": ( "Record concrete check status.", { - "kind": TOOL_STRING_SCHEMA, "method": TOOL_NULLABLE_STRING_SCHEMA, - "criteria": TOOL_STRING_LIST_SCHEMA, "status": {"type": "string", "enum": ["passed", "failed", "blocked"]}, "blocker": {"type": ["string", "null"], "enum": ["user", "environment", "tool", "unknown"]}, "context": TOOL_NULLABLE_STRING_SCHEMA, }, - ["kind", "method", "criteria", "status", "blocker", "context"], + ["status", "context"], ), "keep": ( "Keep visible raw tool result keys in context during observe.", @@ -3314,7 +3296,7 @@ def _state_tool_schema(name: str) -> Json: - Do not stop at state-only updates when a useful tool call is clear. State: -- Goal/Plan track work. Facts are confirmed. Leads are for investigations. Checks are verification. User Rules are future-behavior requests. +- Goal/Plan track work. Facts are confirmed. Leads are for investigations. Checks are checks. User Rules are future-behavior requests. - Save only what matters after results disappear; cite tr.N when result-backed; forget raw results when no longer needed. Default Response Format: Text (Not markdown) @@ -4329,13 +4311,13 @@ def execute( output = "" error_type: Type[Exception] | None = None requires_confirmation = False - requires_verification = False + requires_checks = False try: call = item if isinstance(item, ParsedToolCall) else self.parse_tool_call(item) tool = self._make_tool(call) if isinstance(tool, BashTool): tool.live_output = self.live_output - requires_verification = tool.EFFECT == ToolEffect.EDIT + requires_checks = tool.EFFECT == ToolEffect.EDIT preview_error = getattr(tool, "preview_error", None) if callable(preview_error): preview_error_text = str(preview_error()) @@ -4384,7 +4366,7 @@ def execute( error_type=error_type, result_key=result_key, result_excerpted=result_excerpted, - requires_verification=outcome == "success" and requires_verification, + requires_checks=outcome == "success" and requires_checks, ) executions.append(execution) if outcome == "failure" and error_type is not Cancellation: @@ -4499,10 +4481,10 @@ class AgentStateUpdater: DISPLAY_LIMIT: ClassVar[int] = 5 COMPACT_DISPLAY_LIMIT: ClassVar[int] = 3 MAX_KNOWN_ITEMS: ClassVar[int] = 500 - VERIFY_STATUS_ACTIONS: ClassVar[dict[str, VerificationStatus]] = { - "passed": VerificationStatus.DONE, - "failed": VerificationStatus.FAILED, - "blocked": VerificationStatus.BLOCKED, + CHECK_STATUS_ACTIONS: ClassVar[dict[str, CheckStatus]] = { + "passed": CheckStatus.PASSED, + "failed": CheckStatus.FAILED, + "blocked": CheckStatus.BLOCKED, } def __init__( @@ -4612,7 +4594,7 @@ def compact_report(self) -> str: " Facts" in self.latest_report and self.blackboard.known, self._compact_rows(self.blackboard.known, lambda item: self._compact(KnownItem.format_item(item), 100)), ), - ("Checks", " Checks" in self.latest_report, [" " + self._format_verification()]), + ("Checks", " Checks" in self.latest_report, [" " + self._format_checks()]), ("User Rules", " User_Rules" in self.latest_report, [" updated"]), ) if changed @@ -4815,19 +4797,18 @@ def _known_fact_key(self, fact: KnownItem | str) -> str: return re.sub(r"\s+", " ", KnownItem.text_of(fact)).strip(" \t\r\n。.;；").lower() def _before_extra_state(self) -> str: - return self.blackboard.verification.format() + return self.blackboard.checks.format() def _apply_extra_state(self, actions: list[Json], *, goal_changed: bool, plan_replaced: bool) -> None: if goal_changed: - self.blackboard.verification_required = False - self._reset_stale_verification(actions, goal_changed=goal_changed, plan_replaced=plan_replaced) - self._apply_verification(actions) - self._bind_verification_goal() + self.blackboard.checks_required = False + self._reset_stale_checks(actions, goal_changed=goal_changed, plan_replaced=plan_replaced) + self._apply_checks(actions) def _apply_task_code(self, actions: list[Json]) -> None: action_types = {_json_str(action.get("type")) for action in actions} - if self.blackboard.verification_required or self.blackboard.verification.status == VerificationStatus.REQUIRED: - self.blackboard.task_code = TaskCode.VERIFYING + if self.blackboard.checks_required or self.blackboard.checks.status == CheckStatus.REQUIRED: + self.blackboard.task_code = TaskCode.CHECKING return if "verify" in action_types: self.blackboard.task_code = TaskCode.WORKING @@ -4843,11 +4824,11 @@ def _append_state_section(self, lines: list[str], title: str, rows: list[str] | lines.extend(rows or []) def _append_extra_state_report(self, lines: list[str], before_extra_state: str) -> None: - before_verification = before_extra_state - verification = self.blackboard.verification.format() - if verification == before_verification: + before_checks = before_extra_state + checks = self.blackboard.checks.format() + if checks == before_checks: return - self._append_state_section(lines, " Checks " + self._format_verification()) + self._append_state_section(lines, " Checks " + self._format_checks()) @staticmethod def _actions_of_type(actions: list[Json], action_type: str) -> Iterator[Json]: @@ -4856,70 +4837,51 @@ def _actions_of_type(actions: list[Json], action_type: str) -> Iterator[Json]: def _action_items(self, actions: list[Json], action_type: str) -> Iterator[JsonValue]: return (raw for action in self._actions_of_type(actions, action_type) for raw in _json_list(action.get("items"))) - def _format_verification(self) -> str: - verification = self.blackboard.verification - parts = [verification.status] + def _format_checks(self) -> str: + checks = self.blackboard.checks + parts = [checks.status] parts.extend( part for part in ( - verification.kind, - self._compact(verification.method) if verification.method else "", - "criteria: " + self._compact("; ".join(verification.criteria)) if verification.criteria else "", - "context: " + self._compact(verification.context) if verification.context else "", - "blocker: " + verification.blocker if verification.blocker else "", + self._compact(checks.method) if checks.method else "", + "context: " + self._compact(checks.context) if checks.context else "", + "blocker: " + checks.blocker if checks.blocker else "", ) if part ) return " | ".join(parts) - def _apply_verification(self, actions: list[Json]) -> None: + def _apply_checks(self, actions: list[Json]) -> None: for data in self._actions_of_type(actions, "verify"): - kind = _json_str(data.get("kind")) - if kind is not None: - self.blackboard.verification.kind = kind if kind and all(part in VALID_VERIFICATION_KINDS for part in kind.split("+")) else "" - criteria = [item for item in ((_json_str(raw) or "").strip() for raw in _json_list(data.get("criteria"))) if item] - if "criteria" in data: - self.blackboard.verification.criteria = criteria method = _json_str(data.get("method")) if method is not None: - if method != self.blackboard.verification.method: - self.blackboard.verification.context = "" - self.blackboard.verification.method = method - status = self.VERIFY_STATUS_ACTIONS.get(_json_str(data.get("status")) or "") + if method != self.blackboard.checks.method: + self.blackboard.checks.context = "" + self.blackboard.checks.method = method + status = self.CHECK_STATUS_ACTIONS.get(_json_str(data.get("status")) or "") if status is not None: - self.blackboard.verification.status = status - self.blackboard.verification_required = False - if status != VerificationStatus.BLOCKED: - self.blackboard.verification.blocker = VerificationBlocker.NONE + self.blackboard.checks.status = status + self.blackboard.checks_required = False + if status != CheckStatus.BLOCKED: + self.blackboard.checks.blocker = CheckBlocker.NONE blocker = _json_str(data.get("blocker")) if blocker is not None: - self.blackboard.verification.blocker = VerificationBlocker(blocker) if blocker in ALL_VERIFICATION_BLOCKERS else VerificationBlocker.NONE + self.blackboard.checks.blocker = CheckBlocker(blocker) if blocker in ALL_CHECK_BLOCKERS else CheckBlocker.NONE context = _json_str(data.get("context")) if context is not None: - self.blackboard.verification.context = context + self.blackboard.checks.context = context - def _reset_stale_verification(self, actions: list[Json], *, goal_changed: bool, plan_replaced: bool) -> None: - verification = self.blackboard.verification + def _reset_stale_checks(self, actions: list[Json], *, goal_changed: bool, plan_replaced: bool) -> None: + checks = self.blackboard.checks if goal_changed: - verification.reset() - return - if verification.goal and verification.goal != self.blackboard.goal: - verification.reset() + checks.reset() return if ( plan_replaced and not any(_json_str(action.get("type")) == "verify" for action in actions) - and verification.status in {VerificationStatus.REQUIRED, VerificationStatus.DONE, VerificationStatus.FAILED, VerificationStatus.BLOCKED} + and checks.status in {CheckStatus.REQUIRED, CheckStatus.PASSED, CheckStatus.FAILED, CheckStatus.BLOCKED} ): - verification.reset() - - def _bind_verification_goal(self) -> None: - verification = self.blackboard.verification - if not verification.has_context(): - verification.goal = "" - return - if self.blackboard.goal: - verification.goal = self.blackboard.goal + checks.reset() ############################ @@ -4976,14 +4938,6 @@ def _summarize(self, items: list[ConversationItem]) -> tuple[str, list[KnownItem return summary, known[-self.MAX_COMPACTED_KNOWN_ITEMS :] -############################ -# Verification -############################ - - -VALID_VERIFICATION_KINDS: set[str] = {"syntax_check", "change_syntax_check", "lint", "test", "build", "change_check", "other"} - - ############################ # Agent ############################ @@ -4997,10 +4951,10 @@ class ResponseContext: goal_was_empty: bool plan_was_empty: bool plan_was_complete: bool - verification_was_settled: bool + checks_settled: bool goal_will_change: bool tool_calls: list[JsonValue] - pending_verify_requested: bool + pending_check_requested: bool user_rule_message: str | None completion_message: str has_goal_action: bool @@ -5110,8 +5064,8 @@ def add(name: str, value: str) -> None: if current.plan: add("Plan", "\n".join(item.format() for item in current.plan)) add("Current Focus", self._format_current_focus()) - if current.verification.has_context() or current.verification_required: - add("Checks", current.verification.format() if current.verification.has_context() else "status: required") + if current.checks.has_context() or current.checks_required: + add("Checks", current.checks.format() if current.checks.has_context() else "status: required") return "\n\n".join(sections) if sections else "(empty)" def _format_environment(self) -> str: @@ -5309,7 +5263,7 @@ def _handle_format_gate(self, response: Json, format_error: str, consecutive_err def _finish_current_goal(self) -> None: self.blackboard.task_code = TaskCode.DONE self.blackboard.goal_reached = False - self.blackboard.verification_required = False + self.blackboard.checks_required = False def _format_act_tool_result_context(self) -> tuple[str, str, str]: checkpoint = self.blackboard.memory_checkpoint_tool_result_counter @@ -5541,8 +5495,8 @@ def _can_stream_tools(self) -> bool: def apply_response(self, response: Json) -> list[str]: actions = self._response_actions(response) - if any(self._is_pending_verify_action(action) for action in actions): - response = {**response, "actions": [action for action in actions if not self._is_pending_verify_action(action)]} + if any(self._is_pending_check_action(action) for action in actions): + response = {**response, "actions": [action for action in actions if not self._is_pending_check_action(action)]} actions = self._response_actions(response) if self._goal_changes_task(actions): self.tool_context.kept_results = [] @@ -5646,9 +5600,9 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: "reread only stale ranges; if the edit is large, retry a smaller coherent batch.", ) ) - if execution.requires_verification: - self.blackboard.verification_required = True - self.blackboard.task_code = TaskCode.VERIFYING + if execution.requires_checks: + self.blackboard.checks_required = True + self.blackboard.task_code = TaskCode.CHECKING self._remember_recent_edit(execution) if execution.call.args: _code_index_update(self.session, self.session.resolve_path(str(execution.call.args[0]))) @@ -5766,8 +5720,8 @@ def _gate_action_types( def _plan_is_complete(self) -> bool: return bool(self.blackboard.plan) and all(item.status in self.COMPLETED_PLAN_STATUSES and item.context.strip() for item in self.blackboard.plan) - def _verification_is_settled(self) -> bool: - return self.blackboard.verification.status in {VerificationStatus.DONE, VerificationStatus.BLOCKED} + def _checks_are_settled(self) -> bool: + return self.blackboard.checks.status in {CheckStatus.PASSED, CheckStatus.BLOCKED} def _completion_plan_error(self, ctx: ResponseContext) -> str: if not self.blackboard.goal_reached: @@ -5782,10 +5736,10 @@ def _completion_plan_error(self, ctx: ResponseContext) -> str: return "plan items missing context: " + self._format_plan_gate_items(missing_context) return "" - def _blocked_verification_completion_error(self) -> str: - if not self.blackboard.goal_reached or self.blackboard.verification.status != VerificationStatus.BLOCKED: + def _blocked_checks_completion_error(self) -> str: + if not self.blackboard.goal_reached or self.blackboard.checks.status != CheckStatus.BLOCKED: return "" - if self.blackboard.verification.blocker == VerificationBlocker.USER: + if self.blackboard.checks.blocker == CheckBlocker.USER: return "" return "verify blocked requires blocker=user before completion" @@ -5805,7 +5759,7 @@ def _user_rule_message_from_actions(self, actions: list[Json]) -> str | None: return None @staticmethod - def _is_pending_verify_action(action: Json) -> bool: + def _is_pending_check_action(action: Json) -> bool: return _json_str(action.get("type")) == "verify" and _json_str(action.get("status")) == "pending" def _investigate_completion_error(self) -> str: @@ -5851,8 +5805,8 @@ def _repeated_tool_retry_error(self, tool_calls: list[JsonValue]) -> str: def _build_response_context(self, response: Json) -> ResponseContext: raw_actions = self._response_actions(response) assistant_text = _json_str(response.get("_assistant_text")) or "" - pending_verify_requested = any(self._is_pending_verify_action(action) for action in raw_actions) - actions = [action for action in raw_actions if not self._is_pending_verify_action(action)] + pending_check_requested = any(self._is_pending_check_action(action) for action in raw_actions) + actions = [action for action in raw_actions if not self._is_pending_check_action(action)] tool_calls = [action for action in actions if _json_str(action.get("type")) == "tool"] action_types = {_json_str(action.get("type")) for action in actions} has_edit_tool_call = False @@ -5896,10 +5850,10 @@ def _build_response_context(self, response: Json) -> ResponseContext: goal_was_empty=not self.blackboard.goal, plan_was_empty=not self.blackboard.plan, plan_was_complete=self._plan_is_complete(), - verification_was_settled=self._verification_is_settled(), + checks_settled=self._checks_are_settled(), goal_will_change=bool(self.blackboard.goal and goal_update and goal_update != self.blackboard.goal), tool_calls=tool_calls, - pending_verify_requested=pending_verify_requested, + pending_check_requested=pending_check_requested, user_rule_message=self._user_rule_message_from_actions(actions), completion_message=completion_message, has_goal_action="goal" in action_types, @@ -5910,7 +5864,7 @@ def _build_response_context(self, response: Json) -> ResponseContext: has_state_update_action=bool(action_types & {"goal", "plan", "known", "lead"}), state_or_work_requested=bool( tool_calls - or pending_verify_requested + or pending_check_requested or (assistant_text and actions and not completion_message) or action_types & {"goal", "plan", "forget", "lead", "known"} ), @@ -5923,7 +5877,7 @@ def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallbac if on_message is not None: on_message(ctx.assistant_text) active_task = bool(self.blackboard.plan or self.blackboard.hypotheses) - if active_task and (self.blackboard.task_code in {TaskCode.WORKING, TaskCode.VERIFYING} or self.incomplete_task_context_at_turn_start): + if active_task and (self.blackboard.task_code in {TaskCode.WORKING, TaskCode.CHECKING} or self.incomplete_task_context_at_turn_start): return AgentRunResult() self.blackboard.task_code = TaskCode.DONE return AgentRunResult(done=True, value=ctx.response) @@ -5990,7 +5944,7 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N if ( self.blackboard.task_code == TaskCode.NEW and self.task_alignment_required - and (ctx.tool_calls or ctx.pending_verify_requested) + and (ctx.tool_calls or ctx.pending_check_requested) and not ctx.has_goal_action and not ctx.has_plan_action and not ctx.has_user_rule_action @@ -6001,7 +5955,7 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N ) if self.blackboard.task_code != TaskCode.NEW and ctx.goal_will_change and not ctx.has_fresh_plan_action: self._warn_agent("rewrote Goal after the task was active.", "replace Plan when the task scope changes.") - if ctx.pending_verify_requested: + if ctx.pending_check_requested: self._warn_agent('ignored verify status="pending".', self.RULE_VERIFY_DIRECTLY) if self.session.state.pending_user_feedback and ctx.goal_will_change: self._warn_agent( @@ -6009,9 +5963,9 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N "answer it without rewriting Goal unless the user explicitly replaces or cancels the task.", ) self._drop_goal_rewrite_actions(ctx) - if ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested and (ctx.pending_verify_requested or ctx.has_edit_tool_call): + if ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested and (ctx.pending_check_requested or ctx.has_edit_tool_call): self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) - if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_verify_requested or ctx.has_edit_tool_call): + if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_check_requested or ctx.has_edit_tool_call): self._warn_agent("changed Goal without replacing Plan.", "replace Plan when the task scope changes.") return False @@ -6024,7 +5978,7 @@ def _emit_state_and_text(self, ctx: ResponseContext, on_message: MessageCallback on_message(ctx.assistant_text) def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: - if ctx.plan_was_empty and not self.blackboard.plan and (ctx.pending_verify_requested or ctx.has_edit_tool_call): + if ctx.plan_was_empty and not self.blackboard.plan and (ctx.pending_check_requested or ctx.has_edit_tool_call): self._warn_agent("mutating work before Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ( ctx.plan_was_empty @@ -6034,14 +5988,14 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | ): self._warn_agent("Plan is empty after discovery.", "set a short Plan before more broad exploration.") - if ctx.tool_calls and not any(execution.outcome != "success" for execution in self.tool_runner.latest_executions) and self._verification_is_settled(): + if ctx.tool_calls and not any(execution.outcome != "success" for execution in self.tool_runner.latest_executions) and self._checks_are_settled(): if self._plan_is_complete(): self._warn_agent("Plan and Checks are complete; continuing tools without reopening Plan.") - elif ctx.plan_was_complete and ctx.verification_was_settled: + elif ctx.plan_was_complete and ctx.checks_settled: self._warn_agent("Continuing tools after completed Plan; update Plan if the new work changes scope.") if not ctx.tool_calls and not ctx.plan_was_complete and self._plan_is_complete() and not self.blackboard.goal_reached: - if not self._verification_is_settled(): + if not self._checks_are_settled(): self._warn_agent( "Plan is complete but Checks are not recorded.", "run checks when files changed or checks were requested.", @@ -6053,26 +6007,23 @@ def _gate_after_apply(self, ctx: ResponseContext, on_message: MessageCallback | and self.state_updater.changed and not ctx.goal_was_empty and not ctx.tool_calls - and not ctx.pending_verify_requested + and not ctx.pending_check_requested and not ctx.completion_message and ctx.user_rule_message is None ): self._warn_agent("state update-only turn; include frontier tool, verify, or goal when arguments are known.") return None - def _promote_required_verification(self, ctx: ResponseContext) -> None: - verification = self.blackboard.verification - if not self.blackboard.verification_required or not self.blackboard.goal_reached: + def _promote_required_checks(self, ctx: ResponseContext) -> None: + checks = self.blackboard.checks + if not self.blackboard.checks_required or not self.blackboard.goal_reached: return - if verification.status in {VerificationStatus.REQUIRED, VerificationStatus.DONE, VerificationStatus.BLOCKED}: + if checks.status in {CheckStatus.REQUIRED, CheckStatus.PASSED, CheckStatus.BLOCKED}: return - self.blackboard.task_code = TaskCode.VERIFYING - verification.status = VerificationStatus.REQUIRED - verification.kind = verification.kind or "change_syntax_check" - verification.method = verification.method or self.blackboard.goal or self.blackboard.user_input - if not verification.criteria: - verification.criteria = ["changed files pass the smallest relevant syntax or compile check"] - verification.context = verification.context or ctx.completion_message or self.blackboard.goal + self.blackboard.task_code = TaskCode.CHECKING + checks.status = CheckStatus.REQUIRED + checks.method = checks.method or self.blackboard.goal or self.blackboard.user_input + checks.context = checks.context or ctx.completion_message or self.blackboard.goal def _run_tool_actions( self, @@ -6107,7 +6058,7 @@ def _handle_observe_response( *, on_message: MessageCallback | None, ) -> AgentRunResult: - if ctx.pending_verify_requested: + if ctx.pending_check_requested: self._remember_observe_error(self._warning('ignored verify status="pending".', "observe must keep or forget latest results first.")) repeated_tool_retry_error = self._repeated_tool_retry_error(ctx.tool_calls) if repeated_tool_retry_error: @@ -6147,7 +6098,7 @@ def _handle_observe_response( self.observe_feedback_errors = [] self._warn_weak_observe_memory(ctx.actions) self._emit_tool_context_update(kept_keys, forgotten_keys, on_message) - self._promote_required_verification(ctx) + self._promote_required_checks(ctx) return AgentRunResult() def _warn_weak_observe_memory(self, actions: list[Json]) -> None: @@ -6231,12 +6182,12 @@ def _finish_or_continue(self, ctx: ResponseContext, on_message: MessageCallback return AgentRunResult() def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | None) -> AgentRunResult | None: - if self.blackboard.verification.status == VerificationStatus.REQUIRED: - if self.blackboard.verification_required: + if self.blackboard.checks.status == CheckStatus.REQUIRED: + if self.blackboard.checks_required: self._warn_agent("edited files need Checks before completion.", self.RULE_VERIFY_DIRECTLY) else: self._warn_agent("Checks are required before completion.", self.RULE_VERIFY_DIRECTLY) - if self.blackboard.verification.status == VerificationStatus.FAILED and self.blackboard.goal_reached: + if self.blackboard.checks.status == CheckStatus.FAILED and self.blackboard.goal_reached: self._warn_agent("Checks failed; fix the reported issue first.") completion_plan_error = self._completion_plan_error(ctx) if completion_plan_error: @@ -6246,7 +6197,7 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N "Retrying: finish the plan before completing.", "Completion_Gate: " + completion_plan_error + ".", ) - blocked_completion_error = self._blocked_verification_completion_error() + blocked_completion_error = self._blocked_checks_completion_error() if blocked_completion_error: self._warn_agent("blocked Checks completion invalid: " + blocked_completion_error + ".", self.RULE_BLOCKED_BY_USER) investigate_completion_error = self._investigate_completion_error() @@ -6287,9 +6238,9 @@ def run( self.task_alignment_required = old_task_context and self._task_text_key(user_input) != self._task_text_key(old_goal) self.blackboard.task_code = TaskCode.NEW self.blackboard.goal_reached = False - self.blackboard.verification_required = False + self.blackboard.checks_required = False self.observe_feedback_errors = [] - self.blackboard.verification.reset() + self.blackboard.checks.reset() self.compactor.maybe_compact() self.session.append_conversation(UserMessage(content=user_input)) @@ -6355,7 +6306,7 @@ def handle_response( DebugTrace.handle_event(self, "handle-applied", ctx, response, extra={"forgotten": forgotten_keys}) self._emit_state_and_text(ctx, on_message) self._emit_tool_context_update([], forgotten_keys, on_message) - if ctx.has_user_rule_action and not ctx.tool_calls and not ctx.pending_verify_requested: + if ctx.has_user_rule_action and not ctx.tool_calls and not ctx.pending_check_requested: message = ctx.user_rule_message or "Rule saved." self.session.append_conversation(AssistantMessage(content=message)) if on_message is not None: @@ -6369,7 +6320,7 @@ def handle_response( DebugTrace.handle_event(self, "handle-gated-after-apply", ctx, response, result=gate_result) return gate_result - self._promote_required_verification(ctx) + self._promote_required_checks(ctx) if self._run_tool_actions( ctx, confirm=confirm, @@ -6703,7 +6654,7 @@ def _status(self, args: str) -> str: if session.state.model_usage else " (empty)" ) - verification_status = blackboard.verification.status + checks_status = blackboard.checks.status code_index_status, code_index_message = _code_index_status(session, check=True) if session.state.code_index_error: code_index_status = "error" @@ -6739,7 +6690,7 @@ def _status(self, args: str) -> str: "models:", model_usage, "goal: " + (blackboard.goal or "(empty)"), - "checks: " + verification_status, + "checks: " + checks_status, ] ) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index c613757..40648de 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -3,7 +3,7 @@ from dataclasses import replace import nanocode -from nanocode import Agent, LLMError, ParsedToolCall, Session, VerificationStatus +from nanocode import Agent, LLMError, ParsedToolCall, Session, CheckStatus def _verify_passed_action(): @@ -2488,55 +2488,44 @@ def test_agent_state_report_does_not_repeat_goal_for_restarted_task_when_text_ma assert " Plan\n" in agent.state_updater.latest_report -def test_agent_resets_verification_when_goal_changes(tmp_path): +def test_agent_resets_checks_when_goal_changes(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) agent.blackboard.goal = "old goal" - agent.blackboard.verification.goal = "old goal" - agent.blackboard.verification.status = VerificationStatus.DONE - agent.blackboard.verification.kind = "test" - agent.blackboard.verification.method = "old check" - agent.blackboard.verification.criteria = ["old criterion"] - agent.blackboard.verification.context = "old context" + agent.blackboard.checks.status = CheckStatus.PASSED + agent.blackboard.checks.method = "old check" + agent.blackboard.checks.context = "old context" agent.apply_response({"actions": [{"type": "goal", "text": "new goal", "complete": False}]}) assert agent.blackboard.goal_reached is False - assert agent.blackboard.verification.goal == "" - assert agent.blackboard.verification.status == VerificationStatus.IDLE - assert agent.blackboard.verification.kind == "" - assert agent.blackboard.verification.method == "" - assert agent.blackboard.verification.criteria == [] - assert agent.blackboard.verification.context == "" + assert agent.blackboard.checks.status == CheckStatus.IDLE + assert agent.blackboard.checks.method == "" + assert agent.blackboard.checks.context == "" - agent.apply_response( - {"actions": [{"type": "verify", "kind": "test", "method": "run tests", "criteria": ["tests pass"], "status": "passed", "context": "tests pass"}]} - ) + agent.apply_response({"actions": [{"type": "verify", "method": "run tests", "status": "passed", "context": "tests pass"}]}) - assert agent.blackboard.verification.goal == "new goal" - assert agent.blackboard.verification.status == VerificationStatus.DONE - assert agent.blackboard.verification.kind == "test" - assert agent.blackboard.verification.method == "run tests" - assert agent.blackboard.verification.criteria == ["tests pass"] - assert agent.blackboard.verification.context == "tests pass" + assert agent.blackboard.checks.status == CheckStatus.PASSED + assert agent.blackboard.checks.method == "run tests" + assert agent.blackboard.checks.context == "tests pass" agent.apply_response({"actions": [{"type": "goal", "text": "new goal", "complete": True}]}) assert agent.blackboard.goal_reached is True -def test_agent_task_code_returns_to_working_after_verification_result(tmp_path): +def test_agent_task_code_returns_to_working_after_checks_result(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) - agent.blackboard.task_code = nanocode.TaskCode.VERIFYING + agent.blackboard.task_code = nanocode.TaskCode.CHECKING agent.apply_response({"actions": [{"type": "verify", "status": "passed", "context": "checked"}]}) assert agent.blackboard.task_code == nanocode.TaskCode.WORKING - assert agent.blackboard.verification.status == VerificationStatus.DONE + assert agent.blackboard.checks.status == CheckStatus.PASSED -def test_agent_accepts_combined_verification_kind_and_ignores_pending(tmp_path): +def test_agent_accepts_checks_result_and_ignores_pending(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) agent.apply_response( @@ -2544,27 +2533,23 @@ def test_agent_accepts_combined_verification_kind_and_ignores_pending(tmp_path): "actions": [ { "type": "verify", - "kind": "syntax_check+test", "method": "check edit", - "criteria": ["syntax passes", "tests pass"], "status": "passed", } ] } ) - assert agent.blackboard.verification.kind == "syntax_check+test" - assert agent.blackboard.verification.status == VerificationStatus.DONE + assert agent.blackboard.checks.status == CheckStatus.PASSED + assert agent.blackboard.checks.method == "check edit" - agent.blackboard.verification.reset() + agent.blackboard.checks.reset() result = agent.handle_response( { "actions": [ { "type": "verify", - "kind": "syntax_check+test", "method": "check edit", - "criteria": ["syntax passes", "tests pass"], "status": "pending", } ] @@ -2572,8 +2557,7 @@ def test_agent_accepts_combined_verification_kind_and_ignores_pending(tmp_path): ) assert result.done is False - assert agent.blackboard.verification.status == VerificationStatus.IDLE - assert agent.blackboard.verification.kind == "" + assert agent.blackboard.checks.status == CheckStatus.IDLE assert any('ignored verify status="pending"' in error for error in agent.agent_feedback_errors) @@ -2771,13 +2755,13 @@ def test_agent_blocks_repeated_identical_failed_tool_call(tmp_path): assert any("repeated failed tool call" in error for error in agent.agent_feedback_errors) -def test_agent_execute_bash_does_not_require_verification(tmp_path): +def test_agent_execute_bash_does_not_require_checks(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) agent.execute_tool_calls([{"name": "Bash", "intention": "run command", "args": ["true"]}], confirm=lambda call, tool: True) - assert agent.blackboard.verification_required is False + assert agent.blackboard.checks_required is False def test_agent_marks_nonzero_bash_exit_as_failed_tool_call(tmp_path): @@ -2834,8 +2818,8 @@ def test_agent_execute_tool_calls_shows_auto_approval_in_yolo_mode(tmp_path): assert "+new" in auto_approvals[0][1] assert latest.startswith("- ok") assert path.read_text(encoding="utf-8") == "new\n" - assert agent.blackboard.verification_required is True - assert agent.blackboard.task_code == nanocode.TaskCode.VERIFYING + assert agent.blackboard.checks_required is True + assert agent.blackboard.task_code == nanocode.TaskCode.CHECKING assert agent.recent_edits == ["- sample.txt: edit sample"] @@ -2893,9 +2877,9 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert agent.blackboard.user_input == "read sample" assert agent.blackboard.goal == "read sample" assert agent.blackboard.plan == [nanocode.PlanItem(text="test plan", status=nanocode.PlanStatus.DONE, context="seeded")] - assert agent.blackboard.verification.status == VerificationStatus.DONE + assert agent.blackboard.checks.status == CheckStatus.PASSED assert agent.blackboard.goal_reached is False - assert agent.blackboard.verification_required is False + assert agent.blackboard.checks_required is False def test_agent_run_ingests_queued_user_input_before_next_model_call(tmp_path): @@ -2986,7 +2970,7 @@ def test_agent_normalizes_lowercase_repo_tool_names(tmp_path): assert not any("Protocol_Gate" in message for message in messages) -def test_agent_run_allows_readonly_answer_without_verification(tmp_path): +def test_agent_run_allows_readonly_answer_without_checks(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") class FakeModelClient: @@ -3012,11 +2996,11 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): response = agent.run("answer sample", on_message=messages.append) assert response["actions"][-1]["message_for_complete"] == "sample contains alpha" - assert "Retrying: verification must pass before completion." not in messages + assert "Retrying: checks must pass before completion." not in messages assert messages[-1] == "sample contains alpha" -def test_agent_run_executes_edit_tool_and_requires_verification(tmp_path): +def test_agent_run_executes_edit_tool_and_requires_checks(tmp_path): (tmp_path / "sample.txt").write_text("old\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) anchor = _read_anchors(session, "sample.txt")[0] @@ -3059,12 +3043,12 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert messages[-1] == "done" -def test_agent_warns_but_allows_completion_when_verification_required(tmp_path): +def test_agent_warns_but_allows_completion_when_checks_required(tmp_path): agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "change sample") agent.blackboard.goal_reached = True - agent.blackboard.verification_required = True - agent.blackboard.verification.status = VerificationStatus.REQUIRED + agent.blackboard.checks_required = True + agent.blackboard.checks.status = CheckStatus.REQUIRED ctx = agent._build_response_context({"actions": [{"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}]}) messages = [] @@ -3077,10 +3061,10 @@ def test_agent_warns_but_allows_completion_when_verification_required(tmp_path): ] -def test_agent_plain_text_can_finish_without_active_task_when_verification_required(tmp_path): +def test_agent_plain_text_can_finish_without_active_task_when_checks_required(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) - agent.blackboard.verification_required = True - agent.blackboard.verification.status = VerificationStatus.REQUIRED + agent.blackboard.checks_required = True + agent.blackboard.checks.status = CheckStatus.REQUIRED agent.blackboard.task_code = nanocode.TaskCode.NEW ctx = agent._build_response_context({"actions": [], "_assistant_text": "Done."}) messages = [] @@ -3172,7 +3156,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert agent.blackboard.goal == "read samples" assert agent.blackboard.plan == [nanocode.PlanItem(text="try answer", status=nanocode.PlanStatus.DONE, context="seeded")] assert agent.blackboard.known == ["keep this fact"] - assert agent.blackboard.verification.status == VerificationStatus.IDLE + assert agent.blackboard.checks.status == CheckStatus.IDLE assert agent.blackboard.goal_reached is False @@ -3556,7 +3540,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert "Continuing: assistant must set current task's goal." not in messages -def test_agent_run_retries_when_verification_done_without_goal_complete(tmp_path): +def test_agent_run_retries_when_checks_done_without_goal_complete(tmp_path): class FakeModelClient: def __init__(self): self.user_prompts = [] @@ -3585,11 +3569,11 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert response["actions"][-1]["message_for_complete"] == "done" assert len(agent.model_client.user_prompts) == 3 - assert "Retrying: verification is done but goal is not complete." not in messages - assert agent.blackboard.verification.status == VerificationStatus.DONE + assert "Retrying: checks is done but goal is not complete." not in messages + assert agent.blackboard.checks.status == CheckStatus.PASSED -def test_agent_run_retries_when_plan_complete_without_verification(tmp_path): +def test_agent_run_retries_when_plan_complete_without_checks(tmp_path): class FakeModelClient: def __init__(self): self.user_prompts = [] @@ -3606,9 +3590,7 @@ def __init__(self): "actions": [ { "type": "verify", - "kind": "test", "method": "pytest", - "criteria": ["tests pass"], "status": "passed", "context": "tests passed", } @@ -3632,15 +3614,15 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert response["actions"][-1]["message_for_complete"] == "done" assert len(agent.model_client.user_prompts) == 3 assert any("Plan is complete but Checks are not recorded" in error for error in agent.agent_feedback_errors) - assert agent.blackboard.verification.status == VerificationStatus.DONE + assert agent.blackboard.checks.status == CheckStatus.PASSED -def test_agent_allows_tool_after_completed_plan_and_verification(tmp_path): +def test_agent_allows_tool_after_completed_plan_and_checks(tmp_path): (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "inspect") - agent.blackboard.verification.status = VerificationStatus.DONE - agent.blackboard.verification.context = "syntax check passed" + agent.blackboard.checks.status = CheckStatus.PASSED + agent.blackboard.checks.context = "syntax check passed" messages = [] result = agent.handle_response( @@ -3663,8 +3645,8 @@ def test_agent_allows_tool_after_reopening_completed_plan_with_context(tmp_path) (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(Session(cwd=str(tmp_path))) _seed_plan(agent, "inspect") - agent.blackboard.verification.status = VerificationStatus.DONE - agent.blackboard.verification.context = "syntax check passed" + agent.blackboard.checks.status = CheckStatus.PASSED + agent.blackboard.checks.context = "syntax check passed" result = agent.handle_response( { @@ -3701,8 +3683,8 @@ def test_agent_allows_tool_after_reopening_completed_plan_without_context(tmp_pa (tmp_path / "sample.txt").write_text("alpha\n", encoding="utf-8") agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "inspect") - agent.blackboard.verification.status = VerificationStatus.DONE - agent.blackboard.verification.context = "syntax check passed" + agent.blackboard.checks.status = CheckStatus.PASSED + agent.blackboard.checks.context = "syntax check passed" messages = [] result = agent.handle_response( @@ -3767,7 +3749,7 @@ def test_agent_allows_verify_blocked_completion_with_user_blocker(tmp_path): ) assert result.done is True - assert agent.blackboard.verification.blocker == nanocode.VerificationBlocker.USER + assert agent.blackboard.checks.blocker == nanocode.CheckBlocker.USER assert messages[-1] == "done" @@ -4109,7 +4091,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): agent.run("next task") assert agent.agent_feedback_errors == [] - assert agent.blackboard.verification.status == VerificationStatus.IDLE + assert agent.blackboard.checks.status == CheckStatus.IDLE def test_agent_allows_progress_message_before_goal_complete(tmp_path): @@ -4121,9 +4103,7 @@ def __init__(self): "actions": [ { "type": "verify", - "kind": "light", "method": "check", - "criteria": ["progress can be emitted before completion"], "status": "passed", "blocker": None, "context": "progress context", @@ -4205,7 +4185,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): agent.blackboard.goal = "answer" agent.blackboard.plan = [nanocode.PlanItem(text="try answer")] agent.blackboard.known = ["keep this fact"] - agent.blackboard.verification.status = VerificationStatus.REQUIRED + agent.blackboard.checks.status = CheckStatus.REQUIRED agent.tool_context.latest = ["old tool call"] agent.model_client = FakeModelClient() @@ -4222,7 +4202,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert agent.blackboard.goal == "answer" assert agent.blackboard.plan == [nanocode.PlanItem(text="try answer")] assert agent.blackboard.known == ["keep this fact"] - assert agent.blackboard.verification.status == VerificationStatus.IDLE + assert agent.blackboard.checks.status == CheckStatus.IDLE assert agent.blackboard.goal_reached is False class ChatModelClient: diff --git a/tests/test_nanocode_create_file_tool.py b/tests/test_nanocode_create_file_tool.py index 46ebdbb..003340f 100644 --- a/tests/test_nanocode_create_file_tool.py +++ b/tests/test_nanocode_create_file_tool.py @@ -71,4 +71,4 @@ def test_main_agent_can_execute_create_file_tool(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\n" assert "" in latest - assert agent.blackboard.verification_required is True + assert agent.blackboard.checks_required is True diff --git a/tests/test_nanocode_edit_file_tool.py b/tests/test_nanocode_edit_file_tool.py index 7f78320..92507c1 100644 --- a/tests/test_nanocode_edit_file_tool.py +++ b/tests/test_nanocode_edit_file_tool.py @@ -203,4 +203,4 @@ def test_agent_executes_edit_file_with_structured_args(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\nBETA\n" assert "" in latest - assert agent.blackboard.verification_required is True + assert agent.blackboard.checks_required is True From df4799c294b636e3a74b36d3b6f59fb525dc20de Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 00:58:31 -0700 Subject: [PATCH 119/144] Remove at-file path completion --- README.md | 2 +- nanocode.py | 39 +++---------------------------------- tests/test_nanocode_loop.py | 23 ++-------------------- 3 files changed, 6 insertions(+), 58 deletions(-) diff --git a/README.md b/README.md index ebe46c3..b307d88 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ A lightweight terminal-based AI coding assistant. -nanocode is used to help building itself, including features such as `@file` path completion. +nanocode is used to help building itself. Pre-1.0 note: nanocode is still evolving quickly. Functionality, commands, configuration, and behavior may change incompatibly before a 1.0 release. diff --git a/nanocode.py b/nanocode.py index 71a245a..f4073d5 100644 --- a/nanocode.py +++ b/nanocode.py @@ -6481,8 +6481,6 @@ def _help(self, args: str) -> str: current_category = spec.category lines.append(current_category + ":") lines.append(" " + spec.usage + " - " + spec.description) - lines.append("") - lines.append("Tip: use @path to autocomplete file paths in prompts.") return "\n".join(lines) def _format_source_help_question(self, question: str) -> str: @@ -7661,12 +7659,9 @@ def _make_prompt_session(self): os.makedirs(os.path.dirname(self.history_path), exist_ok=True) return PromptSession( history=FileHistory(self.history_path), - completer=ReferenceFileCompleter( - self.agent.session.cwd, - CommandCompleter( - lambda: self.agent.session.config.providers, - lambda: self.agent.session.config.provider.available_models, - ), + completer=CommandCompleter( + lambda: self.agent.session.config.providers, + lambda: self.agent.session.config.provider.available_models, ), lexer=CommandLexer(), complete_while_typing=True, @@ -8217,34 +8212,6 @@ def get_line(lineno: int): return get_line -class ReferenceFileCompleter(Completer): - def __init__(self, cwd: str, command_completer: Completer): - self.cwd = cwd - self.command_completer = command_completer - - def get_completions(self, document, complete_event): - match = re.search(r"(?:^|\s)@([^\s]*)$", document.text_before_cursor) - if match is None: - yield from self.command_completer.get_completions(document, complete_event) - return - - partial = match.group(1) - dirname, prefix = os.path.split(partial) - base_dir = os.path.abspath(os.path.join(self.cwd, dirname)) - try: - names = sorted(os.listdir(base_dir)) - except OSError: - return - - for name in names: - if not name.startswith(prefix): - continue - full_path = os.path.join(base_dir, name) - suffix = "/" if os.path.isdir(full_path) else "" - candidate = os.path.join(dirname, name) + suffix if dirname else name + suffix - yield Completion(candidate, start_position=-len(partial), display="@" + candidate) - - ############################ # Entrypoint ############################ diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 718ea7c..1195995 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -1,9 +1,9 @@ -from prompt_toolkit.completion import CompleteEvent, WordCompleter +from prompt_toolkit.completion import CompleteEvent from prompt_toolkit.document import Document import time import nanocode -from nanocode import AgentLoop, CommandLexer, Config, ConfigFile, Blackboard, ParsedToolCall, ReferenceFileCompleter, RuntimeSettings, Session, StatusBar, ToolCallDisplayFormatter +from nanocode import AgentLoop, CommandLexer, Config, ConfigFile, Blackboard, ParsedToolCall, RuntimeSettings, Session, StatusBar, ToolCallDisplayFormatter def make_session(tmp_path, *, model: str = "", compact_at: int = 50, yolo: bool = False) -> Session: @@ -426,25 +426,6 @@ def test_agent_loop_command_completer_completes_provider_names(): assert {c.text for c in all_completions} == {"qwen", "openai"} -def test_reference_file_completer_completes_at_paths_and_keeps_command_fallback(tmp_path): - (tmp_path / "README.md").write_text("hello", encoding="utf-8") - (tmp_path / "src").mkdir() - (tmp_path / "src" / "main.py").write_text("print('hello')", encoding="utf-8") - - completer = ReferenceFileCompleter(str(tmp_path), WordCompleter(["/help"], WORD=True)) - event = CompleteEvent(completion_requested=True) - - file_completions = list(completer.get_completions(Document("see @READ"), event)) - dir_completions = list(completer.get_completions(Document("see @sr"), event)) - nested_completions = list(completer.get_completions(Document("see @src/ma"), event)) - command_completions = list(completer.get_completions(Document("/he"), event)) - - assert "README.md" in [completion.text for completion in file_completions] - assert "src/" in [completion.text for completion in dir_completions] - assert "src/main.py" in [completion.text for completion in nested_completions] - assert "/help" in [completion.text for completion in command_completions] - - def test_agent_loop_confirmation_accepts_refusal_reason(tmp_path): class FakeAgent: def __init__(self): From eacc56b2e676b7b796d11e7c6440ebad744e6866 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 01:29:30 -0700 Subject: [PATCH 120/144] Refactor agent state naming and trim formatting noise --- nanocode.py | 793 ++++++++++++----------------------- tests/test_nanocode_agent.py | 159 ++----- 2 files changed, 296 insertions(+), 656 deletions(-) diff --git a/nanocode.py b/nanocode.py index f4073d5..a7a791e 100644 --- a/nanocode.py +++ b/nanocode.py @@ -103,31 +103,25 @@ class Role(StrEnum): @dataclass class ConversationItem: role: Role + content: str = "" time: datetime = field(default_factory=datetime.now) - def format_transcript(self, title: str, content: str, indent: str = "") -> str: - quoted = ["> " + line if line else ">" for line in content.splitlines()] + def format(self, indent: str = "") -> str: + quoted = ["> " + line if line else ">" for line in self.content.splitlines()] if not quoted: quoted = [">"] + title = self.role.value.title() return _format_lines([f"#### {title} {self.time.strftime('%Y-%m-%d %H:%M:%S')}", *quoted], indent) @dataclass class UserMessage(ConversationItem): role: Role = Role.USER - content: str = "" - - def format(self, indent: str = "") -> str: - return self.format_transcript("User", self.content, indent) @dataclass class AssistantMessage(ConversationItem): role: Role = Role.ASSISTANT - content: str = "" - - def format(self, indent: str = "") -> str: - return self.format_transcript("Assistant", self.content, indent) ############################ @@ -156,22 +150,14 @@ class TaskCode(StrEnum): DONE = "done" -class WorkMode(StrEnum): - NORMAL = "normal" - INVESTIGATE = "investigate" - - -ALL_WORK_MODES = frozenset(WorkMode) - - -class HypothesisStatus(StrEnum): +class LeadStatus(StrEnum): ACTIVE = "active" RULED_OUT = "ruled_out" DROPPED = "dropped" CONFIRMED = "confirmed" -ALL_HYPOTHESIS_STATUSES = frozenset(HypothesisStatus) +ALL_LEAD_STATUSES = frozenset(LeadStatus) @dataclass @@ -221,17 +207,24 @@ def format_item(item: "KnownItem | str") -> str: @classmethod def from_json(cls, value: JsonValue) -> "KnownItem | None": - fact = _memory_fact_from_json(value) - if fact is None: - return None item = _json_dict(value) + if item: + fact = (_json_str(item.get("text")) or _json_str(item.get("fact")) or "").strip() + else: + fact = (_json_str(value) or "").strip() + if not fact: + return None + if fact.startswith("<") and fact.endswith(">"): + inner = fact[1:-1].strip().lower() + if inner and any(word in inner for word in ("fact", "target", "arg", "path", "criterion", "result", "context", "message", "goal")): + return None return cls(text=fact, source=_source_from_json(item) if item else ()) @dataclass -class Hypothesis: +class Lead: text: str - status: HypothesisStatus = HypothesisStatus.ACTIVE + status: LeadStatus = LeadStatus.ACTIVE id: str = "" source: tuple[str, ...] = () context: str = "" @@ -247,7 +240,7 @@ def format(self, indent: str = "") -> str: return _format_lines(lines, indent) @classmethod - def from_json(cls, value: JsonValue) -> "Hypothesis | None": + def from_json(cls, value: JsonValue) -> "Lead | None": if isinstance(value, str): text = value.strip() return cls(text=text) if text else None @@ -255,12 +248,12 @@ def from_json(cls, value: JsonValue) -> "Hypothesis | None": text = _json_str(item.get("text")) or "" if not text: return None - status = _json_str(item.get("status")) or HypothesisStatus.ACTIVE - if status not in ALL_HYPOTHESIS_STATUSES: - status = HypothesisStatus.ACTIVE + status = _json_str(item.get("status")) or LeadStatus.ACTIVE + if status not in ALL_LEAD_STATUSES: + status = LeadStatus.ACTIVE return cls( text=text, - status=HypothesisStatus(status), + status=LeadStatus(status), id=_json_str(item.get("id")) or "", source=_source_from_json(item), context=_json_str(item.get("context")) or "", @@ -376,28 +369,23 @@ def _clean_rule(rule: str) -> str: class Blackboard: user_input: str = "" task_code: TaskCode = TaskCode.DONE - work_mode: WorkMode = WorkMode.NORMAL goal: str = "" goal_reached: bool = False plan: list[PlanItem] = field(default_factory=list) - hypotheses: list[Hypothesis] = field(default_factory=list) + leads: list[Lead] = field(default_factory=list) known: list[KnownItem] = field(default_factory=list) memory_checkpoint_tool_result_counter: int = 0 checks_required: bool = False checks: Checks = field(default_factory=Checks) - def source_result_keys(self) -> set[str]: - keys = {key for item in self.known for key in KnownItem.source_of(item) if key.startswith("tr.")} - keys.update(key for item in self.hypotheses for key in item.source if key.startswith("tr.")) - return keys - def referenced_result_keys(self) -> set[str]: - keys = set(self.source_result_keys()) + keys = {key for item in self.known for key in KnownItem.source_of(item) if key.startswith("tr.")} + keys.update(key for item in self.leads for key in item.source if key.startswith("tr.")) texts = [ self.goal, *[KnownItem.text_of(item) for item in self.known], - *[item.text for item in self.hypotheses], - *[item.context for item in self.hypotheses], + *[item.text for item in self.leads], + *[item.context for item in self.leads], *[item.text for item in self.plan], *[item.context for item in self.plan], self.checks.method, @@ -409,7 +397,7 @@ def referenced_result_keys(self) -> set[str]: return {key for key in keys if key.startswith("tr.")} def protected_result_sources(self) -> dict[str, str]: - return {key: "active lead" for item in self.hypotheses if item.status == HypothesisStatus.ACTIVE for key in item.source if key.startswith("tr.")} + return {key: "active lead" for item in self.leads if item.status == LeadStatus.ACTIVE for key in item.source if key.startswith("tr.")} @dataclass(frozen=True) @@ -843,7 +831,7 @@ class Session: config: Config = field(default_factory=Config) settings: RuntimeSettings = field(default_factory=RuntimeSettings) state: RuntimeState = field(default_factory=RuntimeState) - session_id: str = field(default_factory=lambda: Session._new_session_id()) + session_id: str = field(default_factory=lambda: datetime.now().strftime("%Y%m%d-%H%M%S") + "-" + str(os.getpid()) + "-" + uuid.uuid4().hex[:8]) code_index_repository: Any | None = None @classmethod @@ -885,10 +873,6 @@ def project_key(self) -> str: digest = hashlib.sha1(cwd.encode("utf-8")).hexdigest()[:10] return basename + "-" + digest - @staticmethod - def _new_session_id() -> str: - return datetime.now().strftime("%Y%m%d-%H%M%S") + "-" + str(os.getpid()) + "-" + uuid.uuid4().hex[:8] - def project_dir(self) -> str: return self.data_path("projects", self.project_key()) @@ -1119,12 +1103,7 @@ def _json_value_schema(depth: int = 3) -> Json: values: list[Json] = [{"type": "string"}, {"type": "number"}, {"type": "boolean"}, {"type": "null"}] if depth > 0: child = _json_value_schema(depth - 1) - values.extend( - [ - {"type": "array", "items": child}, - {"type": "object", "additionalProperties": child}, - ] - ) + values.extend([{"type": "array", "items": child}, {"type": "object", "additionalProperties": child}]) return {"anyOf": values} @@ -1611,18 +1590,6 @@ def _line_hash(content: str) -> str: ############################ -def _numbered_content(content: str, start: int) -> str: - return "".join(_numbered_line(start + index, line) for index, line in enumerate(content.splitlines(keepends=True))) - - -def _numbered_line(index: int, line: str) -> str: - return f"{index}:{_line_hash(line)}|{line}" - - -def _numbered_line_preview(index: int, line: str, max_chars: int = 300) -> str: - return f"{index}:{_line_hash(line)}|{line.removesuffix(chr(10))[:max_chars]}" - - def _parse_line_range_token(value: str) -> tuple[int, int]: match = re.fullmatch(r"\s*(\d+)\s*[-:,]\s*(\d+)\s*", value) if match is None: @@ -1754,13 +1721,10 @@ def _format_range_result( "Use Search to locate relevant text, Recall with a line range, or Read smaller targeted ranges; do not repeat the same large read." ) lines.extend( - [ - indent + "true", - indent + "" + str(total_lines) + "", - indent + "" + note + "", - ] + [indent + "true", indent + "" + str(total_lines) + "", indent + "" + note + ""] ) - lines.extend([indent + "", _numbered_content(content, start), indent + ""]) + numbered_content = "".join(f"{start + index}:{_line_hash(line)}|{line}" for index, line in enumerate(content.splitlines(keepends=True))) + lines.extend([indent + "", numbered_content, indent + ""]) return lines @@ -1861,13 +1825,7 @@ def call(self) -> str: entry_type = "file" else: entry_type = "other" - entries.append( - { - "name": entry.name, - "path": entry.path, - "type": entry_type, - } - ) + entries.append({"name": entry.name, "path": entry.path, "type": entry_type}) entries.sort(key=lambda item: (sort_order.get(str(item["type"]), 4), str(item["name"]))) lines = [""] for e in entries: @@ -1927,7 +1885,10 @@ class Match: @classmethod def make(cls, session: Session, args: list[str]) -> Self: - args = cls._join_pattern_args_with_explicit_path(args) + args = [str(arg) for arg in args] + path_index = next((index for index, value in enumerate(args[1:], start=1) if value.startswith("path=")), None) + if path_index is not None and path_index > 1: + args = ["|".join(args[:path_index]), *args[path_index:]] if len(args) < 1 or len(args) > 4: raise ToolCallArgError("requires 1 to 4 args: pattern[, path=path][, glob=pattern][, context=N]") if any(str(arg).startswith("ignore_case") or str(arg).startswith("case_sensitive") for arg in args[1:]): @@ -1953,7 +1914,10 @@ def make(cls, session: Session, args: list[str]) -> Self: continue if option.startswith("context=") or option.isdigit(): try: - context_lines = cls._parse_context_arg(option) + raw_context = option[len("context=") :] if option.startswith("context=") else option + context_lines = int(raw_context) + if context_lines < 0 or context_lines > cls.MAX_CONTEXT_LINES: + raise ValueError except ValueError: raise ToolCallArgError(f"context must be an integer between 0 and {cls.MAX_CONTEXT_LINES}") continue @@ -1991,22 +1955,6 @@ def make(cls, session: Session, args: list[str]) -> Self: gitignore_patterns=cls._load_gitignore_patterns(session.cwd), ) - @classmethod - def _join_pattern_args_with_explicit_path(cls, args: list[str]) -> list[str]: - values = [str(arg) for arg in args] - path_index = next((index for index, value in enumerate(values[1:], start=1) if value.startswith("path=")), None) - if path_index is None or path_index <= 1: - return values - return ["|".join(values[:path_index]), *values[path_index:]] - - @classmethod - def _parse_context_arg(cls, value: str) -> int: - raw_context = value[len("context=") :] if value.startswith("context=") else value - context = int(raw_context) - if context < 0 or context > cls.MAX_CONTEXT_LINES: - raise ValueError - return context - def requires_confirmation(self, session: Session) -> bool: return not session.is_path_in_cwd(self.target_path) @@ -2041,9 +1989,6 @@ def _load_gitignore_patterns(cwd: str) -> list[str]: pass return patterns - def _is_hidden_path(self, path: str) -> bool: - return any(part.startswith(".") for part in self._relpath(path).split(os.sep) if part and part != ".") - def _is_gitignored(self, path: str, is_dir: bool = False) -> bool: relpath = self._relpath(path).replace(os.sep, "/") name = os.path.basename(path) @@ -2069,7 +2014,8 @@ def _is_gitignored(self, path: str, is_dir: bool = False) -> bool: return False def _is_skipped_path(self, path: str, is_dir: bool = False) -> bool: - return self._is_hidden_path(path) or self._is_gitignored(path, is_dir) + hidden = any(part.startswith(".") for part in self._relpath(path).split(os.sep) if part and part != ".") + return hidden or self._is_gitignored(path, is_dir) def _iter_files(self) -> Iterator[str]: if os.path.isfile(self.target_path): @@ -2121,7 +2067,7 @@ def _format_result_lines(self, engine: str, matches: list[Match], *, truncated: if include_context: for index, line in match.context: marker = ">" if index == match.line_number - 1 else " " - lines.append(f" {marker} {_numbered_line_preview(index, line)}") + lines.append(f" {marker} {index}:{_line_hash(line)}|{line.removesuffix(chr(10))[:300]}") else: lines.append("No matches.") if truncated: @@ -2172,7 +2118,8 @@ def _call_rg(self, rg: str) -> str: proc = subprocess.run(self._rg_command(rg), text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=30) except subprocess.TimeoutExpired: raise ToolCallError("rg timed out") - if proc.returncode not in (0, 1) and self._should_retry_rg_with_pcre2(proc.stderr): + stderr = proc.stderr.lower() + if proc.returncode not in (0, 1) and "pcre2" in stderr and ("look-around" in stderr or "look-ahead" in stderr or "look-behind" in stderr): pcre2 = True try: proc = subprocess.run(self._rg_command(rg, pcre2=True), text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=30) @@ -2206,10 +2153,6 @@ def _call_rg(self, rg: str) -> str: return self._format_result(engine, matches, True) return self._format_result(engine, matches, False) - def _should_retry_rg_with_pcre2(self, stderr: str) -> bool: - text = stderr.lower() - return "pcre2" in text and ("look-around" in text or "look-ahead" in text or "look-behind" in text) - def _is_multiline(self) -> bool: return "\n" in self.pattern or "\r" in self.pattern @@ -2421,14 +2364,6 @@ def _code_index_update(session: Session, filepath: str) -> None: session.state.code_index_error = str(error) -def _format_code_index_result(tag: str, text: str) -> str: - lines = ["<" + tag + ">"] - if text.strip(): - lines.append(text.rstrip("\n")) - lines.append("") - return "\n".join(lines) - - @dataclass class InspectCodeTool(Tool): NAME: ClassVar[str] = "InspectCode" @@ -2482,7 +2417,12 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: target = str(args[1]).strip() if not target: raise ToolCallArgError("target cannot be empty") - options = cls._options(args) + if len(args) == 2: + options = {} + else: + options = _json_dict(args[2]) + if not options: + raise ToolCallArgError("options must be an object") limit = cls.DEFAULT_LIMIT if mode == "find": cls._validate_symbolish(target, "query") @@ -2520,15 +2460,6 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: session=session, ) - @staticmethod - def _options(args: list[JsonValue]) -> dict[str, JsonValue]: - if len(args) == 2: - return {} - options = _json_dict(args[2]) - if not options: - raise ToolCallArgError("options must be an object") - return options - @staticmethod def _validate_symbolish(value: str, label: str) -> None: if re.search(r"\s", value): @@ -2572,7 +2503,12 @@ def call(self) -> str: ) else: text = repo.outline_text(self.target, symbol=self.symbol or None) - return _format_code_index_result("InspectCodeToolResult", "mode: " + self.mode + "\n" + text) + lines = [""] + result = "mode: " + self.mode + "\n" + text + if result.strip(): + lines.append(result.rstrip("\n")) + lines.append("") + return "\n".join(lines) @dataclass @@ -2749,7 +2685,7 @@ def _edit_from_json(value: JsonValue) -> EditFileEdit: return EditFileEdit(op=op, start=start, end=end, content=content) def preview(self) -> str: - label = self._label() + label = f"EditFile({self.filepath}, {len(self.edits)} edits)" try: original, new_content, _ = self._preview() except (OSError, ToolCallError) as error: @@ -2814,17 +2750,23 @@ def _preview(self) -> tuple[str, str, list[tuple[int, int, list[str]]]]: else: slice_start = start if edit.op == "insert_before" else start + 1 slice_end = slice_start - replacement = [] if edit.op == "delete" else self._replacement_lines(edit.content, has_following_line=slice_end < len(lines)) + if edit.op == "delete": + replacement = [] + else: + replacement = edit.content.splitlines(keepends=True) + if edit.content and slice_end < len(lines) and not edit.content.endswith("\n"): + replacement[-1] += "\n" replacements.append((slice_start, slice_end, replacement)) - self._reject_overlapping_ranges(replacements) + previous: tuple[int, int] | None = None + for start, end, _ in sorted(replacements, key=lambda item: item[0]): + if previous is not None and (start < previous[1] or (start == previous[0] and end == previous[1])): + raise ToolCallError(f"edits overlap or share an insertion point: {previous[0]}:{previous[1]} and {start}:{end}") + previous = (start, end) new_lines = list(lines) for start, end, replacement in sorted(replacements, key=lambda item: item[0], reverse=True): new_lines[start:end] = replacement return original, "".join(new_lines), replacements - def _label(self) -> str: - return f"EditFile({self.filepath}, {len(self.edits)} edits)" - @staticmethod def _resolve_anchor(lines: list[str], anchor: str) -> int: anchor = anchor.split("|", 1)[0].strip() @@ -2840,21 +2782,6 @@ def _resolve_anchor(lines: list[str], anchor: str) -> int: raise ToolCallError(f"stale anchor {anchor}; current hash is {current}; Read the target range again") return index - @staticmethod - def _reject_overlapping_ranges(replacements: list[tuple[int, int, list[str]]]) -> None: - previous: tuple[int, int] | None = None - for start, end, _ in sorted(replacements, key=lambda item: item[0]): - if previous is not None and (start < previous[1] or (start == previous[0] and end == previous[1])): - raise ToolCallError(f"edits overlap or share an insertion point: {previous[0]}:{previous[1]} and {start}:{end}") - previous = (start, end) - - @staticmethod - def _replacement_lines(content: str, *, has_following_line: bool) -> list[str]: - lines = content.splitlines(keepends=True) - if content and has_following_line and not content.endswith("\n"): - lines[-1] += "\n" - return lines - @dataclass class BashTool(Tool): @@ -3198,13 +3125,13 @@ def _canonical_tool_name(name: str | None) -> str: [], ), } -TOOL_HYPOTHESIS_ITEMS_SCHEMA: Json = { +TOOL_LEAD_ITEMS_SCHEMA: Json = { "type": "array", "items": _tool_object_schema( { "id": TOOL_NULLABLE_STRING_SCHEMA, "text": TOOL_NULLABLE_STRING_SCHEMA, - "status": {"type": ["string", "null"], "enum": [*ALL_HYPOTHESIS_STATUSES]}, + "status": {"type": ["string", "null"], "enum": [*ALL_LEAD_STATUSES]}, "source": TOOL_STRING_LIST_SCHEMA, "context": TOOL_NULLABLE_STRING_SCHEMA, }, @@ -3224,7 +3151,7 @@ def _canonical_tool_name(name: str | None) -> str: ["text", "complete", "message_for_complete"], ), "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), - "lead": ("Update investigation leads.", {"items": TOOL_HYPOTHESIS_ITEMS_SCHEMA}, ["items"]), + "lead": ("Update investigation leads.", {"items": TOOL_LEAD_ITEMS_SCHEMA}, ["items"]), "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "user_rule": ( "Remember an explicit future behavior rule from the user.", @@ -3494,7 +3421,8 @@ def request( {"role": "user", "content": user_prompt}, ] stream = config.stream is not False - timeout, first_token_timeout = self._request_timeouts(config, activity=activity) + timeout = config.timeout if config.timeout is not None else 180 + first_token_timeout = config.first_token_timeout if config.first_token_timeout is not None else timeout api = config.resolved_api() params = ( self._responses_params( @@ -3511,7 +3439,7 @@ def request( ) DebugTrace.prompt(self.session, activity=activity, messages=messages) DebugTrace.model_request(self.session, activity=activity, api=api, model=model, stream=stream, params=params, tool_schemas=tool_schemas) - client = self._client(config, timeout=timeout) + client = OpenAI(api_key=config.key, base_url=config.base_url(), timeout=timeout, max_retries=0, default_headers={"User-Agent": HTTP_USER_AGENT}) request_elapsed = 0.0 try: with ModelRetryShortcut(self.session): @@ -3627,15 +3555,6 @@ def request( DebugTrace.model_response(self.session, activity=activity, api=api, stream=stream, raw=result, parsed=parsed) return parsed - def _client(self, config: ProviderConfig, *, timeout: int) -> OpenAI: - return OpenAI( - api_key=config.key, - base_url=config.base_url(), - timeout=timeout, - max_retries=0, - default_headers={"User-Agent": HTTP_USER_AGENT}, - ) - @staticmethod def _reasoning_effort(config: ProviderConfig) -> str: return config.reasoning if config.reasoning in REASONING_LEVELS else "medium" @@ -3719,10 +3638,7 @@ def _read_chat_tool_stream( output_chars = self._stream_output_chars(delta) if output_chars > 0: first_output_seen = self._mark_stream_output( - output_chars, - first_output_seen, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, + output_chars, first_output_seen, request_deadline=request_deadline, first_token_timeout=first_token_timeout ) if isinstance(content, str) and content: text_parts.append(content) @@ -3759,12 +3675,7 @@ def _consume_stream_action( action["_assistant_text"] = "".join(text_parts).strip() text_parts.clear() actions.append(action) - return self._call_stream_action( - on_stream_action, - action, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, - ) + return self._call_stream_action(on_stream_action, action, request_deadline=request_deadline, first_token_timeout=first_token_timeout) def _accumulate_chat_tool_calls(self, tool_calls: dict[int, Json], delta: Json) -> None: for raw in _json_list(delta.get("tool_calls")): @@ -3860,10 +3771,7 @@ def _read_responses_tool_stream( call = self._responses_function_call_for_event(function_calls, data) name = str(getattr(event, "name", "") or _json_str(data.get("name")) or _json_str(call.get("name")) or "") arguments = str(getattr(event, "arguments", "") or _json_str(data.get("arguments")) or _json_str(call.get("arguments")) or "{}") - action = self._action_from_function_call( - name, - arguments, - ) + action = self._action_from_function_call(name, arguments) stopped, request_deadline = self._consume_stream_action( actions, text_parts, @@ -3979,11 +3887,6 @@ def _responses_params( params["reasoning"] = {"effort": "high" if effort in ("max", "xhigh") else effort} return params - def _request_timeouts(self, config: ProviderConfig, *, activity: str) -> tuple[int, int | None]: - timeout = config.timeout if config.timeout is not None else 180 - first_token_timeout = config.first_token_timeout if config.first_token_timeout is not None else timeout - return timeout, first_token_timeout - def _mark_stream_output(self, chars: int, seen: bool, *, request_deadline: float, first_token_timeout: int | None) -> bool: if chars <= 0: return seen @@ -4084,10 +3987,7 @@ def _read_responses_stream( if not output: continue first_output_seen = self._mark_stream_output( - len(output[1]), - first_output_seen, - request_deadline=request_deadline, - first_token_timeout=first_token_timeout, + len(output[1]), first_output_seen, request_deadline=request_deadline, first_token_timeout=first_token_timeout ) if output[0] == "content": parts.append(output[1]) @@ -4314,7 +4214,10 @@ def execute( requires_checks = False try: call = item if isinstance(item, ParsedToolCall) else self.parse_tool_call(item) - tool = self._make_tool(call) + tool_class = TOOL_REGISTRY.get(call.name) + if tool_class is None: + raise ToolCallArgError("tool not found: " + call.name) + tool = tool_class.make(self.session, call.args) if isinstance(tool, BashTool): tool.live_output = self.live_output requires_checks = tool.EFFECT == ToolEffect.EDIT @@ -4350,7 +4253,11 @@ def execute( output = "ToolCallError: " + str(error) error_type = type(error) if call is None: - call = self._invalid_tool_call(item) + raw = _json_dict(item) + summary = "invalid tool action" + if _json_str(raw.get("type")) == "tool" and not _json_str(raw.get("name")): + summary += ": missing required field name" + call = ParsedToolCall(name="InvalidToolCall", intention=summary, args=[]) result_key = "" result_excerpted = False if call.name != ToolResultTool.NAME: @@ -4421,7 +4328,13 @@ def _store_tool_result(self, call: ParsedToolCall, outcome: str, output: str) -> original_chars=bounded.original_chars, excerpted=bounded.excerpted, ) - self._trim_tool_result_store() + keep = self.protected_result_keys() + for old_key in list(self.session.state.tool_result_store): + if len(self.session.state.tool_result_store) <= self.MAX_TOOL_RESULT_STORE_ITEMS: + break + if old_key in keep: + continue + self.session.state.tool_result_store.pop(old_key) return key def _write_tool_result_log(self, key: str, output: str) -> str: @@ -4440,15 +4353,6 @@ def _write_tool_result_log(self, key: str, output: str) -> str: continue return "" - def _trim_tool_result_store(self) -> None: - keep = self.protected_result_keys() - for old_key in list(self.session.state.tool_result_store): - if len(self.session.state.tool_result_store) <= self.MAX_TOOL_RESULT_STORE_ITEMS: - return - if old_key in keep: - continue - self.session.state.tool_result_store.pop(old_key) - def parse_tool_call(self, value: JsonValue) -> ParsedToolCall: item = _json_dict(value) name = _json_str(item.get("name")) @@ -4458,19 +4362,6 @@ def parse_tool_call(self, value: JsonValue) -> ParsedToolCall: intention = _json_str(item.get("intention")) or "" return ParsedToolCall(name=name, intention=intention, args=list(_json_list(item.get("args")))) - def _invalid_tool_call(self, value: JsonValue) -> ParsedToolCall: - item = _json_dict(value) - summary = "invalid tool action" - if _json_str(item.get("type")) == "tool" and not _json_str(item.get("name")): - summary += ": missing required field name" - return ParsedToolCall(name="InvalidToolCall", intention=summary, args=[]) - - def _make_tool(self, call: ParsedToolCall) -> Tool: - tool_class = TOOL_REGISTRY.get(call.name) - if tool_class is None: - raise ToolCallArgError("tool not found: " + call.name) - return tool_class.make(self.session, call.args) - ############################ # Agent State @@ -4502,37 +4393,44 @@ def apply(self, response: Json) -> None: actions = [action for action in (_json_dict(item) for item in _json_list(response.get("actions"))) if action] before_goal = self.blackboard.goal before_plan = [item.format() for item in self.blackboard.plan] - before_hypotheses = [item.format() for item in self.blackboard.hypotheses] + before_leads = [item.format() for item in self.blackboard.leads] before_known = [KnownItem.format_item(item) for item in self.blackboard.known] before_user_rules = self.session.state.user_rules.format() - before_extra_state = self._before_extra_state() + before_checks = self.blackboard.checks.format() goal_changed = self._apply_goal(actions) plan_replaced = self._apply_plan(actions) if goal_changed and not plan_replaced: self.blackboard.plan = [] - self._apply_known(actions) - self._apply_hypotheses(actions) - self._apply_user_rules(actions) - self._apply_extra_state(actions, goal_changed=goal_changed, plan_replaced=plan_replaced) + for raw in self._action_items(actions, "known"): + item = KnownItem.from_json(raw) + if item is not None: + self._add_known_item(item.text, item.source) + for raw in self._action_items(actions, "lead"): + item = Lead.from_json(raw) + if item is not None: + self._add_lead(item) + user_rules_changed = False + for action in self._actions_of_type(actions, "user_rule"): + rule = (_json_str(action.get("text")) or "").strip() + user_rules_changed = self.session.state.user_rules.add(rule) or user_rules_changed + if user_rules_changed: + self.session.save_user_rules() + if goal_changed: + self.blackboard.checks_required = False + self._reset_stale_checks(actions, goal_changed=goal_changed, plan_replaced=plan_replaced) + self._apply_checks(actions) self._apply_task_code(actions) - self.latest_report = self._format_state_report( - before_goal, - before_plan, - before_hypotheses, - before_known, - before_user_rules, - before_extra_state, - ) + self.latest_report = self._format_state_report(before_goal, before_plan, before_leads, before_known, before_user_rules, before_checks) self.changed = bool(self.latest_report) def _format_state_report( self, before_goal: str, before_plan: list[str], - before_hypotheses: list[str], + before_leads: list[str], before_known: list[str], before_user_rules: str, - before_extra_state: str, + before_checks: str, ) -> str: current = self.blackboard lines = [] @@ -4542,12 +4440,16 @@ def _format_state_report( self.latest_compact_plan_rows = [] if plan != before_plan: self.latest_compact_plan_rows = self._compact_changed_plan_rows(before_plan, plan) - self._append_state_section(lines, " Plan", self._format_plan_rows()) - hypotheses = [item.format() for item in current.hypotheses] - if hypotheses != before_hypotheses: - self._append_state_section( - lines, " Leads", self._format_rows(current.hypotheses, lambda index, item: f" {index}. {self._compact(item.format())}") - ) + + def render_plan_row(index: int, item: PlanItem) -> list[str]: + rows = [" " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text)] + rows += [" context: " + self._compact(item.context)] if item.context else [] + return rows + + self._append_state_section(lines, " Plan", self._format_rows(current.plan, render_plan_row)) + leads = [item.format() for item in current.leads] + if leads != before_leads: + self._append_state_section(lines, " Leads", self._format_rows(current.leads, lambda index, item: f" {index}. {self._compact(item.format())}")) known = [KnownItem.format_item(item) for item in current.known] if known != before_known: self._append_state_section( @@ -4556,18 +4458,11 @@ def _format_state_report( user_rules = self.session.state.user_rules.format() if user_rules != before_user_rules: self._append_state_section(lines, " User_Rules updated") - self._append_extra_state_report(lines, before_extra_state) + checks = self.blackboard.checks.format() + if checks != before_checks: + self._append_state_section(lines, " Checks " + self._format_checks()) return "\n".join(lines) - def _format_plan_rows(self) -> list[str]: - def render(index: int, item: PlanItem) -> list[str]: - rows = [" " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text)] - if item.context: - rows.append(" context: " + self._compact(item.context)) - return rows - - return self._format_rows(self.blackboard.plan, render) - def _format_rows(self, items: list[Any], render: Callable[[int, Any], str | list[str]]) -> list[str]: if not items: return [" (empty)"] @@ -4586,8 +4481,8 @@ def compact_report(self) -> str: ("Plan", " Plan" in self.latest_report and self.blackboard.plan, self.latest_compact_plan_rows or self._compact_plan_rows()), ( "Leads", - " Leads" in self.latest_report and self.blackboard.hypotheses, - self._compact_rows(self.blackboard.hypotheses, lambda item: self._compact(item.format(), 100)), + " Leads" in self.latest_report and self.blackboard.leads, + self._compact_rows(self.blackboard.leads, lambda item: self._compact(item.format(), 100)), ), ( "Facts", @@ -4624,12 +4519,11 @@ def _compact_changed_plan_rows(self, before_plan: list[str], plan: list[str]) -> return self._compact_plan_rows() offset = max(0, len(indexes) - self.COMPACT_DISPLAY_LIMIT) rows = [" ... " + str(offset) + " changed older"] if offset else [] - rows.extend(self._compact_plan_row(index + 1, self.blackboard.plan[index]) for index in indexes[offset:]) + for index in indexes[offset:]: + item = self.blackboard.plan[index] + rows.append(" " + str(index + 1) + ". [" + str(item.status) + "] " + self._compact(item.text, 90)) return rows - def _compact_plan_row(self, index: int, item: PlanItem) -> str: - return " " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text, 90) - def _compact_rows(self, items: list[Any], render: Callable[[Any], str]) -> list[str]: offset = max(0, len(items) - self.COMPACT_DISPLAY_LIMIT) rows = [" ... " + str(offset) + " older"] if offset else [] @@ -4651,9 +4545,6 @@ def _apply_goal(self, actions: list[Json]) -> bool: self.blackboard.goal = update if isinstance(complete, bool): self.blackboard.goal_reached = complete - if "work_mode" in action: - mode = _json_str(action.get("work_mode")) or WorkMode.NORMAL - self.blackboard.work_mode = WorkMode(mode) if mode in ALL_WORK_MODES else WorkMode.NORMAL return changed def _apply_plan(self, actions: list[Json]) -> bool: @@ -4732,26 +4623,14 @@ def _normalize_doing_items(plan: list[PlanItem]) -> None: else: seen = True - def _apply_known(self, actions: list[Json]) -> None: - for raw in self._action_items(actions, "known"): - item = KnownItem.from_json(raw) - if item is not None: - self._add_known_item(item.text, item.source) - - def _apply_hypotheses(self, actions: list[Json]) -> None: - for raw in self._action_items(actions, "lead"): - item = Hypothesis.from_json(raw) - if item is not None: - self._add_hypothesis(item) - - def _add_hypothesis(self, item: Hypothesis) -> None: - for index, existing in enumerate(self.blackboard.hypotheses): + def _add_lead(self, item: Lead) -> None: + for index, existing in enumerate(self.blackboard.leads): same_id = item.id and item.id == existing.id - same_text = self._hypothesis_key(item.text) == self._hypothesis_key(existing.text) + same_text = self._lead_key(item.text) == self._lead_key(existing.text) if not same_id and not same_text: continue source = tuple(dict.fromkeys((*existing.source, *item.source))) - self.blackboard.hypotheses[index] = Hypothesis( + self.blackboard.leads[index] = Lead( text=item.text or existing.text, status=item.status, id=item.id or existing.id, @@ -4759,52 +4638,31 @@ def _add_hypothesis(self, item: Hypothesis) -> None: context=item.context or existing.context, ) return - self.blackboard.hypotheses.append(item) + self.blackboard.leads.append(item) - def _hypothesis_key(self, text: str) -> str: + def _lead_key(self, text: str) -> str: return re.sub(r"\s+", " ", text).strip(" \t\r\n。.;；").lower() - def _apply_user_rules(self, actions: list[Json]) -> None: - changed = False - for action in self._actions_of_type(actions, "user_rule"): - rule = (_json_str(action.get("text")) or "").strip() - changed = self.session.state.user_rules.add(rule) or changed - if changed: - self.session.save_user_rules() - def _add_known_item(self, fact: str, source: tuple[str, ...] = ()) -> None: fact = _shorten(" ".join(fact.split())) + fact_key = self._known_fact_key(fact) for index, existing in enumerate(self.blackboard.known): - if self._known_facts_overlap(existing, fact): - text = KnownItem.text_of(existing) - merged_source = tuple(dict.fromkeys((*KnownItem.source_of(existing), *source))) - if len(fact) > len(text): - self.blackboard.known[index] = KnownItem(text=fact, source=merged_source) - elif merged_source != KnownItem.source_of(existing): - self.blackboard.known[index] = KnownItem(text=text, source=merged_source) - return + existing_key = self._known_fact_key(existing) + if existing_key != fact_key and not (min(len(existing_key), len(fact_key)) >= 32 and (existing_key in fact_key or fact_key in existing_key)): + continue + text = KnownItem.text_of(existing) + merged_source = tuple(dict.fromkeys((*KnownItem.source_of(existing), *source))) + if len(fact) > len(text): + self.blackboard.known[index] = KnownItem(text=fact, source=merged_source) + elif merged_source != KnownItem.source_of(existing): + self.blackboard.known[index] = KnownItem(text=text, source=merged_source) + return self.blackboard.known.append(KnownItem(text=fact, source=source)) del self.blackboard.known[: max(0, len(self.blackboard.known) - self.MAX_KNOWN_ITEMS)] - def _known_facts_overlap(self, left: KnownItem | str, right: KnownItem | str) -> bool: - left_key = self._known_fact_key(left) - right_key = self._known_fact_key(right) - if left_key == right_key: - return True - return min(len(left_key), len(right_key)) >= 32 and (left_key in right_key or right_key in left_key) - def _known_fact_key(self, fact: KnownItem | str) -> str: return re.sub(r"\s+", " ", KnownItem.text_of(fact)).strip(" \t\r\n。.;；").lower() - def _before_extra_state(self) -> str: - return self.blackboard.checks.format() - - def _apply_extra_state(self, actions: list[Json], *, goal_changed: bool, plan_replaced: bool) -> None: - if goal_changed: - self.blackboard.checks_required = False - self._reset_stale_checks(actions, goal_changed=goal_changed, plan_replaced=plan_replaced) - self._apply_checks(actions) - def _apply_task_code(self, actions: list[Json]) -> None: action_types = {_json_str(action.get("type")) for action in actions} if self.blackboard.checks_required or self.blackboard.checks.status == CheckStatus.REQUIRED: @@ -4813,7 +4671,7 @@ def _apply_task_code(self, actions: list[Json]) -> None: if "verify" in action_types: self.blackboard.task_code = TaskCode.WORKING return - tracked_state = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) + tracked_state = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.leads) if ( "goal" in action_types or "plan" in action_types or "lead" in action_types or (tracked_state and "tool" in action_types) ) and not self.blackboard.goal_reached: @@ -4823,13 +4681,6 @@ def _append_state_section(self, lines: list[str], title: str, rows: list[str] | lines.append(title) lines.extend(rows or []) - def _append_extra_state_report(self, lines: list[str], before_extra_state: str) -> None: - before_checks = before_extra_state - checks = self.blackboard.checks.format() - if checks == before_checks: - return - self._append_state_section(lines, " Checks " + self._format_checks()) - @staticmethod def _actions_of_type(actions: list[Json], action_type: str) -> Iterator[Json]: return (action for action in actions if _json_str(action.get("type")) == action_type) @@ -5059,11 +4910,15 @@ def add(name: str, value: str) -> None: add("Goal", current.goal) if current.known: add("Facts", "\n".join(KnownItem.format_item(item) for item in current.known)) - if current.hypotheses: - add("Leads", "\n".join(item.format() for item in current.hypotheses)) + if current.leads: + add("Leads", "\n".join(item.format() for item in current.leads)) if current.plan: add("Plan", "\n".join(item.format() for item in current.plan)) - add("Current Focus", self._format_current_focus()) + focus = next((item for item in current.plan if item.status == PlanStatus.DOING), None) or next( + (item for item in current.plan if item.status == PlanStatus.TODO), + None, + ) + add("Current Focus", focus.format() if focus else "(empty)") if current.checks.has_context() or current.checks_required: add("Checks", current.checks.format() if current.checks.has_context() else "status: required") return "\n\n".join(sections) if sections else "(empty)" @@ -5083,14 +4938,6 @@ def _format_environment(self) -> str: ) return "\n".join(lines) - def _format_current_focus(self) -> str: - plan = self.blackboard.plan - item = next((item for item in plan if item.status == PlanStatus.DOING), None) or next( - (item for item in plan if item.status == PlanStatus.TODO), - None, - ) - return item.format() if item else "(empty)" - def build_observe_prompt(self) -> str: current = self.blackboard unreduced = "\n\n".join(self._unreferenced_unreduced_blocks()) @@ -5098,7 +4945,7 @@ def build_observe_prompt(self) -> str: user_rules=self.session.state.user_rules.format(), goal=current.goal or "(empty)", plan="\n".join(item.format() for item in current.plan) if current.plan else "(empty)", - leads="\n".join(item.format() for item in current.hypotheses) if current.hypotheses else "(empty)", + leads="\n".join(item.format() for item in current.leads) if current.leads else "(empty)", known="\n".join(KnownItem.format_item(item) for item in current.known) if current.known else "(empty)", kept_tool_results="\n\n".join(self.tool_context.kept_results) or "(empty)", errors="\n".join("- " + error for error in self.observe_feedback_errors) or "(empty)", @@ -5109,12 +4956,6 @@ def build_observe_prompt(self) -> str: def _system_prompt(self, template: str | None = None) -> str: return (template or AGENT_SYSTEM_PROMPT).strip() - def _available_tool_classes(self, tools: Iterable[ToolClass] | None = None) -> tuple[ToolClass, ...]: - tool_classes = tuple(TOOL_REGISTRY.values() if tools is None else tools) - if _code_index_available(self.session): - return tool_classes - return tuple(tool for tool in tool_classes if tool is not InspectCodeTool) - def _format_user_request(self) -> str: user_request = self.blackboard.user_input or "(empty)" fence = "`" * max(3, max((len(match.group(0)) for match in re.finditer(r"`{3,}", user_request)), default=0) + 1) @@ -5311,15 +5152,6 @@ def _remember_agent_error(self, text: str) -> None: def _remember_observe_error(self, text: str) -> None: self._remember_feedback_error(self.observe_feedback_errors, text) - def _drop_old_feedback_after_successful_tools(self, checkpoint: int) -> None: - if checkpoint <= 0 or not self.tool_runner.latest_executions: - return - if all(execution.outcome == "success" for execution in self.tool_runner.latest_executions): - markers = tuple(marker.lower() for marker in self.STALE_TOOL_FEEDBACK_MARKERS) - self.agent_feedback_errors[:checkpoint] = [ - error for error in self.agent_feedback_errors[:checkpoint] if not any(marker in error.lower() for marker in markers) - ] - def _error(self, text: str, rule: str = "") -> str: return "Error blocked: " + text + ((" Next: " + rule) if rule else "") @@ -5329,12 +5161,6 @@ def _warning(self, text: str, rule: str = "") -> str: def _warn_agent(self, text: str, rule: str = "") -> None: self._remember_agent_error(self._warning(text, rule)) - def _reject_agent(self, on_message: MessageCallback | None, feedback: str, retry: str, debug: str) -> bool: - self.stream_stop_requested = True - self._remember_agent_error(feedback) - self._report_gate(on_message, retry, debug) - return True - def _reject_result( self, remember_error: Callable[[str], None], @@ -5348,10 +5174,6 @@ def _reject_result( self._report_gate(on_message, retry, debug) return AgentRunResult() - def _reject_completion(self, on_message: MessageCallback | None, feedback: str, retry: str, debug: str) -> AgentRunResult: - self.blackboard.goal_reached = False - return self._reject_result(self._remember_agent_error, on_message, feedback, retry, debug) - def _report_gate(self, on_message: MessageCallback | None, message: str, debug_message: str) -> None: is_retry = message.startswith(("Retrying:", "Continuing:")) if on_message is None: @@ -5398,7 +5220,9 @@ def _tool_schemas(self) -> list[Json]: tool_classes: Iterable[ToolClass] = () else: action_names = self.ACT_ACTION_TYPES - {"tool"} - tool_classes = self._available_tool_classes() + tool_classes = tuple(TOOL_REGISTRY.values()) + if not _code_index_available(self.session): + tool_classes = tuple(tool for tool in tool_classes if tool is not InspectCodeTool) actions = [_state_tool_schema(name) for name in STATE_TOOL_PARAMS if name in action_names] return actions + [tool.tool_schema() for tool in tool_classes] @@ -5423,11 +5247,7 @@ def stream_step( response = self.step(on_message=on_message) if _json_str(response.get("_format_error")): return AgentRunResult(), response, False - return ( - self.handle_response(response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message), - response, - False, - ) + return self.handle_response(response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message), response, False committed = False latest_result = AgentRunResult() @@ -5484,11 +5304,7 @@ def on_stream_action(action: Json) -> bool: invalid_response = self._validate_action_response(response) if invalid_response is not None: return AgentRunResult(), invalid_response, False - return ( - self.handle_response(response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message), - response, - False, - ) + return self.handle_response(response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message), response, False def _can_stream_tools(self) -> bool: return self.mode == AgentMode.ACT and isinstance(self.model_client, ModelClient) and self.session.config.provider.stream is not False @@ -5502,7 +5318,7 @@ def apply_response(self, response: Json) -> list[str]: self.tool_context.kept_results = [] self.tool_context.compact_observed(self.tool_context.recent + self.tool_context.latest) self._mark_memory_checkpoint() - self.blackboard.hypotheses = [] + self.blackboard.leads = [] self.state_updater.apply(response) forgotten = self.tool_context.forget_results(ToolResultContext.forget_result_keys_from_actions(actions)) return forgotten @@ -5552,7 +5368,14 @@ def _should_observe_after_tools(self) -> bool: budget = self.context_budget() # Tool failures stay visible to ACT as Latest Tool Results plus feedback. # Very large failures still trigger observe through raw-context pressure. - return len(pending) >= budget.observe_after_results or self._unreferenced_raw_context_chars() >= budget.raw_chars + return ( + len(pending) >= budget.observe_after_results + or self.tool_context.raw_context_chars( + self.blackboard.memory_checkpoint_tool_result_counter, + exclude_keys=self.blackboard.referenced_result_keys(), + ) + >= budget.raw_chars + ) def _unreferenced_unreduced_blocks(self) -> list[str]: return self.tool_context.unreduced_blocks( @@ -5560,12 +5383,6 @@ def _unreferenced_unreduced_blocks(self) -> list[str]: exclude_keys=self.blackboard.referenced_result_keys(), ) - def _unreferenced_raw_context_chars(self) -> int: - return self.tool_context.raw_context_chars( - self.blackboard.memory_checkpoint_tool_result_counter, - exclude_keys=self.blackboard.referenced_result_keys(), - ) - def _after_tool_execution(self, execution: ToolCallExecution) -> None: self._remember_tool_failure(execution) if execution.error_type is Cancellation: @@ -5581,12 +5398,7 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: detail = self._format_tool_arg_error(execution) tool_class = TOOL_REGISTRY.get(execution.call.name) rule = self.RULE_EDIT_SIGNATURE if tool_class is not None and tool_class.EFFECT == ToolEffect.EDIT else self.RULE_TOOL_SIGNATURE - self._remember_agent_error( - self._error( - "tool call args invalid: " + _format_tool_call_summary(execution.call) + " -> " + detail + ".", - rule, - ) - ) + self._remember_agent_error(self._error("tool call args invalid: " + _format_tool_call_summary(execution.call) + " -> " + detail + ".", rule)) if ( execution.error_type is not None and issubclass(execution.error_type, ToolCallError) @@ -5736,13 +5548,6 @@ def _completion_plan_error(self, ctx: ResponseContext) -> str: return "plan items missing context: " + self._format_plan_gate_items(missing_context) return "" - def _blocked_checks_completion_error(self) -> str: - if not self.blackboard.goal_reached or self.blackboard.checks.status != CheckStatus.BLOCKED: - return "" - if self.blackboard.checks.blocker == CheckBlocker.USER: - return "" - return "verify blocked requires blocker=user before completion" - def _format_plan_gate_items(self, items: list[PlanItem]) -> str: rendered = [] for item in items[:3]: @@ -5752,44 +5557,10 @@ def _format_plan_gate_items(self, items: list[PlanItem]) -> str: rendered.append("+" + str(len(items) - 3) + " more") return "; ".join(rendered) - def _user_rule_message_from_actions(self, actions: list[Json]) -> str | None: - for action in actions: - if _json_str(action.get("type")) == "user_rule": - return _json_str(action.get("message")) or "Rule saved." - return None - @staticmethod def _is_pending_check_action(action: Json) -> bool: return _json_str(action.get("type")) == "verify" and _json_str(action.get("status")) == "pending" - def _investigate_completion_error(self) -> str: - if not self.blackboard.goal_reached or not self.blackboard.hypotheses: - return "" - return ( - "" - if any(item.status == HypothesisStatus.CONFIRMED for item in self.blackboard.hypotheses) - else "investigation completion requires a confirmed lead" - ) - - @staticmethod - def _released_result_sources_from_actions(actions: list[Json]) -> set[str]: - released = set() - for action in actions: - values = _json_list(action.get("items")) if _json_str(action.get("type")) == "lead" else [] - for raw in values: - item = Hypothesis.from_json(raw) - if item is not None and item.status != HypothesisStatus.ACTIVE: - released.update(key for key in item.source if key.startswith("tr.")) - return released - - def _forget_protected_result_error(self, actions: list[Json]) -> str: - forgotten = set(ToolResultContext.forget_result_keys_from_actions(actions)) - if not forgotten: - return "" - protected = self.blackboard.protected_result_sources() - conflict = sorted((forgotten & set(protected)) - self._released_result_sources_from_actions(actions)) - return "protected source: " + ", ".join(key + " (" + protected[key] + ")" for key in conflict) if conflict else "" - def _repeated_tool_retry_error(self, tool_calls: list[JsonValue]) -> str: if self.failed_tool_call_key is None or self.failed_tool_call_count < 2: return "" @@ -5843,6 +5614,9 @@ def _build_response_context(self, response: Json) -> ResponseContext: ), "", ) + user_rule_message = next( + (_json_str(action.get("message")) or "Rule saved." for action in actions if _json_str(action.get("type")) == "user_rule"), None + ) return ResponseContext( response=response, actions=actions, @@ -5854,7 +5628,7 @@ def _build_response_context(self, response: Json) -> ResponseContext: goal_will_change=bool(self.blackboard.goal and goal_update and goal_update != self.blackboard.goal), tool_calls=tool_calls, pending_check_requested=pending_check_requested, - user_rule_message=self._user_rule_message_from_actions(actions), + user_rule_message=user_rule_message, completion_message=completion_message, has_goal_action="goal" in action_types, has_plan_action="plan" in action_types, @@ -5876,7 +5650,7 @@ def _handle_text_response(self, ctx: ResponseContext, on_message: MessageCallbac self.session.append_conversation(AssistantMessage(content=ctx.assistant_text)) if on_message is not None: on_message(ctx.assistant_text) - active_task = bool(self.blackboard.plan or self.blackboard.hypotheses) + active_task = bool(self.blackboard.plan or self.blackboard.leads) if active_task and (self.blackboard.task_code in {TaskCode.WORKING, TaskCode.CHECKING} or self.incomplete_task_context_at_turn_start): return AgentRunResult() self.blackboard.task_code = TaskCode.DONE @@ -5893,9 +5667,6 @@ def _ingest_queued_user_input(self, poll_user_input: UserInputPoller | None, on_ if on_message is not None: on_message("sent: " + user_input) - def _gate_before_apply(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: - return self._gate_protocol_actions(ctx, on_message) or self._gate_tool_actions(ctx, on_message) or self._gate_task_state(ctx, on_message) - def _gate_protocol_actions(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: return ( self._gate_action_types( @@ -5913,24 +5684,19 @@ def _gate_tool_actions(self, ctx: ResponseContext, on_message: MessageCallback | return True repeated_tool_retry_error = self._repeated_tool_retry_error(ctx.tool_calls) if repeated_tool_retry_error: - return self._reject_agent( + self.stream_stop_requested = True + self._remember_agent_error(self._error("repeated failed tool call: " + repeated_tool_retry_error + ".", self.RULE_CHANGE_FAILED_TOOL)) + self._report_gate( on_message, - self._error("repeated failed tool call: " + repeated_tool_retry_error + ".", self.RULE_CHANGE_FAILED_TOOL), "Retrying: change the failed tool call instead of repeating it.", "ToolRetry_Gate: " + repeated_tool_retry_error + ".", ) + return True return False - def _drop_goal_rewrite_actions(self, ctx: ResponseContext) -> None: - def keep(action: Json) -> bool: - return not (_json_str(action.get("type")) == "goal" and action.get("complete") is not True) - - ctx.actions[:] = [action for action in ctx.actions if keep(action)] - ctx.response["actions"] = [action for action in _json_list(ctx.response.get("actions")) if not isinstance(action, dict) or keep(action)] - def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | None) -> bool: if ( - not (self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) + not (self.blackboard.goal or self.blackboard.plan or self.blackboard.leads) and any(execution.call.name == BashTool.NAME and execution.outcome == "success" for execution in self.tool_runner.latest_executions) and ctx.tool_calls and not ctx.assistant_text @@ -5938,8 +5704,7 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N and not ctx.has_plan_action ): self._warn_agent( - "last command result is visible with no active task.", - "answer the user when results are sufficient; create Goal/Plan for extended work.", + "last command result is visible with no active task.", "answer the user when results are sufficient; create Goal/Plan for extended work." ) if ( self.blackboard.task_code == TaskCode.NEW @@ -5949,10 +5714,7 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N and not ctx.has_plan_action and not ctx.has_user_rule_action ): - self._warn_agent( - "previous task context is still present.", - "emit goal for a new task; otherwise update or confirm the current plan.", - ) + self._warn_agent("previous task context is still present.", "emit goal for a new task; otherwise update or confirm the current plan.") if self.blackboard.task_code != TaskCode.NEW and ctx.goal_will_change and not ctx.has_fresh_plan_action: self._warn_agent("rewrote Goal after the task was active.", "replace Plan when the task scope changes.") if ctx.pending_check_requested: @@ -5962,7 +5724,12 @@ def _gate_task_state(self, ctx: ResponseContext, on_message: MessageCallback | N "Pending User Feedback is not a new task by default.", "answer it without rewriting Goal unless the user explicitly replaces or cancels the task.", ) - self._drop_goal_rewrite_actions(ctx) + ctx.actions[:] = [action for action in ctx.actions if _json_str(action.get("type")) != "goal" or action.get("complete") is True] + ctx.response["actions"] = [ + action + for action in _json_list(ctx.response.get("actions")) + if not isinstance(action, dict) or _json_str(action.get("type")) != "goal" or action.get("complete") is True + ] if ctx.goal_was_empty and not ctx.has_goal_action and ctx.state_or_work_requested and (ctx.pending_check_requested or ctx.has_edit_tool_call): self._warn_agent("mutating work before Goal/Plan was set.", self.RULE_GOAL_PLAN_FIRST) if ctx.goal_will_change and not ctx.has_fresh_plan_action and (ctx.pending_check_requested or ctx.has_edit_tool_call): @@ -6114,8 +5881,7 @@ def _warn_weak_observe_memory(self, actions: list[Json]) -> None: return self._remember_observe_error( self._warning( - "weak observe memory: known facts need source tr.N or keep/forget coverage.", - "use source-backed Facts/Leads or keep important raw results.", + "weak observe memory: known facts need source tr.N or keep/forget coverage.", "use source-backed Facts/Leads or keep important raw results." ) ) @@ -6144,7 +5910,17 @@ def _gate_forget_actions( "Retrying: forget only visible tool result keys.", "ToolResult_Gate: " + forget_error + ".", ) - forget_protected_error = self._forget_protected_result_error(actions) + forgotten = set(ToolResultContext.forget_result_keys_from_actions(actions)) + released = set() + for action in actions: + values = _json_list(action.get("items")) if _json_str(action.get("type")) == "lead" else [] + for raw in values: + item = Lead.from_json(raw) + if item is not None and item.status != LeadStatus.ACTIVE: + released.update(key for key in item.source if key.startswith("tr.")) + protected = self.blackboard.protected_result_sources() + conflict = sorted((forgotten & set(protected)) - released) + forget_protected_error = "protected source: " + ", ".join(key + " (" + protected[key] + ")" for key in conflict) if conflict else "" if forget_protected_error: return self._reject_result( remember_error, @@ -6191,18 +5967,18 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N self._warn_agent("Checks failed; fix the reported issue first.") completion_plan_error = self._completion_plan_error(ctx) if completion_plan_error: - return self._reject_completion( + self.blackboard.goal_reached = False + return self._reject_result( + self._remember_agent_error, on_message, self._error("completion before Plan was complete.", self.RULE_COMPLETE_PLAN), "Retrying: finish the plan before completing.", "Completion_Gate: " + completion_plan_error + ".", ) - blocked_completion_error = self._blocked_checks_completion_error() - if blocked_completion_error: - self._warn_agent("blocked Checks completion invalid: " + blocked_completion_error + ".", self.RULE_BLOCKED_BY_USER) - investigate_completion_error = self._investigate_completion_error() - if investigate_completion_error: - self._warn_agent(investigate_completion_error + ".", "mark a lead confirmed when claiming a root cause.") + if self.blackboard.goal_reached and self.blackboard.checks.status == CheckStatus.BLOCKED and self.blackboard.checks.blocker != CheckBlocker.USER: + self._warn_agent("blocked Checks completion invalid: verify blocked requires blocker=user before completion.", self.RULE_BLOCKED_BY_USER) + if self.blackboard.goal_reached and self.blackboard.leads and not any(item.status == LeadStatus.CONFIRMED for item in self.blackboard.leads): + self._warn_agent("investigation completion requires a confirmed lead.", "mark a lead confirmed when claiming a root cause.") return None def run( @@ -6226,12 +6002,10 @@ def run( self.session.state.turn_tool_calls = 0 self.session.state.turn_model_calls = 0 old_goal = self.blackboard.goal - old_task_context = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses) + old_task_context = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.leads) self.blackboard.user_input = user_input previous_task_done = self.blackboard.task_code == TaskCode.DONE self.incomplete_task_context_at_turn_start = old_task_context and not previous_task_done - if previous_task_done: - self.blackboard.work_mode = WorkMode.NORMAL # Keep previous task state at a new user turn so short follow-ups like # "continue" can resume. The first response must align with it before work # when the new request does not match the previous goal. @@ -6260,12 +6034,7 @@ def before_step(_index: int, _max_steps: int) -> None: return self.run_loop( max_steps=self.session.settings.max_agent_steps, on_message=on_message, - on_step=lambda response: self.handle_response( - response, - confirm=confirm, - on_auto_approve=on_auto_approve, - on_message=on_message, - ), + on_step=lambda response: self.handle_response(response, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message), on_step_limit=lambda: (_ for _ in ()).throw(LLMError("agent step limit reached")), on_before_step=before_step, ) @@ -6287,13 +6056,9 @@ def handle_response( feedback_checkpoint = len(self.agent_feedback_errors) DebugTrace.handle_event(self, "handle-start", ctx, response) if self.mode == AgentMode.OBSERVE: - return self._handle_observe_response( - ctx, - response, - on_message=on_message, - ) + return self._handle_observe_response(ctx, response, on_message=on_message) - if self._gate_before_apply(ctx, on_message): + if self._gate_protocol_actions(ctx, on_message) or self._gate_tool_actions(ctx, on_message) or self._gate_task_state(ctx, on_message): DebugTrace.handle_event(self, "handle-gated-before-apply", ctx, response) return AgentRunResult() @@ -6321,14 +6086,16 @@ def handle_response( return gate_result self._promote_required_checks(ctx) - if self._run_tool_actions( - ctx, - confirm=confirm, - on_auto_approve=on_auto_approve, - on_message=on_message, - append_to_latest=append_to_latest, - ): - self._drop_old_feedback_after_successful_tools(feedback_checkpoint) + if self._run_tool_actions(ctx, confirm=confirm, on_auto_approve=on_auto_approve, on_message=on_message, append_to_latest=append_to_latest): + if ( + feedback_checkpoint > 0 + and self.tool_runner.latest_executions + and all(execution.outcome == "success" for execution in self.tool_runner.latest_executions) + ): + markers = tuple(marker.lower() for marker in self.STALE_TOOL_FEEDBACK_MARKERS) + self.agent_feedback_errors[:feedback_checkpoint] = [ + error for error in self.agent_feedback_errors[:feedback_checkpoint] if not any(marker in error.lower() for marker in markers) + ] DebugTrace.handle_event(self, "handle-tools", ctx, response) return AgentRunResult() result = self._finish_or_continue(ctx, on_message) @@ -6642,7 +6409,12 @@ def _status(self, args: str) -> str: session = self.agent.session blackboard = self.agent.blackboard provider = session.config.provider - reasoning = self._format_provider_reasoning(provider) + if provider.reasoning == "off": + reasoning = "off" + elif provider.resolved_api() != "chat": + reasoning = provider.reasoning + else: + reasoning = provider.reasoning + "(" + provider.resolved_chat_reasoning() + ")" api = provider.resolved_api() + ("(" + provider.api + ")" if provider.api == "auto" else "") model_usage = ( "\n".join( @@ -6695,7 +6467,19 @@ def _status(self, args: str) -> str: def _compact(self, args: str) -> str: if args: return "Usage: /compact" - return self._with_status(self._compact_history) + + def compact_history() -> str: + before = len(self.agent.session.state.conversation) + count = self.agent.compact_history() + if count: + return "Compacted conversation history: " + str(count) + " item(s) -> " + str(len(self.agent.session.state.conversation)) + " item(s)" + return ( + "Conversation history is empty" + if before == 0 + else "Nothing to compact: " + str(before) + " item(s), keeping recent " + str(ConversationCompactor.KEEP_RECENT) + "." + ) + + return self._with_status(compact_history) def _index(self, args: str) -> str: value = args.strip() @@ -6726,17 +6510,6 @@ def _format_context_budget(self) -> str: ] ) - def _compact_history(self) -> str: - before = len(self.agent.session.state.conversation) - count = self.agent.compact_history() - if count: - return "Compacted conversation history: " + str(count) + " item(s) -> " + str(len(self.agent.session.state.conversation)) + " item(s)" - return ( - "Conversation history is empty" - if before == 0 - else "Nothing to compact: " + str(before) + " item(s), keeping recent " + str(ConversationCompactor.KEEP_RECENT) + "." - ) - def _config(self, args: str) -> str: if args: return "Usage: /config" @@ -6773,7 +6546,9 @@ def _config(self, args: str) -> str: ) def _set(self, args: str) -> str: - key, value = self._parse_set_args(args) + key, separator, raw_value = args.partition(" ") + key = key.strip() + value = (raw_value.strip() or None) if separator else None if not key: return CONFIG_SET_USAGE if key not in CONFIG_SET_KEYS: @@ -6789,10 +6564,6 @@ def _set(self, args: str) -> str: suffix = " and compacted history" if compacted else "" return "Set " + key + " = " + self._config_value(key) + suffix - def _parse_set_args(self, args: str) -> tuple[str, str | None]: - key, separator, value = args.partition(" ") - return key.strip(), (value.strip() or None) if separator else None - def _config_value(self, key: str) -> str: target, attr = self._config_target(key) value = getattr(target, attr) @@ -6865,13 +6636,6 @@ def _clean(self, args: str) -> str: def _format_bool(self, value: bool | None) -> str: return "(fallback)" if value is None else ("on" if value else "off") - def _format_provider_reasoning(self, provider: ProviderConfig) -> str: - if provider.reasoning == "off": - return "off" - if provider.resolved_api() != "chat": - return provider.reasoning - return provider.reasoning + "(" + provider.resolved_chat_reasoning() + ")" - def _format_optional(self, value: object) -> str: return str(value) if value is not None else "(fallback)" @@ -7899,8 +7663,10 @@ def _print_message(self, message: str) -> None: plain = " skipped: " + message.removeprefix("Tool Calls Skipped:").strip() self._emit_segments([("ansibrightblack", plain + "\n")], plain) return - if self._is_tool_report(message): - self._emit_segments(self._indent_segments(self._tool_segments(message), " "), self._tool_plain(message, indent=" "), end="") + lines = message.splitlines() + if lines and (lines[0].startswith(" ...") or self._is_tool_call_line(lines[0])): + plain = "\n".join(" " + line.replace("[success] ", "").replace("[failure] ", "") for line in lines) + self._emit_segments(self._indent_segments(self._tool_segments(message), " "), plain, end="") return if message.startswith("Retrying:"): self._emit_segments([("ansibrightblack", message + "\n")], message) @@ -7920,16 +7686,6 @@ def _print_message(self, message: str) -> None: return self._emit_segments([("ansicyan", message + "\n")], message) - def _tool_plain(self, message: str, *, indent: str) -> str: - return "\n".join(indent + line.replace("[success] ", "").replace("[failure] ", "") for line in message.splitlines()) - - def _is_tool_report(self, message: str) -> bool: - lines = message.splitlines() - if not lines: - return False - first = lines[0] - return first.startswith(" ...") or self._is_tool_call_line(first) - def _is_tool_call_line(self, line: str) -> bool: return line.startswith("[success] ") or line.startswith("[failure] ") @@ -7942,23 +7698,21 @@ def _emit_segments(self, segments: list[tuple[str, str]], plain: str, *, end: st def _preview_segments(self, preview: str) -> list[tuple[str, str]]: segments: list[tuple[str, str]] = [("ansibrightblack", " Preview\n")] content_indent = " " - diff_start = self._unified_diff_start(preview) + preview_lines = preview.splitlines() + diff_start = -1 + for index, line in enumerate(preview_lines): + body = "\n".join(preview_lines[index:]) + if line.startswith("--- ") and "\n+++ " in body and "\n@@ " in body: + diff_start = index + break if diff_start >= 0: - prefix = "\n".join(preview.splitlines()[:diff_start]) - diff = "\n".join(preview.splitlines()[diff_start:]) + prefix = "\n".join(preview_lines[:diff_start]) + diff = "\n".join(preview_lines[diff_start:]) if prefix: segments += self._indented_text_segments(prefix, indent=content_indent, style="ansiyellow") return segments + self._indent_segments(self._diff_segments(diff), content_indent) return segments + self._indented_text_segments(preview, indent=content_indent, style="ansicyan") - def _unified_diff_start(self, text: str) -> int: - lines = text.splitlines() - for index, line in enumerate(lines): - body = "\n".join(lines[index:]) - if line.startswith("--- ") and "\n+++ " in body and "\n@@ " in body: - return index - return -1 - def _diff_segments(self, text: str) -> list[tuple[str, str]]: segments: list[tuple[str, str]] = [] lines = text.splitlines() @@ -8115,21 +7869,6 @@ def _json_str(value: JsonValue) -> str | None: return str(value) -def _memory_fact_from_json(value: JsonValue) -> str | None: - item = _json_dict(value) - if item: - fact = (_json_str(item.get("text")) or _json_str(item.get("fact")) or "").strip() - else: - fact = (_json_str(value) or "").strip() - if not fact: - return None - if fact.startswith("<") and fact.endswith(">"): - inner = fact[1:-1].strip().lower() - if inner and any(word in inner for word in ("fact", "target", "arg", "path", "criterion", "result", "context", "message", "goal")): - return None - return fact - - def _source_from_json(item: Json) -> tuple[str, ...]: source_values = _json_list(item.get("source")) or _json_list(item.get("sources")) source = [(_json_str(raw) or "").strip() for raw in source_values] diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 40648de..4ebbfef 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -476,7 +476,7 @@ def test_observe_prompt_uses_narrow_context(tmp_path): agent.blackboard.user_input = "fix bug" agent.blackboard.goal = "fix bug goal" agent.blackboard.plan = [nanocode.PlanItem(id="p1", text="inspect failing path", status=nanocode.PlanStatus.DOING)] - agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="cache branch", status=nanocode.HypothesisStatus.ACTIVE, source=("tr.1",))] + agent.blackboard.leads = [nanocode.Lead(id="h1", text="cache branch", status=nanocode.LeadStatus.ACTIVE, source=("tr.1",))] agent.blackboard.known = ["known fact"] agent.tool_context.kept_results = ['- ok tool=Read args=["old.py"] key=tr.1\n output:\nselected result'] agent.recent_edits = ["- sample.py: old edit"] @@ -764,10 +764,10 @@ def test_lead_action_updates_blackboard_and_report(tmp_path): ) assert result.done is False - assert agent.blackboard.hypotheses == [ - nanocode.Hypothesis( + assert agent.blackboard.leads == [ + nanocode.Lead( text="admin filtering drops history events", - status=nanocode.HypothesisStatus.ACTIVE, + status=nanocode.LeadStatus.ACTIVE, id="h1", source=("tr.1",), context="feed search", @@ -776,11 +776,11 @@ def test_lead_action_updates_blackboard_and_report(tmp_path): assert messages == ["Leads Updated\n 1. [active] h1: admin filtering drops history events [tr.1] context: feed search"] -def test_forget_rejects_active_hypothesis_source(tmp_path): +def test_forget_rejects_active_lead_source(tmp_path): agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "debug branch") agent.tool_context.kept_results = ['- ok tool=Read args=["a"] key=tr.1\n output:\na'] - agent.blackboard.hypotheses = [nanocode.Hypothesis(text="branch still possible", source=("tr.1",))] + agent.blackboard.leads = [nanocode.Lead(text="branch still possible", source=("tr.1",))] messages = [] result = agent.handle_response({"actions": [{"type": "forget", "source": ["tr.1"], "reason": "branch ruled out"}]}, on_message=messages.append) @@ -795,7 +795,7 @@ def test_forget_allows_source_when_lead_is_closed_same_response(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) _seed_plan(agent, "debug branch") agent.tool_context.kept_results = ['- ok tool=Read args=["a"] key=tr.1\n output:\na'] - agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="branch still possible", source=("tr.1",))] + agent.blackboard.leads = [nanocode.Lead(id="h1", text="branch still possible", source=("tr.1",))] messages = [] result = agent.handle_response( @@ -812,7 +812,7 @@ def test_forget_allows_source_when_lead_is_closed_same_response(tmp_path): ) assert result.done is False - assert agent.blackboard.hypotheses[0].status == nanocode.HypothesisStatus.RULED_OUT + assert agent.blackboard.leads[0].status == nanocode.LeadStatus.RULED_OUT assert "tr.1" not in _blocks_text(agent.tool_context.kept_results) assert messages == [ "Leads Updated\n 1. [ruled_out] h1: branch ruled out [tr.1]", @@ -824,7 +824,7 @@ def test_forget_allows_source_when_lead_is_dropped_same_response(tmp_path): agent = Agent(Session(cwd=str(tmp_path))) _seed_plan(agent, "debug branch") agent.tool_context.kept_results = ['- ok tool=Read args=["a"] key=tr.1\n output:\na'] - agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="branch lost priority", source=("tr.1",))] + agent.blackboard.leads = [nanocode.Lead(id="h1", text="branch lost priority", source=("tr.1",))] messages = [] result = agent.handle_response( @@ -838,7 +838,7 @@ def test_forget_allows_source_when_lead_is_dropped_same_response(tmp_path): ) assert result.done is False - assert agent.blackboard.hypotheses[0].status == nanocode.HypothesisStatus.DROPPED + assert agent.blackboard.leads[0].status == nanocode.LeadStatus.DROPPED assert "tr.1" not in _blocks_text(agent.tool_context.kept_results) assert messages == [ "Leads Updated\n 1. [dropped] h1: branch no longer matters [tr.1]", @@ -1096,7 +1096,7 @@ def test_referenced_raw_context_does_not_force_observe(tmp_path, monkeypatch): ) _set_context_budget(monkeypatch, agent, raw_chars=180, observe_after_results=99) - assert agent._unreferenced_raw_context_chars() == 0 + assert agent.tool_context.raw_context_chars(agent.blackboard.memory_checkpoint_tool_result_counter, exclude_keys=agent.blackboard.referenced_result_keys()) == 0 assert agent._should_observe_after_tools() is False @@ -1133,7 +1133,7 @@ def test_tool_result_store_keeps_latest_256_items(tmp_path): def test_tool_result_store_trim_keeps_lead_source_keys(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) - agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="kept branch", source=("tr.1",))] + agent.blackboard.leads = [nanocode.Lead(id="h1", text="kept branch", source=("tr.1",))] for index in range(257): agent.tool_runner._store_tool_result(ParsedToolCall(name="Read", intention="", args=[str(index)]), "success", "output " + str(index)) @@ -1152,7 +1152,7 @@ def test_agent_prunes_tool_result_store_but_keeps_referenced_result_keys(tmp_pat key = "tr." + str(index + 1) session.state.tool_result_store[key] = nanocode.ToolResultItem(description=key, value="value") agent.tool_context.kept_results = ['- ok tool=Read args=["sample.txt"] key=tr.1\n output:\nvalue'] - agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="kept branch", source=("tr.2",))] + agent.blackboard.leads = [nanocode.Lead(id="h1", text="kept branch", source=("tr.2",))] agent._prune_tool_result_store() @@ -1518,8 +1518,8 @@ def test_agent_accepts_string_lead_items_from_function_call(tmp_path): agent.apply_response({"actions": [{"type": "lead", "items": ["Admin filter excludes history"]}]}) - assert agent.blackboard.hypotheses == [ - nanocode.Hypothesis(text="Admin filter excludes history"), + assert agent.blackboard.leads == [ + nanocode.Lead(text="Admin filter excludes history"), ] @@ -1849,109 +1849,16 @@ def test_agent_request_uses_configured_thinking_disabled_payload(tmp_path, monke def test_agent_request_auto_detects_chat_reasoning_from_provider_url(tmp_path, monkeypatch): calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, tuple(_chat_response() for _ in range(10))) - Agent( - _session( - tmp_path, - api_url="https://api.deepseek.com", - api_key="key", - model="model", - reasoning="xhigh", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://openrouter.ai/api/v1", - api_key="key", - model="model", - api="chat", - reasoning="high", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", - api_key="key", - model="qwen3.6-plus", - api="chat", - reasoning="high", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", - api_key="key", - model="deepseek-v4-flash", - api="chat", - reasoning="xhigh", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", - api_key="key", - model="glm-5.1", - api="chat", - reasoning="high", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://api.openai.com/v1", - api_key="key", - model="gpt-5", - api="chat", - reasoning="medium", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://opencode.ai/zen/go/v1", - api_key="key", - model="deepseek-v4-flash", - reasoning="high", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://opencode.ai/zen/go/v1", - api_key="key", - model="kimi-k2.6", - reasoning="high", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://not-openrouter.ai/api/v1", - api_key="key", - model="model", - stream=False, - ) - ).request("system", "user") - Agent( - _session( - tmp_path, - api_url="https://example.test/v1", - api_key="key", - model="model", - stream=False, - ) - ).request("system", "user") + Agent(_session(tmp_path, api_url="https://api.deepseek.com", api_key="key", model="model", reasoning="xhigh", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://openrouter.ai/api/v1", api_key="key", model="model", api="chat", reasoning="high", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", api_key="key", model="qwen3.6-plus", api="chat", reasoning="high", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", api_key="key", model="deepseek-v4-flash", api="chat", reasoning="xhigh", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://dashscope.aliyuncs.com/compatible-mode/v1", api_key="key", model="glm-5.1", api="chat", reasoning="high", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="gpt-5", api="chat", reasoning="medium", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://opencode.ai/zen/go/v1", api_key="key", model="deepseek-v4-flash", reasoning="high", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://opencode.ai/zen/go/v1", api_key="key", model="kimi-k2.6", reasoning="high", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://not-openrouter.ai/api/v1", api_key="key", model="model", stream=False)).request("system", "user") + Agent(_session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False)).request("system", "user") payloads = [_sdk_payload(call) for call in calls] assert payloads[0]["thinking"] == {"type": "enabled"} @@ -2410,7 +2317,7 @@ def test_agent_accepts_goal_without_plan_for_new_task(tmp_path): agent.blackboard.task_code = nanocode.TaskCode.NEW messages = [] - result = agent.handle_response({"actions": [{"type": "goal", "text": "change map", "work_mode": "normal", "complete": False}]}, on_message=messages.append) + result = agent.handle_response({"actions": [{"type": "goal", "text": "change map", "complete": False}]}, on_message=messages.append) assert result.done is False assert agent.blackboard.goal == "change map" @@ -3896,7 +3803,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): def test_investigate_completion_without_confirmed_lead_warns(tmp_path): agent = Agent(_session(tmp_path, debug=True)) _seed_plan(agent, "find bug") - agent.blackboard.hypotheses = [nanocode.Hypothesis(id="h1", text="bad admin filter", status=nanocode.HypothesisStatus.ACTIVE, source=("tr.1",))] + agent.blackboard.leads = [nanocode.Lead(id="h1", text="bad admin filter", status=nanocode.LeadStatus.ACTIVE, source=("tr.1",))] messages = [] result = agent.handle_response( @@ -3929,11 +3836,11 @@ def test_investigate_completion_without_confirmed_lead_warns(tmp_path): ) assert result.done is True - assert agent.blackboard.hypotheses[0].status == nanocode.HypothesisStatus.CONFIRMED + assert agent.blackboard.leads[0].status == nanocode.LeadStatus.CONFIRMED assert messages[-1] == "done" -def test_goal_declares_investigate_work_mode(tmp_path): +def test_investigation_state_keeps_empty_leads_out_of_initial_prompt(tmp_path): class FakeModelClient: def __init__(self): self.user_prompts = [] @@ -3942,12 +3849,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): self.user_prompts.append(user_prompt) return { "actions": [ - { - "type": "goal", - "text": "find bug", - "work_mode": "investigate", - "complete": False, - }, + {"type": "goal", "text": "find bug", "complete": False}, { "type": "plan", "items": [{"id": "p1", "text": "identify root cause", "status": "done", "context": "reasoned"}], @@ -3964,7 +3866,6 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): result = agent.run("为什么 admin history 不出现") assert result["actions"][-1]["message_for_complete"] == "done" - assert "Work Mode:" not in agent.model_client.user_prompts[0] assert "Leads:" not in agent.model_client.user_prompts[0] From beb3ebc48dbc9c00772ac5b3f602d4057dba57bd Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 01:40:50 -0700 Subject: [PATCH 121/144] Normalize protocol action casing and bump version --- nanocode.py | 17 ++++++++++++++++- pyproject.toml | 2 +- tests/test_nanocode_agent.py | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 50 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index a7a791e..b6096b6 100644 --- a/nanocode.py +++ b/nanocode.py @@ -55,7 +55,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.5" +__version__ = "0.4.6" JsonValue: TypeAlias = Any @@ -3179,6 +3179,13 @@ def _canonical_tool_name(name: str | None) -> str: ["source", "reason"], ), } +PROTOCOL_ACTION_TYPES = frozenset((*STATE_TOOL_PARAMS, "tool")) + + +def _canonical_protocol_action_type(name: str | None) -> str: + if not name: + return "" + return next((action_type for action_type in PROTOCOL_ACTION_TYPES if action_type.lower() == name.lower()), name) def _state_tool_schema(name: str) -> Json: @@ -5311,6 +5318,7 @@ def _can_stream_tools(self) -> bool: def apply_response(self, response: Json) -> list[str]: actions = self._response_actions(response) + response = {**response, "actions": actions} if any(self._is_pending_check_action(action) for action in actions): response = {**response, "actions": [action for action in actions if not self._is_pending_check_action(action)]} actions = self._response_actions(response) @@ -5504,6 +5512,13 @@ def _response_actions(self, response: Json) -> list[Json]: @staticmethod def _normalize_action(action: Json) -> Json: action_type = _json_str(action.get("type")) + canonical_action_type = _canonical_protocol_action_type(action_type) + if canonical_action_type in PROTOCOL_ACTION_TYPES: + if canonical_action_type == action_type: + return action + normalized = dict(action) + normalized["type"] = canonical_action_type + return normalized tool_name = _canonical_tool_name(action_type) if tool_name not in TOOL_REGISTRY: return action diff --git a/pyproject.toml b/pyproject.toml index 0cdd6e5..3da2b67 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.5" +version = "0.4.6" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 4ebbfef..b1e6417 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2832,6 +2832,39 @@ def test_agent_rejects_invalid_action_instead_of_completing(tmp_path): assert messages == ["Protocol_Gate: invalid action type(s): invalid."] +def test_agent_normalizes_protocol_action_type_case(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + + ctx = agent._build_response_context( + { + "actions": [ + {"type": "Goal", "text": "change map", "complete": False}, + {"type": "PLAN", "items": ["inspect files"]}, + {"type": "Known", "items": ["fact"]}, + {"type": "LEAD", "items": ["branch"]}, + {"type": "Verify", "status": "passed", "context": "checked"}, + {"type": "USER_RULE", "text": "prefer concise", "message": "saved"}, + {"type": "FORGET", "source": ["tr.1"], "reason": "old"}, + {"type": "KEEP", "source": ["tr.2"], "reason": "useful"}, + {"type": "Tool", "name": "search", "intention": "find", "args": ["needle"]}, + ] + } + ) + + assert [action["type"] for action in ctx.actions] == ["goal", "plan", "known", "lead", "verify", "user_rule", "forget", "keep", "tool"] + + +def test_agent_accepts_capitalized_goal_action_type(tmp_path): + agent = Agent(_session(tmp_path, debug=True)) + messages = [] + + result = agent.handle_response({"actions": [{"type": "Goal", "text": "change map", "complete": False}]}, on_message=messages.append) + + assert result.done is False + assert agent.blackboard.goal == "change map" + assert not any("Protocol_Gate" in message for message in messages) + + def test_agent_normalizes_direct_repo_tool_action_type(tmp_path): path = tmp_path / "sample.txt" path.write_text("old\n", encoding="utf-8") From e5917fe02f6f078d0d4ee5ae7331329248792cdb Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 01:44:11 -0700 Subject: [PATCH 122/144] Clarify plan as minimal correct path in prompt --- nanocode.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index b6096b6..18a7296 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3222,7 +3222,7 @@ def _state_tool_schema(name: str) -> Json: Workflow: - Chat: answer directly; do not create task state. - One-shot: use only needed tools, then answer and stop; do not create task state just to report. -- Tracked task: for edits/debugging/checks/multi-step work, set Goal, keep a short Plan, act on the current step, record Checks after edits or requested checks, finish with goal.complete=true. +- Tracked task: for edits/debugging/checks/multi-step work, set Goal, keep the shortest necessary correct Plan, act on the current step, record Checks after edits or requested checks, finish with goal.complete=true. Current step: - Choose the smallest useful action from latest request, feedback, visible results, and Plan. @@ -3230,7 +3230,8 @@ def _state_tool_schema(name: str) -> Json: - Do not stop at state-only updates when a useful tool call is clear. State: -- Goal/Plan track work. Facts are confirmed. Leads are for investigations. Checks are checks. User Rules are future-behavior requests. +- Goal/Plan track work. Plan is the minimal correct path to Goal, not a loose TODO list; update it when Facts change the path. +- Facts are confirmed. Leads are for investigations. Checks are checks. User Rules are future-behavior requests. - Save only what matters after results disappear; cite tr.N when result-backed; forget raw results when no longer needed. Default Response Format: Text (Not markdown) From e98435cdcb09a22acdb20a0eda0a937a2cb66c77 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 01:53:25 -0700 Subject: [PATCH 123/144] Add plan obligation closure fields --- nanocode.py | 30 ++++++++++++++++++------- tests/test_nanocode_agent.py | 43 ++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+), 8 deletions(-) diff --git a/nanocode.py b/nanocode.py index 18a7296..9a350b6 100644 --- a/nanocode.py +++ b/nanocode.py @@ -166,6 +166,8 @@ class PlanItem: status: PlanStatus = PlanStatus.TODO id: str = "" context: str = "" + opens: tuple[str, ...] = () + closes: tuple[str, ...] = () def format(self, indent: str = "") -> str: text = "- [" + str(self.status) + "] " + self.text @@ -174,6 +176,10 @@ def format(self, indent: str = "") -> str: lines = [text] if self.context: lines.append(" context: " + self.context) + if self.opens: + lines.append(" opens: " + "; ".join(self.opens)) + if self.closes: + lines.append(" closes: " + "; ".join(self.closes)) return _format_lines(lines, indent) @@ -3121,6 +3127,8 @@ def _canonical_tool_name(name: str | None) -> str: "text": TOOL_NULLABLE_STRING_SCHEMA, "status": {"type": ["string", "null"], "enum": [*ALL_PLAN_STATUSES]}, "context": TOOL_NULLABLE_STRING_SCHEMA, + "opens": {**TOOL_STRING_LIST_SCHEMA, "description": "Follow-up obligations this step creates for later steps or checks to close."}, + "closes": {**TOOL_STRING_LIST_SCHEMA, "description": "Earlier obligations this step closes."}, }, [], ), @@ -3150,7 +3158,7 @@ def _canonical_tool_name(name: str | None) -> str: }, ["text", "complete", "message_for_complete"], ), - "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), + "plan": ("Replace or patch the current plan; use opens/closes for obligations created or satisfied by steps.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), "lead": ("Update investigation leads.", {"items": TOOL_LEAD_ITEMS_SCHEMA}, ["items"]), "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "user_rule": ( @@ -4452,6 +4460,8 @@ def _format_state_report( def render_plan_row(index: int, item: PlanItem) -> list[str]: rows = [" " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text)] rows += [" context: " + self._compact(item.context)] if item.context else [] + rows += [" opens: " + self._compact("; ".join(item.opens))] if item.opens else [] + rows += [" closes: " + self._compact("; ".join(item.closes))] if item.closes else [] return rows self._append_state_section(lines, " Plan", self._format_rows(current.plan, render_plan_row)) @@ -4587,13 +4597,11 @@ def _apply_plan_patches(self, plan: list[PlanItem], value: JsonValue) -> bool: text = _json_str(patch.get("text")) if "text" in patch else None status = _json_str(patch.get("status")) if "status" in patch else None context = _json_str(patch.get("context")) if "context" in patch else existing.context - updated = ( - text or existing.text, - PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, - context or "", - ) - changed = changed or (existing.text, existing.status, existing.context) != updated - existing.text, existing.status, existing.context = updated + opens = _string_tuple_from_json(patch.get("opens")) if "opens" in patch else existing.opens + closes = _string_tuple_from_json(patch.get("closes")) if "closes" in patch else existing.closes + updated = (text or existing.text, PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, context or "", opens, closes) + changed = changed or (existing.text, existing.status, existing.context, existing.opens, existing.closes) != updated + existing.text, existing.status, existing.context, existing.opens, existing.closes = updated continue plan_item = self._plan_item_from_json(patch) if plan_item is None: @@ -4618,6 +4626,8 @@ def _plan_item_from_json(self, value: JsonValue) -> PlanItem | None: status=PlanStatus(status), id=_json_str(item.get("id")) or "", context=_json_str(item.get("context")) or "", + opens=_string_tuple_from_json(item.get("opens")), + closes=_string_tuple_from_json(item.get("closes")), ) @staticmethod @@ -7895,6 +7905,10 @@ def _source_from_json(item: Json) -> tuple[str, ...]: return tuple(dict.fromkeys(item for item in source if item)) +def _string_tuple_from_json(value: JsonValue) -> tuple[str, ...]: + return tuple(dict.fromkeys(text for raw in _json_list(value) for text in [(_json_str(raw) or "").strip()] if text)) + + def _shorten(text: str, limit: int = 500) -> str: return text if len(text) <= limit else text[:limit] + "..." diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index b1e6417..92e186c 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2284,6 +2284,49 @@ def test_agent_applies_partial_plan_patch(tmp_path): ] +def test_agent_plan_items_track_opened_and_closed_obligations(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + + agent.apply_response( + { + "actions": [ + { + "type": "plan", + "items": [ + { + "id": "p1", + "text": "Update dependency declaration", + "opens": ["lock/environment must match dependency declaration"], + }, + { + "id": "p2", + "text": "Sync dependency environment", + "closes": ["lock/environment must match dependency declaration"], + }, + ], + } + ] + } + ) + + assert agent.blackboard.plan == [ + nanocode.PlanItem(id="p1", text="Update dependency declaration", opens=("lock/environment must match dependency declaration",)), + nanocode.PlanItem(id="p2", text="Sync dependency environment", closes=("lock/environment must match dependency declaration",)), + ] + assert "opens: lock/environment must match dependency declaration" in agent.build_user_prompt() + assert "closes: lock/environment must match dependency declaration" in agent.build_user_prompt() + + agent.apply_response({"actions": [{"type": "plan", "mode": "patch", "items": [{"id": "p1", "status": "done", "context": "pyproject updated"}]}]}) + + assert agent.blackboard.plan[0] == nanocode.PlanItem( + id="p1", + text="Update dependency declaration", + status=nanocode.PlanStatus.DONE, + context="pyproject updated", + opens=("lock/environment must match dependency declaration",), + ) + + def test_agent_applies_goal_and_plan_actions(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) From 864be2fce504e791894f29523db2604ffe39d2ae Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 02:09:20 -0700 Subject: [PATCH 124/144] Fix plan patching and completion gate feedback --- nanocode.py | 28 ++++++++++++++----------- tests/test_nanocode_agent.py | 40 +++++++++++++++++++++++++++++++++++- 2 files changed, 55 insertions(+), 13 deletions(-) diff --git a/nanocode.py b/nanocode.py index 9a350b6..bf5354e 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2794,6 +2794,7 @@ class BashTool(Tool): NAME: ClassVar[str] = "Bash" DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Run one explicit shell command via bash -lc in cwd.", + "Args must be exactly one command string; do not pass timeout or extra args.", "Returns exit_code plus stdout/stderr; long output is stored and bounded in context.", "Use Bash when shell semantics, tests/builds, or custom Unix text-tool pipelines are the clearest path.", "rg/grep/sed/awk/perl pipelines in Bash are useful for broad scans, custom filters, and mechanical transforms.", @@ -4414,7 +4415,7 @@ def apply(self, response: Json) -> None: before_user_rules = self.session.state.user_rules.format() before_checks = self.blackboard.checks.format() goal_changed = self._apply_goal(actions) - plan_replaced = self._apply_plan(actions) + plan_replaced = self._apply_plan(actions, replace_by_default=goal_changed) if goal_changed and not plan_replaced: self.blackboard.plan = [] for raw in self._action_items(actions, "known"): @@ -4565,20 +4566,23 @@ def _apply_goal(self, actions: list[Json]) -> bool: self.blackboard.goal_reached = complete return changed - def _apply_plan(self, actions: list[Json]) -> bool: + def _apply_plan(self, actions: list[Json], *, replace_by_default: bool = False) -> bool: replaced = False for update in self._actions_of_type(actions, "plan"): items = _json_list(update.get("items")) - if update.get("mode") != "patch": - if not items: - continue - plan = [item for item in (self._plan_item_from_json(raw) for raw in items) if item] - self._normalize_doing_items(plan) - self.blackboard.plan = plan - replaced = True + mode = _json_str(update.get("mode")) + existing_ids = {item.id for item in self.blackboard.plan if item.id} + targets_existing = bool(existing_ids) and any(_json_str(_json_dict(raw).get("id")) in existing_ids for raw in items) + if mode == "patch" or (not replace_by_default and mode != "replace" and targets_existing): + if self._apply_plan_patches(self.blackboard.plan, items): + self._normalize_doing_items(self.blackboard.plan) + continue + if not items: continue - if self._apply_plan_patches(self.blackboard.plan, items): - self._normalize_doing_items(self.blackboard.plan) + plan = [item for item in (self._plan_item_from_json(raw) for raw in items) if item] + self._normalize_doing_items(plan) + self.blackboard.plan = plan + replaced = True return replaced def _apply_plan_patches(self, plan: list[PlanItem], value: JsonValue) -> bool: @@ -5997,7 +6001,7 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N return self._reject_result( self._remember_agent_error, on_message, - self._error("completion before Plan was complete.", self.RULE_COMPLETE_PLAN), + self._error("completion before Plan was complete: " + completion_plan_error + ".", self.RULE_COMPLETE_PLAN), "Retrying: finish the plan before completing.", "Completion_Gate: " + completion_plan_error + ".", ) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 92e186c..2da7206 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2254,7 +2254,7 @@ def test_agent_ignores_empty_plan_replace(tmp_path): assert agent.state_updater.latest_report == "" -def test_agent_treats_plan_without_mode_as_replace(tmp_path): +def test_agent_patches_existing_plan_ids_without_mode(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) agent.blackboard.plan = [ @@ -2266,6 +2266,43 @@ def test_agent_treats_plan_without_mode_as_replace(tmp_path): assert agent._build_response_context(response).has_fresh_plan_action is True agent.apply_response(response) + assert [item.text for item in agent.blackboard.plan] == ["Inspect new file", "Edit old file"] + assert agent.blackboard.plan[0].status == nanocode.PlanStatus.DOING + + +def test_agent_explicit_plan_replace_discards_old_items(tmp_path): + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + agent.blackboard.plan = [ + nanocode.PlanItem(id="p1", text="Inspect old file", status=nanocode.PlanStatus.DONE), + nanocode.PlanItem(id="p2", text="Edit old file", status=nanocode.PlanStatus.TODO), + ] + + agent.apply_response({"actions": [{"type": "plan", "mode": "replace", "items": [{"id": "p1", "text": "Inspect new file", "status": "doing"}]}]}) + + assert [item.text for item in agent.blackboard.plan] == ["Inspect new file"] + assert agent.blackboard.plan[0].status == nanocode.PlanStatus.DOING + + +def test_agent_replaces_plan_by_default_when_goal_changes(tmp_path): + session = Session(cwd=str(tmp_path)) + agent = Agent(session) + agent.blackboard.goal = "old task" + agent.blackboard.plan = [ + nanocode.PlanItem(id="p1", text="Inspect old file", status=nanocode.PlanStatus.DONE), + nanocode.PlanItem(id="p2", text="Edit old file", status=nanocode.PlanStatus.TODO), + ] + + agent.apply_response( + { + "actions": [ + {"type": "goal", "text": "new task", "complete": False}, + {"type": "plan", "items": [{"id": "p1", "text": "Inspect new file", "status": "doing"}]}, + ] + } + ) + + assert agent.blackboard.goal == "new task" assert [item.text for item in agent.blackboard.plan] == ["Inspect new file"] assert agent.blackboard.plan[0].status == nanocode.PlanStatus.DOING @@ -3980,6 +4017,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): assert response["actions"][-1]["message_for_complete"] == "done" assert any("before Plan was complete" in error for error in agent.agent_feedback_errors) + assert any("plan items missing context" in error for error in agent.agent_feedback_errors) assert agent.agent_feedback_errors assert agent.blackboard.plan == [nanocode.PlanItem(id="p1", text="answer", status=nanocode.PlanStatus.DONE, context="answered")] From b165c829505cecad13dd0b0e80cb7cc810964658 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 02:20:44 -0700 Subject: [PATCH 125/144] Remove plan obligation fields and clarify plan prompt --- nanocode.py | 44 ++++++++++++++++-------------------- tests/test_nanocode_agent.py | 43 ----------------------------------- 2 files changed, 20 insertions(+), 67 deletions(-) diff --git a/nanocode.py b/nanocode.py index bf5354e..79ee574 100644 --- a/nanocode.py +++ b/nanocode.py @@ -166,8 +166,6 @@ class PlanItem: status: PlanStatus = PlanStatus.TODO id: str = "" context: str = "" - opens: tuple[str, ...] = () - closes: tuple[str, ...] = () def format(self, indent: str = "") -> str: text = "- [" + str(self.status) + "] " + self.text @@ -176,10 +174,6 @@ def format(self, indent: str = "") -> str: lines = [text] if self.context: lines.append(" context: " + self.context) - if self.opens: - lines.append(" opens: " + "; ".join(self.opens)) - if self.closes: - lines.append(" closes: " + "; ".join(self.closes)) return _format_lines(lines, indent) @@ -3128,8 +3122,6 @@ def _canonical_tool_name(name: str | None) -> str: "text": TOOL_NULLABLE_STRING_SCHEMA, "status": {"type": ["string", "null"], "enum": [*ALL_PLAN_STATUSES]}, "context": TOOL_NULLABLE_STRING_SCHEMA, - "opens": {**TOOL_STRING_LIST_SCHEMA, "description": "Follow-up obligations this step creates for later steps or checks to close."}, - "closes": {**TOOL_STRING_LIST_SCHEMA, "description": "Earlier obligations this step closes."}, }, [], ), @@ -3159,7 +3151,7 @@ def _canonical_tool_name(name: str | None) -> str: }, ["text", "complete", "message_for_complete"], ), - "plan": ("Replace or patch the current plan; use opens/closes for obligations created or satisfied by steps.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), + "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), "lead": ("Update investigation leads.", {"items": TOOL_LEAD_ITEMS_SCHEMA}, ["items"]), "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "user_rule": ( @@ -3231,7 +3223,12 @@ def _state_tool_schema(name: str) -> Json: Workflow: - Chat: answer directly; do not create task state. - One-shot: use only needed tools, then answer and stop; do not create task state just to report. -- Tracked task: for edits/debugging/checks/multi-step work, set Goal, keep the shortest necessary correct Plan, act on the current step, record Checks after edits or requested checks, finish with goal.complete=true. +- Tracked task: + - set Goal. + - keep the shortest correct Plan. + - act on the current step. + - record Checks after edits or requested checks. + - finish with goal.complete=true. Current step: - Choose the smallest useful action from latest request, feedback, visible results, and Plan. @@ -3239,7 +3236,16 @@ def _state_tool_schema(name: str) -> Json: - Do not stop at state-only updates when a useful tool call is clear. State: -- Goal/Plan track work. Plan is the minimal correct path to Goal, not a loose TODO list; update it when Facts change the path. +- Goal/Plan track work. +- Plan is serious. +- Plan is the shortest correct path to Goal. +- Plan includes required consistency steps caused by edits: + - sync lock/env state. + - regenerate derived files. + - update generated code. + - validate affected behavior. +- Skip a caused step only when not needed. Put why in Plan context. +- Update Plan only when Facts change the path. - Facts are confirmed. Leads are for investigations. Checks are checks. User Rules are future-behavior requests. - Save only what matters after results disappear; cite tr.N when result-backed; forget raw results when no longer needed. @@ -4461,8 +4467,6 @@ def _format_state_report( def render_plan_row(index: int, item: PlanItem) -> list[str]: rows = [" " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text)] rows += [" context: " + self._compact(item.context)] if item.context else [] - rows += [" opens: " + self._compact("; ".join(item.opens))] if item.opens else [] - rows += [" closes: " + self._compact("; ".join(item.closes))] if item.closes else [] return rows self._append_state_section(lines, " Plan", self._format_rows(current.plan, render_plan_row)) @@ -4601,11 +4605,9 @@ def _apply_plan_patches(self, plan: list[PlanItem], value: JsonValue) -> bool: text = _json_str(patch.get("text")) if "text" in patch else None status = _json_str(patch.get("status")) if "status" in patch else None context = _json_str(patch.get("context")) if "context" in patch else existing.context - opens = _string_tuple_from_json(patch.get("opens")) if "opens" in patch else existing.opens - closes = _string_tuple_from_json(patch.get("closes")) if "closes" in patch else existing.closes - updated = (text or existing.text, PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, context or "", opens, closes) - changed = changed or (existing.text, existing.status, existing.context, existing.opens, existing.closes) != updated - existing.text, existing.status, existing.context, existing.opens, existing.closes = updated + updated = (text or existing.text, PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, context or "") + changed = changed or (existing.text, existing.status, existing.context) != updated + existing.text, existing.status, existing.context = updated continue plan_item = self._plan_item_from_json(patch) if plan_item is None: @@ -4630,8 +4632,6 @@ def _plan_item_from_json(self, value: JsonValue) -> PlanItem | None: status=PlanStatus(status), id=_json_str(item.get("id")) or "", context=_json_str(item.get("context")) or "", - opens=_string_tuple_from_json(item.get("opens")), - closes=_string_tuple_from_json(item.get("closes")), ) @staticmethod @@ -7909,10 +7909,6 @@ def _source_from_json(item: Json) -> tuple[str, ...]: return tuple(dict.fromkeys(item for item in source if item)) -def _string_tuple_from_json(value: JsonValue) -> tuple[str, ...]: - return tuple(dict.fromkeys(text for raw in _json_list(value) for text in [(_json_str(raw) or "").strip()] if text)) - - def _shorten(text: str, limit: int = 500) -> str: return text if len(text) <= limit else text[:limit] + "..." diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 2da7206..2b6abb6 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2321,49 +2321,6 @@ def test_agent_applies_partial_plan_patch(tmp_path): ] -def test_agent_plan_items_track_opened_and_closed_obligations(tmp_path): - agent = Agent(Session(cwd=str(tmp_path))) - - agent.apply_response( - { - "actions": [ - { - "type": "plan", - "items": [ - { - "id": "p1", - "text": "Update dependency declaration", - "opens": ["lock/environment must match dependency declaration"], - }, - { - "id": "p2", - "text": "Sync dependency environment", - "closes": ["lock/environment must match dependency declaration"], - }, - ], - } - ] - } - ) - - assert agent.blackboard.plan == [ - nanocode.PlanItem(id="p1", text="Update dependency declaration", opens=("lock/environment must match dependency declaration",)), - nanocode.PlanItem(id="p2", text="Sync dependency environment", closes=("lock/environment must match dependency declaration",)), - ] - assert "opens: lock/environment must match dependency declaration" in agent.build_user_prompt() - assert "closes: lock/environment must match dependency declaration" in agent.build_user_prompt() - - agent.apply_response({"actions": [{"type": "plan", "mode": "patch", "items": [{"id": "p1", "status": "done", "context": "pyproject updated"}]}]}) - - assert agent.blackboard.plan[0] == nanocode.PlanItem( - id="p1", - text="Update dependency declaration", - status=nanocode.PlanStatus.DONE, - context="pyproject updated", - opens=("lock/environment must match dependency declaration",), - ) - - def test_agent_applies_goal_and_plan_actions(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) From 75f6b6cf9f8febe9af26be96eefbcb557f9c60b8 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 02:30:54 -0700 Subject: [PATCH 126/144] Add plan follow-up status gate --- nanocode.py | 82 ++++++++++++++++++------ tests/test_nanocode_agent.py | 117 +++++++++++++++++++++++++++++++++++ 2 files changed, 180 insertions(+), 19 deletions(-) diff --git a/nanocode.py b/nanocode.py index 79ee574..db27a98 100644 --- a/nanocode.py +++ b/nanocode.py @@ -143,6 +143,17 @@ def __str__(self) -> str: ALL_PLAN_STATUSES = frozenset(PlanStatus) +class PlanFollowupStatus(StrEnum): + UNKNOWN = "unknown" + NONE = "none" + NEEDED = "needed" + DONE = "done" + BLOCKED = "blocked" + + +ALL_PLAN_FOLLOWUP_STATUSES = frozenset(PlanFollowupStatus) + + class TaskCode(StrEnum): NEW = "new" WORKING = "working" @@ -166,6 +177,8 @@ class PlanItem: status: PlanStatus = PlanStatus.TODO id: str = "" context: str = "" + followup_action: PlanFollowupStatus = PlanFollowupStatus.UNKNOWN + followup_check: PlanFollowupStatus = PlanFollowupStatus.UNKNOWN def format(self, indent: str = "") -> str: text = "- [" + str(self.status) + "] " + self.text @@ -174,6 +187,10 @@ def format(self, indent: str = "") -> str: lines = [text] if self.context: lines.append(" context: " + self.context) + if self.followup_action != PlanFollowupStatus.UNKNOWN: + lines.append(" followup_action: " + str(self.followup_action)) + if self.followup_check != PlanFollowupStatus.UNKNOWN: + lines.append(" followup_check: " + str(self.followup_check)) return _format_lines(lines, indent) @@ -3113,6 +3130,10 @@ def _canonical_tool_name(name: str | None) -> str: TOOL_NULLABLE_STRING_SCHEMA: Json = {"type": ["string", "null"]} TOOL_ITEMS_SCHEMA: Json = {"type": "array", "items": TOOL_JSON_VALUE_SCHEMA} TOOL_STRING_LIST_SCHEMA: Json = {"type": "array", "items": {"type": "string"}} +TOOL_PLAN_FOLLOWUP_STATUS_SCHEMA: Json = { + "type": ["string", "null"], + "enum": [*ALL_PLAN_FOLLOWUP_STATUSES], +} TOOL_PLAN_ITEMS_SCHEMA: Json = { "type": "array", "items": _tool_object_schema( @@ -3122,6 +3143,8 @@ def _canonical_tool_name(name: str | None) -> str: "text": TOOL_NULLABLE_STRING_SCHEMA, "status": {"type": ["string", "null"], "enum": [*ALL_PLAN_STATUSES]}, "context": TOOL_NULLABLE_STRING_SCHEMA, + "followup_action": {**TOOL_PLAN_FOLLOWUP_STATUS_SCHEMA, "description": "Required non-check work caused by this step: unknown, none, needed, done, or blocked."}, + "followup_check": {**TOOL_PLAN_FOLLOWUP_STATUS_SCHEMA, "description": "Required checking caused by this step: unknown, none, needed, done, or blocked."}, }, [], ), @@ -3223,12 +3246,7 @@ def _state_tool_schema(name: str) -> Json: Workflow: - Chat: answer directly; do not create task state. - One-shot: use only needed tools, then answer and stop; do not create task state just to report. -- Tracked task: - - set Goal. - - keep the shortest correct Plan. - - act on the current step. - - record Checks after edits or requested checks. - - finish with goal.complete=true. +- Tracked task: for edits/debugging/checks/multi-step work, set Goal, keep the shortest necessary correct Plan, act on the current step, record Checks after edits or requested checks, finish with goal.complete=true. Current step: - Choose the smallest useful action from latest request, feedback, visible results, and Plan. @@ -3236,16 +3254,7 @@ def _state_tool_schema(name: str) -> Json: - Do not stop at state-only updates when a useful tool call is clear. State: -- Goal/Plan track work. -- Plan is serious. -- Plan is the shortest correct path to Goal. -- Plan includes required consistency steps caused by edits: - - sync lock/env state. - - regenerate derived files. - - update generated code. - - validate affected behavior. -- Skip a caused step only when not needed. Put why in Plan context. -- Update Plan only when Facts change the path. +- Goal/Plan track work. Plan is the minimal correct path to Goal, not a loose TODO list; update it when Facts change the path. - Facts are confirmed. Leads are for investigations. Checks are checks. User Rules are future-behavior requests. - Save only what matters after results disappear; cite tr.N when result-backed; forget raw results when no longer needed. @@ -4467,6 +4476,8 @@ def _format_state_report( def render_plan_row(index: int, item: PlanItem) -> list[str]: rows = [" " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text)] rows += [" context: " + self._compact(item.context)] if item.context else [] + rows += [" followup_action: " + str(item.followup_action)] if item.followup_action != PlanFollowupStatus.UNKNOWN else [] + rows += [" followup_check: " + str(item.followup_check)] if item.followup_check != PlanFollowupStatus.UNKNOWN else [] return rows self._append_state_section(lines, " Plan", self._format_rows(current.plan, render_plan_row)) @@ -4605,9 +4616,11 @@ def _apply_plan_patches(self, plan: list[PlanItem], value: JsonValue) -> bool: text = _json_str(patch.get("text")) if "text" in patch else None status = _json_str(patch.get("status")) if "status" in patch else None context = _json_str(patch.get("context")) if "context" in patch else existing.context - updated = (text or existing.text, PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, context or "") - changed = changed or (existing.text, existing.status, existing.context) != updated - existing.text, existing.status, existing.context = updated + followup_action = self._plan_followup_status(patch.get("followup_action"), existing.followup_action) if "followup_action" in patch else existing.followup_action + followup_check = self._plan_followup_status(patch.get("followup_check"), existing.followup_check) if "followup_check" in patch else existing.followup_check + updated = (text or existing.text, PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, context or "", followup_action, followup_check) + changed = changed or (existing.text, existing.status, existing.context, existing.followup_action, existing.followup_check) != updated + existing.text, existing.status, existing.context, existing.followup_action, existing.followup_check = updated continue plan_item = self._plan_item_from_json(patch) if plan_item is None: @@ -4632,8 +4645,15 @@ def _plan_item_from_json(self, value: JsonValue) -> PlanItem | None: status=PlanStatus(status), id=_json_str(item.get("id")) or "", context=_json_str(item.get("context")) or "", + followup_action=self._plan_followup_status(item.get("followup_action")), + followup_check=self._plan_followup_status(item.get("followup_check")), ) + @staticmethod + def _plan_followup_status(value: JsonValue, default: PlanFollowupStatus = PlanFollowupStatus.UNKNOWN) -> PlanFollowupStatus: + status = _json_str(value) + return PlanFollowupStatus(status) if status in ALL_PLAN_FOLLOWUP_STATUSES else default + @staticmethod def _normalize_doing_items(plan: list[PlanItem]) -> None: seen = False @@ -4862,6 +4882,7 @@ class Agent: RULE_TOOL_SIGNATURE: ClassVar[str] = "use the tool signature exactly." RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile(filepath, edits) with visible line anchors; split oversized batches." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." + RULE_PLAN_FOLLOWUP: ClassVar[str] = "set followup_action and followup_check to none, done, or blocked before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked Checks only when blocker=user." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." RULE_VALID_TOOL_JSON: ClassVar[str] = "rebuild valid function arguments; for EditFile, use one file/logical block and split oversized batches." @@ -5127,6 +5148,7 @@ def _finish_current_goal(self) -> None: self.blackboard.task_code = TaskCode.DONE self.blackboard.goal_reached = False self.blackboard.checks_required = False + self.recent_edits = [] def _format_act_tool_result_context(self) -> tuple[str, str, str]: checkpoint = self.blackboard.memory_checkpoint_tool_result_counter @@ -5578,6 +5600,18 @@ def _completion_plan_error(self, ctx: ResponseContext) -> str: return "plan items missing context: " + self._format_plan_gate_items(missing_context) return "" + def _completion_plan_followup_error(self) -> str: + if not self.blackboard.goal_reached or not self.recent_edits: + return "" + completed = [item for item in self.blackboard.plan if item.status in self.COMPLETED_PLAN_STATUSES] + missing = [item for item in completed if item.followup_action == PlanFollowupStatus.UNKNOWN or item.followup_check == PlanFollowupStatus.UNKNOWN] + if missing: + return "plan follow-up status missing: " + self._format_plan_gate_items(missing) + needed = [item for item in completed if item.followup_action == PlanFollowupStatus.NEEDED or item.followup_check == PlanFollowupStatus.NEEDED] + if needed: + return "plan follow-up still needed: " + self._format_plan_gate_items(needed) + return "" + def _format_plan_gate_items(self, items: list[PlanItem]) -> str: rendered = [] for item in items[:3]: @@ -6005,6 +6039,16 @@ def _gate_completion(self, ctx: ResponseContext, on_message: MessageCallback | N "Retrying: finish the plan before completing.", "Completion_Gate: " + completion_plan_error + ".", ) + completion_followup_error = self._completion_plan_followup_error() + if completion_followup_error: + self.blackboard.goal_reached = False + return self._reject_result( + self._remember_agent_error, + on_message, + self._error("completion before Plan follow-up was resolved: " + completion_followup_error + ".", self.RULE_PLAN_FOLLOWUP), + "Retrying: resolve Plan follow-up before completing.", + "Completion_Gate: " + completion_followup_error + ".", + ) if self.blackboard.goal_reached and self.blackboard.checks.status == CheckStatus.BLOCKED and self.blackboard.checks.blocker != CheckBlocker.USER: self._warn_agent("blocked Checks completion invalid: verify blocked requires blocker=user before completion.", self.RULE_BLOCKED_BY_USER) if self.blackboard.goal_reached and self.blackboard.leads and not any(item.status == LeadStatus.CONFIRMED for item in self.blackboard.leads): diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 2b6abb6..41d3062 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2321,6 +2321,106 @@ def test_agent_applies_partial_plan_patch(tmp_path): ] +def test_agent_plan_items_track_followup_statuses(tmp_path): + agent = Agent(Session(cwd=str(tmp_path))) + + agent.apply_response( + { + "actions": [ + { + "type": "plan", + "items": [ + { + "id": "p1", + "text": "Update dependency declaration", + "status": "done", + "context": "pyproject updated", + "followup_action": "needed", + "followup_check": "done", + } + ], + } + ] + } + ) + + assert agent.blackboard.plan == [ + nanocode.PlanItem( + id="p1", + text="Update dependency declaration", + status=nanocode.PlanStatus.DONE, + context="pyproject updated", + followup_action=nanocode.PlanFollowupStatus.NEEDED, + followup_check=nanocode.PlanFollowupStatus.DONE, + ) + ] + assert "followup_action: needed" in agent.build_user_prompt() + assert "followup_check: done" in agent.build_user_prompt() + assert "followup_action: needed" in agent.state_updater.latest_report + assert "followup_check: done" in agent.state_updater.latest_report + + +def test_agent_completion_after_edit_requires_plan_followup_status(tmp_path): + agent = Agent(_session(tmp_path, debug=True)) + agent.blackboard.goal = "change sample" + agent.blackboard.goal_reached = True + agent.blackboard.plan = [nanocode.PlanItem(id="p1", text="edit sample", status=nanocode.PlanStatus.DONE, context="edited")] + agent.recent_edits = ["- sample.txt: edit sample"] + ctx = agent._build_response_context({"actions": [{"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}]}) + + result = agent._finish_or_continue(ctx, None) + + assert result.done is False + assert any("plan follow-up status missing" in error for error in agent.agent_feedback_errors) + + +def test_agent_completion_after_edit_blocks_needed_plan_followup(tmp_path): + agent = Agent(_session(tmp_path, debug=True)) + agent.blackboard.goal = "change sample" + agent.blackboard.goal_reached = True + agent.blackboard.plan = [ + nanocode.PlanItem( + id="p1", + text="edit sample", + status=nanocode.PlanStatus.DONE, + context="edited", + followup_action=nanocode.PlanFollowupStatus.NEEDED, + followup_check=nanocode.PlanFollowupStatus.DONE, + ) + ] + agent.recent_edits = ["- sample.txt: edit sample"] + ctx = agent._build_response_context({"actions": [{"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}]}) + + result = agent._finish_or_continue(ctx, None) + + assert result.done is False + assert any("plan follow-up still needed" in error for error in agent.agent_feedback_errors) + + +def test_agent_completion_after_edit_allows_resolved_plan_followup(tmp_path): + agent = Agent(_session(tmp_path, debug=True)) + agent.blackboard.goal = "change sample" + agent.blackboard.goal_reached = True + agent.blackboard.plan = [ + nanocode.PlanItem( + id="p1", + text="edit sample", + status=nanocode.PlanStatus.DONE, + context="edited", + followup_action=nanocode.PlanFollowupStatus.NONE, + followup_check=nanocode.PlanFollowupStatus.DONE, + ) + ] + agent.recent_edits = ["- sample.txt: edit sample"] + ctx = agent._build_response_context({"actions": [{"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}]}) + messages = [] + + result = agent._finish_or_continue(ctx, messages.append) + + assert result.done is True + assert messages == ["done"] + + def test_agent_applies_goal_and_plan_actions(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) @@ -2999,6 +3099,23 @@ def __init__(self): }, {"actions": [{"type": "keep", "source": ["tr.1"], "reason": "keep useful result"}]}, {"actions": [{"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}]}, + { + "actions": [ + { + "type": "plan", + "items": [ + { + "text": "test plan", + "status": "done", + "context": "seeded", + "followup_action": "none", + "followup_check": "done", + } + ], + }, + {"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}, + ] + }, ] def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): From 82a223ca9b1bd289663c1c869a632bd4216e331d Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 02:42:11 -0700 Subject: [PATCH 127/144] Require reasons for plan follow-up status --- nanocode.py | 88 ++++++++++++++++++++++++++++-------- tests/test_nanocode_agent.py | 51 +++++++++++++++------ 2 files changed, 105 insertions(+), 34 deletions(-) diff --git a/nanocode.py b/nanocode.py index db27a98..782d878 100644 --- a/nanocode.py +++ b/nanocode.py @@ -154,6 +154,16 @@ class PlanFollowupStatus(StrEnum): ALL_PLAN_FOLLOWUP_STATUSES = frozenset(PlanFollowupStatus) +@dataclass +class PlanFollowup: + status: PlanFollowupStatus = PlanFollowupStatus.UNKNOWN + reason: str = "" + + def format(self) -> str: + text = str(self.status) + return text + (": " + self.reason if self.reason else "") + + class TaskCode(StrEnum): NEW = "new" WORKING = "working" @@ -177,8 +187,8 @@ class PlanItem: status: PlanStatus = PlanStatus.TODO id: str = "" context: str = "" - followup_action: PlanFollowupStatus = PlanFollowupStatus.UNKNOWN - followup_check: PlanFollowupStatus = PlanFollowupStatus.UNKNOWN + followup_action: PlanFollowup = field(default_factory=PlanFollowup) + followup_check: PlanFollowup = field(default_factory=PlanFollowup) def format(self, indent: str = "") -> str: text = "- [" + str(self.status) + "] " + self.text @@ -187,10 +197,10 @@ def format(self, indent: str = "") -> str: lines = [text] if self.context: lines.append(" context: " + self.context) - if self.followup_action != PlanFollowupStatus.UNKNOWN: - lines.append(" followup_action: " + str(self.followup_action)) - if self.followup_check != PlanFollowupStatus.UNKNOWN: - lines.append(" followup_check: " + str(self.followup_check)) + if self.followup_action.status != PlanFollowupStatus.UNKNOWN: + lines.append(" followup_action: " + self.followup_action.format()) + if self.followup_check.status != PlanFollowupStatus.UNKNOWN: + lines.append(" followup_check: " + self.followup_check.format()) return _format_lines(lines, indent) @@ -405,6 +415,8 @@ def referenced_result_keys(self) -> set[str]: *[item.context for item in self.leads], *[item.text for item in self.plan], *[item.context for item in self.plan], + *[item.followup_action.reason for item in self.plan], + *[item.followup_check.reason for item in self.plan], self.checks.method, self.checks.context, self.checks.blocker, @@ -3134,6 +3146,16 @@ def _canonical_tool_name(name: str | None) -> str: "type": ["string", "null"], "enum": [*ALL_PLAN_FOLLOWUP_STATUSES], } +TOOL_PLAN_FOLLOWUP_SCHEMA: Json = _tool_object_schema( + { + "status": TOOL_PLAN_FOLLOWUP_STATUS_SCHEMA, + "reason": { + **TOOL_NULLABLE_STRING_SCHEMA, + "description": "Short reason or evidence for this status. Required when status is not unknown.", + }, + }, + [], +) TOOL_PLAN_ITEMS_SCHEMA: Json = { "type": "array", "items": _tool_object_schema( @@ -3143,8 +3165,14 @@ def _canonical_tool_name(name: str | None) -> str: "text": TOOL_NULLABLE_STRING_SCHEMA, "status": {"type": ["string", "null"], "enum": [*ALL_PLAN_STATUSES]}, "context": TOOL_NULLABLE_STRING_SCHEMA, - "followup_action": {**TOOL_PLAN_FOLLOWUP_STATUS_SCHEMA, "description": "Required non-check work caused by this step: unknown, none, needed, done, or blocked."}, - "followup_check": {**TOOL_PLAN_FOLLOWUP_STATUS_SCHEMA, "description": "Required checking caused by this step: unknown, none, needed, done, or blocked."}, + "followup_action": { + **TOOL_PLAN_FOLLOWUP_SCHEMA, + "description": "Follow-on non-check work caused by this step. Use needed until the action is added/done, none only with reason.", + }, + "followup_check": { + **TOOL_PLAN_FOLLOWUP_SCHEMA, + "description": "Follow-on validation caused by this step. Use needed until checked, done with evidence, none only with reason.", + }, }, [], ), @@ -4476,8 +4504,8 @@ def _format_state_report( def render_plan_row(index: int, item: PlanItem) -> list[str]: rows = [" " + str(index) + ". [" + str(item.status) + "] " + self._compact(item.text)] rows += [" context: " + self._compact(item.context)] if item.context else [] - rows += [" followup_action: " + str(item.followup_action)] if item.followup_action != PlanFollowupStatus.UNKNOWN else [] - rows += [" followup_check: " + str(item.followup_check)] if item.followup_check != PlanFollowupStatus.UNKNOWN else [] + rows += [" followup_action: " + item.followup_action.format()] if item.followup_action.status != PlanFollowupStatus.UNKNOWN else [] + rows += [" followup_check: " + item.followup_check.format()] if item.followup_check.status != PlanFollowupStatus.UNKNOWN else [] return rows self._append_state_section(lines, " Plan", self._format_rows(current.plan, render_plan_row)) @@ -4616,8 +4644,8 @@ def _apply_plan_patches(self, plan: list[PlanItem], value: JsonValue) -> bool: text = _json_str(patch.get("text")) if "text" in patch else None status = _json_str(patch.get("status")) if "status" in patch else None context = _json_str(patch.get("context")) if "context" in patch else existing.context - followup_action = self._plan_followup_status(patch.get("followup_action"), existing.followup_action) if "followup_action" in patch else existing.followup_action - followup_check = self._plan_followup_status(patch.get("followup_check"), existing.followup_check) if "followup_check" in patch else existing.followup_check + followup_action = self._plan_followup(patch.get("followup_action"), existing.followup_action) if "followup_action" in patch else existing.followup_action + followup_check = self._plan_followup(patch.get("followup_check"), existing.followup_check) if "followup_check" in patch else existing.followup_check updated = (text or existing.text, PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, context or "", followup_action, followup_check) changed = changed or (existing.text, existing.status, existing.context, existing.followup_action, existing.followup_check) != updated existing.text, existing.status, existing.context, existing.followup_action, existing.followup_check = updated @@ -4645,14 +4673,23 @@ def _plan_item_from_json(self, value: JsonValue) -> PlanItem | None: status=PlanStatus(status), id=_json_str(item.get("id")) or "", context=_json_str(item.get("context")) or "", - followup_action=self._plan_followup_status(item.get("followup_action")), - followup_check=self._plan_followup_status(item.get("followup_check")), + followup_action=self._plan_followup(item.get("followup_action")), + followup_check=self._plan_followup(item.get("followup_check")), ) @staticmethod - def _plan_followup_status(value: JsonValue, default: PlanFollowupStatus = PlanFollowupStatus.UNKNOWN) -> PlanFollowupStatus: - status = _json_str(value) - return PlanFollowupStatus(status) if status in ALL_PLAN_FOLLOWUP_STATUSES else default + def _plan_followup(value: JsonValue, default: PlanFollowup | None = None) -> PlanFollowup: + fallback = default or PlanFollowup() + item = _json_dict(value) + if not item: + return fallback + raw_status = _json_str(item.get("status")) + status = PlanFollowupStatus(raw_status) if raw_status in ALL_PLAN_FOLLOWUP_STATUSES else fallback.status + reason_value = _json_str(item.get("reason")) if "reason" in item else fallback.reason + reason = _shorten(" ".join((reason_value or "").split()), 240) + if status != fallback.status and "reason" not in item: + reason = "" + return PlanFollowup(status=status, reason=reason) @staticmethod def _normalize_doing_items(plan: list[PlanItem]) -> None: @@ -4882,7 +4919,7 @@ class Agent: RULE_TOOL_SIGNATURE: ClassVar[str] = "use the tool signature exactly." RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile(filepath, edits) with visible line anchors; split oversized batches." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." - RULE_PLAN_FOLLOWUP: ClassVar[str] = "set followup_action and followup_check to none, done, or blocked before completion." + RULE_PLAN_FOLLOWUP: ClassVar[str] = "set followup_action and followup_check as {status, reason}; resolve needed before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked Checks only when blocker=user." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." RULE_VALID_TOOL_JSON: ClassVar[str] = "rebuild valid function arguments; for EditFile, use one file/logical block and split oversized batches." @@ -5604,10 +5641,21 @@ def _completion_plan_followup_error(self) -> str: if not self.blackboard.goal_reached or not self.recent_edits: return "" completed = [item for item in self.blackboard.plan if item.status in self.COMPLETED_PLAN_STATUSES] - missing = [item for item in completed if item.followup_action == PlanFollowupStatus.UNKNOWN or item.followup_check == PlanFollowupStatus.UNKNOWN] + missing = [ + item + for item in completed + if item.followup_action.status == PlanFollowupStatus.UNKNOWN or item.followup_check.status == PlanFollowupStatus.UNKNOWN + ] if missing: return "plan follow-up status missing: " + self._format_plan_gate_items(missing) - needed = [item for item in completed if item.followup_action == PlanFollowupStatus.NEEDED or item.followup_check == PlanFollowupStatus.NEEDED] + missing_reason = [item for item in completed if not item.followup_action.reason.strip() or not item.followup_check.reason.strip()] + if missing_reason: + return "plan follow-up reason missing: " + self._format_plan_gate_items(missing_reason) + needed = [ + item + for item in completed + if item.followup_action.status == PlanFollowupStatus.NEEDED or item.followup_check.status == PlanFollowupStatus.NEEDED + ] if needed: return "plan follow-up still needed: " + self._format_plan_gate_items(needed) return "" diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 41d3062..5a2174a 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -2335,8 +2335,8 @@ def test_agent_plan_items_track_followup_statuses(tmp_path): "text": "Update dependency declaration", "status": "done", "context": "pyproject updated", - "followup_action": "needed", - "followup_check": "done", + "followup_action": {"status": "needed", "reason": "dependency change may require sync"}, + "followup_check": {"status": "done", "reason": "tests passed after edit"}, } ], } @@ -2350,14 +2350,14 @@ def test_agent_plan_items_track_followup_statuses(tmp_path): text="Update dependency declaration", status=nanocode.PlanStatus.DONE, context="pyproject updated", - followup_action=nanocode.PlanFollowupStatus.NEEDED, - followup_check=nanocode.PlanFollowupStatus.DONE, + followup_action=nanocode.PlanFollowup(nanocode.PlanFollowupStatus.NEEDED, "dependency change may require sync"), + followup_check=nanocode.PlanFollowup(nanocode.PlanFollowupStatus.DONE, "tests passed after edit"), ) ] - assert "followup_action: needed" in agent.build_user_prompt() - assert "followup_check: done" in agent.build_user_prompt() - assert "followup_action: needed" in agent.state_updater.latest_report - assert "followup_check: done" in agent.state_updater.latest_report + assert "followup_action: needed: dependency change may require sync" in agent.build_user_prompt() + assert "followup_check: done: tests passed after edit" in agent.build_user_prompt() + assert "followup_action: needed: dependency change may require sync" in agent.state_updater.latest_report + assert "followup_check: done: tests passed after edit" in agent.state_updater.latest_report def test_agent_completion_after_edit_requires_plan_followup_status(tmp_path): @@ -2384,8 +2384,8 @@ def test_agent_completion_after_edit_blocks_needed_plan_followup(tmp_path): text="edit sample", status=nanocode.PlanStatus.DONE, context="edited", - followup_action=nanocode.PlanFollowupStatus.NEEDED, - followup_check=nanocode.PlanFollowupStatus.DONE, + followup_action=nanocode.PlanFollowup(nanocode.PlanFollowupStatus.NEEDED, "edit requires another file update"), + followup_check=nanocode.PlanFollowup(nanocode.PlanFollowupStatus.DONE, "unit test passed"), ) ] agent.recent_edits = ["- sample.txt: edit sample"] @@ -2397,6 +2397,29 @@ def test_agent_completion_after_edit_blocks_needed_plan_followup(tmp_path): assert any("plan follow-up still needed" in error for error in agent.agent_feedback_errors) +def test_agent_completion_after_edit_requires_plan_followup_reason(tmp_path): + agent = Agent(_session(tmp_path, debug=True)) + agent.blackboard.goal = "change sample" + agent.blackboard.goal_reached = True + agent.blackboard.plan = [ + nanocode.PlanItem( + id="p1", + text="edit sample", + status=nanocode.PlanStatus.DONE, + context="edited", + followup_action=nanocode.PlanFollowup(nanocode.PlanFollowupStatus.NONE), + followup_check=nanocode.PlanFollowup(nanocode.PlanFollowupStatus.DONE), + ) + ] + agent.recent_edits = ["- sample.txt: edit sample"] + ctx = agent._build_response_context({"actions": [{"type": "goal", "text": "change sample", "complete": True, "message_for_complete": "done"}]}) + + result = agent._finish_or_continue(ctx, None) + + assert result.done is False + assert any("plan follow-up reason missing" in error for error in agent.agent_feedback_errors) + + def test_agent_completion_after_edit_allows_resolved_plan_followup(tmp_path): agent = Agent(_session(tmp_path, debug=True)) agent.blackboard.goal = "change sample" @@ -2407,8 +2430,8 @@ def test_agent_completion_after_edit_allows_resolved_plan_followup(tmp_path): text="edit sample", status=nanocode.PlanStatus.DONE, context="edited", - followup_action=nanocode.PlanFollowupStatus.NONE, - followup_check=nanocode.PlanFollowupStatus.DONE, + followup_action=nanocode.PlanFollowup(nanocode.PlanFollowupStatus.NONE, "edit has no generated follow-up"), + followup_check=nanocode.PlanFollowup(nanocode.PlanFollowupStatus.DONE, "smoke test passed"), ) ] agent.recent_edits = ["- sample.txt: edit sample"] @@ -3108,8 +3131,8 @@ def __init__(self): "text": "test plan", "status": "done", "context": "seeded", - "followup_action": "none", - "followup_check": "done", + "followup_action": {"status": "none", "reason": "seeded plan has no follow-up action"}, + "followup_check": {"status": "done", "reason": "seeded plan check complete"}, } ], }, From c73e432bb817085260e7ff19c16d27e35ddac67f Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 02:45:00 -0700 Subject: [PATCH 128/144] Upgrade codex-symbol-index dependency from >=0.1.8 to >=0.1.13 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 3da2b67..3cce75b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,7 +27,7 @@ classifiers = [ "Topic :: Terminals", ] dependencies = [ - "code-symbol-index>=0.1.8", + "code-symbol-index>=0.1.13", "openai>=2.37.0", "prompt-toolkit>=3.0", "socksio>=1.0.0", From 3d502cd71213dd1acf319cfa89384023267f2d80 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 02:49:32 -0700 Subject: [PATCH 129/144] Clarify available shell commands in prompt --- nanocode.py | 9 ++++++--- tests/test_nanocode_agent.py | 7 ++++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/nanocode.py b/nanocode.py index 782d878..37b8fa8 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3278,7 +3278,10 @@ def _state_tool_schema(name: str) -> Json: Current step: - Choose the smallest useful action from latest request, feedback, visible results, and Plan. -- Batch independent actions; serialize dependent actions; ask only when blocked. +- Batch clear tool calls in one response. +- Tool calls run in order. If one fails, later tool calls are skipped. +- Use ordered tools for edit-then-check when the check is clear. +- Ask only when blocked. - Do not stop at state-only updates when a useful tool call is clear. State: @@ -5009,9 +5012,9 @@ def _format_environment(self) -> str: "- arch: " + self.session.arch, "- cwd: " + self.session.cwd, ] - shell_tools = [name for name in ("find", "rg", "perl", "sed", "awk", "xargs", "grep", "jq") if shutil.which(name)] + shell_tools = [name for name in ("find", "rg", "python3", "perl", "sed", "awk", "xargs", "grep", "jq") if shutil.which(name)] if shell_tools: - lines.append("- shell_tools: " + ", ".join(shell_tools)) + lines.append("- detected-available-shell-commands: " + ", ".join(shell_tools)) if _code_index_available(self.session): lines.append( "- inspect_code_hint: Use InspectCode for structural code navigation: mode=find for symbol candidates, mode=inspect for anchored symbol source, mode=outline for file outlines. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 5a2174a..063fb26 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -648,13 +648,14 @@ def test_edit_tool_without_goal_or_plan_warns(tmp_path): def test_act_prompt_lists_available_shell_tools_in_environment(tmp_path, monkeypatch): - monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/bin/" + name if name in {"rg", "jq"} else None) + monkeypatch.setattr(nanocode.shutil, "which", lambda name: "/bin/" + name if name in {"rg", "python3", "jq"} else None) agent = Agent(Session(cwd=str(tmp_path))) prompt = agent.build_user_prompt() - assert "- shell_tools: rg, jq" in prompt - assert "- shell_tools: find" not in prompt + assert "- detected-available-shell-commands: rg, python3, jq" in prompt + assert "- detected-available-shell-commands: find" not in prompt + assert "- shell_tools:" not in prompt def test_act_prompt_includes_kept_tool_results(tmp_path): From c89e10df5710d5c85f40f85c2263d56a90f6f030 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 02:52:37 -0700 Subject: [PATCH 130/144] Show indexed language breakdown in prompt --- nanocode.py | 31 +++++++++++++++++++++++++++++++ tests/test_nanocode_agent.py | 22 ++++++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/nanocode.py b/nanocode.py index 37b8fa8..13f8e1c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2294,6 +2294,34 @@ def _code_index_status(session: Session, *, check: bool = False) -> tuple[str, s return str(getattr(status, "status", "error")), message +def _code_index_language_breakdown(session: Session) -> str: + module = _code_index_module() + if module is None: + return "" + try: + status = module.status(session.cwd, db_path=_code_index_db_path(session), check=False, max_pending_files=0, format="object") + except Exception: + return "" + if str(getattr(status, "status", "error")) not in {"ready", "stale"}: + return "" + rows = [] + for item in getattr(status, "language_breakdown", ()) or (): + language = item.get("language") if isinstance(item, dict) else getattr(item, "language", None) + files = item.get("files") if isinstance(item, dict) else getattr(item, "files", None) + percent = item.get("percent") if isinstance(item, dict) else getattr(item, "percent", None) + if language and files is not None and percent is not None: + try: + rows.append(f"{language} {files} files ({float(percent):.1f}%)") + except (TypeError, ValueError): + rows.append(f"{language} {files} files") + if rows: + return ", ".join(rows) + languages = getattr(status, "languages", ()) or () + if isinstance(languages, str): + languages = (languages,) + return ", ".join(str(language) for language in languages if language) + + def _code_index_available(session: Session) -> bool: status, message = _code_index_status(session) session.state.code_index_error = message if status == "error" else "" @@ -5016,6 +5044,9 @@ def _format_environment(self) -> str: if shell_tools: lines.append("- detected-available-shell-commands: " + ", ".join(shell_tools)) if _code_index_available(self.session): + language_breakdown = _code_index_language_breakdown(self.session) + if language_breakdown: + lines.append("- indexed-language-breakdown: " + language_breakdown) lines.append( "- inspect_code_hint: Use InspectCode for structural code navigation: mode=find for symbol candidates, mode=inspect for anchored symbol source, mode=outline for file outlines. Do not pass natural language. Use Search/Read for text, config, logs, commands, and exact ranges." ) diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 063fb26..1e7c162 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1,6 +1,7 @@ import os import re from dataclasses import replace +from types import SimpleNamespace import nanocode from nanocode import Agent, LLMError, ParsedToolCall, Session, CheckStatus @@ -658,6 +659,27 @@ def test_act_prompt_lists_available_shell_tools_in_environment(tmp_path, monkeyp assert "- shell_tools:" not in prompt +def test_act_prompt_lists_indexed_language_breakdown_in_environment(tmp_path, monkeypatch): + def status_fn(root, *, db_path=None, check=False, max_pending_files=50, format="object"): + return SimpleNamespace( + status="ready", + reason="", + message="", + languages=("python", "typescript"), + language_breakdown=( + {"language": "python", "files": 80, "percent": 62.5}, + {"language": "typescript", "files": 48, "percent": 37.5}, + ), + ) + + monkeypatch.setattr(nanocode, "_code_index_module", lambda: SimpleNamespace(status=status_fn)) + agent = Agent(Session(cwd=str(tmp_path))) + + prompt = agent.build_user_prompt() + + assert "- indexed-language-breakdown: python 80 files (62.5%), typescript 48 files (37.5%)" in prompt + + def test_act_prompt_includes_kept_tool_results(tmp_path): (tmp_path / "sample.txt").write_text("alpha unique\n", encoding="utf-8") (tmp_path / "other.txt").write_text("beta unique\n", encoding="utf-8") From 3690a48beea07d0a29f80527e2db20f973192aba Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 02:56:42 -0700 Subject: [PATCH 131/144] Support reading multiple files with Read --- nanocode.py | 41 +++++++++++++++++++++++++++----- tests/test_nanocode_read_tool.py | 18 ++++++++++++++ 2 files changed, 53 insertions(+), 6 deletions(-) diff --git a/nanocode.py b/nanocode.py index 13f8e1c..7c6e081 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1626,21 +1626,28 @@ def _parse_line_range_token(value: str) -> tuple[int, int]: return _parse_line_range(match.group(1), match.group(2)) +def _looks_like_read_range_error(value: JsonValue) -> bool: + text = str(value).strip() + return bool(re.fullmatch(r"\d+(?:\s*[-:,]\s*)?", text) or re.search(r"[:,]", text)) + + @dataclass class ReadTool(Tool): NAME: ClassVar[str] = "Read" MAX_LINES: ClassVar[int] = 600 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Read a single known UTF-8 file; pass multiple 0-based start,end ranges for it.", + "Read known UTF-8 files, or pass multiple 0-based start,end ranges for one file.", "Each range returns at most 600 lines.", 'Content is numbered as "line:hash|code"; the "line:hash" part is the line anchor.', ) SIGNATURES: ClassVar[tuple[str, ...]] = ( "Read(filepath) -> first 600 lines with line:hash anchors", + "Read(filepath[, filepath...]) -> first 600 lines from each file", "Read(filepath, 'start,end'[, 'start,end'...]) -> selected 0-based ranges with line:hash anchors", ) EXAMPLE: ClassVar[tuple[str, ...]] = ( + 'Example args: ["pyproject.toml", "uv.lock"]', 'Example args: ["code.py", "0,80", "160,220"]', 'Example args: ["code.py"]', ) @@ -1649,6 +1656,7 @@ class ReadTool(Tool): start: int = 0 end: int = 0 ranges: list[tuple[int, int]] = field(default_factory=list) + filepaths: list[str] = field(default_factory=list) cwd: str = "" @classmethod @@ -1669,23 +1677,44 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: ranges = [(0, 0)] elif all(re.fullmatch(r"\s*\d+\s*[-:,]\s*\d+\s*", str(arg)) for arg in args[1:]): ranges = [_parse_line_range_token(str(arg)) for arg in args[1:]] + elif not any(_looks_like_read_range_error(arg) for arg in args[1:]): + filepaths = [session.resolve_path(str(arg)) for arg in args] + return cls(filepath=filepaths[0], start=0, end=0, ranges=[(0, 0)], filepaths=filepaths, cwd=session.cwd) elif len(args) == 2: - raise ToolCallArgError('Read args error: invalid range token; expected ["filepath", "start,end"]. Example: Read("nanocode.py", "2065,2095").') + raise ToolCallArgError( + 'Read args error: invalid range token; expected ["filepath", "start,end"] or ["file1", "file2"]. Example: Read("nanocode.py", "2065,2095").' + ) else: raise ToolCallArgError('Read args error: for multiple ranges use comma tokens. Example: Read("nanocode.py", "0,40", "200,260").') start, end = ranges[0] - return cls(filepath=filepath, start=start, end=end, ranges=ranges, cwd=session.cwd) + return cls(filepath=filepath, start=start, end=end, ranges=ranges, filepaths=[filepath], cwd=session.cwd) def requires_confirmation(self, session: Session) -> bool: - return not session.is_path_in_cwd(self.filepath) + return any(not session.is_path_in_cwd(filepath) for filepath in (self.filepaths or [self.filepath])) def preview(self) -> str: + if len(self.filepaths) > 1: + return "Read(" + ", ".join(self.filepaths) + ")" if len(self.ranges) > 1: ranges = ", ".join(str(start) + ":" + str(end) for start, end in self.ranges) return f"Read({self.filepath}, {ranges})" return f"Read({self.filepath}, {self.start}, {self.end})" def call(self) -> str: + if len(self.filepaths) > 1: + lines = [ + "", + ' Content lines are "line:hash|code"; the "line:hash" part is the line anchor.', + " " + str(len(self.filepaths)) + "", + ] + for filepath in self.filepaths: + content, returned_end, range_end, truncated, total_lines = self._read_range(0, 0, filepath=filepath) + lines.extend([" ", " " + os.path.relpath(filepath, self.cwd) + ""]) + lines.extend(self._format_range_result(0, returned_end, range_end, truncated, total_lines, content, indent=" ")) + lines.append(" ") + lines.append("") + return "\n".join(lines) + if len(self.ranges) > 1: lines = [ "", @@ -1706,8 +1735,8 @@ def call(self) -> str: lines.append("") return "\n".join(lines) - def _read_range(self, start: int, end: int) -> tuple[str, int, int, bool, int]: - target_filepath = self.filepath + def _read_range(self, start: int, end: int, *, filepath: str | None = None) -> tuple[str, int, int, bool, int]: + target_filepath = filepath or self.filepath total_lines = 0 selected_lines = [] truncated = False diff --git a/tests/test_nanocode_read_tool.py b/tests/test_nanocode_read_tool.py index fa11037..ee13a81 100644 --- a/tests/test_nanocode_read_tool.py +++ b/tests/test_nanocode_read_tool.py @@ -59,6 +59,24 @@ def test_read_tool_reads_multiple_line_range_tokens(tmp_path): assert "|two" not in result +def test_read_tool_reads_multiple_files(tmp_path): + (tmp_path / "pyproject.toml").write_text("[project]\nname = \"demo\"\n", encoding="utf-8") + (tmp_path / "uv.lock").write_text("version = 1\n", encoding="utf-8") + session = Session(cwd=str(tmp_path)) + + tool = ReadTool.make(session, ["pyproject.toml", "uv.lock"]) + result = tool.call() + + assert tool.filepaths == [str(tmp_path / "pyproject.toml"), str(tmp_path / "uv.lock")] + assert tool.requires_confirmation(session) is False + assert "pyproject.toml, " in tool.preview() + assert "2" in result + assert "pyproject.toml" in result + assert "uv.lock" in result + assert _hashline(0, "[project]\n") in result + assert _hashline(0, "version = 1\n") in result + + def test_read_tool_reads_colon_and_comma_range_tokens(tmp_path): path = tmp_path / "sample.txt" path.write_text("zero\none\ntwo\nthree\nfour\n", encoding="utf-8") From c8c192d52f23d2cf37caa27dab3afd7192fa69a5 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 03:00:38 -0700 Subject: [PATCH 132/144] Simplify tool descriptions for LLM use --- nanocode.py | 118 ++++++++++++++++++++++++---------------------------- 1 file changed, 54 insertions(+), 64 deletions(-) diff --git a/nanocode.py b/nanocode.py index 7c6e081..d925629 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1637,14 +1637,14 @@ class ReadTool(Tool): MAX_LINES: ClassVar[int] = 600 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Read known UTF-8 files, or pass multiple 0-based start,end ranges for one file.", - "Each range returns at most 600 lines.", - 'Content is numbered as "line:hash|code"; the "line:hash" part is the line anchor.', + "Read one or more UTF-8 files with line:hash anchors.", + "Multiple files: pass filepaths only; each file returns first 600 lines.", + "Ranges: pass one filepath then 0-based start,end tokens; each range returns at most 600 lines.", ) SIGNATURES: ClassVar[tuple[str, ...]] = ( "Read(filepath) -> first 600 lines with line:hash anchors", - "Read(filepath[, filepath...]) -> first 600 lines from each file", - "Read(filepath, 'start,end'[, 'start,end'...]) -> selected 0-based ranges with line:hash anchors", + "Read(filepath, filepath...) -> first 600 lines from each file", + "Read(filepath, range[, range...]) -> selected ranges from one file", ) EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["pyproject.toml", "uv.lock"]', @@ -1791,10 +1791,11 @@ class LineCountTool(Tool): NAME: ClassVar[str] = "LineCount" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Count lines for one or more files. Useful before reading large files or deciding Read ranges.", - "Returns total line count across all requested files.", + "Count total lines in one or more files.", + "Use before large Read calls when choosing ranges.", + "Returns one total line count.", ) - SIGNATURE: ClassVar[str] = "LineCount(*filepaths) -> LineCountToolResult" + SIGNATURE: ClassVar[str] = "LineCount(filepath[, filepath...]) -> LineCountToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["code.py", "other.py"]',) filepaths: list[str] = field(default_factory=list) @@ -1835,13 +1836,13 @@ class ListTool(Tool): NAME: ClassVar[str] = "List" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "List one directory non-recursively; optional glob filters immediate entry names.", - "Returns each immediate entry with type and relative path.", - "Batch multiple List actions in one turn when checking several known directories.", + "List immediate entries in one directory; non-recursive.", + "Optional glob filters immediate entry names.", + "Returns type and relative path for each entry.", ) SIGNATURES: ClassVar[tuple[str, ...]] = ( "List() -> current directory entries", - "List(dirpath) -> one directory entries", + "List(dirpath) -> entries in one directory", "List(dirpath, glob) -> immediate entries matching glob", ) EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["src"]', 'Example args: ["src", "*.py"]', "Current dir args: []") @@ -1903,27 +1904,18 @@ class SearchTool(Tool): MAX_CONTEXT_LINES: ClassVar[int] = 30 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Case-insensitive regex search before Read; use A|B|C for alternatives and \\n for multiline matches.", - 'Returns matching file paths, matched lines, and 0-based context lines as "line:hash|code".', - "Compared with rg/grep in Bash, returns structured bounded results, anchors, and tool-result context keys.", - "For exact text, escape regex metacharacters like braces, parens, dots, stars, and brackets.", - "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py; omitted context defaults to 0.", - "Use context=N only when nearby lines are needed; prefer context=0 for broad searches and renames.", - "Second positional arg is always path, third positional arg is always glob; with path=, extra leading positional args are joined as regex alternatives.", - "Use at most one glob= per Search. For multiple extensions, run multiple Search actions or search path=. without glob.", - "Batch multiple Search actions in one turn when checking independent patterns or multiple globs.", - "Only options are path=, glob=, context=; escape regex symbols for literal text.", + "Case-insensitive regex search across files; use before Read when location is unknown.", + "Returns file:line matches and optional line:hash context anchors.", + "Options: path=FILE_OR_DIR, glob=GLOB, context=N. Use at most one glob per call.", + "Use InspectCode for symbol structure; use Bash rg/grep for custom shell pipelines.", + "Escape regex metacharacters for literal text; use A|B for alternatives and \\n for multiline.", ) SIGNATURES: ClassVar[tuple[str, ...]] = ( - "Search(pattern) -> recursive match lines under current directory", - "Search(pattern, path=FILE_OR_DIR) -> recursive match lines under path", - "Search(pattern, path=FILE_OR_DIR, glob=GLOB) -> recursive match lines filtered by glob", - "Search(pattern, path=FILE_OR_DIR, context=N) -> match lines plus N surrounding lines", + "Search(pattern[, path=FILE_OR_DIR][, glob=GLOB][, context=N]) -> matching lines", ) EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Example args: ["class .*Tool", "path=nanocode.py", "context=0"]', + 'Example args: ["class .*Tool", "path=nanocode.py"]', 'Example args: ["TODO|FIXME", "path=.", "glob=*.py", "context=2"]', - 'Multiple globs: use separate actions like ["pytest", "path=.", "glob=*.toml"] and ["pytest", "path=.", "glob=*.ini"].', 'Literal paren args: ["def __init__\\(", "path=.", "glob=*.py"]', ) @@ -2457,10 +2449,10 @@ class InspectCodeTool(Tool): MAX_LIMIT: ClassVar[int] = 80 EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Use the built-in code index for structural code navigation.", - "Modes: find symbol candidates, inspect one symbol with anchored source, or outline one file.", - "find options: limit, kind, path, exact_only; inspect options: kind, path, exact_only; outline options: symbol.", - "find/inspect targets are symbol names or prefixes, not natural language or literal text; outline target is a file path.", + "Use the current code index for symbols and file outlines.", + "find: symbol prefix -> candidates. inspect: one symbol -> anchored source and references. outline: file path -> symbol outline.", + "Targets are symbol names/prefixes, not natural language. Use Search/Read for literal text, config, or logs.", + "Options: limit, kind, path, exact_only, symbol.", ) SIGNATURES: ClassVar[tuple[str, ...]] = ( "InspectCode('find', symbol_prefix[, {limit, kind, path, exact_only}]) -> symbol candidates with file/range", @@ -2602,9 +2594,9 @@ class CreateFileTool(Tool): NAME: ClassVar[str] = "CreateFile" EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Create a new UTF-8 file with short initial content; target file must not exist.", + "Create a new UTF-8 file; target file must not exist.", + "Use EditFile for existing files.", "Returns changed path and created=true.", - "For substantial new files, create only a small skeleton first, then grow it with focused EditFile edits.", ) SIGNATURE: ClassVar[str] = "CreateFile(filepath, content) -> CreateFileToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["new.py", "minimal content\\n"]',) @@ -2670,12 +2662,10 @@ class EditFileTool(Tool): PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "edits") EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Edit an existing UTF-8 file as soon as target lines and replacement text are known.", - 'Use "line:hash" anchors already shown by Read, Search, or InspectCode.', - "Supports atomic multi-edit batches: replace, delete, insert_before, insert_after, and replace_all.", - "Use replace_all for literal file-wide text replacement when anchors are unnecessary.", - "Do not reread visible target lines for confidence; reread only if EditFile reports stale or missing anchors.", - "Returns changed path plus applied edit count.", + "Edit an existing UTF-8 file atomically.", + "Use line:hash anchors from Read, Search, or InspectCode for replace/delete/insert.", + "Use replace_all only for exact literal file-wide replacement.", + "Returns changed path, edit count, and applied ranges.", ) SIGNATURES: ClassVar[tuple[str, ...]] = ( "EditFile(filepath, [{op:'replace', start, end, content}, ...]) -> replace anchored ranges", @@ -2684,9 +2674,9 @@ class EditFileTool(Tool): "EditFile(filepath, [{op:'replace_all', old, new}]) -> literal file-wide replacement", ) EXAMPLE: ClassVar[tuple[str, ...]] = ( - 'Batch: ["code.py", [{"op":"replace","start":"10:a1b2c3","end":"12:d4e5f6","content":"new lines\\n"},{"op":"delete","start":"20:abc123","end":"20:abc123"}]]', - 'Literal replace all: ["code.py", [{"op":"replace_all","old":"OldName","new":"NewName"}]]', - 'Insert: ["code.py", [{"op":"insert_after","start":"20:abc123","content":"new line\\n"}]]', + 'Example args: ["code.py", [{"op":"replace","start":"10:a1b2c3","end":"12:d4e5f6","content":"new lines\\n"}]]', + 'Example args: ["code.py", [{"op":"insert_after","start":"20:abc123","content":"new line\\n"}]]', + 'Example args: ["code.py", [{"op":"replace_all","old":"OldName","new":"NewName"}]]', ) filepath: str = "" @@ -2873,12 +2863,10 @@ def _resolve_anchor(lines: list[str], anchor: str) -> int: class BashTool(Tool): NAME: ClassVar[str] = "Bash" DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Run one explicit shell command via bash -lc in cwd.", - "Args must be exactly one command string; do not pass timeout or extra args.", - "Returns exit_code plus stdout/stderr; long output is stored and bounded in context.", - "Use Bash when shell semantics, tests/builds, or custom Unix text-tool pipelines are the clearest path.", - "rg/grep/sed/awk/perl pipelines in Bash are useful for broad scans, custom filters, and mechanical transforms.", - "Mechanical shell edits are allowed, but verify afterward with Git diff, Read, tests, or another focused check.", + "Run one shell command via bash -lc in cwd.", + "Use for tests, builds, scripts, or custom shell pipelines.", + "Prefer Search for anchored search results; use Bash rg/grep for custom filters.", + "Pass exactly one command string. Returns exit_code, stdout, and stderr.", ) SIGNATURE: ClassVar[str] = "Bash(command) -> BashToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ('Example args: ["python3 -m py_compile nanocode.py"]', 'Example args: ["make test"]') @@ -3045,10 +3033,10 @@ def _read_stream_chunk( class GitTool(Tool): NAME: ClassVar[str] = "Git" DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Run git without a shell for repository state, history, status, diff, and changed files.", - "Returns exit_code plus stdout/stderr.", + "Run git directly without a shell.", + "Use for status, diff, log, show, blame, staging, and commits.", "Pass each git argument separately; optional first arg cwd=path changes repository directory.", - "By default, stage/commit only files changed for the current task; include unrelated dirty files only when the user explicitly asks.", + "Returns exit_code, stdout, and stderr. Mutating git commands require confirmation.", ) SIGNATURE: ClassVar[str] = "Git([cwd=path,] git_arg...) -> GitToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( @@ -3111,14 +3099,16 @@ class ToolResultTool(Tool): NAME: ClassVar[str] = "Recall" EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY DESCRIPTION: ClassVar[tuple[str, ...]] = ( - "Recall stored tool results by tr.* key; pass optional 0-based line ranges to read exact slices from the stored full log.", - "Returns recalled result metadata plus bounded content or requested full-log slices.", + "Retrieve stored tool results by tr.N key.", + "Use when output was truncated, forgotten, or no longer visible.", + "Optional 0-based ranges read exact slices from the stored full log.", + "Returns result metadata plus content.", ) - SIGNATURE: ClassVar[str] = "Recall(key...[, range_token...]) -> RecallToolResult" + SIGNATURE: ClassVar[str] = "Recall(key[, key...][, range...]) -> RecallToolResult" EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["tr.1"]', - 'Batch keys: ["tr.1", "tr.2"]', - 'Full-log slice: ["tr.1", "0,120"]', + 'Example args: ["tr.1", "tr.2"]', + 'Example args: ["tr.1", "0,120"]', ) REQUIRES_CONFIRMATION: ClassVar[bool | None] = False @@ -3251,7 +3241,7 @@ def _canonical_tool_name(name: str | None) -> str: STATE_TOOL_PARAMS: dict[str, tuple[str, Json, list[str]]] = { "goal": ( - "Set, update, or complete the current goal. Use message_for_complete for the final user message.", + "Set or complete the active task goal. Use message_for_complete for the final user message.", { "text": TOOL_STRING_SCHEMA, "complete": {"type": "boolean"}, @@ -3259,21 +3249,21 @@ def _canonical_tool_name(name: str | None) -> str: }, ["text", "complete", "message_for_complete"], ), - "plan": ("Replace or patch the current plan.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), - "lead": ("Update investigation leads.", {"items": TOOL_LEAD_ITEMS_SCHEMA}, ["items"]), - "known": ("Record settled current-task facts.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), + "plan": ("Set or patch the shortest necessary plan for tracked work.", {"mode": TOOL_NULLABLE_STRING_SCHEMA, "items": TOOL_PLAN_ITEMS_SCHEMA}, ["items"]), + "lead": ("Record investigation leads and their status.", {"items": TOOL_LEAD_ITEMS_SCHEMA}, ["items"]), + "known": ("Record confirmed Facts that affect the current task.", {"items": TOOL_ITEMS_SCHEMA}, ["items"]), "user_rule": ( - "Remember an explicit future behavior rule from the user.", + "Save an explicit future behavior rule from the user.", {"text": TOOL_STRING_SCHEMA, "message": TOOL_STRING_SCHEMA}, ["text", "message"], ), "forget": ( - "Remove visible tool result keys from active context while keeping them recallable.", + "Remove visible tool result keys from active context; keys remain recallable.", {"source": TOOL_STRING_LIST_SCHEMA, "reason": TOOL_STRING_SCHEMA}, ["source", "reason"], ), "verify": ( - "Record concrete check status.", + "Record a concrete check result or blocker.", { "method": TOOL_NULLABLE_STRING_SCHEMA, "status": {"type": "string", "enum": ["passed", "failed", "blocked"]}, From 6021e8da64cfd405d102e83f7c0ab88ecee217b8 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 03:09:29 -0700 Subject: [PATCH 133/144] Simplify session cleanup and bump version --- nanocode.py | 73 +++++++--------------- pyproject.toml | 2 +- tests/test_nanocode_commands.py | 104 +++----------------------------- 3 files changed, 32 insertions(+), 147 deletions(-) diff --git a/nanocode.py b/nanocode.py index d925629..f601743 100644 --- a/nanocode.py +++ b/nanocode.py @@ -55,7 +55,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.6" +__version__ = "0.4.7" JsonValue: TypeAlias = Any @@ -1554,41 +1554,25 @@ def is_locked(path: str) -> bool: return False -@dataclass -class CleanResult: - cleaned: int = 0 - failed: int = 0 - skipped: int = 0 - - -class SessionCleaner: - def __init__(self, session: Session): - self.session = session - - def clean(self, *, older_than_seconds: int = 0) -> CleanResult: - result = CleanResult() - sessions_dir = self.session.data_path("sessions") - if not os.path.isdir(sessions_dir): - return result - cutoff = time.time() - older_than_seconds if older_than_seconds > 0 else 0.0 - for session_name in sorted(os.listdir(sessions_dir)): - session_dir = os.path.join(sessions_dir, session_name) - if not os.path.isdir(session_dir): - continue - if cutoff and os.path.getmtime(session_dir) >= cutoff: - continue - if session_name == self.session.session_id: - result.skipped += 1 - continue - if SessionLock.is_locked(os.path.join(session_dir, "session.lock")): - result.skipped += 1 - continue - try: - shutil.rmtree(session_dir) - result.cleaned += 1 - except OSError: - result.failed += 1 - return result +def clean_sessions(session: Session, *, older_than_seconds: int = 0) -> None: + sessions_dir = session.data_path("sessions") + if not os.path.isdir(sessions_dir): + return + cutoff = time.time() - older_than_seconds if older_than_seconds > 0 else 0.0 + for session_name in sorted(os.listdir(sessions_dir)): + session_dir = os.path.join(sessions_dir, session_name) + if not os.path.isdir(session_dir): + continue + if cutoff and os.path.getmtime(session_dir) >= cutoff: + continue + if session_name == session.session_id: + continue + if SessionLock.is_locked(os.path.join(session_dir, "session.lock")): + continue + try: + shutil.rmtree(session_dir) + except OSError: + pass ############################ @@ -6322,7 +6306,6 @@ class CommandSpec: CommandSpec("/provider", "Show or switch provider", "Config", "/provider [name]"), CommandSpec("/yolo", "Toggle yolo mode (skip confirmations)", "Config", "/yolo"), CommandSpec("/index", "Initialize, sync, or rebuild code index", "Maintenance", "/index [force]"), - CommandSpec("/clean", "Clean inactive session directories", "Maintenance", "/clean"), CommandSpec("/exit", "Exit nanocode", "Control", "/exit"), CommandSpec("/quit", "Exit nanocode", "Control", "/quit"), ) @@ -6794,20 +6777,6 @@ def _config_target(self, key: str) -> tuple[object, str]: return self.agent.session.config.provider, CONFIG_PROVIDER_ATTRS[key] return self.agent.session.settings, CONFIG_RUNTIME_ATTRS[key] - def _clean(self, args: str) -> str: - if args: - return "Usage: /clean" - sessions_dir = self.agent.session.data_path("sessions") - if not os.path.isdir(sessions_dir): - return f"No sessions directory found at {sessions_dir}" - result = SessionCleaner(self.agent.session).clean() - msg = f"Cleaned {result.cleaned} session(s) from {sessions_dir}" - if result.skipped: - msg += f" ({result.skipped} active session(s) skipped)" - if result.failed: - msg += f" ({result.failed} failed)" - return msg - def _format_bool(self, value: bool | None) -> str: return "(fallback)" if value is None else ("on" if value else "off") @@ -7043,7 +7012,7 @@ def run(self) -> int: with SessionLock(self.agent.session.lock_path()), self.status_bar: seconds = RuntimeSettings.clean_retention_seconds(self.agent.session.settings.auto_clean_recent) if seconds > 0: - SessionCleaner(self.agent.session).clean(older_than_seconds=seconds) + clean_sessions(self.agent.session, older_than_seconds=seconds) self._start_existing_code_index_refresh() dispatcher = CommandDispatcher( self.agent, diff --git a/pyproject.toml b/pyproject.toml index 3cce75b..f6aab7e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.6" +version = "0.4.7" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 92e4cef..190bf3d 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -1,9 +1,8 @@ import os -import shutil import time import nanocode -from nanocode import Config, Agent, CommandDispatcher, CommandStatus, ModelUsage, RuntimeSettings, Session, SessionLock, SessionCleaner, UserMessage +from nanocode import Config, Agent, CommandDispatcher, CommandStatus, ModelUsage, RuntimeSettings, Session, SessionLock, UserMessage, clean_sessions class FakeModelClient: @@ -588,24 +587,25 @@ def test_help_question_runs_agent_with_source_aware_prompt(tmp_path): assert len(prompts) == 1 -def test_clean_command_removes_inactive_session_directories(tmp_path): +def test_clean_sessions_removes_old_inactive_session_directories(tmp_path): session = Session(cwd=str(tmp_path)) current_dir = session.session_dir() old_dir = session.data_path("sessions", "old-session") recent_dir = session.data_path("sessions", "recent-session") for path in (current_dir, old_dir, recent_dir): os.makedirs(path, exist_ok=True) - dispatcher = CommandDispatcher(Agent(session)) - result = dispatcher.dispatch("/clean") + old_time = time.time() - 10 * 86400 + os.utime(old_dir, (old_time, old_time)) + + with SessionLock(session.lock_path()): + clean_sessions(session, older_than_seconds=3 * 86400) - assert result.status == CommandStatus.HANDLED - assert "Cleaned 2 session(s)" in result.message assert os.path.exists(current_dir) assert not os.path.exists(old_dir) - assert not os.path.exists(recent_dir) + assert os.path.exists(recent_dir) -def test_clean_command_skips_active_sessions(tmp_path): +def test_clean_sessions_skips_locked_sessions(tmp_path): session = Session(cwd=str(tmp_path)) active_dir = session.data_path("sessions", "active-session") stale_dir = session.data_path("sessions", "stale-session") @@ -616,98 +616,14 @@ def test_clean_command_skips_active_sessions(tmp_path): with SessionLock(os.path.join(active_dir, "session.lock")): os.utime(active_dir, (old_time, old_time)) os.utime(stale_dir, (old_time, old_time)) - dispatcher = CommandDispatcher(Agent(session)) - result = dispatcher.dispatch("/clean") + clean_sessions(session, older_than_seconds=86400) - assert result.status == CommandStatus.HANDLED - assert "Cleaned 1 session(s)" in result.message - assert "1 active session(s) skipped" in result.message assert os.path.exists(active_dir) assert not os.path.exists(stale_dir) -def test_session_cleaner_removes_only_old_inactive_sessions(tmp_path): - session = Session(cwd=str(tmp_path)) - old_dir = session.data_path("sessions", "old-session") - recent_dir = session.data_path("sessions", "recent-session") - current_dir = session.session_dir() - for path in (old_dir, recent_dir, current_dir): - os.makedirs(path, exist_ok=True) - old_time = time.time() - 10 * 86400 - os.utime(old_dir, (old_time, old_time)) - os.utime(current_dir, (old_time, old_time)) - - with SessionLock(session.lock_path()): - result = SessionCleaner(session).clean(older_than_seconds=3 * 86400) - - assert result.cleaned == 1 - assert not os.path.exists(old_dir) - assert os.path.exists(recent_dir) - assert os.path.exists(current_dir) - - def test_session_lock_removes_lock_file_on_release(tmp_path): session = Session(cwd=str(tmp_path)) with SessionLock(session.lock_path()): assert os.path.exists(session.lock_path()) assert not os.path.exists(session.lock_path()) - - -def test_clean_command_no_directory(tmp_path): - session = Session(cwd=str(tmp_path)) - sessions_dir = session.data_path("sessions") - if os.path.exists(sessions_dir): - shutil.rmtree(sessions_dir) - - dispatcher = CommandDispatcher(Agent(session)) - result = dispatcher.dispatch("/clean") - - assert result.status == CommandStatus.HANDLED - assert "No sessions directory found" in result.message - - -def test_clean_command_empty_directory(tmp_path): - session = Session(cwd=str(tmp_path)) - os.makedirs(session.session_dir(), exist_ok=True) - - dispatcher = CommandDispatcher(Agent(session)) - result = dispatcher.dispatch("/clean") - - assert result.status == CommandStatus.HANDLED - assert "Cleaned 0 session(s)" in result.message - - -def test_clean_command_with_args_returns_usage(tmp_path): - session = Session(cwd=str(tmp_path)) - os.makedirs(session.session_dir(), exist_ok=True) - - dispatcher = CommandDispatcher(Agent(session)) - result = dispatcher.dispatch("/clean extra-arg") - - assert result.status == CommandStatus.HANDLED - assert result.message == "Usage: /clean" - - -def test_clean_command_reports_failed_deletions(tmp_path): - session = Session(cwd=str(tmp_path)) - good_dir = session.data_path("sessions", "good-session") - fail_dir = session.data_path("sessions", "fail-session") - os.makedirs(good_dir, exist_ok=True) - os.makedirs(fail_dir, exist_ok=True) - original_rmtree = shutil.rmtree - call_count = [0] - - def mock_rmtree(path): - call_count[0] += 1 - if call_count[0] == 2: - raise OSError("Permission denied") - original_rmtree(path) - - import unittest.mock - with unittest.mock.patch("shutil.rmtree", side_effect=mock_rmtree): - dispatcher = CommandDispatcher(Agent(session)) - result = dispatcher.dispatch("/clean") - - assert result.status == CommandStatus.HANDLED - assert "Cleaned 1 session(s)" in result.message - assert "1 failed" in result.message From 80c739afa89eb44565505eba8344352e54b09f76 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 03:29:58 -0700 Subject: [PATCH 134/144] Add prompt cache key and cached token stats --- nanocode.py | 156 +++++++++++++++++++++++++------- tests/test_nanocode_agent.py | 51 ++++++++++- tests/test_nanocode_commands.py | 12 ++- 3 files changed, 183 insertions(+), 36 deletions(-) diff --git a/nanocode.py b/nanocode.py index f601743..9bcc3eb 100644 --- a/nanocode.py +++ b/nanocode.py @@ -495,6 +495,7 @@ class ProviderConfig: key: str = "" model: str = "" api: str = "auto" + prompt_cache_key: str = "auto" available_models: tuple[str, ...] = () temperature: float | None = None reasoning: str = "medium" @@ -507,6 +508,7 @@ class ProviderConfig: def from_dict(cls, data: Json) -> "ProviderConfig": defaults = cls() api = Config.str(data, "api", defaults.api) + prompt_cache_key = cls.clean_prompt_cache_key(Config.str(data, "prompt_cache_key", defaults.prompt_cache_key)) reasoning = Config.str(data, "reasoning", defaults.reasoning) chat_reasoning = Config.str(data, "chat_reasoning", defaults.chat_reasoning) if api not in ("chat", "responses", "auto"): @@ -520,6 +522,7 @@ def from_dict(cls, data: Json) -> "ProviderConfig": key=Config.str(data, "key", defaults.key), model=Config.str(data, "model", defaults.model), api=api, + prompt_cache_key=prompt_cache_key, available_models=Config.str_tuple(data, "available_models"), temperature=Config.float(data, "temperature", defaults.temperature), reasoning=reasoning, @@ -554,6 +557,18 @@ def resolved_api(self) -> str: profile = PROVIDER_PROFILES.get(self.host()) return profile.api if profile else "chat" + @staticmethod + def clean_prompt_cache_key(value: str) -> str: + value = value.strip() + if not value: + return "auto" + lower = value.lower() + if lower in {"auto", "off"}: + return lower + if len(value) > 64 or any(char.isspace() for char in value): + raise ConfigError("config provider.prompt_cache_key must be auto, off, or a stable key up to 64 chars without whitespace") + return value + @dataclass class ModelUsage: @@ -561,12 +576,14 @@ class ModelUsage: prompt_tokens: int = 0 completion_tokens: int = 0 total_tokens: int = 0 + cached_prompt_tokens: int = 0 - def add(self, *, prompt_tokens: int, completion_tokens: int, total_tokens: int) -> None: + def add(self, *, prompt_tokens: int, completion_tokens: int, total_tokens: int, cached_prompt_tokens: int = 0) -> None: self.calls += 1 self.prompt_tokens += prompt_tokens self.completion_tokens += completion_tokens self.total_tokens += total_tokens + self.cached_prompt_tokens += cached_prompt_tokens CONTEXT_BUDGET_CHOICES: tuple[str, ...] = ("low", "medium", "high") @@ -742,6 +759,8 @@ class ConfigFile: # api = "auto" # Optional: add available_models = ["model-a", "model-b"] manually to pin preferred # /model choices above automatically discovered provider models. +# Prompt cache key: "auto", "off", or a custom stable key. +prompt_cache_key = "auto" # Optional. Uncomment only for models/providers that support temperature. # temperature = 0.7 reasoning = "medium" @@ -822,9 +841,11 @@ class RuntimeState: last_prompt_tokens: int = 0 last_completion_tokens: int = 0 last_total_tokens: int = 0 + last_cached_prompt_tokens: int = 0 session_prompt_tokens: int = 0 session_completion_tokens: int = 0 session_total_tokens: int = 0 + session_cached_prompt_tokens: int = 0 model_usage: dict[str, ModelUsage] = field(default_factory=dict) current_model_call_started_at: float = 0.0 current_model_call_label: str = "" @@ -3292,11 +3313,16 @@ def _state_tool_schema(name: str) -> Json: # Agent Prompt ############################ +# Prompt design: +# - Keep the system prompt short and stable; put tool-specific rules in tool descriptions. +# - Order the user prompt from stable context to volatile context to preserve provider prefix cache hits. +# - Keep the latest request, blocking feedback, and output guide near the end because they change most and steer the next output. +# - Keep section names stable; change prompt shape only when the workflow meaning changes. AGENT_SYSTEM_PROMPT = """You are nanocode, a terminal coding agent. Use assistant text for chat/final answers; use function tools for state/repo work. Use tool schemas for exact names, capabilities, and arguments. -Use the latest user language. Keep terminal output plain and concise. Preserve literals. +Reply in the latest user language unless asked otherwise. Keep output plain and concise. Preserve literals. WHEN THE NEXT USEFUL ACTION IS CLEAR, TAKE IT NOW. Priority: latest user request > blocking feedback > user rules > active state > conversation. @@ -3653,6 +3679,32 @@ def request( def _reasoning_effort(config: ProviderConfig) -> str: return config.reasoning if config.reasoning in REASONING_LEVELS else "medium" + def _prompt_cache_key(self, config: ProviderConfig, *, model: str, tool_schemas: list[Json] | None) -> str: + configured = config.prompt_cache_key + if configured == "off": + return "" + if configured != "auto": + return configured + payload = { + "api": config.resolved_api(), + "cwd": self.session.cwd, + "host": config.host(), + "model": model, + "tools": self._tool_schema_cache_names(tool_schemas), + } + digest = hashlib.sha256(json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest() + return "nanocode-" + digest[:24] + + @staticmethod + def _tool_schema_cache_names(tool_schemas: list[Json] | None) -> str: + names = [] + for schema in tool_schemas or []: + function = _json_dict(schema.get("function")) + name = _json_str(function.get("name")) or _json_str(schema.get("name")) or _json_str(schema.get("type")) + if name: + names.append(name) + return ",".join(sorted(names)) or "(none)" + def _chat_completion_params( self, config: ProviderConfig, @@ -3665,6 +3717,9 @@ def _chat_completion_params( ) -> Json: params: Json = {"model": model, "messages": messages, "stream": stream} extra_body: Json = {} + prompt_cache_key = self._prompt_cache_key(config, model=model, tool_schemas=tool_schemas) + if prompt_cache_key: + params["prompt_cache_key"] = prompt_cache_key if config.temperature is not None: params["temperature"] = config.temperature if stream: @@ -3970,6 +4025,9 @@ def _responses_params( required_tool: str | None = None, ) -> Json: params: Json = {"model": model, "instructions": system_prompt, "input": user_prompt, "stream": stream, "store": False} + prompt_cache_key = self._prompt_cache_key(config, model=model, tool_schemas=tool_schemas) + if prompt_cache_key: + params["prompt_cache_key"] = prompt_cache_key if tool_schemas: params["tools"] = self._responses_tool_schemas(tool_schemas) params["tool_choice"] = {"type": "function", "name": required_tool} if required_tool else "auto" @@ -4208,22 +4266,32 @@ def _record_usage(self, usage: Json, config: ProviderConfig, *, elapsed: float = prompt_tokens = self._json_int(usage.get("prompt_tokens")) or self._json_int(usage.get("input_tokens")) completion_tokens = self._json_int(usage.get("completion_tokens")) or self._json_int(usage.get("output_tokens")) total_tokens = self._json_int(usage.get("total_tokens")) + cached_prompt_tokens = self._cached_prompt_tokens(usage) if completion_tokens > 0 and elapsed > 0: self.session.state.last_model_call_rate = completion_tokens / elapsed self.session.state.last_prompt_tokens = prompt_tokens self.session.state.last_completion_tokens = completion_tokens self.session.state.last_total_tokens = total_tokens + self.session.state.last_cached_prompt_tokens = cached_prompt_tokens self.session.state.session_prompt_tokens += prompt_tokens self.session.state.session_completion_tokens += completion_tokens self.session.state.session_total_tokens += total_tokens + self.session.state.session_cached_prompt_tokens += cached_prompt_tokens self.session.state.model_usage.setdefault(config.model or "(empty)", ModelUsage()).add( - prompt_tokens=prompt_tokens, completion_tokens=completion_tokens, total_tokens=total_tokens + prompt_tokens=prompt_tokens, completion_tokens=completion_tokens, total_tokens=total_tokens, cached_prompt_tokens=cached_prompt_tokens ) @staticmethod def _json_int(value: JsonValue) -> int: return value if isinstance(value, int) else 0 + def _cached_prompt_tokens(self, usage: Json) -> int: + for key in ("prompt_tokens_details", "input_tokens_details"): + cached_tokens = self._json_int(_json_dict(usage.get(key)).get("cached_tokens")) + if cached_tokens: + return cached_tokens + return 0 + ############################ # ToolCallRunner @@ -6318,6 +6386,7 @@ class CommandSpec: CONFIG_PROVIDER_ATTRS: dict[str, str] = { "provider.model": "model", + "provider.prompt_cache_key": "prompt_cache_key", "provider.reasoning": "reasoning", "provider.chat_reasoning": "chat_reasoning", "provider.stream": "stream", @@ -6576,7 +6645,13 @@ def _status(self, args: str) -> str: api = provider.resolved_api() + ("(" + provider.api + ")" if provider.api == "auto" else "") model_usage = ( "\n".join( - " " + (model.rsplit("/", 1)[-1] or model) + ": calls=" + str(usage.calls) + " tokens=" + _format_count(usage.total_tokens) + " " + + (model.rsplit("/", 1)[-1] or model) + + ": calls=" + + str(usage.calls) + + " tokens=" + + _format_count(usage.total_tokens) + + ((" cached=" + _format_count(usage.cached_prompt_tokens)) if usage.cached_prompt_tokens else "") for model, usage in session.state.model_usage.items() ) if session.state.model_usage @@ -6593,34 +6668,40 @@ def _status(self, args: str) -> str: elif code_index_status in {"missing", "stale"}: code_index_message = (code_index_message + "; " if code_index_message else "") + "run /index" code_index = code_index_status + (": " + _shorten(code_index_message, 80) if code_index_message else "") - return "\n".join( - [ - "provider: " + session.config.active_provider, - "model: " - + (provider.model or "(empty)") - + " api=" - + api - + " reasoning=" - + (reasoning or "(empty)") - + " stream=" - + self._format_bool(provider.stream), - "session: " + session.session_id, - "runtime: yolo=" - + self._format_bool(session.settings.yolo) - + " compact_at=" - + str(session.settings.compact_at) - + " context_budget=" - + session.settings.context_budget, - "conversation: " + str(len(session.state.conversation)) + "/" + str(session.settings.compact_at), - "tool_calls: turn=" + str(session.state.turn_tool_calls) + " session=" + str(session.state.session_tool_calls), - "tools: code_index=" + code_index, - "tokens: last=" + _format_count(session.state.last_total_tokens) + " session=" + _format_count(session.state.session_total_tokens), - "models:", - model_usage, - "goal: " + (blackboard.goal or "(empty)"), - "checks: " + checks_status, - ] - ) + lines = [ + "provider: " + session.config.active_provider, + "model: " + + (provider.model or "(empty)") + + " api=" + + api + + " reasoning=" + + (reasoning or "(empty)") + + " stream=" + + self._format_bool(provider.stream), + "session: " + session.session_id, + "runtime: yolo=" + + self._format_bool(session.settings.yolo) + + " compact_at=" + + str(session.settings.compact_at) + + " context_budget=" + + session.settings.context_budget, + "conversation: " + str(len(session.state.conversation)) + "/" + str(session.settings.compact_at), + "tool_calls: turn=" + str(session.state.turn_tool_calls) + " session=" + str(session.state.session_tool_calls), + "tools: code_index=" + code_index, + "tokens: last=" + _format_count(session.state.last_total_tokens) + " session=" + _format_count(session.state.session_total_tokens), + ] + if session.state.last_cached_prompt_tokens or session.state.session_cached_prompt_tokens: + rate = _format_percent(session.state.session_cached_prompt_tokens, session.state.session_prompt_tokens) + lines.append( + "cache: last=" + + _format_count(session.state.last_cached_prompt_tokens) + + " session=" + + _format_count(session.state.session_cached_prompt_tokens) + + " rate=" + + rate + ) + lines.extend(["models:", model_usage, "goal: " + (blackboard.goal or "(empty)"), "checks: " + checks_status]) + return "\n".join(lines) def _compact(self, args: str) -> str: if args: @@ -6682,6 +6763,7 @@ def _config(self, args: str) -> str: "provider.key: " + ("(set)" if provider_config.key else "(empty)"), "provider.model: " + (provider_config.model or "(empty)"), "provider.api: " + provider_config.api, + "provider.prompt_cache_key: " + provider_config.prompt_cache_key, "provider.available_models: " + (", ".join(provider_config.available_models) or "(empty)"), "provider.reasoning: " + provider_config.reasoning, "provider.chat_reasoning: " + (provider_config.chat_reasoning or "(empty)"), @@ -6735,6 +6817,12 @@ def _config_value(self, key: str) -> str: def _apply_config_value(self, key: str, value: str) -> str: target, attr = self._config_target(key) + if key == "provider.prompt_cache_key": + try: + setattr(target, attr, ProviderConfig.clean_prompt_cache_key(value)) + except ConfigError: + return "Usage: /set provider.prompt_cache_key [auto|off|]" + return "" if key in CONFIG_BOOL_KEYS: if value not in {"on", "off"}: return "Usage: /set " + key + " [on|off]" @@ -6797,6 +6885,10 @@ def _format_count(value: int) -> str: return str(value) +def _format_percent(value: int, total: int) -> str: + return "-" if value <= 0 or total <= 0 else str(round(value * 100 / total)) + "%" + + ############################ # Interactive Loop ############################ diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 1e7c162..cb26566 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -56,10 +56,13 @@ def _session( yolo: bool = False, debug: bool = False, api: str = "", + prompt_cache_key: str = "", ) -> Session: provider: dict[str, object] = {"url": api_url, "key": api_key, "model": model} if api: provider["api"] = api + if prompt_cache_key: + provider["prompt_cache_key"] = prompt_cache_key if stream is not None: provider["stream"] = stream if timeout is not None: @@ -1204,6 +1207,7 @@ def test_agent_request_calls_chat_completions_and_returns_text(tmp_path, monkeyp assert "response_format" not in payload assert "reasoning_effort" not in payload assert "reasoning" not in payload + assert payload["prompt_cache_key"].startswith("nanocode-") assert session.state.last_prompt_tokens == 2 assert session.state.last_completion_tokens == 3 assert session.state.last_total_tokens == 5 @@ -1242,12 +1246,36 @@ def test_agent_request_sends_temperature_only_when_configured(tmp_path, monkeypa assert _sdk_payload(calls[0])["temperature"] == 0.2 +def test_agent_request_prompt_cache_key_can_be_custom_or_off(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, (_chat_response(), _chat_response())) + + Agent(_session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False, prompt_cache_key="project-cache")).request("system", "user") + Agent(_session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False, prompt_cache_key="off")).request("system", "user") + + assert _sdk_payload(calls[0])["prompt_cache_key"] == "project-cache" + assert "prompt_cache_key" not in _sdk_payload(calls[1]) + + +def test_agent_request_auto_prompt_cache_key_is_stable_per_tool_set(tmp_path, monkeypatch): + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, (_chat_response(), _chat_response(), _chat_response())) + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) + agent = Agent(session) + + agent.request("system", "user", tool_schemas=[nanocode.ReadTool.tool_schema(), nanocode.SearchTool.tool_schema()]) + agent.request("system", "changed user", tool_schemas=[nanocode.SearchTool.tool_schema(), nanocode.ReadTool.tool_schema()]) + agent.request("system", "user", tool_schemas=[nanocode.ReadTool.tool_schema()]) + + keys = [_sdk_payload(call)["prompt_cache_key"] for call in calls] + assert keys[0] == keys[1] + assert keys[2] != keys[0] + + def test_agent_request_uses_responses_api_and_sdk_output_text(tmp_path, monkeypatch): class FakeResponse: output_text = "ok" def model_dump(self, mode="json"): - return {"output": [], "usage": {"input_tokens": 2, "output_tokens": 3, "total_tokens": 5}} + return {"output": [], "usage": {"input_tokens": 2, "input_tokens_details": {"cached_tokens": 1}, "output_tokens": 3, "total_tokens": 5}} calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, FakeResponse()) session = _session( @@ -1269,10 +1297,26 @@ def model_dump(self, mode="json"): assert payload["instructions"] == "system" assert payload["input"] == "user" assert payload["store"] is False + assert payload["prompt_cache_key"].startswith("nanocode-") assert payload["reasoning"] == {"effort": "high"} assert session.state.last_prompt_tokens == 2 assert session.state.last_completion_tokens == 3 assert session.state.last_total_tokens == 5 + assert session.state.last_cached_prompt_tokens == 1 + assert session.state.session_cached_prompt_tokens == 1 + + +def test_agent_request_records_chat_cached_prompt_tokens(tmp_path, monkeypatch): + usage = {"prompt_tokens": 10, "prompt_tokens_details": {"cached_tokens": 6}, "completion_tokens": 3, "total_tokens": 13} + calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response(usage=usage)) + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) + + Agent(session).request("system", "user") + + assert _sdk_payload(calls[0])["prompt_cache_key"].startswith("nanocode-") + assert session.state.last_cached_prompt_tokens == 6 + assert session.state.session_cached_prompt_tokens == 6 + assert session.state.model_usage["model"].cached_prompt_tokens == 6 def test_agent_request_responses_api_omits_reasoning_when_disabled(tmp_path, monkeypatch): @@ -1891,7 +1935,10 @@ def test_agent_request_auto_detects_chat_reasoning_from_provider_url(tmp_path, m assert payloads[2]["thinking_budget"] == nanocode.CHAT_REASONING_EFFORT_VALUES["enable_thinking"]["high"] assert payloads[3]["thinking"] == {"type": "enabled"} assert payloads[3]["reasoning_effort"] == "max" - assert payloads[4] == {"model": "glm-5.1", "messages": [{"role": "system", "content": "system"}, {"role": "user", "content": "user"}], "stream": False} + assert payloads[4]["model"] == "glm-5.1" + assert payloads[4]["messages"] == [{"role": "system", "content": "system"}, {"role": "user", "content": "user"}] + assert payloads[4]["stream"] is False + assert payloads[4]["prompt_cache_key"].startswith("nanocode-") assert payloads[5]["reasoning_effort"] == "medium" assert payloads[6]["reasoning"] == {"effort": "high"} for payload in payloads[7:]: diff --git a/tests/test_nanocode_commands.py b/tests/test_nanocode_commands.py index 190bf3d..e61322f 100644 --- a/tests/test_nanocode_commands.py +++ b/tests/test_nanocode_commands.py @@ -55,6 +55,7 @@ def test_command_dispatcher_updates_config_and_auto_compacts(tmp_path): session.state.conversation = [UserMessage(content="one"), UserMessage(content="two"), UserMessage(content="three")] model_result = dispatcher.dispatch("/set provider.model new-model") + cache_result = dispatcher.dispatch("/set provider.prompt_cache_key off") reason_result = dispatcher.dispatch("/set provider.reasoning high") chat_reasoning_result = dispatcher.dispatch("/set provider.chat_reasoning reasoning") stream_result = dispatcher.dispatch("/set provider.stream off") @@ -66,6 +67,8 @@ def test_command_dispatcher_updates_config_and_auto_compacts(tmp_path): assert model_result.status == CommandStatus.HANDLED assert session.config.provider.model == "new-model" + assert cache_result.message == "Set provider.prompt_cache_key = off" + assert session.config.provider.prompt_cache_key == "off" assert reason_result.message == "Set provider.reasoning = high" assert session.config.provider.reasoning == "high" assert chat_reasoning_result.message == "Set provider.chat_reasoning = reasoning" @@ -89,19 +92,23 @@ def test_status_reports_tokens_in_human_readable_format(tmp_path, monkeypatch): monkeypatch.setattr(nanocode, "_code_index_status", lambda session, *, check=False: ("unavailable", "")) session = make_session(tmp_path, model="model") session.state.last_total_tokens = 1200 + session.state.last_cached_prompt_tokens = 400 session.state.session_total_tokens = 2_345_678 - session.state.model_usage["model"] = ModelUsage(calls=2, total_tokens=2_345_678) + session.state.session_prompt_tokens = 1000 + session.state.session_cached_prompt_tokens = 400 + session.state.model_usage["model"] = ModelUsage(calls=2, total_tokens=2_345_678, cached_prompt_tokens=400) dispatcher = CommandDispatcher(Agent(session)) result = dispatcher.dispatch("/status") assert result.status == CommandStatus.HANDLED assert "tokens: last=1k session=2m" in result.message + assert "cache: last=400 session=400 rate=40%" in result.message assert "model: model api=chat(auto) reasoning=medium(off) stream=on" in result.message assert "session: " + session.session_id in result.message assert "runtime: yolo=off compact_at=50" in result.message assert "models:" in result.message - assert "model: calls=2 tokens=2m" in result.message + assert "model: calls=2 tokens=2m cached=400" in result.message assert "tool_calls: turn=0 session=0" in result.message assert "tools: code_index=unavailable" in result.message assert "task:" not in result.message @@ -165,6 +172,7 @@ def test_config_command_reports_resolved_provider_config(tmp_path): assert "config: " in result.message assert "provider.active: default" in result.message assert "provider.model: config-model" in result.message + assert "provider.prompt_cache_key: auto" in result.message assert "provider.available_models: config-model, other-model" in result.message assert "provider.first_token_timeout: 90" in result.message assert "paths.data_dir: " + str(tmp_path / ".nanocode") in result.message From 741a190c750bf8a5563075a15887e1bc4888395c Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 03:37:36 -0700 Subject: [PATCH 135/144] Clarify reply language rule --- nanocode.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index 9bcc3eb..c9addca 100644 --- a/nanocode.py +++ b/nanocode.py @@ -3322,7 +3322,7 @@ def _state_tool_schema(name: str) -> Json: Use assistant text for chat/final answers; use function tools for state/repo work. Use tool schemas for exact names, capabilities, and arguments. -Reply in the latest user language unless asked otherwise. Keep output plain and concise. Preserve literals. +Reply in the language of the latest user input unless asked otherwise. Keep output plain and concise. Preserve literals. WHEN THE NEXT USEFUL ACTION IS CLEAR, TAKE IT NOW. Priority: latest user request > blocking feedback > user rules > active state > conversation. @@ -3398,7 +3398,7 @@ def _state_tool_schema(name: str) -> Json: If Pending User Feedback is not empty, answer it briefly first. Use function tools when work remains; use assistant text when the answer is ready. -Keep user-facing text in the latest user language. +Reply in the language of Latest User Request. YOUR OUTPUT: """ From b1241d7ab587ae97dc5e0b60d548bb2dc6398e0b Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 03:40:57 -0700 Subject: [PATCH 136/144] language rule --- nanocode.py | 35 ++++++++++++++++++++--------------- 1 file changed, 20 insertions(+), 15 deletions(-) diff --git a/nanocode.py b/nanocode.py index c9addca..4973564 100644 --- a/nanocode.py +++ b/nanocode.py @@ -1915,9 +1915,7 @@ class SearchTool(Tool): "Use InspectCode for symbol structure; use Bash rg/grep for custom shell pipelines.", "Escape regex metacharacters for literal text; use A|B for alternatives and \\n for multiline.", ) - SIGNATURES: ClassVar[tuple[str, ...]] = ( - "Search(pattern[, path=FILE_OR_DIR][, glob=GLOB][, context=N]) -> matching lines", - ) + SIGNATURES: ClassVar[tuple[str, ...]] = ("Search(pattern[, path=FILE_OR_DIR][, glob=GLOB][, context=N]) -> matching lines",) EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["class .*Tool", "path=nanocode.py"]', 'Example args: ["TODO|FIXME", "path=.", "glob=*.py", "context=2"]', @@ -3322,7 +3320,6 @@ def _state_tool_schema(name: str) -> Json: Use assistant text for chat/final answers; use function tools for state/repo work. Use tool schemas for exact names, capabilities, and arguments. -Reply in the language of the latest user input unless asked otherwise. Keep output plain and concise. Preserve literals. WHEN THE NEXT USEFUL ACTION IS CLEAR, TAKE IT NOW. Priority: latest user request > blocking feedback > user rules > active state > conversation. @@ -3346,7 +3343,9 @@ def _state_tool_schema(name: str) -> Json: - Facts are confirmed. Leads are for investigations. Checks are checks. User Rules are future-behavior requests. - Save only what matters after results disappear; cite tr.N when result-backed; forget raw results when no longer needed. -Default Response Format: Text (Not markdown) +Response: +- Reply in the LANGUAGE of the latest user input unless asked otherwise. Keep output plain and concise. Preserve literals. +- Default Response Format: Text (Not markdown) """ AGENT_USER_PROMPT_TEMPLATE = """ @@ -3398,7 +3397,7 @@ def _state_tool_schema(name: str) -> Json: If Pending User Feedback is not empty, answer it briefly first. Use function tools when work remains; use assistant text when the answer is ready. -Reply in the language of Latest User Request. +REPLY IN THE LANGUAGE OF LATEST USER REQUEST. YOUR OUTPUT: """ @@ -4746,9 +4745,19 @@ def _apply_plan_patches(self, plan: list[PlanItem], value: JsonValue) -> bool: text = _json_str(patch.get("text")) if "text" in patch else None status = _json_str(patch.get("status")) if "status" in patch else None context = _json_str(patch.get("context")) if "context" in patch else existing.context - followup_action = self._plan_followup(patch.get("followup_action"), existing.followup_action) if "followup_action" in patch else existing.followup_action - followup_check = self._plan_followup(patch.get("followup_check"), existing.followup_check) if "followup_check" in patch else existing.followup_check - updated = (text or existing.text, PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, context or "", followup_action, followup_check) + followup_action = ( + self._plan_followup(patch.get("followup_action"), existing.followup_action) if "followup_action" in patch else existing.followup_action + ) + followup_check = ( + self._plan_followup(patch.get("followup_check"), existing.followup_check) if "followup_check" in patch else existing.followup_check + ) + updated = ( + text or existing.text, + PlanStatus(status) if status in ALL_PLAN_STATUSES else existing.status, + context or "", + followup_action, + followup_check, + ) changed = changed or (existing.text, existing.status, existing.context, existing.followup_action, existing.followup_check) != updated existing.text, existing.status, existing.context, existing.followup_action, existing.followup_check = updated continue @@ -5747,9 +5756,7 @@ def _completion_plan_followup_error(self) -> str: return "" completed = [item for item in self.blackboard.plan if item.status in self.COMPLETED_PLAN_STATUSES] missing = [ - item - for item in completed - if item.followup_action.status == PlanFollowupStatus.UNKNOWN or item.followup_check.status == PlanFollowupStatus.UNKNOWN + item for item in completed if item.followup_action.status == PlanFollowupStatus.UNKNOWN or item.followup_check.status == PlanFollowupStatus.UNKNOWN ] if missing: return "plan follow-up status missing: " + self._format_plan_gate_items(missing) @@ -5757,9 +5764,7 @@ def _completion_plan_followup_error(self) -> str: if missing_reason: return "plan follow-up reason missing: " + self._format_plan_gate_items(missing_reason) needed = [ - item - for item in completed - if item.followup_action.status == PlanFollowupStatus.NEEDED or item.followup_check.status == PlanFollowupStatus.NEEDED + item for item in completed if item.followup_action.status == PlanFollowupStatus.NEEDED or item.followup_check.status == PlanFollowupStatus.NEEDED ] if needed: return "plan follow-up still needed: " + self._format_plan_gate_items(needed) From bf05b1eef6f8a5c442bd6e7c5ebbc24384d313a2 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 03:46:13 -0700 Subject: [PATCH 137/144] Record DeepSeek cached prompt tokens --- nanocode.py | 4 ++++ tests/test_nanocode_agent.py | 12 ++++++++++++ 2 files changed, 16 insertions(+) diff --git a/nanocode.py b/nanocode.py index 4973564..ec499ee 100644 --- a/nanocode.py +++ b/nanocode.py @@ -4285,6 +4285,10 @@ def _json_int(value: JsonValue) -> int: return value if isinstance(value, int) else 0 def _cached_prompt_tokens(self, usage: Json) -> int: + for key in ("prompt_cache_hit_tokens", "cached_tokens"): + cached_tokens = self._json_int(usage.get(key)) + if cached_tokens: + return cached_tokens for key in ("prompt_tokens_details", "input_tokens_details"): cached_tokens = self._json_int(_json_dict(usage.get(key)).get("cached_tokens")) if cached_tokens: diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index cb26566..68965e4 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1319,6 +1319,18 @@ def test_agent_request_records_chat_cached_prompt_tokens(tmp_path, monkeypatch): assert session.state.model_usage["model"].cached_prompt_tokens == 6 +def test_agent_request_records_deepseek_cached_prompt_tokens(tmp_path, monkeypatch): + usage = {"prompt_tokens": 10, "prompt_cache_hit_tokens": 7, "prompt_cache_miss_tokens": 3, "completion_tokens": 2, "total_tokens": 12} + _calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response(usage=usage)) + session = _session(tmp_path, api_url="https://api.deepseek.com/v1", api_key="key", model="model", stream=False) + + Agent(session).request("system", "user") + + assert session.state.last_cached_prompt_tokens == 7 + assert session.state.session_cached_prompt_tokens == 7 + assert session.state.model_usage["model"].cached_prompt_tokens == 7 + + def test_agent_request_responses_api_omits_reasoning_when_disabled(tmp_path, monkeypatch): calls, response_calls, _client_kwargs = _patch_openai(monkeypatch, _responses_response()) session = _session(tmp_path, api_url="https://api.openai.com/v1", api_key="key", model="model", api="responses", stream=False) From fab9820ec87ea4eeff3b15885c5a217d9501d669 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 04:07:12 -0700 Subject: [PATCH 138/144] Compact cached token handling --- nanocode.py | 15 ++++++--------- tests/test_nanocode_agent.py | 33 +++++++++++---------------------- 2 files changed, 17 insertions(+), 31 deletions(-) diff --git a/nanocode.py b/nanocode.py index ec499ee..8a99fc4 100644 --- a/nanocode.py +++ b/nanocode.py @@ -4285,15 +4285,12 @@ def _json_int(value: JsonValue) -> int: return value if isinstance(value, int) else 0 def _cached_prompt_tokens(self, usage: Json) -> int: - for key in ("prompt_cache_hit_tokens", "cached_tokens"): - cached_tokens = self._json_int(usage.get(key)) - if cached_tokens: - return cached_tokens - for key in ("prompt_tokens_details", "input_tokens_details"): - cached_tokens = self._json_int(_json_dict(usage.get(key)).get("cached_tokens")) - if cached_tokens: - return cached_tokens - return 0 + return ( + self._json_int(usage.get("prompt_cache_hit_tokens")) + or self._json_int(usage.get("cached_tokens")) + or self._json_int(_json_dict(usage.get("prompt_tokens_details")).get("cached_tokens")) + or self._json_int(_json_dict(usage.get("input_tokens_details")).get("cached_tokens")) + ) ############################ diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index 68965e4..b01369c 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -1307,28 +1307,17 @@ def model_dump(self, mode="json"): def test_agent_request_records_chat_cached_prompt_tokens(tmp_path, monkeypatch): - usage = {"prompt_tokens": 10, "prompt_tokens_details": {"cached_tokens": 6}, "completion_tokens": 3, "total_tokens": 13} - calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response(usage=usage)) - session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) - - Agent(session).request("system", "user") - - assert _sdk_payload(calls[0])["prompt_cache_key"].startswith("nanocode-") - assert session.state.last_cached_prompt_tokens == 6 - assert session.state.session_cached_prompt_tokens == 6 - assert session.state.model_usage["model"].cached_prompt_tokens == 6 - - -def test_agent_request_records_deepseek_cached_prompt_tokens(tmp_path, monkeypatch): - usage = {"prompt_tokens": 10, "prompt_cache_hit_tokens": 7, "prompt_cache_miss_tokens": 3, "completion_tokens": 2, "total_tokens": 12} - _calls, _response_calls, _client_kwargs = _patch_openai(monkeypatch, _chat_response(usage=usage)) - session = _session(tmp_path, api_url="https://api.deepseek.com/v1", api_key="key", model="model", stream=False) - - Agent(session).request("system", "user") - - assert session.state.last_cached_prompt_tokens == 7 - assert session.state.session_cached_prompt_tokens == 7 - assert session.state.model_usage["model"].cached_prompt_tokens == 7 + cases = ( + ({"prompt_tokens": 10, "prompt_tokens_details": {"cached_tokens": 6}, "completion_tokens": 3, "total_tokens": 13}, 6), + ({"prompt_tokens": 10, "prompt_cache_hit_tokens": 7, "prompt_cache_miss_tokens": 3, "completion_tokens": 2, "total_tokens": 12}, 7), + ) + _patch_openai(monkeypatch, tuple(_chat_response(usage=usage) for usage, _expected in cases)) + for _usage, expected in cases: + session = _session(tmp_path, api_url="https://example.test/v1", api_key="key", model="model", stream=False) + Agent(session).request("system", "user") + assert session.state.last_cached_prompt_tokens == expected + assert session.state.session_cached_prompt_tokens == expected + assert session.state.model_usage["model"].cached_prompt_tokens == expected def test_agent_request_responses_api_omits_reasoning_when_disabled(tmp_path, monkeypatch): From 926a8ba15480abfd53e45f3ad87f19d5570f14e1 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 04:11:07 -0700 Subject: [PATCH 139/144] Bump version to 0.4.8 --- nanocode.py | 2 +- pyproject.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nanocode.py b/nanocode.py index 8a99fc4..7858777 100644 --- a/nanocode.py +++ b/nanocode.py @@ -55,7 +55,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.7" +__version__ = "0.4.8" JsonValue: TypeAlias = Any diff --git a/pyproject.toml b/pyproject.toml index f6aab7e..22a0724 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.7" +version = "0.4.8" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" From 1890ed674793d1dcf7a5555b66161a05383b94f9 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 04:13:16 -0700 Subject: [PATCH 140/144] Complete 0.3.35 changelog --- CHANGELOG.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index e588004..6c1acae 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -48,14 +48,22 @@ ## 0.3.35 - 2026-05-16 +### Added +- Added batched `ReplaceRange` edits for multiple independent ranges in the same file. +- Added a design document covering agent state, context construction, tool-result storage, observe policy, and verification. + ### Changed - Aligned tool-result context layout with the design document. +- Refined tool-result context reduction around unreduced raw results, retained results, and checkpoint-based pruning. - Compressed ACT and OBSERVE system prompts. - Reduced routine OBSERVE triggers by raising the pending-result threshold and keeping ordinary tool failures in ACT for repair. +- Simplified agent gate and feedback handling, including single active plan item normalization. - Added soft feedback for state-update-only ACT turns so models continue with frontier tools, verification, or completion. +- Highlighted recognized slash commands and reported unknown slash commands directly. ### Fixed - Accepted harmless model output variants including trailing progress text, action type casing, and `message` action aliases. +- Ignored pending verification requests instead of treating them as blocking model output. ## 0.3.34 - 2026-05-16 From 2023c787334fe4d9f0bd7be1f390152b84cdaf01 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 04:14:41 -0700 Subject: [PATCH 141/144] ignore .code-workflow-probe --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 5bd750d..04d9654 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,4 @@ __pycache__/ uv.lock .python-version .code-symbol-index/ +.code-workflow-probe.json From 36a16dda41db32f4fb4a4f4c60c0679b2deb8e77 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 04:22:12 -0700 Subject: [PATCH 142/144] Rename EditFile tool to Edit across codebase and tests --- nanocode.py | 36 ++++++++--------- tests/test_nanocode_agent.py | 34 ++++++++-------- ...ile_tool.py => test_nanocode_edit_tool.py} | 40 +++++++++---------- tests/test_nanocode_loop.py | 4 +- tests/test_nanocode_search_tool.py | 26 ++++++------ 5 files changed, 70 insertions(+), 70 deletions(-) rename tests/{test_nanocode_edit_file_tool.py => test_nanocode_edit_tool.py} (80%) diff --git a/nanocode.py b/nanocode.py index 7858777..5c86c5e 100644 --- a/nanocode.py +++ b/nanocode.py @@ -2598,7 +2598,7 @@ class CreateFileTool(Tool): EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( "Create a new UTF-8 file; target file must not exist.", - "Use EditFile for existing files.", + "Use Edit for existing files.", "Returns changed path and created=true.", ) SIGNATURE: ClassVar[str] = "CreateFile(filepath, content) -> CreateFileToolResult" @@ -2650,7 +2650,7 @@ def call(self) -> str: @dataclass -class EditFileEdit: +class EditEdit: op: str start: str end: str @@ -2660,8 +2660,8 @@ class EditFileEdit: @dataclass -class EditFileTool(Tool): - NAME: ClassVar[str] = "EditFile" +class EditTool(Tool): + NAME: ClassVar[str] = "Edit" PARAM_NAMES: ClassVar[tuple[str, ...]] = ("filepath", "edits") EFFECT: ClassVar[ToolEffect] = ToolEffect.EDIT DESCRIPTION: ClassVar[tuple[str, ...]] = ( @@ -2671,10 +2671,10 @@ class EditFileTool(Tool): "Returns changed path, edit count, and applied ranges.", ) SIGNATURES: ClassVar[tuple[str, ...]] = ( - "EditFile(filepath, [{op:'replace', start, end, content}, ...]) -> replace anchored ranges", - "EditFile(filepath, [{op:'delete', start, end}, ...]) -> delete anchored ranges", - "EditFile(filepath, [{op:'insert_before'|'insert_after', start, content}, ...]) -> insert at anchors", - "EditFile(filepath, [{op:'replace_all', old, new}]) -> literal file-wide replacement", + "Edit(filepath, [{op:'replace', start, end, content}, ...]) -> replace anchored ranges", + "Edit(filepath, [{op:'delete', start, end}, ...]) -> delete anchored ranges", + "Edit(filepath, [{op:'insert_before'|'insert_after', start, content}, ...]) -> insert at anchors", + "Edit(filepath, [{op:'replace_all', old, new}]) -> literal file-wide replacement", ) EXAMPLE: ClassVar[tuple[str, ...]] = ( 'Example args: ["code.py", [{"op":"replace","start":"10:a1b2c3","end":"12:d4e5f6","content":"new lines\\n"}]]', @@ -2683,7 +2683,7 @@ class EditFileTool(Tool): ) filepath: str = "" - edits: list[EditFileEdit] = field(default_factory=list) + edits: list[EditEdit] = field(default_factory=list) cwd: str = "" @classmethod @@ -2733,7 +2733,7 @@ def make(cls, session: Session, args: list[JsonValue]) -> Self: return cls(filepath=session.resolve_path(str(args[0])), edits=[cls._edit_from_json(item) for item in edits], cwd=session.cwd) @staticmethod - def _edit_from_json(value: JsonValue) -> EditFileEdit: + def _edit_from_json(value: JsonValue) -> EditEdit: item = _json_dict(value) if not item: raise ToolCallArgError("each edit must be an object") @@ -2752,7 +2752,7 @@ def _edit_from_json(value: JsonValue) -> EditFileEdit: raise ToolCallArgError("replace_all old cannot be empty") if start or end: raise ToolCallArgError("replace_all does not use anchors") - return EditFileEdit(op=op, start="", end="", content="", old=old, new=new) + return EditEdit(op=op, start="", end="", content="", old=old, new=new) if not start: raise ToolCallArgError("edit start anchor is required") if op in {"replace", "delete"} and not end: @@ -2761,10 +2761,10 @@ def _edit_from_json(value: JsonValue) -> EditFileEdit: raise ToolCallArgError("insert edits use start anchor only") if op in {"replace", "insert_before", "insert_after"} and "content" not in item: raise ToolCallArgError("edit content is required") - return EditFileEdit(op=op, start=start, end=end, content=content) + return EditEdit(op=op, start=start, end=end, content=content) def preview(self) -> str: - label = f"EditFile({self.filepath}, {len(self.edits)} edits)" + label = f"Edit({self.filepath}, {len(self.edits)} edits)" try: original, new_content, _ = self._preview() except (OSError, ToolCallError) as error: @@ -2786,7 +2786,7 @@ def call(self) -> str: f.write(new_content) relpath = os.path.relpath(self.filepath, self.cwd) lines = [ - "", + "", f"* path: {relpath}", f"* edits: {len(replacements)}", ] @@ -2795,7 +2795,7 @@ def call(self) -> str: lines.append(f"* replace_all[{index}]: {end} replacements") else: lines.append(f"* range[{index}]: {start}:{end}") - lines.append("") + lines.append("") return "\n".join(lines) def _preview(self) -> tuple[str, str, list[tuple[int, int, list[str]]]]: @@ -3175,7 +3175,7 @@ def _content(self, item: ToolResultItem) -> str: InspectCodeTool.NAME: InspectCodeTool, SearchTool.NAME: SearchTool, CreateFileTool.NAME: CreateFileTool, - EditFileTool.NAME: EditFileTool, + EditTool.NAME: EditTool, BashTool.NAME: BashTool, GitTool.NAME: GitTool, ToolResultTool.NAME: ToolResultTool, @@ -5029,12 +5029,12 @@ class Agent: RULE_GOAL_PLAN_FIRST: ClassVar[str] = "set goal and a short plan before mutating tools or verify." RULE_VERIFY_DIRECTLY: ClassVar[str] = 'run checks, then report verify status="passed"|"failed"|"blocked".' RULE_TOOL_SIGNATURE: ClassVar[str] = "use the tool signature exactly." - RULE_EDIT_SIGNATURE: ClassVar[str] = "use EditFile(filepath, edits) with visible line anchors; split oversized batches." + RULE_EDIT_SIGNATURE: ClassVar[str] = "use Edit(filepath, edits) with visible line anchors; split oversized batches." RULE_COMPLETE_PLAN: ClassVar[str] = "mark every Plan item done or blocked with result context before completion." RULE_PLAN_FOLLOWUP: ClassVar[str] = "set followup_action and followup_check as {status, reason}; resolve needed before completion." RULE_BLOCKED_BY_USER: ClassVar[str] = "complete blocked Checks only when blocker=user." RULE_FUNCTION_TOOLS: ClassVar[str] = "use the provided function tools." - RULE_VALID_TOOL_JSON: ClassVar[str] = "rebuild valid function arguments; for EditFile, use one file/logical block and split oversized batches." + RULE_VALID_TOOL_JSON: ClassVar[str] = "rebuild valid function arguments; for Edit, use one file/logical block and split oversized batches." STALE_TOOL_FEEDBACK_MARKERS: ClassVar[tuple[str, ...]] = ( "invalid function/tool response", "invalid function-tool response", diff --git a/tests/test_nanocode_agent.py b/tests/test_nanocode_agent.py index b01369c..5195355 100644 --- a/tests/test_nanocode_agent.py +++ b/tests/test_nanocode_agent.py @@ -258,8 +258,8 @@ def test_agent_does_not_dedupe_same_batch_edit_tool_calls(tmp_path): agent.execute_tool_calls( [ - {"name": "EditFile", "intention": "first edit", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, - {"name": "EditFile", "intention": "second edit", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, + {"name": "Edit", "intention": "first edit", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, + {"name": "Edit", "intention": "second edit", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, ], confirm=lambda call, tool: True, ) @@ -639,7 +639,7 @@ def test_edit_tool_without_goal_or_plan_warns(tmp_path): result = agent.handle_response( { "actions": [ - {"type": "tool", "name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]} + {"type": "tool", "name": "Edit", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]} ] }, confirm=lambda call, tool: True, @@ -2708,12 +2708,12 @@ def test_agent_execute_tool_calls_requests_confirmation_for_edit_tools(tmp_path) anchor = _read_anchors(session, "sample.txt")[0] latest = agent.execute_tool_calls( - [{"name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], + [{"name": "Edit", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], confirm=lambda call, tool: confirmations.append((call.executed, tool.preview())) or False, ) assert confirmations - assert confirmations[0][0].startswith('EditFile("sample.txt", ') + assert confirmations[0][0].startswith('Edit("sample.txt", ') assert "-old" in confirmations[0][1] assert "+new" in confirmations[0][1] assert "Cancelled: user refused" in latest @@ -2728,7 +2728,7 @@ def test_agent_execute_tool_calls_records_refusal_reason(tmp_path): anchor = _read_anchors(session, "sample.txt")[0] latest = agent.execute_tool_calls( - [{"name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], + [{"name": "Edit", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], confirm=lambda call, tool: "please inspect tests first", ) @@ -2749,7 +2749,7 @@ def test_agent_execute_tool_calls_stops_batch_after_refusal(tmp_path): latest = agent.execute_tool_calls( [ - {"name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, + {"name": "Edit", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}, {"name": "Bash", "intention": "should not run", "args": ["touch should-not-exist"]}, ], confirm=lambda call, tool: "use English question", @@ -2757,7 +2757,7 @@ def test_agent_execute_tool_calls_stops_batch_after_refusal(tmp_path): assert "Cancelled: user refused: use English question" in latest assert "Bash" not in latest - assert [execution.call.name for execution in agent.tool_runner.latest_executions] == ["EditFile"] + assert [execution.call.name for execution in agent.tool_runner.latest_executions] == ["Edit"] assert path.read_text(encoding="utf-8") == "old\n" assert not (tmp_path / "should-not-exist").exists() @@ -2795,7 +2795,7 @@ def test_agent_execute_tool_calls_rejects_failed_preview_before_confirmation(tmp confirmations = [] latest = agent.execute_tool_calls( - [{"name": "EditFile", "intention": "edit stale range", "args": ["sample.txt", [{"op": "replace", "start": "0:abcdef", "end": "0:abcdef", "content": "new\n"}]]}], + [{"name": "Edit", "intention": "edit stale range", "args": ["sample.txt", [{"op": "replace", "start": "0:abcdef", "end": "0:abcdef", "content": "new\n"}]]}], confirm=lambda call, tool: confirmations.append((call.executed, tool.preview())) or True, ) @@ -2834,11 +2834,11 @@ def test_agent_execute_tool_calls_reports_arg_count_details(tmp_path): session = Session(cwd=str(tmp_path)) agent = Agent(session) - latest = agent.execute_tool_calls([{"name": "EditFile", "intention": "bad edit", "args": ["sample.txt", "0", "1"]}]) + latest = agent.execute_tool_calls([{"name": "Edit", "intention": "bad edit", "args": ["sample.txt", "0", "1"]}]) assert "ToolCallError: requires args: filepath, edits" in latest assert "got 3 args, expected 2, extra: 1" in agent.agent_feedback_errors[0] - assert "use EditFile(filepath, edits) with visible line anchors" in agent.agent_feedback_errors[0] + assert "use Edit(filepath, edits) with visible line anchors" in agent.agent_feedback_errors[0] def test_agent_drops_old_feedback_after_successful_tool_progress(tmp_path): @@ -2944,14 +2944,14 @@ def test_agent_execute_tool_calls_shows_auto_approval_in_yolo_mode(tmp_path): anchor = _read_anchors(session, "sample.txt")[0] latest = agent.execute_tool_calls( - [{"name": "EditFile", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], + [{"name": "Edit", "intention": "edit sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]]}], confirm=lambda call, tool: confirmations.append(call.executed) or False, on_auto_approve=lambda call, tool: auto_approvals.append((call.executed, tool.preview())), ) assert confirmations == [] assert auto_approvals - assert auto_approvals[0][0].startswith('EditFile("sample.txt", ') + assert auto_approvals[0][0].startswith('Edit("sample.txt", ') assert "-old" in auto_approvals[0][1] assert "+new" in auto_approvals[0][1] assert latest.startswith("- ok") @@ -3108,7 +3108,7 @@ def test_agent_normalizes_direct_repo_tool_action_type(tmp_path): { "actions": [ { - "type": "EditFile", + "type": "Edit", "intention": "change sample", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]], } @@ -3120,7 +3120,7 @@ def test_agent_normalizes_direct_repo_tool_action_type(tmp_path): assert result.done is False assert path.read_text(encoding="utf-8") == "new\n" - assert agent.tool_runner.latest_executions[0].call.name == "EditFile" + assert agent.tool_runner.latest_executions[0].call.name == "Edit" assert not any("Protocol_Gate" in message for message in messages) @@ -3185,7 +3185,7 @@ def __init__(self): {"type": "goal", "text": "change sample", "complete": False}, { "type": "tool", - "name": "EditFile", + "name": "Edit", "intention": "change sample text", "args": ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "new\n"}]], }, @@ -3224,7 +3224,7 @@ def request(self, system_prompt, user_prompt, *, activity="agent", **_kwargs): response = agent.run("change sample", confirm=lambda call, tool: True, on_message=messages.append) assert response["actions"][-1]["message_for_complete"] == "done" - assert any(message.startswith("[success] EditFile sample.txt 1 edits") for message in messages) + assert any(message.startswith("[success] Edit sample.txt 1 edits") for message in messages) assert not any(message.startswith("State Updated") for message in messages) assert any("edited files need Checks before completion" in error for error in agent.agent_feedback_errors) assert (tmp_path / "sample.txt").read_text(encoding="utf-8") == "new\n" diff --git a/tests/test_nanocode_edit_file_tool.py b/tests/test_nanocode_edit_tool.py similarity index 80% rename from tests/test_nanocode_edit_file_tool.py rename to tests/test_nanocode_edit_tool.py index 92507c1..5db5bd4 100644 --- a/tests/test_nanocode_edit_file_tool.py +++ b/tests/test_nanocode_edit_tool.py @@ -2,7 +2,7 @@ import pytest -from nanocode import Agent, EditFileTool, ReadTool, Session, ToolCallError +from nanocode import Agent, EditTool, ReadTool, Session, ToolCallError def _anchors(read_result: str) -> list[str]: @@ -20,7 +20,7 @@ def test_edit_file_replaces_range_from_read_anchors(tmp_path): session = Session(cwd=str(tmp_path)) anchors = _read_anchors(session, "sample.txt") - tool = EditFileTool.make(session, ["sample.txt", [{"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}]]) + tool = EditTool.make(session, ["sample.txt", [{"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}]]) display = tool.preview() result = tool.call() @@ -30,11 +30,11 @@ def test_edit_file_replaces_range_from_read_anchors(tmp_path): assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" assert result == "\n".join( [ - "", + "", "* path: sample.txt", "* edits: 1", "* range[1]: 1:2", - "", + "", ] ) @@ -46,7 +46,7 @@ def test_edit_file_accepts_full_hashline_anchor(tmp_path): read_result = ReadTool.make(session, ["sample.txt"]).call() full_hashline = next(line for line in read_result.splitlines() if line.endswith("|beta")) - EditFileTool.make(session, ["sample.txt", [{"op": "replace", "start": full_hashline, "end": full_hashline, "content": "BETA\n"}]]).call() + EditTool.make(session, ["sample.txt", [{"op": "replace", "start": full_hashline, "end": full_hashline, "content": "BETA\n"}]]).call() assert path.read_text(encoding="utf-8") == "alpha\nBETA\n" @@ -57,7 +57,7 @@ def test_edit_file_inserts_and_deletes_atomically(tmp_path): session = Session(cwd=str(tmp_path)) anchors = _read_anchors(session, "sample.txt") - result = EditFileTool.make( + result = EditTool.make( session, [ "sample.txt", @@ -78,7 +78,7 @@ def test_edit_file_replace_all_literal_text_without_anchors(tmp_path): path.write_text("OldName alpha\nOldName beta\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = EditFileTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "OldName", "new": "NewName"}]]) + tool = EditTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "OldName", "new": "NewName"}]]) display = tool.preview() result = tool.call() @@ -96,9 +96,9 @@ def test_edit_file_replace_all_rejects_no_match_or_mixed_edits(tmp_path): anchors = _read_anchors(session, "sample.txt") with pytest.raises(ToolCallError, match="old text not found"): - EditFileTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "missing", "new": "x"}]]).call() + EditTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "missing", "new": "x"}]]).call() with pytest.raises(ToolCallError, match="cannot be mixed"): - EditFileTool.make( + EditTool.make( session, [ "sample.txt", @@ -118,7 +118,7 @@ def test_edit_file_rejects_stale_anchor_without_writing(tmp_path): anchors = _read_anchors(session, "sample.txt") path.write_text("alpha\nchanged\n", encoding="utf-8") - tool = EditFileTool.make(session, ["sample.txt", [{"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}]]) + tool = EditTool.make(session, ["sample.txt", [{"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}]]) assert "stale anchor" in tool.preview() with pytest.raises(ToolCallError, match="stale anchor"): @@ -132,7 +132,7 @@ def test_edit_file_rejects_overlapping_edits_without_writing(tmp_path): session = Session(cwd=str(tmp_path)) anchors = _read_anchors(session, "sample.txt") - tool = EditFileTool.make( + tool = EditTool.make( session, [ "sample.txt", @@ -150,7 +150,7 @@ def test_edit_file_rejects_overlapping_edits_without_writing(tmp_path): def test_edit_file_rejects_missing_files(tmp_path): session = Session(cwd=str(tmp_path)) - tool = EditFileTool.make(session, ["missing.txt", [{"op": "insert_after", "start": "0:abcdef", "content": "alpha\n"}]]) + tool = EditTool.make(session, ["missing.txt", [{"op": "insert_after", "start": "0:abcdef", "content": "alpha\n"}]]) assert "use CreateFile" in tool.preview() with pytest.raises(ToolCallError, match="use CreateFile"): @@ -161,19 +161,19 @@ def test_edit_file_rejects_wrong_arg_shape(tmp_path): session = Session(cwd=str(tmp_path)) with pytest.raises(ToolCallError, match="requires args: filepath, edits"): - EditFileTool.make(session, []) + EditTool.make(session, []) with pytest.raises(ToolCallError, match="edits cannot be empty"): - EditFileTool.make(session, ["sample.txt", []]) + EditTool.make(session, ["sample.txt", []]) with pytest.raises(ToolCallError, match="edit op must be"): - EditFileTool.make(session, ["sample.txt", [{"op": "move", "start": "0:abcdef"}]]) + EditTool.make(session, ["sample.txt", [{"op": "move", "start": "0:abcdef"}]]) with pytest.raises(ToolCallError, match="replace_all requires old and new"): - EditFileTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "alpha"}]]) + EditTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "alpha"}]]) with pytest.raises(ToolCallError, match="replace_all old cannot be empty"): - EditFileTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "", "new": "beta"}]]) + EditTool.make(session, ["sample.txt", [{"op": "replace_all", "old": "", "new": "beta"}]]) def test_edit_file_schema_describes_two_structured_args(): - args_schema = EditFileTool.tool_schema()["function"]["parameters"]["properties"]["args"] + args_schema = EditTool.tool_schema()["function"]["parameters"]["properties"]["args"] assert args_schema["minItems"] == 2 assert args_schema["maxItems"] == 2 @@ -193,7 +193,7 @@ def test_agent_executes_edit_file_with_structured_args(tmp_path): latest = agent.execute_tool_calls( [ { - "name": "EditFile", + "name": "Edit", "intention": "replace beta", "args": ["sample.txt", [{"op": "replace", "start": anchors[1], "end": anchors[1], "content": "BETA\n"}]], } @@ -202,5 +202,5 @@ def test_agent_executes_edit_file_with_structured_args(tmp_path): ) assert path.read_text(encoding="utf-8") == "alpha\nBETA\n" - assert "" in latest + assert "" in latest assert agent.blackboard.checks_required is True diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index 1195995..f13fc41 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -366,12 +366,12 @@ def preview(self): outputs = [] loop = AgentLoop(FakeAgent(), output_fn=outputs.append) - call = ParsedToolCall(name="EditFile", intention="edit sample", args=["sample.txt", [{"op": "replace", "start": "0:abcdef", "end": "0:abcdef", "content": "new\n"}]]) + call = ParsedToolCall(name="Edit", intention="edit sample", args=["sample.txt", [{"op": "replace", "start": "0:abcdef", "end": "0:abcdef", "content": "new\n"}]]) loop._show_auto_tool_call(call, FakeTool()) assert any("Auto Tool Call | auto approved" in output for output in outputs) - assert any('Run EditFile("sample.txt", ' in output for output in outputs) + assert any('Run Edit("sample.txt", ' in output for output in outputs) assert any("Why edit sample" in output for output in outputs) assert any("Preview\npreview" in output for output in outputs) diff --git a/tests/test_nanocode_search_tool.py b/tests/test_nanocode_search_tool.py index 79b64c9..f2ceb7e 100644 --- a/tests/test_nanocode_search_tool.py +++ b/tests/test_nanocode_search_tool.py @@ -3,7 +3,7 @@ import nanocode import pytest -from nanocode import EditFileTool, SearchTool, Session, ToolCallError +from nanocode import EditTool, SearchTool, Session, ToolCallError def test_search_tool_python_backend_finds_or_patterns_and_applies_glob(tmp_path, monkeypatch): @@ -42,23 +42,23 @@ def test_search_tool_rejects_many_plain_args_without_explicit_path(tmp_path): session = Session(cwd=str(tmp_path)) with pytest.raises(ToolCallError, match="requires 1 to 4 args"): - SearchTool.make(session, ["class EditFile", "class Bash", "class Search", "class Read", "class CreateFile"]) + SearchTool.make(session, ["class Edit", "class Bash", "class Search", "class Read", "class CreateFile"]) def test_search_tool_treats_second_plain_arg_as_path(tmp_path): path = tmp_path / "sample.py" - path.write_text("class EditFileTool:\nclass BashTool:\n", encoding="utf-8") + path.write_text("class EditTool:\nclass BashTool:\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = SearchTool.make(session, ["class EditFile|class Bash", "sample.py"]) + tool = SearchTool.make(session, ["class Edit|class Bash", "sample.py"]) - assert tool.pattern == "class EditFile|class Bash" + assert tool.pattern == "class Edit|class Bash" assert tool.target_path == str(path) def test_search_tool_accepts_explicit_path_option_with_regex_and_context(tmp_path, monkeypatch): path = tmp_path / "nanocode.py" - path.write_text("class EditFileTool:\nclass BashTool:\n", encoding="utf-8") + path.write_text("class EditTool:\nclass BashTool:\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) monkeypatch.setattr(nanocode.shutil, "which", lambda name: "") @@ -67,16 +67,16 @@ def test_search_tool_accepts_explicit_path_option_with_regex_and_context(tmp_pat assert tool.target_path == str(path) assert tool.context_lines == 0 - assert "* nanocode.py:1: class EditFileTool:" in result + assert "* nanocode.py:1: class EditTool:" in result assert "* nanocode.py:2: class BashTool:" in result def test_search_tool_accepts_explicit_path_option_as_second_arg(tmp_path): path = tmp_path / "nanocode.py" - path.write_text("class EditFileTool:\nclass BashTool:\n", encoding="utf-8") + path.write_text("class EditTool:\nclass BashTool:\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = SearchTool.make(session, ["class EditFile", "path=nanocode.py"]) + tool = SearchTool.make(session, ["class Edit", "path=nanocode.py"]) assert tool.target_path == str(path) assert tool.context_lines == SearchTool.CONTEXT_LINES @@ -84,12 +84,12 @@ def test_search_tool_accepts_explicit_path_option_as_second_arg(tmp_path): def test_search_tool_accepts_explicit_path_option_with_multiple_terms(tmp_path): path = tmp_path / "nanocode.py" - path.write_text("class EditFileTool:\nclass BashTool:\n", encoding="utf-8") + path.write_text("class EditTool:\nclass BashTool:\n", encoding="utf-8") session = Session(cwd=str(tmp_path)) - tool = SearchTool.make(session, ["class EditFile", "class Bash", "path=nanocode.py"]) + tool = SearchTool.make(session, ["class Edit", "class Bash", "path=nanocode.py"]) - assert tool.pattern == "class EditFile|class Bash" + assert tool.pattern == "class Edit|class Bash" assert tool.target_path == str(path) @@ -189,7 +189,7 @@ def test_search_tool_context_anchor_can_drive_edit_file(tmp_path, monkeypatch): result = SearchTool.make(session, ["beta", "sample.txt", "context=0"]).call() anchor = re.search(r">\s+(\d+:[0-9a-f]{6})\|beta", result).group(1) - EditFileTool.make(session, ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "BETA\n"}]]).call() + EditTool.make(session, ["sample.txt", [{"op": "replace", "start": anchor, "end": anchor, "content": "BETA\n"}]]).call() assert path.read_text(encoding="utf-8") == "alpha\nBETA\ngamma\n" From 57eeb84656abb15a0af1b44a61aa8a3d32575ab8 Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 04:25:58 -0700 Subject: [PATCH 143/144] Update CHANGELOG for 0.4.8: rename EditFile to Edit --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6c1acae..aa8e1af 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## 0.4.8 - 2026-05-23 + +### Changed +- Renamed the `EditFile` tool to `Edit` across the codebase and tests. + ## 0.4.5 - 2026-05-21 ### Changed From e4cf832faa61ea333157b315c8b0ab7b33cd33dc Mon Sep 17 00:00:00 2001 From: hit9 Date: Sat, 23 May 2026 04:34:18 -0700 Subject: [PATCH 144/144] Update code index after task completion --- nanocode.py | 30 ++++++++++++++++++------- pyproject.toml | 2 +- tests/test_nanocode_code_index_tools.py | 30 +++++++++++++++++++++++-- tests/test_nanocode_loop.py | 3 ++- 4 files changed, 53 insertions(+), 12 deletions(-) diff --git a/nanocode.py b/nanocode.py index 5c86c5e..3cc885c 100644 --- a/nanocode.py +++ b/nanocode.py @@ -55,7 +55,7 @@ from prompt_toolkit.patch_stdout import patch_stdout from prompt_toolkit.styles import Style -__version__ = "0.4.8" +__version__ = "0.4.9" JsonValue: TypeAlias = Any @@ -2432,14 +2432,29 @@ def _code_index_sync(session: Session, *, force: bool = False) -> str: return "\n".join(lines) -def _code_index_update(session: Session, filepath: str) -> None: - if _code_index_module() is None or not session.is_path_in_cwd(filepath): +CODE_INDEX_AUTO_UPDATE_PENDING_LIMIT = 20 + + +def _code_index_update_pending(session: Session, *, limit: int = CODE_INDEX_AUTO_UPDATE_PENDING_LIMIT) -> None: + module = _code_index_module() + if module is None or session.state.code_index_refreshing: return - status, _message = _code_index_status(session) - if status == "missing": + try: + status = module.status(session.cwd, db_path=_code_index_db_path(session), check=True, max_pending_files=limit + 1, format="object") + except Exception as error: + session.state.code_index_error = str(error) + return + if str(getattr(status, "status", "")) != "stale": + return + pending_changes = getattr(status, "pending_changes", None) + files = [str(path) for path in getattr(status, "pending_files", ()) if path] + if not files or len(files) > limit or (isinstance(pending_changes, int) and pending_changes > limit): + return + paths = list(dict.fromkeys(path for path in (session.resolve_path(path) for path in files) if session.is_path_in_cwd(path))) + if not paths: return try: - _code_index_repository(session).update([filepath]) + _code_index_repository(session).update(paths) session.state.code_index_error = "" except Exception as error: session.state.code_index_error = str(error) @@ -5613,8 +5628,6 @@ def _after_tool_execution(self, execution: ToolCallExecution) -> None: self.blackboard.checks_required = True self.blackboard.task_code = TaskCode.CHECKING self._remember_recent_edit(execution) - if execution.call.args: - _code_index_update(self.session, self.session.resolve_path(str(execution.call.args[0]))) def _remember_tool_failure(self, execution: ToolCallExecution) -> None: if execution.outcome != "failure": @@ -7717,6 +7730,7 @@ def _run_agent(self, user_input: str) -> None: self.agent.session.state.manual_model_retry_requested = False if runtime_ui_running: self._stop_runtime_ui() + _code_index_update_pending(self.agent.session) self.status_bar.pause() def _run_with_status(self, action: StatusAction) -> str: diff --git a/pyproject.toml b/pyproject.toml index 22a0724..13a7483 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "nanocode-cli" -version = "0.4.8" +version = "0.4.9" description = "A lightweight terminal-based AI coding assistant" readme = "README.md" requires-python = ">=3.11" diff --git a/tests/test_nanocode_code_index_tools.py b/tests/test_nanocode_code_index_tools.py index d52c77d..e8c89f0 100644 --- a/tests/test_nanocode_code_index_tools.py +++ b/tests/test_nanocode_code_index_tools.py @@ -47,14 +47,21 @@ def outline_text(self, filepath, *, symbol=None): return "file: " + filepath + "\noutline:\n class Tool 0:2 class Tool:" -def fake_code_index_module(status="ready", *, refresh_status=None): +def fake_code_index_module(status="ready", *, refresh_status=None, pending_changes=None, pending_files=()): FakeRepository.status = status FakeRepository.refresh_status = refresh_status def status_fn(root, *, db_path=None, check=False, max_pending_files=50, format="object"): status = FakeRepository.status FakeRepository.events.append(("status", root, db_path, check, max_pending_files, format)) - return SimpleNamespace(status=status, reason="index not initialized" if status == "missing" else "", message="") + files = tuple(pending_files[:max_pending_files]) + return SimpleNamespace( + status=status, + reason="index not initialized" if status == "missing" else "", + message="", + pending_changes=len(pending_files) if pending_changes is None else pending_changes, + pending_files=files, + ) def refresh_async(root, *, db_path=None, progress=None, **kwargs): FakeRepository.events.append(("refresh_async", root, db_path, progress is not None, kwargs)) @@ -173,6 +180,25 @@ def test_code_index_refresh_existing_async_starts_for_ready_index(tmp_path, monk assert session.state.code_index_reload_needed is False +def test_code_index_update_pending_updates_small_stale_file_set(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module("stale", pending_files=("a.py", "pkg/b.py"))) + + nanocode._code_index_update_pending(session, limit=3) + + assert ("status", str(tmp_path), nanocode._code_index_db_path(session), True, 4, "object") in FakeRepository.events + assert ("update", (str(tmp_path / "a.py"), str(tmp_path / "pkg" / "b.py")), str(tmp_path), nanocode._code_index_db_path(session), False) in FakeRepository.events + + +def test_code_index_update_pending_skips_large_stale_file_set(tmp_path, monkeypatch): + session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) + monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module("stale", pending_changes=4, pending_files=("a.py", "b.py", "c.py"))) + + nanocode._code_index_update_pending(session, limit=3) + + assert not [event for event in FakeRepository.events if event[0] == "update"] + + def test_inspect_code_find_uses_search_text(tmp_path, monkeypatch): session = Session(cwd=str(tmp_path), config=nanocode.Config(data_dir=str(tmp_path / "data"))) monkeypatch.setattr(nanocode, "_code_index_module", lambda: fake_code_index_module()) diff --git a/tests/test_nanocode_loop.py b/tests/test_nanocode_loop.py index f13fc41..d9fbb40 100644 --- a/tests/test_nanocode_loop.py +++ b/tests/test_nanocode_loop.py @@ -597,13 +597,14 @@ def run(self, user_input, **kwargs): monkeypatch.setattr(loop.status_bar, "reset_timer", lambda: calls.append("reset")) monkeypatch.setattr(loop.status_bar, "resume", lambda: calls.append("resume")) monkeypatch.setattr(loop.status_bar, "pause", lambda: calls.append("pause")) + monkeypatch.setattr(nanocode, "_code_index_update_pending", lambda session: calls.append("index")) loop._run_agent("hello") assert loop.agent.runs == ["hello"] assert loop.agent.poll_user_input.__self__ is loop assert loop.agent.poll_user_input.__func__ is AgentLoop._pop_queued_input - assert calls == ["reset", "start-ui", "stop-ui", "pause"] + assert calls == ["reset", "start-ui", "stop-ui", "index", "pause"] def test_agent_loop_clears_queued_input_on_cancel(tmp_path, monkeypatch):