@hncode/hncode 0.3.0 → 0.3.1

package/README_CN.md

@@ -65,7 +65,6 @@ npx @hncode/hncode
 
 hncode 从以下几个优秀项目中汲取了灵感：
 
-- **[Kimi Code](https://github.com/MoonshotAI/kimi-code)** - 原始的青色蓝调终端界面 AI 编程助手，启发了本项目的设计和理念
 - **[Kimi Code](https://github.com/MoonshotAI/kimi-code)** - 原始的青色蓝调终端界面 AI 编程助手，启发了本项目的设计和理念
 - **[Claude Code](https://github.com/anthropics/claude-code)** - 对话流程和工具交互模式
 - **[Codex](https://github.com/openai/codex)** - 通过阅读其开源实现，本项目确定了几处行为：AGENTS.md 的加载规则、未获明确许可不得开启子代理、计划工具的状态流转约束、代码审查的判定标准，以及系统提示词的部分内容

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hncode/hncode",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "hncode — A cyan-blue TUI AI coding agent with zero runtime dependencies.",
   "type": "module",
   "main": "src/index.js",

package/src/agent.js

@@ -445,6 +445,11 @@ export class Agent {
       });
     }
     if (!emittedEnd && this.onEvent) this.onEvent({ type: 'done' });
+    // The turn is over, so the inline-reasoning block it may have left open is
+    // abandoned: the NEXT user turn starts a fresh one. Without this, a model that
+    // never wrote its closing tag would leave the following turn's answer classified
+    // as reasoning.
+    if (typeof this.llm.resetThink === 'function') this.llm.resetThink();
     // Plugin lifecycle: the turn is over (normally, interrupted, or out of steps).
     // In a finally-equivalent position — every exit path above reaches here.
     await runHooks('onTurnEnd', { messages: this.messages, stopped: this.stopRequested });

package/src/config.js

@@ -6,6 +6,7 @@ import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs';
 import { parse } from './toml.js';
+import { pluginConfigDefaults } from './plugin.js';
 
 const home = os.homedir();
 
@@ -194,6 +195,11 @@ function loadBaseToml() {
 
 export function resolveConfig() {
   const root = loadBaseToml() || {};
+  // Merge plugin-provided defaults UNDER the user's config: an explicitly set
+  // user value always wins.
+  for (const [k, v] of Object.entries(pluginConfigDefaults || {})) {
+    if (!(k in root)) root[k] = v;
+  }
 
   const providers = root.providers || {};
   const models = root.models || {};
@@ -234,8 +240,11 @@ export function resolveConfig() {
   // The base URL is used EXACTLY as configured — we only append the API path.
   // (No `/v1` is injected: if the user's base ends in /v1, the result is
   // `<base>/chat/completions`; if it doesn't, it's `<base>/chat/completions` too.)
-  const b = baseUrl.replace(/\/+$/, '');
-  const endpoint = protocol === 'anthropic' ? `${b}/messages` : `${b}/chat/completions`;
+const b = baseUrl.replace(/\/+$/, '');
+  // An empty base URL produces a relative endpoint like "/chat/completions",
+  // which fetch() rejects with a URL-scheme error the model can't decode. Leave
+  // the endpoint empty instead so the caller can show "not set".
+  const endpoint = !b ? '' : (protocol === 'anthropic' ? `${b}/messages` : `${b}/chat/completions`);
 
   // Context window: an explicit env/root override wins, then the model's own
   // `contextLength` (discovered from the provider's /v1/models), then the
@@ -283,22 +292,47 @@ export function resolveConfig() {
 
 export function saveConfig(overlay) {
   const dir = hncodeConfigFile();
+  const entries = Object.entries(overlay || {});
+  if (entries.length === 0) return dir;
+  // Render the overlay to TOML lines, preserving key order.
   let out = '';
-  for (const [k, v] of Object.entries(overlay)) out += toTomlLine(k, v) + '\n';
+  for (const [k, v] of entries) out += toTomlLine(k, v) + '\n';
   fs.mkdirSync(path.dirname(dir), { recursive: true });
-  
+
   // Check if file exists and has content
   try {
     if (fs.statSync(dir).isFile()) {
       const existing = fs.readFileSync(dir, 'utf8');
       if (existing.trim().length > 0) {
-        // Append to existing config instead of overwriting
-        fs.writeFileSync(dir, existing + '\n' + out, 'utf8');
+        // Append to existing config instead of overwriting — but only for keys
+        // that are NOT already present as top-level lines, so two saveConfig
+        // calls for the same key never produce duplicate keys. Reuse the same
+        // "top-level before any [table] header" rule as setConfigString.
+        const keys = new Set(entries.map(([k]) => k));
+        const lines = existing.split(/\r?\n/);
+        const seen = new Set();       // top-level keys already in the file
+        let inTable = false;
+        for (const ln of lines) {
+          if (/^\s*\[/.test(ln)) inTable = true;
+          if (!inTable) {
+            const km = /^\s*([A-Za-z0-9_]+)\s*=\s*/.exec(ln);
+            if (km) seen.add(km[1]);
+          }
+        }
+        // Nothing to add: every overlay key is already present top-level.
+        let add = '';
+        for (const [k, v] of entries) {
+          if (!seen.has(k)) add += toTomlLine(k, v) + '\n';
+        }
+        if (add) {
+          const sep = existing.endsWith('\n') ? '' : '\n';
+          fs.writeFileSync(dir, existing + sep + '\n' + add.trimEnd() + '\n', 'utf8');
+        }
         return dir;
       }
     }
   } catch {}
-  
+
   // New file or empty file
   fs.writeFileSync(dir, out, 'utf8');
   return dir;
@@ -634,6 +668,20 @@ export function effectiveSnapshot(cfg) {
 // sub-table takes precedence (it's the point of switching); env vars set at boot
 // are already baked into `cfg` and only remain in effect when the provider table
 // does not override a given field.
+// Recompute the context window for a given model key. `resolveConfig` picks the
+// window from the model's [models.*] entry (context_length), an env/root
+// override, or the default. resolveProvider / resolveModelArg must reuse the
+// SAME rule when the user switches provider/model mid-session, otherwise the
+// status-bar context gauge (state.ctxMax) keeps the stale previous model's value.
+function contextForModel(cfg, modelName) {
+  const root = (cfg && cfg.raw) || {};
+  const models = (root.models) || {};
+  const overrideContext = process.env.HNCODE_MAX_CONTEXT || root.max_context_size || root.max_context_tokens;
+  const entry = models[modelName] || {};
+  const modelContext = Number(entry.contextLength || entry.context_length || entry.max_context_size || 0);
+  return Number(overrideContext || modelContext || DEFAULTS.maxContextTokens);
+}
+
 export function resolveProvider(cfg, providerName, innerModel) {
   const pr = (cfg.raw && cfg.raw.providers) || {};
   const prov = pr[providerName] || {};
@@ -642,8 +690,11 @@ export function resolveProvider(cfg, providerName, innerModel) {
   const protocol = (prov.protocol) || cfg.protocol;
   const inner = prov.model || (innerModel != null ? innerModel : cfg.innerModel);
   const b = String(baseUrl || '').replace(/\/+$/, '');
-  const endpoint = protocol === 'anthropic' ? `${b}/messages` : `${b}/chat/completions`;
-  return { ...cfg, provider: providerName, innerModel: inner, baseUrl: b, endpoint, apiKey, protocol };
+  const endpoint = !b ? '' : (protocol === 'anthropic' ? `${b}/messages` : `${b}/chat/completions`);
+  // Provider switch may move the active model too; refresh the context window
+  // so the gauge reflects the newly active model, not the old one.
+  const maxContextTokens = contextForModel(cfg, cfg.model);
+  return { ...cfg, provider: providerName, innerModel: inner, baseUrl: b, endpoint, apiKey, protocol, maxContextTokens };
 }
 
 // Switch model, optionally moving to a provider declared via [models.NAME].
@@ -655,7 +706,9 @@ export function resolveModelArg(cfg, modelName) {
   const entry = models[modelName] || {};
   const provider = entry.provider || cfg.provider;
   const inner = bareModelId(provider, modelName, entry);
-  return { ...resolveProvider(cfg, provider, inner), model: modelName };
+  // Refresh the context window for the newly selected model.
+  const maxContextTokens = contextForModel(cfg, modelName);
+  return { ...resolveProvider(cfg, provider, inner), model: modelName, maxContextTokens };
 }
 
 export default { resolveConfig, saveConfig, effectiveSnapshot, resolveProvider, resolveModelArg, addProvider, removeProvider, addModel, fetchModels, fetchCatalog, modelKey, modelLabel, bareModelId, rememberModel, hncodeConfigFile };

package/src/index.js

@@ -8,8 +8,11 @@ import * as sess from './session.js';
 import { Agent, SYSTEM_PROMPT } from './agent.js';
 import { llmTools } from './tools/index.js';
 import { setToolsList } from './llm.js';
+import { localVersion } from './version.js';
 
-export const VERSION = '0.1.0';
+// The version shown by `hncode -V` and the help banner. Read from package.json
+// (via version.js) so it can never drift from the published version again.
+export const VERSION = localVersion();
 
 const HELP = `hncode ${VERSION} — a Kimi Code-style coding agent.
 
@@ -53,17 +56,31 @@ export function parseArgs(argv) {
       else { key = a.slice(2); val = null; }
       if (key === 'resume') key = 'session'; // `--resume <id>` is an alias for `--session <id>`
       if (['session'].includes(key) && val === null) { const nx = argv[i + 1]; out[key] = nx !== undefined && !nx.startsWith('-') ? (i++, nx) : true; }
-      else if (key === 'model' || key === 'prompt' || key === 'output-format' || key === 'add-dir') {
-        if (val === null) { val = argv[++i]; }
-        out[key] = key === 'add-dir' ? (out[key] || []).concat([val]) : val;
+else if (key === 'model' || key === 'prompt' || key === 'output-format' || key === 'add-dir') {
+        if (val === null) {
+          const nx = argv[i + 1];
+          // Only consume the next token if it is a real value, not another flag
+          // or the end of argv. Previously `--model -y` and a trailing `--model`
+          // swallowed or mangled the value, breaking the real flag.
+          val = (nx !== undefined && !nx.startsWith('-')) ? argv[++i] : undefined;
+        }
+out[key] = (key === 'add-dir' && val !== undefined)
+        ? (out[key] || []).concat([val])
+        : val;
       } else if (val !== null) { out[key] = val === 'true' ? true : val === 'false' ? false : val; }
       else out[key] = true;
     } else if (a.startsWith('-') && a.length > 1) {
       const key = a.slice(1);
       const short = { V: 'version', S: 'session', c: 'continue', y: 'yolo', auto: 'auto', m: 'model', p: 'prompt', h: 'help' };
-      if (key === 'S' || key === 'm' || key === 'p') {
-        let val = argv[++i];
-        out[short[key]] = val;
+if (key === 'S' || key === 'm' || key === 'p') {
+        const nx = argv[i + 1];
+        // Take the next token as the value only if it exists and is not another
+        // flag. Previously `-S -y` swallowed `-y` as the session id and a bare
+        // trailing `-m` became undefined; both silently broke the real flag.
+        const hasVal = nx !== undefined && !nx.startsWith('-');
+        if (hasVal) { out[short[key]] = argv[i + 1]; i++; }
+        else if (key === 'S') { out.session = true; }  // "-S" with no id => pick interactively
+        // '-m' / '-p' with no usable value: leave unset (same as a missing arg).
       } else out[short[key]] = true;
     } else {
       out.positional.push(a);

package/src/llm.js

@@ -111,7 +111,23 @@ let llmToolsList = [];
 export function setToolsList(list) { llmToolsList = list; }
 
 export class LLM {
-  constructor(cfg) { this.cfg = cfg; this.controller = null; }
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.controller = 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
+    // ends (see resetThink).
+    this._inThink = false;
+    this._tagPending = '';
+  }
+
+  // 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() {
+    this._inThink = false;
+    this._tagPending = '';
+  }
 
   // Abort an in-flight request (Esc / Ctrl-C while the agent is running).
   abort() {
@@ -219,7 +235,15 @@ export class LLM {
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buf = '';
-    const state = { tools: new Map(), indexToId: {}, doneEmitted: false };
+    // The inline-reasoning state (`inThink` / `tagPending`) is carried on the LLM
+    // instance, NOT recreated per request. A model that opens <think>, runs a tool,
+    // and only writes </think> in the NEXT step would otherwise have everything
+    // after the tool call reclassified as the ANSWER — the reasoning text and the
+    // literal `</think>` tag both showed up in the transcript.
+    const state = {
+      tools: new Map(), indexToId: {}, doneEmitted: false,
+      inThink: !!this._inThink, tagPending: this._tagPending || '',
+    };
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -242,6 +266,12 @@ export class LLM {
       return;
     } finally {
       reader.releaseLock?.();
+      // Carry the inline-reasoning state forward on EVERY exit path — a normal end,
+      // [DONE], an abort and an error all pass through here. The model may resume an
+      // open <think> span after a tool call in the next step, so this belongs to the
+      // turn, not to one request.
+      this._inThink = !!state.inThink;
+      this._tagPending = state.tagPending || '';
     }
     finish(state, onEvent);
   }
@@ -249,15 +279,28 @@ export class LLM {
 
 // ---- inline reasoning tags -------------------------------------------------
 // Some OpenAI-compatible servers do not send a separate `reasoning_content`
-// field: they put the chain of thought INLINE in `content`, wrapped in a tag
-// such as ` thinking…<｜end▁of▁thinking｜>` or `<thinking>…</thinking>`. Without splitting
-// those out, the raw tags and the whole reasoning trace are rendered as the
-// assistant's answer (and counted as output tokens). This is a streaming state
-// machine: a tag can be split across chunks, so a trailing partial tag is held
-// back until the next chunk decides what it is.
-const THINK_OPEN_TAGS = [' thinking', '<thinking>'];
+// field: they put the chain of thought INLINE in `content`, wrapped in a tag.
+// Three spellings have to be supported, because they come from three places:
+//   ` thinking…`                 — the DeepSeek-R1 token markers, as emitted by
+//                               vLLM / llama.cpp builds of that model
+//   `<thinking>…</thinking>`    — what several OpenAI-compatible servers wrap it in
+//   `<think>…</think>`          — what OUR OWN system prompt asks for (agent.js
+//                               and prompt-presets.js both instruct this)
+// The last one was missing, so a model that followed our prompt had its whole
+// reasoning trace rendered as the ANSWER, raw tags and all.
+//
+// The three are mutually distinguishable, which is what makes supporting all of
+// them safe: `</think>` does not occur inside `</thinking>`, `<think>` does not
+// occur inside `<thinking>`, and `' thinking'` does not occur inside `<think>`.
+// So an early match can never be caused by the longer tag.
+//
+// Without splitting these out, the raw tags and the whole reasoning trace are
+// rendered as the assistant's answer (and counted as output tokens). This is a
+// streaming state machine: a tag can be split across chunks, so a trailing partial
+// tag is held back until the next chunk decides what it is.
+const THINK_OPEN_TAGS = [' thinking', '<thinking>', '<think>'];
 // Closing tags. If none of these appear, the block stays in think mode to EOI.
-const THINK_CLOSE_TAGS = ['<｜end▁of▁thinking｜>', '</thinking>'];
+const THINK_CLOSE_TAGS = ['<｜end▁of▁thinking｜>', '</thinking>', '</think>'];
 
 // Longest suffix of `buf` that is a proper prefix of one of `tags`.
 // A single trailing space is deliberately NOT a candidate: `' '` is a prefix of
@@ -313,7 +356,13 @@ function flushContent(onEvent, state) {
 function finish(state, onEvent) {
   // close any tool calls that started but never got an explicit end
   if (state.doneEmitted) return;
-  flushContent(onEvent, state);
+  // A still-OPEN reasoning block is deliberately NOT flushed here. The model can
+  // continue it after a tool call in the next step — our own system prompt tells it
+  // to put ALL reasoning in one <think> span, and tool calls happen inside that
+  // span. Flushing would dump the held-back partial tag and end the block early, so
+  // the rest of the reasoning would be reclassified as the ANSWER. The caller keeps
+  // `inThink`/`tagPending` on the LLM instance and the block resumes there.
+  if (!state.inThink) flushContent(onEvent, state);
   for (const [, t] of state.tools) {
     if (!t.done) onEvent({ type: 'tool_end', id: t.id });
   }

package/src/plugin.js

@@ -125,6 +125,15 @@ export async function loadPlugins(dir) {
   const pluginDir = dir || PLUGIN_DIR;
   if (!fs.existsSync(pluginDir)) return [];
 
+  // loadPlugins() may be called more than once (tests, hot reload). Reset the
+  // registries first so a second load cannot throw "tool already registered"
+  // and accumulate stale hooks/config over reloads.
+  registeredTools.length = 0;
+  registeredCommands.length = 0;
+  for (const k of Object.keys(registeredHooks)) delete registeredHooks[k];
+  for (const k of Object.keys(registeredConfig)) delete registeredConfig[k];
+  loadedPlugins.length = 0;
+
   const files = fs.readdirSync(pluginDir)
     .filter((f) => f.endsWith('.js') || f.endsWith('.mjs'))
     .sort();
@@ -189,6 +198,10 @@ export async function runHooks(name, ...args) {
 // ---------------------------------------------------------------------------
 
 export { API, registeredTools as pluginTools, registeredCommands as pluginCommands };
+// Plugin-provided config DEFAULTS. resolveConfig() must merge these BEFORE
+// user config so a plugin can supply a value the user has not set. Previously
+// registerConfig() stored into this object and nothing ever read it.
+export { registeredConfig as pluginConfigDefaults };
 
 // Reset state — useful for tests.
 export function _resetPlugins() {