@hncode/hncode 0.4.2 → 0.5.0

package/src/prompt-presets.js

@@ -61,7 +61,7 @@ const RULES = {
     ],
     // Only for models with no dedicated reasoning channel.
     tagFallback: [
-      'Put all internal reasoning inside <think>...</think> and close the block before your answer. Reasoning must never appear outside it.',
+      'Put all internal reasoning inside <|thinking|>...<|/thinking|> and close the block before your answer. Reasoning must never appear outside it.',
     ],
   },
   scope: [

package/src/registry-browser.js

@@ -108,8 +108,8 @@ export function rowsForTab(state, tabId) {
       name: r.name,
       label: r.name,
       description: r.description || (r.readable === false ? '(no SKILL.md — cannot install)' : '(no description)'),
-      status: local.has(r.name) ? 'installed' : 'install',
-      statusTone: local.has(r.name) ? 'dim' : 'primary',
+      status: local.has(r.name) ? 'Installed' : 'Not Install',
+      statusTone: local.has(r.name) ? 'ok' : 'warn',
       action: local.has(r.name) ? 'reinstall-skill' : 'install-skill',
       disabled: r.readable === false,
     }));
@@ -132,8 +132,8 @@ export function rowsForTab(state, tabId) {
       label: p.name + (p.kind === 'dir' ? '/' : ''),
       description: loadedNames.has(p.name)
         ? 'loaded in this session'
-        : 'not loaded — restart hncode to load it',
-      status: loadedNames.has(p.name) ? 'loaded' : 'restart',
+        : 'not loaded — Need Restart',
+      status: loadedNames.has(p.name) ? 'loaded' : 'Need Restart',
       statusTone: loadedNames.has(p.name) ? 'ok' : 'warn',
       action: 'remove-plugin',
     }));
@@ -143,8 +143,8 @@ export function rowsForTab(state, tabId) {
     name: r.name,
     label: r.name,
     description: local.has(r.name) ? 'already installed locally' : 'available in the repository',
-    status: local.has(r.name) ? 'installed' : 'install',
-    statusTone: local.has(r.name) ? 'dim' : 'primary',
+    status: local.has(r.name) ? 'Installed' : 'Not Install',
+    statusTone: local.has(r.name) ? 'ok' : 'warn',
     action: local.has(r.name) ? 'reinstall-plugin' : 'install-plugin',
   }));
 }
