nanocode-cli 0.6.4__tar.gz → 0.6.6__tar.gz

{nanocode_cli-0.6.4/nanocode_cli.egg-info → nanocode_cli-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.6.4
+Version: 0.6.6
 Summary: A small terminal coding agent written in Python
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause
@@ -240,7 +240,7 @@ model request
 |   conversation, compacted summaries, tools       |
 +--------------------------------------------------+
 | user                                             |
-|   Memory: goal, plan, known, date                |
+|   Memory: goal, plan, known, code index, date    |
 +--------------------------------------------------+
 | user                                             |
 |   FILE STATE: latest Read/Edit file view         |
@@ -249,6 +249,7 @@ model request
 
 Core rules:
 
+- Environment holds only stable host facts (cwd, os, arch, detected commands) so it stays byte-identical across turns and keeps the conversation prefix cacheable; volatile state like the code index status lives in the late Memory section instead.
 - Mid-turn assistant text and appended user input are kept as conversation.
 - Earlier conversation is compacted into an explicit summary when the context grows too large.
 - FILE STATE is updated by successful `Read` and `Edit` tools and shows current listed file ranges, with recent files first.

{nanocode_cli-0.6.4 → nanocode_cli-0.6.6}/README.md

@@ -204,7 +204,7 @@ model request
 |   conversation, compacted summaries, tools       |
 +--------------------------------------------------+
 | user                                             |
-|   Memory: goal, plan, known, date                |
+|   Memory: goal, plan, known, code index, date    |
 +--------------------------------------------------+
 | user                                             |
 |   FILE STATE: latest Read/Edit file view         |
@@ -213,6 +213,7 @@ model request
 
 Core rules:
 
+- Environment holds only stable host facts (cwd, os, arch, detected commands) so it stays byte-identical across turns and keeps the conversation prefix cacheable; volatile state like the code index status lives in the late Memory section instead.
 - Mid-turn assistant text and appended user input are kept as conversation.
 - Earlier conversation is compacted into an explicit summary when the context grows too large.
 - FILE STATE is updated by successful `Read` and `Edit` tools and shows current listed file ranges, with recent files first.

{nanocode_cli-0.6.4 → nanocode_cli-0.6.6}/nanocode.py

@@ -41,7 +41,7 @@ from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.completion import CompleteEvent, Completer, Completion
 from prompt_toolkit.document import Document
 from prompt_toolkit.filters import Condition, has_completions, is_done
-from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.formatted_text import ANSI, FormattedText
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.keys import Keys
@@ -59,7 +59,7 @@ from rich.console import Console
 from rich.markdown import Markdown
 from rich.rule import Rule
 
-__version__ = "0.6.4"
+__version__ = "0.6.6"
 
 Json = dict[str, Any]
 HTTP_USER_AGENT = "nanocode/" + __version__
@@ -410,6 +410,7 @@ class ModelUsage:
     total_tokens: int = 0
     cached_prompt_tokens: int = 0
     last_total_tokens: int = 0
+    last_prompt_tokens: int = 0
     last_cached_prompt_tokens: int = 0
 
     def add(self, usage: Any) -> None:
@@ -436,6 +437,7 @@ class ModelUsage:
         self.total_tokens += total_tokens
         self.cached_prompt_tokens += cached_tokens
         self.last_total_tokens = total_tokens
+        self.last_prompt_tokens = prompt_tokens
         self.last_cached_prompt_tokens = cached_tokens
 
 
@@ -659,6 +661,15 @@ class MCPToolInfo:
     annotations: Json = field(default_factory=dict)
 
 
+@dataclass
+class MCPResourceInfo:
+    server: str
+    uri: str
+    name: str
+    description: str
+    mime_type: str = ""
+
+
 @dataclass
 class SystemInfo:
     COMMANDS: ClassVar[tuple[str, ...]] = (
@@ -773,6 +784,7 @@ class SessionSnapshotCodec:
             "total_tokens": usage.total_tokens,
             "cached_prompt_tokens": usage.cached_prompt_tokens,
             "last_cached_prompt_tokens": usage.last_cached_prompt_tokens,
+            "last_prompt_tokens": usage.last_prompt_tokens,
             "last_total_tokens": usage.last_total_tokens,
         }
 
@@ -858,6 +870,7 @@ class SessionSnapshotCodec:
         usage.total_tokens = data.get("total_tokens", 0)
         usage.cached_prompt_tokens = data.get("cached_prompt_tokens", 0)
         usage.last_cached_prompt_tokens = data.get("last_cached_prompt_tokens", 0)
+        usage.last_prompt_tokens = data.get("last_prompt_tokens", 0)
         usage.last_total_tokens = data.get("last_total_tokens", 0)
         return usage
 
@@ -2880,8 +2893,8 @@ class QuestionTool(Tool):
 
 class MCPTool(Tool):
     NAME = "MCP"
-    DESCRIPTION = "Call or describe external MCP server tools"
-    SIGNATURE = 'MCP(action="call"|"describe", server, tool, arguments={})'
+    DESCRIPTION = "Call/describe external MCP server tools, and list/read MCP resources"
+    SIGNATURE = 'MCP(action="call"|"describe"|"list_resources"|"read_resource", server, tool?, arguments?, uri?)'
     MUTATES = True
 
     @classmethod
@@ -2891,8 +2904,8 @@ class MCPTool(Tool):
             "properties": {
                 "action": {
                     "type": "string",
-                    "enum": ["call", "describe"],
-                    "description": '"call" invokes the tool; "describe" returns metadata',
+                    "enum": ["call", "describe", "list_resources", "read_resource"],
+                    "description": '"call" invokes a tool; "describe" returns a tool\'s schema; "list_resources" lists a server\'s resources; "read_resource" reads one by uri',
                 },
                 "server": {
                     "type": "string",
@@ -2900,14 +2913,18 @@ class MCPTool(Tool):
                 },
                 "tool": {
                     "type": "string",
-                    "description": "Remote MCP tool name",
+                    "description": "Remote MCP tool name (required for call/describe)",
                 },
                 "arguments": {
                     "type": "object",
                     "description": "Arguments for the remote tool (required for call)",
                 },
+                "uri": {
+                    "type": "string",
+                    "description": "Resource URI (required for read_resource), e.g. scheme://path",
+                },
             },
-            "required": ["action", "server", "tool"],
+            "required": ["action", "server"],
             "additionalProperties": False,
         }
 
