@hncode/hncode 0.5.1 → 0.5.4

package/src/git.js

@@ -33,6 +33,10 @@ const GIT_ENV = [
 
 // Run git with args in `cwd`. Returns { ok, stdout, stderr, code, error }.
 // Never throws: a missing git binary or a non-repo is data, not an exception.
+//
+// SYNCHRONOUS, and therefore only for the queries made at STARTUP (the status bar's branch and
+// sha). It blocks the event loop, so an AbortSignal cannot fire during it — use `runGitAsync` for
+// anything a tool call reaches.
 export function runGit(args, cwd, opts = {}) {
   const timeout = opts.timeoutMs || 30_000;
   try {
@@ -53,7 +57,6 @@ export function runGit(args, cwd, opts = {}) {
     return { ok: false, stdout: '', stderr: '', code: null, error: e.message };
   }
 }
-
 export function isRepo(cwd) {
   const r = runGit(['rev-parse', '--is-inside-work-tree'], cwd);
   return r.ok && r.stdout.trim() === 'true';
@@ -436,10 +439,20 @@ export function rebase(cwd, onto) {
 // The async form below runs the same command off the main thread, so the frame
 // draws immediately and the badge fills in when the data arrives.
 
+/**
+ * Run git without blocking the event loop.
+ *
+ * `opts.signal` makes the command interruptible, which is the whole reason a tool call must use this
+ * rather than `runGit`: a synchronous `spawnSync` holds the event loop, so an AbortSignal can never
+ * fire during it — measured, `spawnSync` accepts a `signal` option and ignores it, waiting out the
+ * full timeout. With Esc interrupting a turn, `git status` or `git log` on a large repository would
+ * otherwise freeze the TUI for up to the timeout with no key able to reach it.
+ */
 export function runGitAsync(args, cwd, opts = {}) {
   return new Promise((resolve) => {
     let child;
     const timeout = opts.timeoutMs || 30_000;
+    const signal = opts.signal;
     try {
       child = cp.spawn('git', [...GIT_ENV, ...args], {
         cwd: cwd || process.cwd(),
@@ -453,11 +466,29 @@ export function runGitAsync(args, cwd, opts = {}) {
     let stdout = '';
     let stderr = '';
     let done = false;
-    const finish = (r) => { if (!done) { done = true; clearTimeout(timer); resolve(r); } };
+    const finish = (r) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener('abort', onAbort);
+      resolve(r);
+    };
     const timer = setTimeout(() => {
-      try { child.kill(); } catch {}
-      finish({ ok: false, stdout: '', stderr: '', code: null, error: 'git timed out' });
+      try { child.kill(); } catch { /* already gone */ }
+      // The partial output is returned rather than dropped: it is often still useful, and an empty
+      // string would look like "git had nothing to say" instead of "git was cut short".
+      finish({ ok: false, stdout, stderr, code: null, error: 'git timed out' });
     }, timeout);
+    // `interrupted` is a distinct error from a timeout, so the caller can tell a user's Esc from a
+    // command that hung.
+    const onAbort = () => {
+      try { child.kill(); } catch { /* already gone */ }
+      finish({ ok: false, stdout, stderr, code: null, error: 'interrupted' });
+    };
+    if (signal) {
+      if (signal.aborted) { clearTimeout(timer); onAbort(); return; }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
     if (child.stdout) child.stdout.on('data', (d) => { stdout += d.toString('utf8'); });
     if (child.stderr) child.stderr.on('data', (d) => { stderr += d.toString('utf8'); });
     child.on('error', (e) => finish({ ok: false, stdout: '', stderr: '', code: null, error: e.message }));

package/src/index.js

@@ -5,9 +5,8 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { resolveConfig, effectiveSnapshot, saveConfig, resolveModelArg, readPersonalPrompt } from './config.js';
 import * as sess from './session.js';
-import { Agent, SYSTEM_PROMPT } from './agent.js';
+import { Agent, SYSTEM_PROMPT, canSplitAfter } from './agent.js';
 import { llmTools } from './tools/index.js';
-import { setToolsList } from './llm.js';
 import { localVersion } from './version.js';
 import { EXIT, FORMATS, isValidFormat, buildResult, exitCodeFor, resultLine, createRunTracker, trackEvent, finalReply } from './ci.js';
 
@@ -301,13 +300,31 @@ async function runPrompt({ cfg, prompt, format, session, modelArg, timeoutSecond
     return EXIT.CONFIG;
   }
   const messages = [];
-  if (session && session.messages) for (const m of session.messages.slice(-30)) messages.push(m);
   // Same layering as the TUI: built-in prompt first, then the user's own
   // system_prompt override if any, then the /personal notes, then calm mode.
   let sysText = (cfg.systemPrompt && String(cfg.systemPrompt).trim()) || SYSTEM_PROMPT;
   const personal = readPersonalPrompt(cfg.workspace);
   if (personal) sysText += '\n\n' + personal;
   messages.push({ role: 'system', content: sysText });
+  if (session && session.messages) {
+    // Resume on a TOOL-EXCHANGE BOUNDARY: a cut that separates an assistant
+    // message from its tool results (or leaves orphaned tool results) is a 400
+    // from the provider, not just a shorter history. `canSplitAfter` is the same
+    // rule the compaction logic uses. System messages are dropped — the fresh
+    // one above is authoritative.
+    const hist = session.messages.filter((m) => m && m.role !== 'system');
+    // A session persisted mid-step can end with an assistant message whose tool
+    // results were never appended; sending it before the user message is a 400.
+    while (hist.length && hist[hist.length - 1].role === 'assistant'
+      && Array.isArray(hist[hist.length - 1].toolCalls) && hist[hist.length - 1].toolCalls.length) hist.pop();
+    let start = Math.max(0, hist.length - 30);
+    while (start > 0 && !canSplitAfter(hist, start - 1)) start++;
+    for (let i = start; i < hist.length; i++) messages.push(hist[i]);
+  }
+  // THE PROMPT ITSELF. This used to never be pushed: -p sent only the resumed
+  // history and the system message, so a fresh session answered nothing the
+  // user asked and a resumed one answered nothing new.
+  messages.push({ role: 'user', content: prompt });
   const saved = session || { id: sess.newId(), title: prompt.slice(0, 60), workspace: path.resolve(process.cwd()), model: cfg.model, createdAt: Date.now(), messages: [] };
   const tracker = createRunTracker();
   const startedAt = Date.now();
@@ -355,6 +372,13 @@ async function runPrompt({ cfg, prompt, format, session, modelArg, timeoutSecond
     await agent.run();
   } finally {
     if (timer) clearTimeout(timer);
+    // MCP stdio children were spawned for this run; most die on stdin EOF at
+    // process exit, but one that ignores EOF would linger. Kill them outright —
+    // best-effort, the result has already been produced.
+    try {
+      const mcp = await import('./mcp.js');
+      mcp.disconnectAll(mcp.getLiveConnections());
+    } catch { /* best-effort */ }
   }
   sess.saveSession(saved);
 
@@ -505,14 +529,14 @@ export async function main(argv) {
   //     starts this in the background and reports the result as a notice.
   // Failures are reported but never fatal: an unreachable server must not stop
   // the session from starting.
-  const connectMcp = async () => {
+  const connectMcp = async (mcpOpts = {}) => {
     if (cfg.mcp === false) return { servers: [], toolCount: 0 };
     try {
       const mcp = await import('./mcp.js');
       const { API } = await import('./plugin.js');
       const mcpCfg = mcp.loadMcpConfig(cfg.workspace);
       if (!Object.keys(mcpCfg.servers).length) return { servers: [], toolCount: 0 };
-      const res = await mcp.connectAll(mcpCfg, (spec) => API.registerTool(spec));
+      const res = await mcp.connectAll(mcpCfg, (spec) => API.registerTool(spec), mcpOpts);
       mcp.setLiveConnections(res.servers);
       if (process.env.HNCODE_MCP_VERBOSE === '1') {
         for (const s of res.servers) {

package/src/keybindings.js

@@ -110,13 +110,35 @@ const isCommand = (s) => typeof s === 'string' && s.trim().startsWith('/');
  * Read and validate the bindings file.
 
 /**
- * Read and validate the bindings file.
+ * Read and validate the bindings file, cached by mtime+size.
  *
- * @returns {{bindings: Map<string, {key?:string, command?:string}>, errors: string[], file: string}}
- *   `bindings` maps a NORMALISED source key to exactly one target.
+ * The TUI resolves EVERY special keystroke through this, and a readFileSync per key
+ * (an ENOENT open is still a syscall; with AV scanning on Windows it is milliseconds)
+ * sat directly in the input path. The cache returns the parsed result unchanged while
+ * the file's stat is unchanged, so an edit still takes effect immediately — the stat
+ * is the only thing a keystroke pays for.
  */
+let _kbCache = null;   // { file, mtimeMs, size, out }
 export function loadKeybindings(home) {
   const file = keybindingsFile(home);
+  try {
+    const st = fs.statSync(file);
+    if (_kbCache && _kbCache.file === file && _kbCache.mtimeMs === st.mtimeMs && _kbCache.size === st.size) {
+      return _kbCache.out;
+    }
+    const out = readKeybindingsFile(file);
+    _kbCache = { file, mtimeMs: st.mtimeMs, size: st.size, out };
+    return out;
+  } catch {
+    // Absent/unstatable: parse anyway so the error reporting below still runs,
+    // and drop the cache — the file may have just been deleted.
+    _kbCache = null;
+    return readKeybindingsFile(file);
+  }
+}
+
+/** The uncached parse (the body of the old loadKeybindings). */
+function readKeybindingsFile(file) {
   const out = { bindings: new Map(), errors: [], file };
   let raw;
   try { raw = fs.readFileSync(file, 'utf8'); }

package/src/llm.js

@@ -93,7 +93,7 @@ export function toOpenAi(messages) {
     } else if (m.role === 'assistant') {
       const hasText = typeof m.content === 'string' && m.content.trim();
       const hasCalls = Array.isArray(m.toolCalls) && m.toolCalls.length;
-      if (!hasText && !hasCalls) continue; // 上游不允许空 assistant，直接丢弃
+        if (!hasText && !hasCalls) continue; // the provider rejects an empty assistant turn; drop it
       const msg = { role: 'assistant', content: m.content || null };
       if (hasCalls) {
         msg.tool_calls = m.toolCalls.map((tc) => ({
@@ -296,7 +296,9 @@ function buildBody(cfg, messages, streaming = true, opts = {}) {
     model: cfg.innerModel, messages: toOpenAi(messages),
     ...common, ...wire,
   };
-  if (!opts.noTools) body.tools = defs;
+  // Only attach a NON-EMPTY tools array: `tools: []` is rejected by some strict
+  // gateways, and an instance that registered no list means "no tools here".
+  if (!opts.noTools && defs.length) body.tools = defs;
   return JSON.stringify(applyPromptCache('openai', body, {
     enabled: cfg.promptCache !== false,
     sessionKey: cfg.sessionId,
@@ -313,6 +315,12 @@ export class LLM {
   constructor(cfg) {
     this.cfg = cfg;
     this.controller = null;
+    // The tool defs THIS instance sends. Per-instance, NOT module-global: the
+    // global (`llmToolsList` below) was overwritten by every `new Agent()` in
+    // the process, so a subagent, swarm member or teammate constructed while a
+    // parent request was building its body silently swapped the parent's tool
+    // list mid-turn. The agent sets this via setTools() right after construction.
+    this._tools = null;
     // Inline-reasoning state carried ACROSS requests. Our system prompt tells the
     // model to put all its reasoning inside one <think> span, and tool calls happen
     // inside that span — so the span outlives a single request. Reset when the turn
@@ -321,6 +329,11 @@ export class LLM {
     this._tagPending = '';
   }
 
+  // Register the tool list this instance advertises (see `_tools`). Only ever
+  // store an array or null: a non-array would make every later request throw
+  // when the defs are built.
+  setTools(list) { this._tools = Array.isArray(list) ? list : null; }
+
   // Called by the agent at the end of a turn: the next turn starts a fresh
   // reasoning block, even if the previous one never saw its closing tag.
   resetThink() {
@@ -341,13 +354,29 @@ export class LLM {
   // a capped budget plus a reasoning model is what silently produced an empty
   // title (see buildBody), and an internal request has no tools to call.
   async requestText(messages, opts = {}) {
+    // One silent retry on FAILURE (null). These one-shot requests (title,
+    // compaction summary) have no outer retry loop, and a single transient
+    // 429/network blip used to come back as null — which the compaction path
+    // treated as "no summary" and trimmed the history over. `''` (capped-empty)
+    // is a meaningful verdict for the caller and is NOT retried here.
+    let out = await this._requestTextOnce(messages, opts);
+    if (out === null && !(this.controller && this.controller.signal.aborted)) {
+      await new Promise((r) => setTimeout(r, 400));
+      out = await this._requestTextOnce(messages, opts);
+    }
+    return out;
+  }
+
+  async _requestTextOnce(messages, opts = {}) {
     const cfg = this.cfg;
     this.controller = new AbortController();
+    // This instance's tools, unless the caller opted out (internal one-shots).
+    const bodyOpts = { ...opts, ...((this._tools && !opts.noTools) ? { tools: this._tools } : {}) };
     try {
       const res = await fetch(cfg.endpoint, {
         method: 'POST',
         headers: (() => { const h = authHeaders(cfg); try { const out = runPatchSync('llmHeaders', { headers: h }, (c) => c); if (out && out.headers) return out.headers; } catch (e) {} return h; })(),
-        body: (() => { let b = buildBody(cfg, messages, false, opts); try { const out = runPatchSync('llmBody', { body: b, cfg }, (c) => c); if (out && out.body !== undefined) b = out.body; } catch (e) {} return b; })(),
+        body: (() => { let b = buildBody(cfg, messages, false, bodyOpts); try { const out = runPatchSync('llmBody', { body: b, cfg }, (c) => c); if (out && out.body !== undefined) b = out.body; } catch (e) {} return b; })(),
         signal: this.controller.signal,
       });
       if (!res || !res.ok) {
@@ -397,7 +426,7 @@ export class LLM {
     }
   }
 
-  async request(messages, onEvent) {
+  async request(messages, onEvent, cacheEnd) {
     // Mixin seam: let plugins mutate the messages sent to the model.
     try { const out = await runPatch('llmRequest', { messages, cfg: this.cfg }, (c) => c); if (out && out.messages) messages = out.messages; } catch (e) { /* patch failed; proceed with original */ }
     const cfg = this.cfg;
@@ -418,9 +447,20 @@ export class LLM {
     // turns it off and the retry goes out without it — degrading to an estimate
     // rather than failing the request over an accounting nicety.
     const reqOpts = {};
+    // This instance's tools ride along on every attempt (per-instance; see the
+    // constructor note on `_tools`). `tools` is only included when set, so
+    // buildBody's hasOwnProperty probe falls through to the global for callers
+    // that never registered a list.
+    const instanceTools = this._tools ? { tools: this._tools } : {};
 
     for (let attempt = 1; attempt <= RETRIES; attempt++) {
       attempts = attempt;
+      // Reset per attempt. Left holding the PREVIOUS attempt's response, a network error on
+      // this attempt left `res` truthy and `!res.ok` true, so the loop reported the old
+      // status and the old body — `LLM request failed (503)` for a connection that was
+      // actually refused, with `lastError` (the real cause) never reaching the user.
+      res = null;
+      lastError = null;
       // Fresh controller per attempt so an abort aborts this specific request
       // and the retry loop stops.
       this.controller = new AbortController();
@@ -429,7 +469,7 @@ export class LLM {
         res = await fetch(cfg.endpoint, {
           method: 'POST',
           headers: (() => { const h = authHeaders(cfg); try { const out = runPatchSync('llmHeaders', { headers: h }, (c) => c); if (out && out.headers) return out.headers; } catch (e) {} return h; })(),
-          body: (() => { let b = buildBody(cfg, messages, true, reqOpts); try { const out = runPatchSync('llmBody', { body: b, cfg }, (c) => c); if (out && out.body !== undefined) b = out.body; } catch (e) {} return b; })(),
+          body: (() => { let b = buildBody(cfg, messages, true, { ...reqOpts, cacheEnd, ...instanceTools }); try { const out = runPatchSync('llmBody', { body: b, cfg }, (c) => c); if (out && out.body !== undefined) b = out.body; } catch (e) {} return b; })(),
           signal,
         });
       } catch (e) {
@@ -446,6 +486,10 @@ export class LLM {
         if (res.status === 400 && reqOpts.includeUsage !== false) reqOpts.includeUsage = false;
       }
       if (attempt < RETRIES) {
+        // Release the FAILED attempt's body so its socket returns to the pool.
+        // An unread body pins the connection until GC — under a sustained
+        // 429/5xx storm the retries accumulated one open connection per attempt.
+        if (res && res.body) { try { await res.body.cancel(); } catch { /* already gone */ } }
         // Small exponential backoff (200ms, 400ms). If the user hit Esc during
         // the wait, stop retrying.
         const tryingSignal = this.controller.signal;
@@ -469,7 +513,17 @@ export class LLM {
       return;
     }
     if (cfg.stream === false) {
-      const json = await res.json();
+      // A 200 with a malformed/empty body used to reject here, and the caller
+      // (an unawaited `runAgent`) turned that rejection into a process exit via
+      // the global unhandledRejection handler. Surface it as an error EVENT —
+      // the same channel every other failure on this path uses.
+      let json;
+      try {
+        json = await res.json();
+      } catch (e) {
+        onEvent({ type: 'error', error: new Error(`LLM returned a malformed non-streaming body: ${e && e.message}`) });
+        return;
+      }
       return consumeNonStreaming(cfg.protocol, json, onEvent);
     }
     if (!res.body) { onEvent({ type: 'end' }); return; }