@@ -171,6 +171,12 @@ export function renderRegistryBrowser(state, cols, rows) {
 
   const out = [];
   const rule = C.border + '\u2500'.repeat(cols) + C.reset;
+  // Mouse targets for this frame. The browser is pure render + key, so it records
+  // its own hitboxes here and the caller (tui.js) maps mouse events onto them —
+  // exactly like the tasks browser does with `_taskHits`. Row is a FRAME row
+  // (0 = the top rule); the caller converts the 1-based screen row.
+  const hits = [];
+  state._regHits = hits;
   out.push(rule);
   out.push(fitExactly(C.cyan + C.bold + title + C.reset, cols));
   // The key hints stay visible while the fetch runs: the panel is usable during it
@@ -181,13 +187,21 @@ export function renderRegistryBrowser(state, cols, rows) {
   out.push('');
 
   // Tab strip, with the count of each tab's rows.
-  // Tab strip, with the count of each tab's rows.
-  out.push(tabs.map((t) => {
-    const n = rowsForTab(state, t.id).length;
-    return t.id === tab.id
-      ? C.cyan + C.bold + `[${t.label} (${n})]` + C.reset
-      : C.gray + ` ${t.label} (${n}) ` + C.reset;
-  }).join(' '));
+  {
+    const stripRow = out.length;
+    let col = 0;
+    const segs = tabs.map((t) => {
+      const n = rowsForTab(state, t.id).length;
+      const text = t.id === tab.id ? `[${t.label} (${n})]` : ` ${t.label} (${n}) `;
+      const col0 = col;
+      col += visWidth(text) + 1;   // +1 for the joining space
+      return { id: t.id, text, col0, col1: col0 + visWidth(text) - 1 };
+    });
+    out.push(segs.map((s) => (s.id === tab.id
+      ? C.cyan + C.bold + s.text + C.reset
+      : C.gray + s.text + C.reset)).join(' '));
+    for (const s of segs) hits.push({ row: stripRow, col0: s.col0, col1: s.col1, kind: 'regTab', tab: s.id });
+  }
   out.push('');
 
   // Body: each row is a label line plus its wrapped description, so the footer must be
@@ -218,7 +232,11 @@ export function renderRegistryBrowser(state, cols, rows) {
     const nameStyle = isSel ? (C.cyan + C.bold) : C.white;
     const badge = r.status ? '  ' + statusColor(r.statusTone) + r.status + C.reset : '';
     const dis = r.disabled ? C.gray : '';
+    const labelRow = out.length;   // the clickable row for this item
     out.push(fitExactly(ptr + nameStyle + dis + r.label + C.reset + badge, cols));
+    // The whole label row is a click target: clicking selects the item (and a
+    // second click / the footer activates it), mirroring the tasks browser.
+    hits.push({ row: labelRow, col0: 0, col1: cols - 1, kind: 'regRow', index: i });
     for (const line of wrapText(r.description, Math.max(8, cols - 6))) {
       out.push(C.gray + '    ' + line + C.reset);
     }

package/src/remote.js

@@ -23,6 +23,24 @@ import os from 'node:os';
 import path from 'node:path';
 import { skillsDir, normalizeSkillName } from './skills.js';
 
+// TLS verification is ON by default. If a local proxy / AV breaks the cert
+// chain, set HNCODE_DISABLE_TLS_VERIFY to skip verification for GitHub fetches.
+if (process.env.HNCODE_DISABLE_TLS_VERIFY) {
+  // Node prints an "insecure TLS" warning for this intentional opt-out. Replace the
+  // default `warning` handler with one that swallows only that message, so the rest
+  // of Node's warnings still come through.
+  process.removeAllListeners('warning');
+  process.on('warning', (warning) => {
+    if (warning && /NODE_TLS_REJECT_UNAUTHORIZED/i.test(warning.message || '')) return;
+    const pid = process.pid;
+    const name = warning && warning.name ? `${warning.name}: ` : '';
+    let line = `(node:${pid}) ${name}${warning && warning.message ? warning.message : String(warning)}`;
+    if (warning && warning.detail) line += `\n${warning.detail}`;
+    process.stderr.write(line + '\n');
+  });
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+}
+
 // The canonical source. Overridable so a fork (or a test) can point elsewhere.
 export const DEFAULT_REPO = process.env.HNCODE_REPO || 'NiceHello666/hncode';
 export const DEFAULT_REF = process.env.HNCODE_REPO_REF || 'main';
@@ -75,11 +93,11 @@ async function fetchText(url, { timeoutMs = 20000 } = {}) {
 }
 
 function apiContents(repo, ref, dir) {
-  return `http://127.0.0.1:62578/api/repos/${repo}/contents/${dir}${ref ? `?ref=${encodeURIComponent(ref)}` : ''}`;
+  return `https://api.github.com/repos/${repo}/contents/${dir}${ref ? `?ref=${encodeURIComponent(ref)}` : ''}`;
 }
 
 function rawUrl(repo, ref, file) {
-  return `http://127.0.0.1:62578/raw/${repo}/${ref}/${file}`;
+  return `https://raw.githubusercontent.com/${repo}/${ref}/${file}`;
 }
 
 // Each item is a DIRECTORY in the repo (skills/<name>/, plugins/<name>/). A loose file

package/src/rollout.js

@@ -0,0 +1,151 @@
+// Session replay (/replay) — play a recorded conversation back, one step at a time.
+//
+// Why this exists: a session file records WHAT happened but not how long it took or
+// in what ORDER relative to the tools, and reading the raw JSON to understand a run
+// is unpleasant. More importantly, when something went wrong two hours ago, the
+// question is "what did the model see when it made that bad call" — and the answer is
+// the transcript AS IT STOOD at that step, which is not the same as the final
+// transcript.
+//
+// So the replay is a step index over the session's messages, with the state at each
+// step reconstructable. It is deliberately read-only: nothing here writes a file or
+// resumes execution. A replay that could act would be a footgun.
+//
+// Steps are the unit the user cares about — a user message, an assistant reply, a
+// tool call, a tool result — not raw JSON entries, because one assistant message can
+// carry several tool calls and the interesting question is "which tool ran, in what
+// order".
+
+/** The kinds of step a replay can stop on, in the order they can occur. */
+export const STEP_KINDS = ['user', 'assistant', 'thinking', 'tool', 'system'];
+
+/**
+ * Turn a session's messages into replay steps.
+ *
+ * Returns an array of
+ * `{ index, kind, role, label, text, toolName, args, at }`. `at` is only present
+ * when the recording kept a timestamp, which older sessions do not.
+ */
+export function buildSteps(messages) {
+  const list = Array.isArray(messages) ? messages : [];
+  const steps = [];
+  for (const m of list) {
+    if (!m || typeof m !== 'object') continue;
+    const role = String(m.role || '');
+    const at = m.at || m.timestamp || null;
+    if (role === 'assistant') {
+      // Split one assistant message into its reasoning, its prose, and each tool
+      // call: the tool calls are the steps a debugging reader wants on their own.
+      const thinking = typeof m.reasoning === 'string' ? m.reasoning : '';
+      if (thinking.trim()) {
+        steps.push({ kind: 'thinking', role, label: 'thinking', text: thinking, at });
+      }
+      const text = typeof m.content === 'string' ? m.content : '';
+      if (text.trim()) {
+        steps.push({ kind: 'assistant', role, label: 'reply', text, at });
+      }
+      const calls = Array.isArray(m.toolCalls) ? m.toolCalls : [];
+      for (const c of calls) {
+        const name = (c && (c.name || (c.function && c.function.name))) || 'tool';
+        steps.push({
+          kind: 'tool', role, label: name, toolName: name,
+          text: '', args: c && (c.args || c.arguments || (c.function && c.function.arguments)) || null,
+          at,
+        });
+      }
+      if (!thinking.trim() && !text.trim() && !calls.length) {
+        steps.push({ kind: 'assistant', role, label: 'reply', text: '', at });
+      }
+      continue;
+    }
+    if (role === 'tool') {
+      const name = m.toolName || m.name || 'tool';
+      steps.push({ kind: 'tool', role, label: `${name} result`, toolName: name, text: typeof m.content === 'string' ? m.content : '', at });
+      continue;
+    }
+    if (role === 'user' || role === 'system') {
+      steps.push({ kind: role, role, label: role === 'user' ? 'prompt' : 'system', text: typeof m.content === 'string' ? m.content : '', at });
+      continue;
+    }
+    // Anything else (a plugin-injected role, a future one) is shown as itself rather
+    // than dropped: a replay that silently omits steps is worse than an ugly label.
+    steps.push({ kind: 'other', role, label: role || 'entry', text: typeof m.content === 'string' ? m.content : '', at });
+  }
+  return steps.map((s, i) => ({ ...s, index: i }));
+}
+
+/**
+ * The state at step `i`: which prompt is being answered and what has been seen.
+ *
+ * This is the "as it stood" view — the whole reason to replay rather than scroll.
+ */
+export function stateAtStep(steps, i) {
+  const list = Array.isArray(steps) ? steps : [];
+  const at = Math.max(0, Math.min(list.length - 1, i | 0));
+  let lastPrompt = '';
+  let tools = 0;
+  for (let n = 0; n <= at; n++) {
+    const s = list[n];
+    if (!s) continue;
+    if (s.kind === 'user') lastPrompt = s.text;
+    if (s.kind === 'tool') tools++;
+  }
+  return {
+    index: at,
+    lastPrompt,
+    tools,
+    // The turn number the step belongs to, counting prompts: 1-based for display.
+    turn: list.slice(0, at + 1).filter((s) => s && s.kind === 'user').length || 1,
+  };
+}
+
+/** A one-line summary per step, for the scrubber list. */
+export function stepLine(step, width = 72) {
+  if (!step) return '';
+  const t = String(step.text || '').replace(/\s+/g, ' ').trim();
+  const arg = step.args == null ? ''
+    : (typeof step.args === 'string' ? step.args : JSON.stringify(step.args)).replace(/\s+/g, ' ');
+  const body = t || arg;
+  const cut = body.length > width ? body.slice(0, width - 1) + '…' : body;
+  return cut;
+}
+
+/**
+ * The frame for one step: a header plus the step's body, wrapped.
+ *
+ * Wrapping is done here rather than by the caller so a replay view and a test agree
+ * on the exact rows.
+ */
+export function renderStep(steps, i, opts = {}) {
+  const list = Array.isArray(steps) ? steps : [];
+  if (!list.length) return ['(this session has no steps to replay)'];
+  const at = Math.max(0, Math.min(list.length - 1, i | 0));
+  const s = list[at];
+  const st = stateAtStep(list, at);
+  const width = Math.max(20, opts.width || 76);
+  const out = [];
+  out.push(`step ${at + 1}/${list.length}  turn ${st.turn}  ${s.kind}${s.toolName ? ' ' + s.toolName : ''}`);
+  if (st.lastPrompt) out.push(`  answering: ${st.lastPrompt.split('\n')[0].slice(0, width - 12)}`);
+  if (s.at) out.push(`  at: ${s.at}`);
+  out.push('');
+  const body = [String(s.text || ''), s.args == null ? '' : (typeof s.args === 'string' ? s.args : JSON.stringify(s.args, null, 2))]
+    .filter((x) => x && String(x).trim()).join('\n');
+  const rows = body ? String(body).split('\n') : ['(no content)'];
+  for (const r of rows) {
+    if (r.length <= width) { out.push(r); continue; }
+    for (let k = 0; k < r.length; k += width) out.push(r.slice(k, k + width));
+  }
+  return out;
+}
+
+/** Totals for the header: how many steps of each kind, and how many tools ran. */
+export function replaySummary(steps) {
+  const list = Array.isArray(steps) ? steps : [];
+  const counts = {};
+  for (const s of list) counts[s.kind] = (counts[s.kind] || 0) + 1;
+  const calls = list.filter((s) => s.kind === 'tool' && s.role === 'assistant').length;
+  const results = list.filter((s) => s.kind === 'tool' && s.role === 'tool').length;
+  return { total: list.length, counts, calls, results };
+}
+
+export default { buildSteps, stateAtStep, stepLine, renderStep, replaySummary, STEP_KINDS };

package/src/row-cache.js

@@ -0,0 +1,143 @@
+// A shared, bounded cache of rendered transcript rows.
+//
+// WHY THIS EXISTS
+// ---------------
+// Wrapping and markdown-rendering a message is the expensive half of every frame, and the
+// result depends only on (message text, width, colours) — so it is cacheable. The TUI
+// already cached it, but on the message object itself, which makes the cache a property of
+// the TRANSCRIPT rather than of the renderer:
+//
+//   * It was dropped by position, not by size. `CACHE_KEEP` counted messages from the
+//     tail, so a 4000-message session threw away the caches of the 3700 oldest messages
+//     while keeping the caches of 300 tiny ones — the window tracked message COUNT, not
+//     memory. Scrolling back into a long session re-rendered from scratch every time.
+//   * It could not survive a session switch, because it lived on messages that
+//     `reconstructChat` throws away and rebuilds from the log. Every `--continue` and
+//     every `/sessions` resume started with a cold cache, re-wrapping the whole
+//     transcript before the first frame.
+//   * It had two independent mechanisms — `m._cache` for the row list, `m._mdCache` for
+//     the markdown blocks — with separate lifetimes and no bound between them.
+//
+// A `Map` keyed by a string, with entries ordered by use, fixes all three: the bound is
+// real, the key survives any rebuild of the transcript, and both caches share one budget.
+//
+// THE KEY IS THE WHOLE POINT
+// --------------------------
+// A key that omitted a component of the layout would serve a row rendered for a different
+// width or colour — which is not a stale cache, it is a MISDRAWN frame. So the key spells
+// out everything the render depends on, and `makeRowKey` is the single place that decides
+// what "the same" means. `evictIfStale` is the second half of the same contract: a streamed
+// message's text grows every frame, so an entry whose text no longer matches is not a
+// reuse, and the cache has to notice rather than serve it.
+
+/** How many messages keep their rows. Chosen by measurement, not by feel: the rows for a
+ *  typical assistant message are a few hundred bytes each, so 1500 covers a long session's
+ *  visible history while staying in the low megabytes. */
+export const ROW_CACHE_LIMIT = 1500;
+
+/**
+ * A cache key that identifies a rendered message.
+ *
+ * Every input the render reads goes in, so "the same key" means "the same rows":
+ *   `id`  a stable identity for the message. Index-based ids break the moment a message
+ *         is inserted or removed, which is exactly what compaction and /undo do.
+ *   `text`  the content. Compared by VALUE, not by reference: a streamed message's
+ *         `text` is replaced on every delta, and a reference check would miss every
+ *         reuse after the first frame.
+ *   `w`  the wrap width, `fg`/`codeFg` the colours, `expanded` the plugin-log toggle,
+ *   `raw` the raw-mode flag, `pending`/`failed` the live-state flags, and `spin` the
+ *   spinner key.
+ */
+export function makeRowKey(parts) {
+  return [
+    parts.id,
+    parts.text == null ? '' : parts.text,
+    parts.w,
+    parts.fg,
+    parts.codeFg,
+    parts.expanded ? 1 : 0,
+    parts.raw ? 1 : 0,
+    parts.pending ? 1 : 0,
+    parts.failed ? 1 : 0,
+    parts.spin,
+  ].join('\x1f');
+}
+
+/**
+ * The shared store.
+ *
+ * A single `Map` with insertion order: `Map` iterates in insertion order and `set` on an
+ * existing key does NOT move it, so "touch on every read" has to be an explicit
+ * delete-then-set. That is what makes it an LRU rather than a FIFO — and the difference
+ * matters here, because the entries worth keeping are the ones being read, not the ones
+ * written most recently.
+ */
+const store = new Map();
+
+/** Hits and misses, so a caller can tell "the cache is not helping" from "there is
+ *  nothing to cache" without instrumenting the renderer. */
+const stats = { hits: 0, misses: 0, evictions: 0 };
+
+export function cacheStats() {
+  return { ...stats, size: store.size };
+}
+
+/** For tests: a clean slate. */
+export function resetRowCache() {
+  store.clear();
+  stats.hits = 0;
+  stats.misses = 0;
+  stats.evictions = 0;
+}
+
+/**
+ * Look up `key`, marking it as recently used.
+ *
+ * @returns the cached value, or undefined on a miss. Callers treat `undefined` as "render
+ *   it" — a cache that cannot say "no" is not a cache.
+ */
+export function rowCacheGet(key) {
+  if (!store.has(key)) { stats.misses++; return undefined; }
+  const v = store.get(key);
+  // Touch: re-insert so this key moves to the young end of the Map's iteration order.
+  store.delete(key);
+  store.set(key, v);
+  stats.hits++;
+  return v;
+}
+
+/**
+ * Store `value` under `key` and enforce the bound.
+ *
+ * Eviction is oldest-first, and it is done HERE rather than by the caller counting
+ * messages: the caller cannot know what the entries cost, and a message-count window
+ * keeps a lot of large messages while discarding a lot of small ones.
+ */
+export function rowCacheSet(key, value) {
+  // Re-inserting an existing key would leave the old entry in place, so drop it first —
+  // otherwise the bound could be evictions short of what it looks like.
+  store.delete(key);
+  store.set(key, value);
+  while (store.size > ROW_CACHE_LIMIT) {
+    // Map iteration is insertion order, so the first key is the least recently used.
+    const oldest = store.keys().next();
+    if (oldest.done) break;
+    store.delete(oldest.value);
+    stats.evictions++;
+  }
+  return value;
+}
+
+/**
+ * Is `cached` still valid for `key`'s message?
+ *
+ * A separate question from `rowCacheGet`, because a message can change without its key
+ * changing: a streamed reply's text is the key's own `text` component, so its key DOES
+ * change — but the row COUNT memo does not carry the text, and that one has to be asked
+ * whether the content moved. Kept as a function so the check is named at the call site
+ * rather than being an open-coded `===` someone later widens by accident.
+ */
+export function evictIfStale(entry, key) {
+  if (!entry) return true;
+  return entry.key !== key;
+}