@@ -2920,21 +2937,35 @@ class MCPTool(Tool):
             raise ToolError("MCP requires named fields")
         return self.args[0]
 
+    ACTIONS: ClassVar[tuple[str, ...]] = ("call", "describe", "list_resources", "read_resource")
+
+    @classmethod
+    def resolved_action(cls, payload: Json) -> str:
+        """Effective action; defaults to "call" when omitted but the envelope looks like an invocation."""
+        action = str(payload.get("action") or "").strip()
+        if action:
+            return action
+        if payload.get("tool") or payload.get("arguments") is not None:
+            return "call"
+        return action
+
     def needs_confirmation(self) -> bool:
         payload = self.payload()
-        action = payload.get("action", "")
-        if action == "describe":
+        if self.resolved_action(payload) != "call":
             return False
-        if action != "call" or self.session.mcp is None:
+        if self.session.mcp is None:
             return False
         return self.session.mcp.tool_needs_confirmation(str(payload.get("server") or ""), str(payload.get("tool") or ""))
 
     def short_args(self) -> list[str]:
         payload = self.payload()
-        action = str(payload.get("action") or "")
+        action = self.resolved_action(payload)
         server = str(payload.get("server") or "")
         tool_name = str(payload.get("tool") or "")
-        target = (server + "." + tool_name).strip(".")
+        if action == "read_resource":
+            target = (server + " " + str(payload.get("uri") or "")).strip()
+        else:
+            target = (server + "." + tool_name).strip(".")
         parts = [part for part in (action, target) if part]
         arguments = payload.get("arguments")
         if action == "call" and isinstance(arguments, dict) and arguments:
@@ -2948,7 +2979,7 @@ class MCPTool(Tool):
 
     def call(self) -> str:
         payload = self.payload()
-        action = payload.get("action", "")
+        action = self.resolved_action(payload)
         server = payload.get("server", "")
         tool_name = payload.get("tool", "")
         arguments = payload.get("arguments", {})
@@ -2962,8 +2993,20 @@ class MCPTool(Tool):
         if action == "describe":
             return mcp.describe_tool(server, tool_name)
         if action == "call":
