@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/src/renderer/tool-result-summary.ts

@@ -0,0 +1,148 @@
+/**
+ * summarizeToolResult — one-line human summaries for tool RESULTS, so the
+ * transcript (and the fleet attach view, which shares the same rendering seam
+ * in conversation-rendering.ts) shows "wrote haiku.txt (532 B)" instead of a
+ * raw `{"files_written":1,"bytes_written":532,...}` JSON blob. The full payload
+ * stays reachable behind the existing collapse/expand toggle — this only
+ * changes the collapsed preview line, never destroys data. (UX-B item 3.)
+ *
+ * Returning `null` means "no honest summary for this shape" — the caller then
+ * falls back to the previous raw-first-line preview, so an unrecognised tool or
+ * an unexpected payload is never mis-summarised.
+ */
+
+/** Compact byte count: "87 B", "1.2 KB", "3.4 MB". */
+function formatBytes(n: number): string {
+  if (!Number.isFinite(n) || n < 0) return '? B';
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/** Compact duration: "820ms", "1.2s", "1m3s". */
+function formatDuration(ms: number): string {
+  if (!Number.isFinite(ms) || ms < 0) return '?';
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const s = Math.round(ms / 1000);
+  return `${Math.floor(s / 60)}m${s % 60}s`;
+}
+
+/** Trailing filename for compact display (paths can be long/absolute). */
+function baseName(p: string): string {
+  const cleaned = p.replace(/[/\\]+$/, '');
+  const idx = Math.max(cleaned.lastIndexOf('/'), cleaned.lastIndexOf('\\'));
+  return idx >= 0 ? cleaned.slice(idx + 1) : cleaned;
+}
+
+function asNumber(v: unknown): number | undefined {
+  return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+}
+
+function firstPath(files: unknown): string | undefined {
+  if (!Array.isArray(files) || files.length === 0) return undefined;
+  const first = files[0];
+  if (typeof first === 'string') return first;
+  if (first && typeof first === 'object') {
+    const rec = first as Record<string, unknown>;
+    if (typeof rec.path === 'string') return rec.path;
+    if (typeof rec.resolved_path === 'string') return rec.resolved_path;
+  }
+  return undefined;
+}
+
+/** write: { files_written, bytes_written, files?: [{path, bytes_written}], dry_run? } */
+function summarizeWrite(obj: Record<string, unknown>): string | null {
+  const count = asNumber(obj.files_written);
+  const bytes = asNumber(obj.bytes_written);
+  if (count === undefined) return null;
+  const verb = obj.dry_run === true ? 'would write' : 'wrote';
+  const size = bytes !== undefined ? ` (${formatBytes(bytes)})` : '';
+  if (count === 1) {
+    const path = firstPath(obj.files);
+    return path ? `${verb} ${baseName(path)}${size}` : `${verb} 1 file${size}`;
+  }
+  return `${verb} ${count} files${size}`;
+}
+
+/** read: { summary: { files_read, total_lines }, files?: [{path, lineCount}] } */
+function summarizeRead(obj: Record<string, unknown>): string | null {
+  const summary = (obj.summary && typeof obj.summary === 'object')
+    ? obj.summary as Record<string, unknown>
+    : obj;
+  const count = asNumber(summary.files_read);
+  const lines = asNumber(summary.total_lines);
+  if (count === undefined && lines === undefined) return null;
+  const lineText = lines !== undefined ? ` (${lines} line${lines === 1 ? '' : 's'})` : '';
+  if (count === 1) {
+    const path = firstPath(obj.files);
+    return path ? `read ${baseName(path)}${lineText}` : `read 1 file${lineText}`;
+  }
+  return `read ${count ?? '?'} files${lineText}`;
+}
+
+/** edit: { applied, failed, dry_run } or richer with a path. */
+function summarizeEdit(obj: Record<string, unknown>): string | null {
+  const applied = asNumber(obj.applied);
+  if (applied === undefined) return null;
+  const failed = asNumber(obj.failed) ?? 0;
+  const verb = obj.dry_run === true ? 'would apply' : 'applied';
+  const path = typeof obj.path === 'string' ? obj.path : firstPath(obj.files);
+  const target = path ? ` to ${baseName(path)}` : '';
+  const failText = failed > 0 ? `, ${failed} failed` : '';
+  return `${verb} ${applied} edit${applied === 1 ? '' : 's'}${target}${failText}`;
+}
+
+/** A single exec command result. */
+function summarizeExecOne(obj: Record<string, unknown>): string | null {
+  const exit = obj.exit_code;
+  const dur = asNumber(obj.duration_ms);
+  const durText = dur !== undefined ? ` · ${formatDuration(dur)}` : '';
+  if (obj.timed_out === true) return `timed out${durText}`;
+  if (obj.cancelled === true) return `cancelled${durText}`;
+  const stdout = typeof obj.stdout === 'string' ? obj.stdout : '';
+  const lineCount = stdout.length === 0
+    ? 0
+    : stdout.replace(/\n$/, '').split('\n').length;
+  const lineText = lineCount > 0 ? ` · ${lineCount} line${lineCount === 1 ? '' : 's'}` : '';
+  const code = typeof exit === 'number' ? String(exit) : '?';
+  return `exit ${code}${durText}${lineText}`;
+}
+
+/** exec: single { cmd, exit_code, ... } or multi { commands: [...], total }. */
+function summarizeExec(obj: Record<string, unknown>): string | null {
+  if (Array.isArray(obj.commands)) {
+    const total = asNumber(obj.total) ?? obj.commands.length;
+    const failed = obj.commands.filter(
+      (c) => c && typeof c === 'object' && (c as Record<string, unknown>).success === false,
+    ).length;
+    return failed > 0
+      ? `${total} commands · ${failed} failed`
+      : `${total} commands · all ok`;
+  }
+  if ('exit_code' in obj || 'timed_out' in obj || 'cancelled' in obj) {
+    return summarizeExecOne(obj);
+  }
+  return null;
+}
+
+export function summarizeToolResult(toolName: string | undefined, content: string): string | null {
+  if (!toolName) return null;
+  const family = toolName.includes('__') ? toolName.split('__').pop()! : toolName;
+  let data: unknown;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  if (data === null || typeof data !== 'object' || Array.isArray(data)) return null;
+  const obj = data as Record<string, unknown>;
+
+  switch (family) {
+    case 'write': return summarizeWrite(obj);
+    case 'read': return summarizeRead(obj);
+    case 'edit': return summarizeEdit(obj);
+    case 'exec': return summarizeExec(obj);
+    default: return null;
+  }
+}

package/src/renderer/turn-injection.ts

@@ -0,0 +1,133 @@
+/**
+ * Per-turn knowledge injection record rendering (Wave-5 W5.2, wo803).
+ *
+ * The SDK's passive per-turn retrieval engine (wo801, W5.1 —
+ * packages/sdk/src/platform/agents/turn-knowledge-injection.ts) stores one
+ * `TurnInjectionRecord` per turn on `AgentRecord.turnInjections` (a bounded
+ * ring, default 20 entries) and appends the same record to the agent's
+ * session transcript as `{type:'knowledge_injection', turn, ...record}`.
+ *
+ * `TurnInjectionRecord` itself is not re-exported from the SDK's
+ * `platform/agents` barrel (only `AgentRecord.turnInjections` carries its
+ * structural shape through the already-public `platform/tools` barrel), so
+ * the entry type here is DERIVED from `AgentRecord` rather than imported by
+ * name — this needs no SDK export change.
+ *
+ * Reality check (updated wo805): as of Wave-5 wo805 the TUI's main interactive
+ * session DOES route through this engine. The SDK `Orchestrator` runs per-turn
+ * passive injection on the evolving primary conversation and records each turn
+ * on its own bounded ring, exposed via `Orchestrator.getTurnInjections()` — the
+ * main-session counterpart to `AgentRecord.turnInjections` (there is no
+ * AgentRecord for the primary conversation). `buildMainSessionTurnInjectionsText`
+ * renders that ring for `/recall injections` with no agent id. Spawned agents
+ * (Task-tool runs, automation-triggered runs, session continuations) still
+ * record onto their own `AgentRecord.turnInjections`, rendered per-agent by
+ * `buildTurnInjectionsText` when an explicit agent id is given.
+ */
+import type { AgentRecord } from '@pellux/goodvibes-sdk/platform/tools';
+
+/** One TurnInjectionRecord entry, derived from AgentRecord (see module doc). */
+export type TurnInjectionEntry = NonNullable<AgentRecord['turnInjections']>[number];
+
+function fmtN(n: number): string {
+  return n.toLocaleString();
+}
+
+/**
+ * Annotate each injected id with its source (Stage B). Code-index hits get a
+ * ` [code]` tag; memory records are left bare so a memory-only line renders
+ * byte-identically to the pre-Stage-B output. `injectedSources` is parallel to
+ * `injectedIds`; a missing/short entry defaults to memory (no tag).
+ */
+function labelInjectedIds(entry: TurnInjectionEntry): string {
+  const sources = entry.injectedSources ?? [];
+  return entry.injectedIds
+    .map((id, i) => (sources[i] === 'code-index' ? `${id} [code]` : id))
+    .join(', ');
+}
+
+/** Honest one-clause note when a wired code index was queried but injected nothing this turn. */
+function codeSkipNote(entry: TurnInjectionEntry): string {
+  return entry.codeInjectionSkipped ? `, code skipped: ${entry.codeInjectionSkipped}` : '';
+}
+
+/** Render a single TurnInjectionRecord as one readable line. */
+export function formatTurnInjectionEntry(entry: TurnInjectionEntry): string {
+  const backendTag = entry.embeddingBackend === 'fallback-lexical' ? ' [lexical fallback]' : '';
+  if (entry.injectedIds.length === 0) {
+    // Honest empty state: the engine ran this turn but injected nothing —
+    // distinct from "the engine never ran" (see buildTurnInjectionsText).
+    const reasonText = entry.reason === 'no records cleared relevance floor'
+      ? 'nothing injected this turn — nothing cleared the relevance floor'
+      : `nothing injected this turn — ${entry.reason ?? 'unknown reason'}`;
+    const codeConsidered = entry.codeCandidatesConsidered ? `, code considered ${entry.codeCandidatesConsidered}` : '';
+    return `  turn ${entry.turn}: ${reasonText}${backendTag} (considered ${entry.candidatesConsidered}${codeConsidered}, floor ${entry.relevanceFloor})${codeSkipNote(entry)}`;
+  }
+  const droppedStr = entry.droppedForBudget.length > 0
+    ? `, dropped for budget: ${entry.droppedForBudget.join(', ')}`
+    : '';
+  // The retrieval query is part of the record's honesty contract — without it
+  // an injected line can't be traced back to WHY those ids were retrieved
+  // (Wave-5 replay flagged the omission). Truncated to keep the line scannable.
+  const queryStr = entry.query ? ` for ${JSON.stringify(truncateQuery(entry.query))}` : '';
+  return (
+    `  turn ${entry.turn}: injected ${labelInjectedIds(entry)}${queryStr} ` +
+    `(~${fmtN(entry.tokenCost)}/${fmtN(entry.budgetTokens)} tok, floor ${entry.relevanceFloor})${droppedStr}${backendTag}${codeSkipNote(entry)}`
+  );
+}
+
+function truncateQuery(query: string): string {
+  const flat = query.replace(/\s+/g, ' ').trim();
+  return flat.length > 48 ? `${flat.slice(0, 47)}…` : flat;
+}
+
+/**
+ * Render the full per-turn injection history for one agent, most-recent-turn
+ * first, with an honest empty state when nothing has been recorded yet.
+ *
+ * An empty `entries` array is deliberately ambiguous about WHY it's empty
+ * (flag disabled, no turn with new input has run yet, or every turn's token
+ * budget had no headroom) — the SDK does not distinguish these cases in the
+ * ring itself, so this renders all three possibilities rather than guessing.
+ */
+export function buildTurnInjectionsText(agentId: string, entries: readonly TurnInjectionEntry[]): string {
+  if (entries.length === 0) {
+    return (
+      `[recall] No per-turn injection records for agent ${agentId} yet. This means one of: ` +
+      'passive knowledge injection is disabled, no turn with new input has run yet, or the ' +
+      'token budget had no headroom on every turn so far — there is no record either way.'
+    );
+  }
+  const lines = [`[recall] Per-turn knowledge injections for agent ${agentId} (${entries.length}, most recent first):`];
+  for (const entry of [...entries].reverse()) {
+    lines.push(formatTurnInjectionEntry(entry));
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Render the MAIN interactive session's per-turn injection ring
+ * (`Orchestrator.getTurnInjections()`, wo805), most-recent-turn first, with the
+ * same honest empty state as the per-agent path. The main-session counterpart
+ * to {@link buildTurnInjectionsText}: no agent id, main-session-appropriate
+ * wording, but the identical per-entry rendering (`formatTurnInjectionEntry`).
+ *
+ * As with the agent path, an empty `entries` array is deliberately ambiguous
+ * about WHY it's empty (flag disabled, no turn with new input has run yet, or
+ * every turn's token budget had no headroom) — the ring does not distinguish
+ * these, so this renders all three possibilities rather than guessing.
+ */
+export function buildMainSessionTurnInjectionsText(entries: readonly TurnInjectionEntry[]): string {
+  if (entries.length === 0) {
+    return (
+      '[recall] No per-turn injection records for the main session yet. This means one of: ' +
+      'passive knowledge injection is disabled, no turn with new input has run yet, or the ' +
+      'token budget had no headroom on every turn so far — there is no record either way.'
+    );
+  }
+  const lines = [`[recall] Per-turn knowledge injections for the main session (${entries.length}, most recent first):`];
+  for (const entry of [...entries].reverse()) {
+    lines.push(formatTurnInjectionEntry(entry));
+  }
+  return lines.join('\n');
+}