@hncode/hncode 0.5.5 → 0.6.0

package/package.json

@@ -1,38 +1,37 @@
-{
-  "name": "@hncode/hncode",
-  "version": "0.5.5",
-  "description": "hncode — A cyan-blue TUI AI coding agent with zero runtime dependencies.",
-  "type": "module",
-  "main": "src/index.js",
-  "bin": {
-    "hncode": "bin/hncode"
-  },
-  "files": [
-    "bin/",
-    "src/",
-    "LICENSE",
-    "README.md",
-    "README_CN.md",
-    "package.json"
-  ],
-  "scripts": {
-    "preinstall": "node bin/preinstall.cjs",
-    "install": "node bin/install.cjs",
-    "i18n": "node tools/sync-i18n.mjs",
-    "i18n:check": "node tools/sync-i18n.mjs --check",
-    "test": "node --test \"test/**/*.test.mjs\""
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "license": "PolyForm-Noncommercial-1.0.0",
-  "author": "NiceHello666",
-  "keywords": [
-    "cli",
-    "agent",
-    "coding",
-    "ai",
-    "tui"
-  ],
-  "dependencies": {}
-}
+{
+  "name": "@hncode/hncode",
+  "version": "0.6.0",
+  "description": "hncode — A cyan-blue TUI AI coding agent with zero runtime dependencies.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "hncode": "bin/hncode"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "LICENSE",
+    "README.md",
+    "README_CN.md",
+    "package.json"
+  ],
+  "scripts": {
+    "preinstall": "node bin/preinstall.cjs",
+    "install": "node bin/install.cjs",
+    "i18n": "node tools/sync-i18n.mjs",
+    "i18n:check": "node tools/sync-i18n.mjs --check",
+    "test": "node --test \"test/**/*.test.mjs\""
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "author": "NiceHello666",
+  "keywords": [
+    "cli",
+    "agent",
+    "coding",
+    "ai",
+    "tui"
+  ]
+}

package/src/agent.js

@@ -4,6 +4,7 @@
 
 import { LLM, setToolsList } from './llm.js';
 import { tools, combinedTools, getTool, llmTools } from './tools/index.js';
+import { validateToolArgs } from './tools/validate-args.js';
 import { DELEGATION_TOOLS } from './subagent-types.js';
 import { estimateMessagesTokens, estimateRequestOverhead, estimateTokens, measureToolDefTokens, messageTokens, TokenLedger, forgetMessageTokens } from './term.js';
 import { runHooks, runPatch, runPatchSync } from './plugin.js';
@@ -72,10 +73,46 @@ const COMPACTION_INSTRUCTION = [
   '',
   'Be concise and proportional: a long multi-step task warrants detail, a nearly finished exchange needs only a sentence or two.',
   '',
-  'Respond with text only. Do not call any tools.',
+  'Respond with text only. Do not call any tools. Any tool-call syntax in your answer is discarded and scores the handoff as failed.'
 ].join('\n');
 
 // Trailing note: the model should RESUME, not answer the summary.
+// A summariser can answer with tool-call syntax even when no tools were offered — the format is in its
+// training data, and a model interrupted mid-workflow reaches for it. Nothing was called, so the text is
+// noise, and left in a handoff summary the next turn reads it as a step that happened.
+//
+// The shapes covered are the ones these models actually emit: a special-token block (`<|tool_call|>`), a
+// fenced ```tool_call block, and a bare JSON object that claims a `name` and `arguments`. Only a block that
+// occupies whole lines is removed, so prose that merely mentions calling a tool survives.
+function stripToolCallText(text) {
+  if (typeof text !== 'string' || !text) return text || '';
+
+  // NOTHING WAS CALLED, SO THE BLOCK IS NOISE — but removing it outright can leave nothing at all.
+  //
+  // A summariser that answers ONLY with a tool call produced no summary: stripping to '' makes the caller
+  // treat the compaction as failed, and the fallback there is to drop the history. So the stripped text is
+  // measured: if it lost its substance, the original is kept VERBATIM with a note saying what it is. A
+  // confusing summary is recoverable; a discarded one is not.
+  let out = text;
+  // A special-token block: closed form, or an unterminated one running to the end of its line.
+  out = out.replace(/<\|tool_call\|>[^\n]*(?:<\|\/tool_call\|>)?/g, '');
+  // Fenced block form.
+  out = out.replace(/```tool_call[\s\S]*?```/g, '');
+  // A bare JSON object on its own lines that declares a tool invocation.
+  out = out.replace(/^\s*\{[^\n]*"name"\s*:\s*"[^"]+"[^\n]*"arguments"[^\n]*\}\s*$/gm, '');
+  out = out.replace(/\n{3,}/g, '\n\n').trim();
+
+  if (out.length > 0) return out;
+
+  // Every remaining character was a tool call: keep the original, marked for what it is.
+  return [
+    '(The summariser answered with a tool call instead of a summary. No tool was actually run — the text is',
+    'reproduced below unchanged so nothing is lost. Treat it as a summary that was never written.)',
+    '',
+    text.trim(),
+  ].join('\n');
+}
+
 const COMPACTION_CONTINUATION_TEXT = 'Context compaction is complete — continue the work that was in progress when it began.';
 
 // Clip to a TOKEN budget, counting non-ASCII as one token per character (the same
@@ -842,7 +879,20 @@ const filtered = (Array.isArray(cfg.toolFilter) && cfg.toolFilter.length
           // reasoning model they can consume the whole output budget — which
           // returns an EMPTY summary, and an empty summary is what turns a
           // compaction into a silent loss of history.
-          try { summary = await llm.requestText(summaryPrompt, { noReasoning: true, noTools: true }); } catch { summary = ''; }
+          try {
+            // A DECLARATION IS NEEDED FOR THE REFUSAL.
+            //
+            // `tool_choice: 'none'` is rejected by both providers unless a tool list accompanies it, and the
+            // summariser is a fresh instance with none. One inert definition is declared so the refusal can be
+            // expressed: the model then cannot produce a tool call, rather than being asked not to.
+            llm._tools = [{
+              name: 'noop',
+              description: 'Takes no action. Present only so the request can refuse tool use.',
+              parameters: { type: 'object', properties: {}, additionalProperties: false },
+            }];
+            const raw = await llm.requestText(summaryPrompt, { noReasoning: true, toolChoice: 'none' });
+            summary = stripToolCallText(raw);
+          } catch { summary = ''; }
           this._summaryLlm = null;
         }
         // Interrupted mid-summary: do NOT trim. Aborting yields an empty summary, and
@@ -1123,6 +1173,21 @@ const filtered = (Array.isArray(cfg.toolFilter) && cfg.toolFilter.length
           return { ok: false, result, editDiff: null, media: false };
         }
 
+        // THE ARGUMENTS MUST MATCH THE TOOL'S OWN SCHEMA.
+        //
+        // An unknown parameter used to be accepted in silence, and the model had no way to learn that the
+        // argument it took trouble to compute was thrown away: it sends `line_offset` to a tool that takes
+        // `start_line`, gets a plausible answer computed from defaults, and concludes the tool is broken.
+        // Refusing the call names the key and lists the accepted ones, which is the only thing that stops the
+        // same mistake being retried with a different spelling.
+        const argError = validateToolArgs(tc.args, tool.parameters);
+        if (argError) {
+          result = `Error: ${tc.name}: ${argError}`;
+          this.onEvent({ type: 'tool_use', id: tc.id, name: tc.name, args: tc.args });
+          return { ok: false, result, editDiff: null, media: false };
+        }
+
+
         // SHELL HOOK: PreToolUse. A non-zero exit blocks the tool, and its
         // message goes back to the model in place of the tool result — that is
         // the whole point of a pre-hook (e.g. refuse a write that fails a lint

package/src/image-row.js

@@ -0,0 +1,111 @@
+/**
+ * Where a bitmap sits in a text frame.
+ *
+ * The TUI composes a frame as an array of strings and writes only the rows that changed, each addressed
+ * absolutely. A bitmap breaks that model twice: it is not text, so it cannot live in a row's bytes, and it
+ * is more than one row tall, so the rows under it must stay blank or the next repaint paints over it.
+ *
+ * So a row that carries an image is written as a sentinel — a single private-use character plus the
+ * payload — and this module turns a frame into the bytes that place it: address the row, emit the
+ * sequence, then remember which rows the image covers so the following text rows can be skipped.
+ *
+ * A SIXEL PAYLOAD DRAWN INLINE IS JUST CHARACTERS. That is why the first attempt showed nothing: the
+ * terminal consumed the bytes as text, scrolled them, and the formula never appeared. Placement needs a
+ * cursor move first, which is what `\x1b[<row>;<col>H` does.
+ */
+
+/** Marks a row whose content is a placed bitmap. A private-use code point no text will contain. */
+export const IMAGE_MARK = '\u0001IMG:';
+
+/**
+ * Separates the payload from the source that produced it.
+ *
+ * NOT A NUL BYTE. `SPIN_PLACEHOLDER` in the transcript renderer is `\u0000`, and every row is run through a
+ * substitution that replaces it with the spinner frame — so a tag built on it arrived as `⠋SRC:…` and the
+ * source was unreadable. `\u0001` is what `IMAGE_MARK` already uses and nothing substitutes it.
+ */
+export const SOURCE_TAG = '\u0001SRC:';
+
+
+/**
+ * Encode an image row: the mark, then the payload and its geometry, base64-free but length-prefixed so a
+ * payload containing the mark cannot be misparsed.
+ *
+ * `source` is optional and travels with the row for pictures that can be REGENERATED: a formula that straddles
+ * the top of the window must be redrawn from its first visible row, and only its TeX can produce that raster.
+ * It is stored last, after the sequence, so a row written before this field existed still parses.
+ *
+ * @param {string} sequence The terminal sequence to emit.
+ * @param {number} rows Rows of text the image covers.
+ * @param {number} cols Columns the image covers.
+ * @param {string} [source] What produced the sequence, for a picture that may need cropping later.
+ */
+export function encodeImageRow(sequence, rows, cols, source) {
+  const head = IMAGE_MARK + rows + ':' + cols + ':';
+  return typeof source === 'string' && source !== ''
+    ? head + sequence + SOURCE_TAG + source
+    : head + sequence;
+}
+
+/**
+ * True when a composed row is an image rather than text.
+ *
+ * The row may carry the transcript's indent prefix — `messageLines` gives every line one — so the marker is
+ * not necessarily at index 0. Matching it anywhere in the first few characters is what makes this work
+ * without the row builder having to special-case images.
+ */
+export function isImageRow(line) {
+  if (typeof line !== 'string') return false;
+  const at = line.indexOf(IMAGE_MARK);
+  return at >= 0 && at < 8 && /^\s*$/.test(line.slice(0, at));
+}
+
+/**
+ * Split an image row back into its parts.
+ * @returns {{sequence: string, rows: number, cols: number, source: string}|null}
+ */
+export function parseImageRow(line) {
+  if (!isImageRow(line)) return null;
+  const at = line.indexOf(IMAGE_MARK);
+  const rest = line.slice(at + IMAGE_MARK.length);
+  const firstColon = rest.indexOf(':');
+  if (firstColon < 0) return null;
+  const secondColon = rest.indexOf(':', firstColon + 1);
+  if (secondColon < 0) return null;
+  const rows = Number(rest.slice(0, firstColon));
+  const cols = Number(rest.slice(firstColon + 1, secondColon));
+  if (!Number.isFinite(rows) || !Number.isFinite(cols)) return null;
+  let body = rest.slice(secondColon + 1);
+  let source = '';
+  const tag = body.lastIndexOf(SOURCE_TAG);
+  if (tag >= 0) {
+    source = body.slice(tag + SOURCE_TAG.length);
+    body = body.slice(0, tag);
+  }
+  return { rows, cols, sequence: body, source };
+}
+
+
+/**
+ * The bytes that place one image at its row, and how many rows it covers.
+ *
+ * @param {string} line The image row.
+ * @param {number} rowIndex 0-based screen row the row was composed for.
+ * @param {string} reset SGR reset to restore after the sequence.
+ * @returns {{bytes: string, covered: number}|null}
+ */
+export function imageBytes(line, rowIndex, reset) {
+  const parsed = parseImageRow(line);
+  if (!parsed) return null;
+
+  // DEC PRIVATE MODE 80 IS THE SIXEL SCROLLING MODE.
+  //
+  // With it enabled (the default) a terminal that draws a bitmap pushes the text below it down — and in a
+  // full-screen TUI every bitmap therefore scrolls the whole interface. That is what produced the repeated
+  // composer: each formula shoved the frame up and the next paint drew it again further down.
+  //
+  // `?80l` turns the mode off for the duration of the draw and `?80h` restores it. dsh-tui wraps its own
+  // placement the same way.
+  const bytes = `\x1b[?80l\x1b[${rowIndex + 1};1H${reset}${parsed.sequence}\x1b[?80h`;
+  return { bytes, covered: parsed.rows };
+}