-            return mcp.call_tool(server, tool_name, arguments)
-        raise ToolError(f"unknown MCP action: {action}")
+            prefix = mcp.auto_read_prefix(server, tool_name)
+            try:
+                output = mcp.call_tool(server, tool_name, arguments)
+            except ToolError as error:
+                raise ToolError(f"{error}\n\n{prefix}" if prefix else str(error)) from error
+            return prefix + output if prefix else output
+        if action == "list_resources":
+            return mcp.list_resources(server)
+        if action == "read_resource":
+            return mcp.read_resource(server, str(payload.get("uri") or ""))
+        raise ToolError(
+            f"unknown MCP action {action!r}. Valid actions: {', '.join(self.ACTIONS)}. "
+            f"To invoke a remote tool named {action!r}, use action=\"call\", tool={action!r}."
+        )
 
 TOOLS: tuple[type[Tool], ...] = (
     MCPTool,
@@ -2993,9 +3036,7 @@ class ToolCall:
 class ContextManager:
     COMPACT_TITLE: ClassVar[str] = "--- Prior Conversation Summary (compacted) ---"
     COMPACT_RECENT_MESSAGES: ClassVar[int] = 8
-    MCP_DETAILS_BUDGET: ClassVar[int] = 8_000
-    MCP_DETAILS_MAX_TOOLS: ClassVar[int] = 20
-    MCP_DETAILS_MAX_TOOL_CHARS: ClassVar[int] = 2_000
+    MCP_DESCRIBE_BLOCK: ClassVar[re.Pattern] = re.compile(r"<MCPDescribe server=(\".*?\") tool=(\".*?\")>.*?</MCPDescribe>", re.DOTALL)
     CODE_EXTENSIONS: ClassVar[set[str]] = set(
         ".c .cc .cpp .cxx .css .go .h .hpp .html .java .js .json .jsx .kt .lua .php .py .rb .rs .scss .sh .sql "
         ".swift .toml .ts .tsx .vue .yaml .yml".split()
@@ -3022,7 +3063,6 @@ class ContextManager:
     def model_messages(self, base_system: str, turn_messages: list[Json] | None = None) -> list[Json]:
         file_context = self.file_context() or "(empty)"
         mcp_tools = self.mcp_tools_context()
-        mcp_details = self.mcp_tool_details()
 
         messages: list[Json] = [
             {"role": "system", "content": base_system.strip()},
@@ -3032,75 +3072,51 @@ class ContextManager:
         if mcp_tools:
             messages.append({"role": "user", "content": mcp_tools})
 
-        messages.extend(self.session.messages)
-        messages.extend(turn_messages or [])
+        messages.extend(self.dedup_mcp_describes([*self.session.messages, *(turn_messages or [])]))
         messages.append({"role": "user", "content": "--- Memory ---\n" + (self.memory_context(with_date=True) or "(empty)")})
-
-        if mcp_details:
-            messages.append({"role": "user", "content": mcp_details})
-
         messages.append({"role": "user", "content": "--- FILE STATE ---\n" + file_context})
         return Text.value(messages)
 
+    def dedup_mcp_describes(self, messages: list[Json]) -> list[Json]:
+        """Collapse repeated MCP describe results to a pointer, keeping the first per (server, tool).
+
+        Pure send-time transform — stored history is never mutated. The first describe of a tool keeps
+        its full schema (and stays in the cached prefix); a later duplicate shrinks to a one-line pointer
+        the moment it appears, so the sent prefix stays byte-stable across calls and we reclaim the
+        repeated schema tokens. Only ever collapses the newer occurrence, never an earlier (cached) one;
+        if the first occurrence is later compacted away, the next one is promoted to full on its own.
+        """
+        seen: dict[tuple[str, str], str] = {}
+        result: list[Json] = []
+        for message in messages:
+            content = message.get("content")
+            if message.get("role") != "tool" or not isinstance(content, str):
+                result.append(message)
+                continue
+            match = self.MCP_DESCRIBE_BLOCK.search(content)
+            if match is None:
+                result.append(message)
+                continue
+            try:
+                identity = (str(json.loads(match.group(1))), str(json.loads(match.group(2))))
+            except (json.JSONDecodeError, ValueError):
+                result.append(message)
+                continue
+            first_key = seen.get(identity)
+            if first_key is None:
+                key = re.search(r"\btr\.\d+\b", content)
+                seen[identity] = key.group(0) if key else "above"
+                result.append(message)
+                continue
+            marker = f"(repeat describe of {identity[0]}.{identity[1]}; schema shown earlier at {first_key}, unchanged)"
+            result.append({**message, "content": self.MCP_DESCRIBE_BLOCK.sub(lambda _: marker, content)})
+        return result
+
     def mcp_tools_context(self) -> str:
         if self.session.mcp is None:
             return ""
         return self.session.mcp.render_tools_index()
 
-    def mcp_tool_details(self) -> str:
-        items = self.active_mcp_tool_details()
-        if not items:
-            return ""
-
-        chunks: list[str] = []
-        chunks.append("--- MCP TOOL DETAILS ---")
-        chunks.append('Details previously requested with MCP(action="describe").')
-        chunks.append('Use MCP(action="call", server, tool, arguments) to call them.')
-        chunks.append("")
-
-        for _source_order, server, tool, key, body in items:
-            detail_block = f"{server}.{tool} source={key}\n{body}"
-            chunks.append(detail_block)
-            chunks.append("")
-
-        return "\n".join(chunks).strip()
-
-    def active_mcp_tool_details(self) -> list[tuple[int, str, str, str, str]]:
-        details: dict[tuple[str, str], tuple[int, str, str]] = {}
-        for order, record in enumerate(self.session.tool_records):
-            if record.name != "MCP":
-                continue
-            for match in re.finditer(r'<MCPDescribe server=(".*?") tool=(".*?")>(.*?)</MCPDescribe>', record.output, re.DOTALL):
-                try:
-                    server = str(json.loads(match.group(1)))
-                    tool = str(json.loads(match.group(2)))
-                    body = match.group(3).strip()
-                except (json.JSONDecodeError, ValueError):
-                    continue
-                details[(server, tool)] = (order, record.key, body)
-
-        items = sorted((order, server, tool, key, body) for (server, tool), (order, key, body) in details.items())
-        items = items[-self.MCP_DETAILS_MAX_TOOLS :]
-        active: list[tuple[int, str, str, str, str]] = []
-        total_chars = len("--- MCP TOOL DETAILS ---\n") + 160
-        truncated = False
-        for order, server, tool, key, body in items:
-            header = f"{server}.{tool} source={key}"
-            detail_block = f"{header}\n{body}"
-            if len(detail_block) > self.MCP_DETAILS_MAX_TOOL_CHARS:
-                body = body[: max(0, self.MCP_DETAILS_MAX_TOOL_CHARS - len(header) - 24)] + "\n... detail truncated"
-                detail_block = f"{header}\n{body}"
-                truncated = True
-            if total_chars + len(detail_block) + 1 > self.MCP_DETAILS_BUDGET:
-                truncated = True
-                break
-            active.append((order, server, tool, key, body))
-            total_chars += len(detail_block) + 1
-        if truncated and active:
-            order, server, tool, key, body = active[-1]
-            active[-1] = (order, server, tool, key, body + '\n... MCP tool details truncated; use MCP(action="describe", server, tool) again if needed.')
-        return active
-
     def update_percent(self, messages: list[Json]) -> int:
         tokens = self.estimated_tokens(messages)
         self.session.state.context_percent = min(100, tokens * 100 // self.session.settings.max_context_tokens)
@@ -3127,11 +3143,14 @@ class ContextManager:
         return self.estimated_tokens(self.model_messages(base_system, turn_messages)) >= self.session.settings.max_context_tokens
 
     def memory_context(self, *, with_date: bool = False) -> str:
+        index_status = self.session.state.code_index_status or "missing"
+        index_usable = "yes" if index_status in {"synced", "ready", "stale"} else "no"
         rows = [
             "Goal: " + (self.session.state.goal or "(empty; use Note for multi-step work)"),
             "Plan:\n" + "\n".join(self.session.state.plan_rows() or ["- (empty; use Note for a short plan)"]),
             "Known:\n" + "\n".join("- " + item for item in self.session.state.known or ["(empty)"]),
             "Check: " + (self.session.state.check or "(empty)"),
+            f"Code index: {index_status} (InspectCode usable: {index_usable})",
         ]
         if with_date:
             rows.append("Date: " + datetime.now().astimezone().strftime("%Y-%m-%d"))
@@ -3139,15 +3158,12 @@ class ContextManager:
 
     def environment(self) -> str:
         info = self.session.system_info
-        index_status = self.session.state.code_index_status or "missing"
-        index_usable = "yes" if index_status in {"synced", "ready", "stale"} else "no"
         rows = [
             f"- cwd: {info.cwd}",
             f"- os: {info.os}",
             f"- arch: {info.arch}",
             f"- shell_timeout: {self.session.settings.shell_timeout}s",
             "- detected_commands: " + (", ".join(info.commands) or "(none)"),
-            f"- code_index: {index_status} (InspectCode usable: {index_usable})",
         ]
         if branch := self.session.git_branch(self.session.cwd):
             rows.append(f"- git_branch: {branch}")
@@ -3413,8 +3429,6 @@ class ContextManager:
         for offset, record in enumerate(records):
             if record.name == "Edit" and any(path in mins and offset >= mins[path] for path in paths.get(record.key, [])):
                 keep.add(record.key)
-        for _order, _server, _tool, key, _body in self.active_mcp_tool_details():
-            keep.add(key)
 
         self.session.tool_records = [record for record in records if record.key in keep][-400:]
         self.session.tool_results = {record.key: record.output for record in self.session.tool_records}
@@ -3689,10 +3703,14 @@ class MCPManager:
     DESCRIBE_DESCRIPTION_LIMIT: ClassVar[int] = 1_000
     DESCRIBE_ARGUMENT_LIMIT: ClassVar[int] = 50
     DESCRIBE_ARGUMENT_DESCRIPTION_LIMIT: ClassVar[int] = 160
+    INDEX_SCHEMA_LIMIT: ClassVar[int] = 700  # per-tool schema cap in the early (cached) tools index
+    INDEX_TOTAL_LIMIT: ClassVar[int] = 16_000  # overall cap for the tools index block
 
     def __init__(self, session: Session):
         self.session = session
         self.tools: dict[str, list[MCPToolInfo]] = {}
+        self.resources: dict[str, list[MCPResourceInfo]] = {}
+        self._auto_read_done: set[tuple[str, str]] = set()
         self.server_errors: dict[str, str] = {}
         self.server_skips: dict[str, str] = {}
         self.lock = threading.Lock()
@@ -3802,6 +3820,8 @@ class MCPManager:
 
     def _forget_locked(self, name: str) -> None:
         self.tools.pop(name, None)
+        self.resources.pop(name, None)
+        self._auto_read_done = {entry for entry in self._auto_read_done if entry[0] != name}
         self.server_errors.pop(name, None)
         self.server_skips.pop(name, None)
 
@@ -3854,22 +3874,31 @@ class MCPManager:
                 self.set_server_error(config.name, headers)
             return
 
+        if config.auth == "oauth" and not self.oauth_token_store().has_server_tokens(config.url):
+            self.set_server_error(config.name, "oauth login required; run /mcp login " + config.name)
+            return
         try:
-            if config.auth == "oauth":
-                if not self.oauth_token_store().has_server_tokens(config.url):
-                    self.set_server_error(config.name, "oauth login required; run /mcp login " + config.name)
-                    return
-                tools = self.run_async(self._list_oauth_tools(config, headers))
-            else:
-                tools = self.run_async(self._list_tools(config, headers))
-            tools_info = self._tools_info(config.name, tools)
+            tools, resources = self.run_async(self._gather_assets(config, headers))
             with self.lock:
-                self.tools[config.name] = tools_info
+                self.tools[config.name] = self._tools_info(config.name, tools)
+                self.resources[config.name] = self._resources_info(config.name, resources)
                 self.server_errors.pop(config.name, None)
                 self.server_skips.pop(config.name, None)
         except Exception as e:
             self.set_server_error(config.name, self.error_text(e, timeout=self.discovery_timeout()))
 
+    async def _gather_assets(self, config: MCPServerConfig, headers: dict[str, str]) -> tuple[Any, list[Any]]:
+        """Fetch tools and resources concurrently. Tool failure aborts discovery; resources are best-effort."""
+        oauth = config.auth == "oauth"
+        tools_co = self._list_oauth_tools(config, headers) if oauth else self._list_tools(config, headers)
+        resources_co = self._list_oauth_resources(config, headers) if oauth else self._list_resources(config, headers)
+        tools, resources = await asyncio.gather(tools_co, resources_co, return_exceptions=True)
+        if isinstance(tools, BaseException):
+            raise tools
+        if isinstance(resources, BaseException):
+            resources = []
+        return tools, resources
+
     def set_server_error(self, name: str, error: str) -> None:
         with self.lock:
             self._forget_locked(name)
@@ -3908,6 +3937,26 @@ class MCPManager:
             for t in tools
         ]
 
+    def _resources_info(self, server: str, resources: Any) -> list[MCPResourceInfo]:
+        infos: list[MCPResourceInfo] = []
+        for r in resources or []:
+            uri = str(getattr(r, "uri", "") or "")
+            if not uri:
+                continue
+            infos.append(
+                MCPResourceInfo(
+                    server=server,
+                    uri=uri,
+                    name=str(getattr(r, "name", "") or ""),
+                    description=str(getattr(r, "description", "") or ""),
+                    mime_type=str(getattr(r, "mimeType", "") or ""),
+                )
+            )
+        return infos
+
+    def resource_info(self, server: str, uri: str) -> MCPResourceInfo | None:
+        return next((res for res in self.resources.get(server, []) if res.uri == uri), None)
+
     @staticmethod
     def tool_annotations(tool: Any) -> Json:
         annotations = getattr(tool, "annotations", None)
@@ -4061,6 +4110,109 @@ class MCPManager:
         text = self.normalize_result(result)
         return f"<MCPCall server={json.dumps(server)} tool={json.dumps(tool_name)}>\n{text}\n</MCPCall>"
 
+    def _resource_preamble(self, server: str) -> tuple[MCPServerConfig, dict[str, str]]:
+        config = self.find_config(server)
+        if config is None:
+            raise ToolError(f"MCP server '{server}' not found")
+        if config.error:
+            raise ToolError(config.error)
+        headers = self._build_mcp_headers(config)
+        if isinstance(headers, str):
+            raise ToolError(headers)
+        if config.auth == "oauth" and not self.oauth_token_store().has_server_tokens(config.url):
+            raise ToolError(f"MCP server '{server}' requires OAuth login; run /mcp login {server}")
+        if server not in self.tools and server not in self.resources:
+            self.discover_server(server)
+        if server in self.server_errors:
+            raise ToolError(f"MCP server '{server}' error: {self.server_errors[server]}")
+        return config, headers
+
+    def list_resources(self, server: str) -> str:
+        self._resource_preamble(server)
+        resources = self.resources.get(server, [])
+        lines = [f"<MCPResources server={json.dumps(server)}>"]
+        if resources:
+            lines.extend(self._format_resource_line(res) for res in resources)
+        else:
+            lines.append("(no resources advertised by this server)")
+        lines.append("</MCPResources>")
+        return "\n".join(lines)
+
+    def read_resource(self, server: str, uri: str) -> str:
+        if not uri:
+            raise ToolError("MCP read_resource requires a uri")
+        config, headers = self._resource_preamble(server)
+        try:
+            result = self.run_async(
+                self._read_oauth_resource(config, headers, uri) if config.auth == "oauth" else self._read_resource(config, headers, uri)
+            )
+        except Exception as e:
+            raise ToolError("MCP resource read failed: " + self.error_text(e))
+        text = self.normalize_resource(result)
+        return f"<MCPResource server={json.dumps(server)} uri={json.dumps(uri)}>\n{text}\n</MCPResource>"
+
+    AUTO_READ_LIMIT: ClassVar[int] = 6_000  # per-doc cap for resources auto-injected on first tool call
+
+    def auto_read_prefix(self, server: str, tool_name: str) -> str:
+        """On the first call to a tool whose description references a resource doc, fetch it once.
+
+        Returns a block to attach to that call's result (so the grammar reaches the model on the
+        first attempt and lands in cached history), or "" when there is nothing new to inject.
+        Best-effort: failures are swallowed and never retried for the same uri.
+        """
+        info = self.tool_info(server, tool_name)
+        if info is None:
+            return ""
+        advertised = {res.uri for res in self.resources.get(server, [])}
+        blocks: list[str] = []
+        for uri in self._extract_uris(info.description):
+            if (server, uri) in self._auto_read_done:
+                continue
+            scheme = uri.split("://", 1)[0].lower()
+            # Only fetch things we can actually read over MCP: advertised resources or custom
+            # (non-web) schemes. Plain http(s) links are left for the model to read explicitly.
+            if uri not in advertised and scheme in ("http", "https"):
+                continue
+            self._auto_read_done.add((server, uri))  # mark before fetching so failures don't retry
+            try:
+                blocks.append(self.read_resource(server, uri)[: self.AUTO_READ_LIMIT])
+            except Exception:
+                continue
+        if not blocks:
+            return ""
+        body = "\n".join(blocks)
+        return f'<MCPAutoResources note="docs referenced by {server}.{tool_name}; injected once">\n{body}\n</MCPAutoResources>\n'
+
+    def normalize_resource(self, result: Any) -> str:
+        items = result if isinstance(result, list) else [result]
+        parts: list[str] = []
+        for item in items:
+            text = getattr(item, "text", None)
+            if text:
+                parts.append(str(text))
+                continue
+            blob = getattr(item, "blob", None)
+            if blob is not None:
+                mime = str(getattr(item, "mimeType", "") or "application/octet-stream")
+                parts.append(f"<binary mimeType={json.dumps(mime)} bytes={len(blob)}/>")
+                continue
+            if hasattr(item, "model_dump"):
+                parts.append(json.dumps(item.model_dump(mode="json"), ensure_ascii=False, indent=2))
+                continue
+            parts.append(str(item))
+        text = "\n".join(part for part in parts if part).strip()
+        if len(text) > self.RAW_OUTPUT_LIMIT:
+            text = text[: self.RAW_OUTPUT_LIMIT] + f"\n<MCPOutputTruncated chars={json.dumps(len(text))}/>"
+        return text
+
+    def _format_resource_line(self, info: MCPResourceInfo) -> str:
+        desc = " ".join((info.description or "").split())
+        if len(desc) > 100:
+            desc = desc[:97] + "..."
+        mime = f" [{info.mime_type}]" if info.mime_type else ""
+        label = f"{info.uri}{mime}"
+        return f"- {label} - {desc}" if desc else f"- {label}"
+
     def normalize_result(self, result: Any) -> str:
         parts: list[str] = []
         content = getattr(result, "content", result)
@@ -4099,6 +4251,36 @@ class MCPManager:
         async with Client(self._transport(config, headers), timeout=timeout, init_timeout=timeout) as client:
             return await asyncio.wait_for(client.call_tool(name, arguments), timeout=timeout)
 
+    async def _list_resources(self, config: MCPServerConfig, headers: dict[str, str]) -> list[Any]:
+        from fastmcp.client import Client
+
+        timeout = self.discovery_timeout()
+        async with Client(self._transport(config, headers), timeout=timeout, init_timeout=timeout) as client:
+            return await asyncio.wait_for(client.list_resources(), timeout=timeout)
+
+    async def _list_oauth_resources(self, config: MCPServerConfig, headers: dict[str, str]) -> list[Any]:
+        from fastmcp.client import Client
+        from fastmcp.client.transports import StreamableHttpTransport
+
+        timeout = self.discovery_timeout()
+        async with Client(StreamableHttpTransport(config.url, headers=headers), auth=self.oauth_client(config), timeout=timeout, init_timeout=timeout) as client:
+            return await asyncio.wait_for(client.list_resources(), timeout=timeout)
+
+    async def _read_resource(self, config: MCPServerConfig, headers: dict[str, str], uri: str) -> Any:
+        from fastmcp.client import Client
+
+        timeout = self.call_timeout()
+        async with Client(self._transport(config, headers), timeout=timeout, init_timeout=timeout) as client:
+            return await asyncio.wait_for(client.read_resource(uri), timeout=timeout)
+
+    async def _read_oauth_resource(self, config: MCPServerConfig, headers: dict[str, str], uri: str) -> Any:
+        from fastmcp.client import Client
+        from fastmcp.client.transports import StreamableHttpTransport
+
+        timeout = self.call_timeout()
+        async with Client(StreamableHttpTransport(config.url, headers=headers), auth=self.oauth_client(config), timeout=timeout, init_timeout=timeout) as client:
+            return await asyncio.wait_for(client.read_resource(uri), timeout=timeout)
+
     async def _call_oauth_tool(self, config: MCPServerConfig, headers: dict[str, str], name: str, arguments: Json) -> Any:
         from fastmcp.client import Client
         from fastmcp.client.transports import StreamableHttpTransport
@@ -4198,15 +4380,10 @@ class MCPManager:
             desc = Tool.compact(str(prop.get("description", "") or ""), self.DESCRIBE_ARGUMENT_DESCRIPTION_LIMIT)
             lines.append(f"- {name} {req} {typ}: {desc}")
         lines.append("</arguments>")
-        lines.append("<schema_summary>")
-        if props:
-            summary = f"Top-level object with {', '.join(props.keys())}."
-        else:
-            summary = "No arguments."
-        if len(summary) > 200:
-            summary = summary[:197] + "..."
-        lines.append(summary)
-        lines.append("</schema_summary>")
+        if isinstance(schema, dict) and schema:
+            lines.append("<schema>")
+            lines.append(json.dumps(schema, ensure_ascii=False, indent=2))
+            lines.append("</schema>")
         lines.append("</MCPDescribe>")
         return "\n".join(lines)
 
@@ -4218,14 +4395,17 @@ class MCPManager:
         lines: list[str] = []
         lines.append("--- MCP TOOLS ---")
         lines.append('Use MCP(action="call", server, tool, arguments) for external MCP server tools.')
-        lines.append('Use MCP(action="describe", server, tool) for full details when needed.')
+        lines.append('Use MCP(action="describe", server, tool) for the full schema when one is truncated below; the result stays in the conversation, so do not describe the same tool again once its schema is shown — just call it.')
+        lines.append('Use MCP(action="read_resource", server, uri) to read a listed resource (e.g. docs describing how to build a tool\'s arguments). Read relevant resources before calling.')
         lines.append("Format: server.tool(req: type; opt: type) - description")
+        lines.append("        schema: <JSON Schema for the arguments object>")
         lines.append("")
 
         pending: list[str] = []
         for config in configs:
             tools = self.tools.get(config.name, [])
-            if not tools:
+            resources = self.resources.get(config.name, [])
+            if not tools and not resources:
                 pending.append(f"- {config.name}: {self._pending_status(config.name)}")
                 continue
             name_display = config.name.capitalize()
@@ -4234,6 +4414,9 @@ class MCPManager:
                 line = self._format_tool_line(config.name, tool)
                 if line:
                     lines.append(line)
+            if resources:
+                lines.append(f"resources ({len(resources)}) — read with MCP(action=\"read_resource\", server={json.dumps(config.name)}, uri=...):")
+                lines.extend(self._format_resource_line(res) for res in resources)
             lines.append("")
 
         if pending:
@@ -4242,8 +4425,8 @@ class MCPManager:
             lines.append("")
 
         text = "\n".join(lines)
-        if len(text) > 4000:
-            text = text[:3990] + "\n... MCP tools truncated; use /mcp tools for full list."
+        if len(text) > self.INDEX_TOTAL_LIMIT:
+            text = text[: self.INDEX_TOTAL_LIMIT - 10] + "\n... MCP tools truncated; use /mcp tools for full list."
         return text
 
     def server_issue(self, name: str) -> tuple[str, str] | None:
@@ -4260,6 +4443,8 @@ class MCPManager:
             return message if kind == "error" else "skipped: " + message
         if self.discovery_status == "discovering":
             return "discovering — tools not loaded yet; retry shortly"
+        if name in self.tools:
+            return "connected; no tools or resources advertised"
         return "not connected"
 
     MENTION_PATTERN = re.compile(r"@([A-Za-z0-9_-]+)(?:\.([A-Za-z0-9_-]+))?")
@@ -4312,6 +4497,10 @@ class MCPManager:
             line = self._format_tool_line(server, info)
             if line:
                 lines.append(line)
+        resources = self.resources.get(server, [])
+        if resources:
+            lines.append(f"resources ({len(resources)}) — read with MCP(action=\"read_resource\", server={json.dumps(server)}, uri=...):")
+            lines.extend(self._format_resource_line(res) for res in resources)
         return "\n".join(lines)
 
     def _format_tool_line(self, server: str, info: MCPToolInfo) -> str:
@@ -4324,8 +4513,40 @@ class MCPManager:
         line = f"{server}.{info.name}{args_str} - {desc}"
         if len(line) > 200:
             line = line[:197] + "..."
+        # The full description (often naming a resource doc with the argument grammar) is
+        # truncated above, so surface any resource-like URIs it mentions explicitly.
+        uris = self._extract_uris(info.description)
+        if uris:
+            line += "\n  refs (read with MCP action=\"read_resource\"): " + ", ".join(uris)
+        schema = self._schema_json(info.input_schema, self.INDEX_SCHEMA_LIMIT)
+        if schema:
+            line += f"\n  schema: {schema}"
         return line
 
+    URI_PATTERN: ClassVar[re.Pattern] = re.compile(r"[a-zA-Z][a-zA-Z0-9+.\-]*://[^\s'\"<>)\]}]+")
+
+    @classmethod
+    def _extract_uris(cls, text: str, limit: int = 5) -> list[str]:
+        """Pull resource-like URIs out of free text, deduped and lightly de-punctuated."""
+        seen: list[str] = []
+        for match in cls.URI_PATTERN.findall(text or ""):
+            uri = match.rstrip(".,;:")
+            if uri not in seen:
+                seen.append(uri)
+            if len(seen) >= limit:
+                break
+        return seen
+
+    @staticmethod
+    def _schema_json(schema: Json, limit: int) -> str:
+        """Render a remote tool's input schema as compact JSON, capped at `limit` chars (0 = no cap)."""
+        if not isinstance(schema, dict) or not schema:
+            return ""
+        text = json.dumps(schema, ensure_ascii=False, separators=(",", ":"))
+        if limit and len(text) > limit:
+            text = text[: limit - 1].rstrip() + "… (truncated; MCP describe for full schema)"
+        return text
+
     def _tool_args_summary(self, info: MCPToolInfo) -> str:
         schema = info.input_schema or {}
         props = schema.get("properties", {})
@@ -4510,9 +4731,16 @@ class ToolRunner:
         if self.session.settings.debug:
             return self.finish(call, output, failed=True, elapsed=elapsed, display=display, batch_suffix=batch_suffix)
         self.session.record_tool_error("-", call.name, call.args, output)
-        self.output_fn(self.finish_display(call, "", output, failed=True, display=display, batch_suffix=batch_suffix))
+        self.output_fn(self.reject_display(call, output, display=display, batch_suffix=batch_suffix))
         return self.tool_message(call, "", output, failed=True, display=display)
 
+    def reject_display(self, call: ToolCall, output: str, *, display: str | None = None, batch_suffix: str = "") -> str:
+        # Argument/usage rejections are usually self-corrected on retry, so show a quiet one-liner
+        # (rendered dim by UiPrinter) instead of the full red failed block. Full error still goes to
+        # the model and to debug.
+        reason = self.oneline(output.removeprefix("ToolError:").strip(), 60)
+        return self.with_batch_suffix("tool " + (display or self.short_call(call)) + " · rejected: " + reason, batch_suffix)
+
     def finish(
         self,
         call: ToolCall,
@@ -4542,8 +4770,6 @@ class ToolRunner:
         head = "tool " + ((key + " ") if key else ("- " if failed else "")) + (display or self.short_call(call))
         if not failed and call.name in {"Read", "Edit"}:
             return head + " -> FILE STATE"
-        if not failed and call.name == "MCP" and "<MCPDescribe " in output:
-            return head + " -> MCP TOOL DETAILS"
         rows = [head]
         if failed:
             rows.append("status: failed")
@@ -5093,7 +5319,7 @@ You are nanocode, a concise terminal coding agent.
 TOOLS:
 - Available: Read LineCount List Find InspectCode Search Edit Bash Git Recall Note Question MCP.
 - Use exact tool names and named parameters; obey each tool DESCRIPTION/SIGNATURE.
-- Files/code: Read/LineCount/List inspect files; Find/Search locate paths/text; InspectCode navigates symbols when available.
+- Files/code: Read/LineCount/List inspect files; Find/Search locate paths/text; prefer InspectCode over Search for symbols (defs, refs, impls, callers/callees, outline) when code_index is usable.
 - Changes/commands: Edit writes files; Git handles git; Bash is fallback when built-ins do not fit.
 - State/external: Recall retrieves tr.N outputs; Note maintains goal/plan/known/check; MCP calls configured external tools.
 - Restraint: Before calling "Question", make progress with other tools first; only ask when genuinely blocked, and batch related questions into one call.
@@ -5112,9 +5338,8 @@ FILE STATE:
 - Read and Edit refresh FILE STATE; after Edit, trust the edited range.
 
 FINAL:
-- Concise markdown in the user's language.
-- Include changed files and checks when relevant.
-- Mention checks run, or say checks not run.\
+- Default to a few lines; scale to the task. Lead with the result; no preamble or recap.
+- Concise markdown in the user's language; note changed files and checks run (or not run).\
 """
 
     def __init__(self, session: Session, input_fn=input, output_fn=print):
@@ -5309,6 +5534,9 @@ class UiPrinter:
         self.output_fn = output_fn
         self.color = output_fn is print and sys.stdout.isatty()
         self.console = Console() if self.color else None
+        # When set, render Rich answers to an ANSI string and emit via prompt_toolkit, so
+        # answers printed from inside a running prompt app (queue input) aren't mangled by patch_stdout.
+        self.capture_ansi = False
 
     def emit(self, text: str = "") -> None:
         if not self.color:
@@ -5321,6 +5549,13 @@ class UiPrinter:
             self.emit(text)
             return
         assert self.console is not None
+        if self.capture_ansi:
+            console = Console(force_terminal=True, width=shutil.get_terminal_size().columns)
+            with console.capture() as capture:
+                console.print(Rule(style="bright_black", characters="─"))
+                console.print(Markdown(text))
+            print_formatted_text(ANSI(capture.get()), end="", flush=True)
+            return
         self.console.print(Rule(style="bright_black", characters="─"))
         self.console.print(Markdown(text))
 
@@ -5344,7 +5579,9 @@ class UiPrinter:
     def tool_segments(self, text: str) -> list[tuple[str, str]]:
         segments = []
         for line in text.splitlines() or [""]:
-            if line.startswith("tool "):
+            if line.startswith("tool ") and " · rejected:" in line:
+                segments.append(("ansibrightblack", line))
+            elif line.startswith("tool "):
                 body = line[5:]
                 call, sep, tail = body.partition(" -> ")
                 failed = body.endswith(" [failed]") or body.endswith(" [refused]")
@@ -5768,6 +6005,9 @@ class StatusBar:
 
 
 class CommandLoop:
+    # Commands safe to run from the background queue-input thread while the agent works: read-only
+    # views plus /yolo, whose single atomic flag flip the agent simply reads at the next approval.
+    QUEUE_RUN_COMMANDS: ClassVar[frozenset[str]] = frozenset({"/help", "/status", "/memory", "/mcp", "/yolo"})
     MODEL_CONFIGURED_LABEL = "---- Configured models ----"
     MODEL_DISCOVERED_LABEL = "---- Discovered models ----"
     MODEL_LABELS = frozenset((MODEL_CONFIGURED_LABEL, MODEL_DISCOVERED_LABEL))
@@ -5873,7 +6113,13 @@ Tools:
         def changed(buffer: Buffer) -> None:
             self.queue_input_text = buffer.text
 
-        buffer = Buffer(document=Document(self.queue_input_text), multiline=False, on_text_changed=changed)
+        buffer = Buffer(
+            document=Document(self.queue_input_text),
+            multiline=False,
+            on_text_changed=changed,
+            completer=self.input_completer,
+            complete_while_typing=False,
+        )
         control = BufferControl(buffer=buffer, input_processors=[BeforeInput(prompt)])
         input_window = Window(control, height=1, dont_extend_height=True, wrap_lines=False)
         bindings = KeyBindings()
@@ -5882,11 +6128,15 @@ Tools:
             texts = [Text.clean(text.strip()) for text in texts if text.strip()]
             if not texts:
                 return
-            self.session.pending_user_inputs.extend(texts)
+            queued = [text for text in texts if not text.startswith("/")]
+            commands = [text for text in texts if text.startswith("/")]
+            self.session.pending_user_inputs.extend(queued)
 
             def show() -> None:
-                for text in texts:
+                for text in queued:
                     self.emit("+ " + text)
+                for text in commands:
+                    self.run_queued_command(text)
 
             run_in_terminal(show)
 
@@ -5907,6 +6157,21 @@ Tools:
                 self.session.state.model_retry_count += 1
                 os.kill(os.getpid(), signal.SIGINT)
 
+        @bindings.add("tab")
+        def _tab(event):
+            if buffer.complete_state:
+                buffer.complete_next()
+                return
+            completions = list(self.input_completer.get_completions(buffer.document, CompleteEvent(completion_requested=True)))
+            if len(completions) == 1:
+                buffer.apply_completion(completions[0])
+            else:
+                buffer.start_completion(select_first=False)
+
+        @bindings.add("s-tab")
+        def _shift_tab(event):
+            buffer.complete_previous() if buffer.complete_state else buffer.start_completion(select_last=True)
+
         @bindings.add(Keys.BracketedPaste)
         def _paste(event):
             parts = event.data.replace("\r\n", "\n").replace("\r", "\n").split("\n")
@@ -5917,7 +6182,12 @@ Tools:
             self.queue_input_text = parts[-1]
             buffer.reset(Document(self.queue_input_text))
 
-        app = self._make_app(Layout(HSplit([input_window, self.status_window(active=True)]), focused_element=input_window), bindings)
+        completion_space = ConditionalContainer(Window(height=12, dont_extend_height=True), filter=has_completions & ~is_done)
+        root = FloatContainer(
+            HSplit([input_window, completion_space, self.status_window(active=True)]),
+            [Float(CompletionsMenu(max_height=12, scroll_offset=1), xcursor=True, ycursor=True, attach_to_window=input_window, transparent=True)],
+        )
+        app = self._make_app(Layout(root, focused_element=input_window), bindings)
         self.queue_input_app = app
         self.queue_input_active.set()
 
@@ -5938,6 +6208,24 @@ Tools:
             if self.queue_input_app is app:
                 self.queue_input_app = None
 
+    def run_queued_command(self, text: str) -> None:
+        """Dispatch a slash command typed in the queue input. Only read-only commands run while the
+        agent is working; mutating/control commands would race the in-flight turn, so they are refused."""
+        name = text.partition(" ")[0]
+        if name not in self.QUEUE_RUN_COMMANDS:
+            self.emit(f"{name} is unavailable while the agent is working; press Ctrl-C to run it.")
+            return
+        if name == "/mcp":
+            sub = text.partition(" ")[2].split()
+            if sub and sub[0] != "tools":
+                self.emit("Only read-only /mcp (status, tools) is available while the agent is working.")
+                return
+        self.ui.capture_ansi = True
+        try:
+            self.command(text)
+        finally:
+            self.ui.capture_ansi = False
+
     def pause_queue_input(self) -> None:
         self.queue_input_paused.set()
         if self.queue_input_app is not None:
@@ -5967,11 +6255,8 @@ Tools:
         UpdateChecker(self.session).start()
         while True:
             try:
-                user_input = self.drain_queued_input()
-                if not user_input:
-                    user_input = self.read_input(initial_text="")
-                elif self.input_history is not None:
-                    self.input_history.append_string(user_input)
+                # Pre-fill any queued input into the prompt for review/edit instead of auto-submitting it.
+                user_input = self.read_input(initial_text=self.drain_queued_input())
             except EOFError:
                 self.emit("")
                 self.save_and_emit_resume()
@@ -6181,7 +6466,7 @@ Tools:
         initial_text: str = "",
     ) -> str:
         if self.input_history is None:
-            return self.input_fn(prompt_text)
+            return initial_text or self.input_fn(prompt_text)
 
         def accept(buffer: Buffer) -> bool:
             app.exit(result=buffer.text)
@@ -6750,8 +7035,8 @@ Tools:
             index_message = (index_message + "; " if index_message else "") + "run /index"
         elif index_status == "stale" and "run /index" not in index_message:
             index_message = (index_message + "; " if index_message else "") + "run /index or wait for auto update"
-        cache_ratio = (usage.cached_prompt_tokens * 100 / usage.total_tokens) if usage.total_tokens else 0
-        last_cache_ratio = (usage.last_cached_prompt_tokens * 100 / usage.last_total_tokens) if usage.last_total_tokens else 0
+        cache_ratio = (usage.cached_prompt_tokens * 100 / usage.prompt_tokens) if usage.prompt_tokens else 0
+        last_cache_ratio = (usage.last_cached_prompt_tokens * 100 / usage.last_prompt_tokens) if usage.last_prompt_tokens else 0
         rows = [
             ("workspace", "`" + self.session.cwd + "`"),
             ("session", "`" + self.session.uid + "`"),
@@ -6766,7 +7051,7 @@ Tools:
             ("goal", self.session.state.goal or "(empty)"),
             (
                 "usage",
-                f"calls `{usage.calls}`; total `{usage.total_tokens}`; cached `{usage.cached_prompt_tokens}` (`{cache_ratio:.1f}%`); last `{usage.last_cached_prompt_tokens}/{usage.last_total_tokens}` (`{last_cache_ratio:.1f}%`)",
+                f"calls `{usage.calls}`; total `{usage.total_tokens}`; cached `{usage.cached_prompt_tokens}/{usage.prompt_tokens}` (`{cache_ratio:.1f}%`); last `{usage.last_cached_prompt_tokens}/{usage.last_prompt_tokens}` (`{last_cache_ratio:.1f}%`)",
             ),
             (
                 "runtime",

{nanocode_cli-0.6.4 → nanocode_cli-0.6.6/nanocode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.6.4
+Version: 0.6.6
 Summary: A small terminal coding agent written in Python
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause
@@ -240,7 +240,7 @@ model request
 |   conversation, compacted summaries, tools       |
 +--------------------------------------------------+
 | user                                             |
-|   Memory: goal, plan, known, date                |
+|   Memory: goal, plan, known, code index, date    |
 +--------------------------------------------------+
 | user                                             |
 |   FILE STATE: latest Read/Edit file view         |
@@ -249,6 +249,7 @@ model request
 
 Core rules:
 
+- Environment holds only stable host facts (cwd, os, arch, detected commands) so it stays byte-identical across turns and keeps the conversation prefix cacheable; volatile state like the code index status lives in the late Memory section instead.
 - Mid-turn assistant text and appended user input are kept as conversation.
 - Earlier conversation is compacted into an explicit summary when the context grows too large.
 - FILE STATE is updated by successful `Read` and `Edit` tools and shows current listed file ranges, with recent files first.

{nanocode_cli-0.6.4 → nanocode_cli-0.6.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nanocode-cli"
-version = "0.6.4"
+version = "0.6.6"
 description = "A small terminal coding agent written in Python"
 readme = "README.md"
 requires-python = ">=3.11"