ompchamber 3.1.0 → 3.2.0

package/src/shared/lib/code/language.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Language detection for the highlighter: which Shiki grammar a path maps to,
+ * and whether a block of text looks like code at all.
+ *
+ * Both are pure string predicates over the input, with no highlighter state, so
+ * they live beside the tokenizer rather than inside it — the tokenizer needs a
+ * booted Shiki instance, these do not, and a caller that only wants to pick a
+ * language (a tool card deciding whether to render a code surface) does not
+ * have to pull one in.
+ */
+
+/** Map file extension to Shiki language id */
+export function getLanguageFromPath(filePath?: string): string {
+  if (!filePath) return 'javascript';
+  const clean = filePath.split('?')[0].split('#')[0].replace(/:\d+(?:-\d+)?$/, '');
+  const ext = clean.split('.').pop()?.toLowerCase();
+  switch (ext) {
+    case 'ts': return 'typescript';
+    case 'tsx': return 'tsx';
+    case 'js':
+    case 'mjs':
+    case 'cjs': return 'javascript';
+    case 'jsx': return 'jsx';
+    case 'json': return 'json';
+    case 'md':
+    case 'markdown': return 'markdown';
+    case 'css': return 'css';
+    case 'sh':
+    case 'bash':
+    case 'zsh': return 'bash';
+    case 'diff':
+    case 'patch': return 'diff';
+    case 'yaml':
+    case 'yml': return 'yaml';
+    case 'html': return 'html';
+    case 'svg':
+    case 'xml': return 'xml';
+    case 'py': return 'python';
+    case 'go': return 'go';
+    case 'rs': return 'rust';
+    case 'sql': return 'sql';
+    case 'toml': return 'toml';
+    case 'java': return 'java';
+    case 'c':
+    case 'h': return 'c';
+    case 'cpp':
+    case 'cc':
+    case 'hpp': return 'cpp';
+    case 'cs': return 'csharp';
+    case 'rb': return 'ruby';
+    case 'php': return 'php';
+    case 'kt':
+    case 'kts': return 'kotlin';
+    case 'swift': return 'swift';
+    case 'scala': return 'scala';
+    case 'lua': return 'lua';
+    case 'pl': return 'perl';
+    case 'dockerfile': return 'dockerfile';
+    case 'ini':
+    case 'cfg':
+    case 'conf': return 'ini';
+    case 'properties': return 'properties';
+    case 'env': return 'bash';
+    case 'zig': return 'zig';
+    case 'ex':
+    case 'exs': return 'elixir';
+    case 'dart': return 'dart';
+    case 'ml':
+    case 'mli': return 'ocaml';
+    case 'hs': return 'haskell';
+    case 'nix': return 'nix';
+    case 'tf':
+    case 'tfvars':
+    case 'hcl': return 'hcl';
+    case 'graphql':
+    case 'gql': return 'graphql';
+    case 'sol': return 'solidity';
+    case 'r': return 'r';
+    case 'jl': return 'julia';
+    case 'erl': return 'erlang';
+    case 'clj':
+    case 'cljs':
+    case 'cljc':
+    case 'edn': return 'clojure';
+    case 'scm':
+    case 'ss': return 'scheme';
+    case 'rkt': return 'racket';
+    case 'proto': return 'protobuf';
+    case 'makefile':
+    case 'mk': return 'makefile';
+    case 'ps1':
+    case 'psm1': return 'powershell';
+    case 'json5': return 'json5';
+    case 'less': return 'less';
+    case 'scss': return 'scss';
+    case 'sass': return 'sass';
+    case 'styl': return 'stylus';
+    case 'vue': return 'vue';
+    case 'svelte': return 'svelte';
+    case 'astro': return 'astro';
+    // `.m` is genuinely ambiguous (Objective-C vs MATLAB); map to Objective-C,
+    // the common editor default.
+    case 'mm':
+    case 'm': return 'objective-c';
+    case 'groovy':
+    case 'gvy':
+    case 'gradle': return 'groovy';
+    default: return 'javascript';
+  }
+}
+
+/**
+ * The patterns `isCodeLike` probes, at module scope.
+ *
+ * A regex *literal* inside the function body constructs a fresh `RegExp` on
+ * every call, and this runs per render from the notice, task-result and Bash
+ * cards. Compiled once here instead.
+ */
+const CODE_PATTERNS = [
+  /^(?:import|export)\s+.+from\s+['"][^'"]+['"]/m,
+  /^(?:const|let|var|function|class|interface|type|enum)\s+[A-Za-z0-9_$]+/m,
+  /(?:=>|\bconsole\.(?:log|error|warn)|return\s+|async\s+function)/,
+  /^\s*\d+:\s*(?:import|const|let|function|\/\/|\/\*|<|[A-Za-z])/m,
+  /^\s*\[[A-Za-z0-9_./-]+\.[a-zA-Z0-9]+\]\s*\n\d+:/m,
+] as const;
+
+/** Check if a string looks like code or structured programming text */
+export function isCodeLike(text: string): boolean {
+  if (!text || text.length < 5) return false;
+  const trimmed = text.trim();
+  if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+    try {
+      JSON.parse(trimmed);
+      return true;
+    } catch {
+      // not valid JSON
+    }
+  }
+
+  return CODE_PATTERNS.some((pattern) => pattern.test(trimmed));
+}

package/src/shared/lib/code/syntax-highlight.test.ts

@@ -7,7 +7,8 @@ import { beforeAll, describe, expect, test } from 'bun:test';
 
 import { bootSyntax, onLanguageReady, requestLanguage } from '@/shared/lib/code/highlighter';
 import { findMatches } from '@/shared/lib/code/editor/find';
-import { getLanguageFromPath, highlightCode, highlightLines } from '@/shared/lib/code/syntax-highlight';
+import { getLanguageFromPath } from '@/shared/lib/code/language';
+import { highlightCode, highlightLines } from '@/shared/lib/code/syntax-highlight';
 import { highlightCodeWindow } from '@/shared/lib/code/windowed-highlight';
 
 /** Shiki emits `<span class="shiki">…` with dual-theme CSS variables per token. */

package/src/shared/lib/code/syntax-highlight.ts

@@ -7,128 +7,6 @@ import { SHIKI_THEMES } from '@/shared/lib/code/shiki-themes';
 
 export type { HighlightLinesOptions };
 
-/** Map file extension to Shiki language id */
-export function getLanguageFromPath(filePath?: string): string {
-  if (!filePath) return 'javascript';
-  const clean = filePath.split('?')[0].split('#')[0].replace(/:\d+(?:-\d+)?$/, '');
-  const ext = clean.split('.').pop()?.toLowerCase();
-  switch (ext) {
-    case 'ts': return 'typescript';
-    case 'tsx': return 'tsx';
-    case 'js':
-    case 'mjs':
-    case 'cjs': return 'javascript';
-    case 'jsx': return 'jsx';
-    case 'json': return 'json';
-    case 'md':
-    case 'markdown': return 'markdown';
-    case 'css': return 'css';
-    case 'sh':
-    case 'bash':
-    case 'zsh': return 'bash';
-    case 'diff':
-    case 'patch': return 'diff';
-    case 'yaml':
-    case 'yml': return 'yaml';
-    case 'html': return 'html';
-    case 'svg':
-    case 'xml': return 'xml';
-    case 'py': return 'python';
-    case 'go': return 'go';
-    case 'rs': return 'rust';
-    case 'sql': return 'sql';
-    case 'toml': return 'toml';
-    case 'java': return 'java';
-    case 'c':
-    case 'h': return 'c';
-    case 'cpp':
-    case 'cc':
-    case 'hpp': return 'cpp';
-    case 'cs': return 'csharp';
-    case 'rb': return 'ruby';
-    case 'php': return 'php';
-    case 'kt':
-    case 'kts': return 'kotlin';
-    case 'swift': return 'swift';
-    case 'scala': return 'scala';
-    case 'lua': return 'lua';
-    case 'pl': return 'perl';
-    case 'dockerfile': return 'dockerfile';
-    case 'ini':
-    case 'cfg':
-    case 'conf': return 'ini';
-    case 'properties': return 'properties';
-    case 'env': return 'bash';
-    case 'zig': return 'zig';
-    case 'ex':
-    case 'exs': return 'elixir';
-    case 'dart': return 'dart';
-    case 'ml':
-    case 'mli': return 'ocaml';
-    case 'hs': return 'haskell';
-    case 'nix': return 'nix';
-    case 'tf':
-    case 'tfvars':
-    case 'hcl': return 'hcl';
-    case 'graphql':
-    case 'gql': return 'graphql';
-    case 'sol': return 'solidity';
-    case 'r': return 'r';
-    case 'jl': return 'julia';
-    case 'erl': return 'erlang';
-    case 'clj':
-    case 'cljs':
-    case 'cljc':
-    case 'edn': return 'clojure';
-    case 'scm':
-    case 'ss': return 'scheme';
-    case 'rkt': return 'racket';
-    case 'proto': return 'protobuf';
-    case 'makefile':
-    case 'mk': return 'makefile';
-    case 'ps1':
-    case 'psm1': return 'powershell';
-    case 'json5': return 'json5';
-    case 'less': return 'less';
-    case 'scss': return 'scss';
-    case 'sass': return 'sass';
-    case 'styl': return 'stylus';
-    case 'vue': return 'vue';
-    case 'svelte': return 'svelte';
-    case 'astro': return 'astro';
-    // `.m` is genuinely ambiguous (Objective-C vs MATLAB); map to Objective-C,
-    // the common editor default.
-    case 'mm':
-    case 'm': return 'objective-c';
-    case 'groovy':
-    case 'gvy':
-    case 'gradle': return 'groovy';
-    default: return 'javascript';
-  }
-}
-
-/** Check if a string looks like code or structured programming text */
-export function isCodeLike(text: string): boolean {
-  if (!text || text.length < 5) return false;
-  const trimmed = text.trim();
-  if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
-    try {
-      JSON.parse(trimmed);
-      return true;
-    } catch {
-      // not valid JSON
-    }
-  }
-
-  const codePatterns = [
-    /^(?:import|export)\s+.+from\s+['"][^'"]+['"]/m,
-    /^(?:const|let|var|function|class|interface|type|enum)\s+[A-Za-z0-9_$]+/m,
-    /(?:=>|\bconsole\.(?:log|error|warn)|return\s+|async\s+function)/,
-    /^\s*\d+:\s*(?:import|const|let|function|\/\/|\/\*|<|[A-Za-z])/m,
-    /^\s*\[[A-Za-z0-9_./-]+\.[a-zA-Z0-9]+\]\s*\n\d+:/m,
-  ];
-  return codePatterns.some((pattern) => pattern.test(trimmed));
-}
 
 /**
  * Pick a language that can be tokenized *synchronously* right now. A grammar

package/src/shared/lib/fs/diff-parser.test.ts

@@ -61,7 +61,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('folds a whitespace-only rewrite into context when ignoring whitespace', () => {
-    const { lines, splitRows, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY, true);
+    const { lines, splitRows, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY, { ignoreWhitespace: true });
 
     // The counts the toolbar renders must match what is on screen.
     expect(additions).toBe(0);
@@ -81,7 +81,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('keeps a real change when ignoring whitespace', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(REAL_CHANGE, true);
+    const { lines, additions, deletions } = parseUnifiedDiff(REAL_CHANGE, { ignoreWhitespace: true });
 
     expect(additions).toBe(1);
     expect(deletions).toBe(1);
@@ -90,7 +90,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('folds only the whitespace pair of a mixed hunk', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(MIXED, true);
+    const { lines, additions, deletions } = parseUnifiedDiff(MIXED, { ignoreWhitespace: true });
 
     // Line 1 differs by indentation only; line 2 is a genuine edit.
     expect(additions).toBe(1);
@@ -110,7 +110,7 @@ describe('parseUnifiedDiff', () => {
   });
 
   test('returns empty results for an empty diff', () => {
-    expect(parseUnifiedDiff('', true)).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
-    expect(parseUnifiedDiff('   \n', false)).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
+    expect(parseUnifiedDiff('', { ignoreWhitespace: true })).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
+    expect(parseUnifiedDiff('   \n', { ignoreWhitespace: false })).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
   });
 });

package/src/shared/lib/fs/diff-parser.ts

@@ -31,12 +31,29 @@ interface PendingChange {
  * which is what this used to do — left the row painted red/green and counted in
  * `+n/-n`, so the toggle changed the glyphs and nothing else.
  */
-export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = false): {
+export interface ParseDiffOptions {
+  /** Fold `-`/`+` pairs that differ only in whitespace back into context. */
+  ignoreWhitespace?: boolean;
+  /**
+   * Which view the caller renders. Both views are built from one flush so a
+   * decision cannot land in one and not the other, but building the one nobody
+   * shows doubled the allocations on a full-context diff — an 80k-line file
+   * produced ~60k discarded `SplitDiffRow` objects. `'both'` is the default so
+   * the counts and the shared flush stay exactly as they were.
+   */
+  views?: 'unified' | 'split' | 'both';
+}
+
+export function parseUnifiedDiff(rawDiff: string, options: ParseDiffOptions = {}): {
   lines: DiffLine[];
   splitRows: SplitDiffRow[];
   additions: number;
   deletions: number;
 } {
+  const ignoreWhitespace = options.ignoreWhitespace ?? false;
+  const views = options.views ?? 'both';
+  const wantUnified = views !== 'split';
+  const wantSplit = views !== 'unified';
   const lines: DiffLine[] = [];
   const splitRows: SplitDiffRow[] = [];
   let additions = 0;
@@ -73,43 +90,47 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
       }
     }
 
-    for (let i = 0; i < delBuffer.length; i++) {
-      const del = delBuffer[i];
-      const add = addBuffer[i];
-      if (folded[i] && add) {
-        // Show it as unchanged on both sides: the change is still in the file,
-        // the reader asked not to be shown formatting noise.
-        lines.push({
-          type: 'context',
-          // The new form, so the row reads as the file's current state.
-          text: add.text,
-          oldLineNumber: del.lineNumber,
-          newLineNumber: add.lineNumber,
-        });
-        continue;
+    if (wantUnified) {
+      for (let i = 0; i < delBuffer.length; i++) {
+        const del = delBuffer[i];
+        const add = addBuffer[i];
+        if (folded[i] && add) {
+          // Show it as unchanged on both sides: the change is still in the file,
+          // the reader asked not to be shown formatting noise.
+          lines.push({
+            type: 'context',
+            // The new form, so the row reads as the file's current state.
+            text: add.text,
+            oldLineNumber: del.lineNumber,
+            newLineNumber: add.lineNumber,
+          });
+          continue;
+        }
+        lines.push({ type: 'del', text: del.text, oldLineNumber: del.lineNumber });
+      }
+      for (let i = 0; i < addBuffer.length; i++) {
+        const add = addBuffer[i];
+        if (folded[i]) continue;
+        lines.push({ type: 'add', text: add.text, newLineNumber: add.lineNumber });
       }
-      lines.push({ type: 'del', text: del.text, oldLineNumber: del.lineNumber });
-    }
-    for (let i = 0; i < addBuffer.length; i++) {
-      const add = addBuffer[i];
-      if (folded[i]) continue;
-      lines.push({ type: 'add', text: add.text, newLineNumber: add.lineNumber });
     }
 
-    for (let i = 0; i < maxLen; i++) {
-      const del = delBuffer[i];
-      const add = addBuffer[i];
-      if (folded[i] && del && add) {
+    if (wantSplit) {
+      for (let i = 0; i < maxLen; i++) {
+        const del = delBuffer[i];
+        const add = addBuffer[i];
+        if (folded[i] && del && add) {
+          splitRows.push({
+            left: { type: 'context', text: del.text, lineNumber: del.lineNumber },
+            right: { type: 'context', text: add.text, lineNumber: add.lineNumber },
+          });
+          continue;
+        }
         splitRows.push({
-          left: { type: 'context', text: del.text, lineNumber: del.lineNumber },
-          right: { type: 'context', text: add.text, lineNumber: add.lineNumber },
+          left: del ? { type: 'del', text: del.text, lineNumber: del.lineNumber } : undefined,
+          right: add ? { type: 'add', text: add.text, lineNumber: add.lineNumber } : undefined,
         });
-        continue;
       }
-      splitRows.push({
-        left: del ? { type: 'del', text: del.text, lineNumber: del.lineNumber } : undefined,
-        right: add ? { type: 'add', text: add.text, lineNumber: add.lineNumber } : undefined,
-      });
     }
     delBuffer = [];
     addBuffer = [];
@@ -156,16 +177,20 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
     } else {
       flushBuffers();
       const text = rawLine.startsWith(' ') ? rawLine.slice(1) : rawLine;
-      lines.push({
-        type: 'context',
-        text,
-        oldLineNumber: oldCounter,
-        newLineNumber: newCounter,
-      });
-      splitRows.push({
-        left: { type: 'context', text, lineNumber: oldCounter },
-        right: { type: 'context', text, lineNumber: newCounter },
-      });
+      if (wantUnified) {
+        lines.push({
+          type: 'context',
+          text,
+          oldLineNumber: oldCounter,
+          newLineNumber: newCounter,
+        });
+      }
+      if (wantSplit) {
+        splitRows.push({
+          left: { type: 'context', text, lineNumber: oldCounter },
+          right: { type: 'context', text, lineNumber: newCounter },
+        });
+      }
       oldCounter++;
       newCounter++;
     }

package/src/shared/lib/omp/subagent/parse.test.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Covers `readSubagentProgressFrame`, the one reader every subagent-progress
+ * consumer goes through (sidebar roster, transcript hook, server liveness).
+ *
+ * The wrapper shape is the whole point: omp's `subagent_progress` frame nests
+ * the child's `AgentProgress` under `payload.progress` and puts NO `id` on the
+ * wrapper, so a reader that parses the wrapper alone yields an id-less object
+ * with none of the reported fields — silently, because every field is
+ * optional. The payload below is a verbatim frame captured from omp 18.3.2.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { parseSubagentProgress, readSubagentProgressFrame } from '@/shared/lib/omp/subagent/parse';
+
+/** One `subagent_progress` frame as omp emits it (trimmed to the read fields). */
+const REAL_FRAME = {
+  index: 0,
+  agent: 'scout',
+  agentSource: 'user',
+  task: 'Complete assignment thoroughly:\n\n# Target\nCount files.',
+  parentToolCallId: 'call_00_LsrwnITatwhVYX5NElPf2544',
+  detached: true,
+  assignment: '# Target\nCount files.',
+  sessionFile: '/tmp/sessions/parent/CountTsx.jsonl',
+  progress: {
+    index: 0,
+    id: 'CountTsx',
+    agent: 'scout',
+    agentSource: 'user',
+    status: 'running',
+    task: 'Complete assignment thoroughly:\n\n# Target\nCount files.',
+    recentTools: [],
+    recentOutput: [],
+    toolCount: 3,
+    requests: 2,
+    tokens: 10400,
+    cost: 0.003,
+    durationMs: 8700,
+    modelRole: 'smol',
+    resolvedModelIdentity: 'kenari/deepseek-v4-flash',
+    resolvedThinkingLevel: 'low',
+    resolvedModel: 'kenari/deepseek-v4-flash:low',
+    resolvedModelIsFallback: false,
+  },
+};
+
+describe('readSubagentProgressFrame', () => {
+  test('unwraps the nested AgentProgress and keeps the fields it reports', () => {
+    const progress = readSubagentProgressFrame(REAL_FRAME);
+    expect(progress?.id).toBe('CountTsx');
+    expect(progress?.resolvedModel).toBe('kenari/deepseek-v4-flash:low');
+    expect(progress?.resolvedThinkingLevel).toBe('low');
+    expect(progress?.status).toBe('running');
+    expect(progress?.tokens).toBe(10400);
+  });
+
+  test('reads a bare AgentProgress payload (snapshot field, not a frame)', () => {
+    const progress = readSubagentProgressFrame(REAL_FRAME.progress);
+    expect(progress?.id).toBe('CountTsx');
+    expect(progress?.resolvedThinkingLevel).toBe('low');
+  });
+
+  test('keeps the wrapper id when the nested snapshot omits it', () => {
+    const progress = readSubagentProgressFrame({ id: 'Wrapped', progress: { status: 'running' } });
+    expect(progress?.id).toBe('Wrapped');
+    expect(progress?.status).toBe('running');
+  });
+
+  test('returns undefined for a payload carrying no progress fields at all', () => {
+    expect(readSubagentProgressFrame({ event: { type: 'message_end' } })).toBeUndefined();
+    expect(readSubagentProgressFrame(null)).toBeUndefined();
+    expect(readSubagentProgressFrame('nonsense')).toBeUndefined();
+  });
+});
+
+describe('parseSubagentProgress', () => {
+  test('carries the resolved thinking level and drops a non-string one', () => {
+    expect(parseSubagentProgress({ resolvedThinkingLevel: 'max' })?.resolvedThinkingLevel).toBe('max');
+    expect(parseSubagentProgress({ resolvedThinkingLevel: null })?.resolvedThinkingLevel).toBeUndefined();
+    expect(parseSubagentProgress({ resolvedThinkingLevel: 3 })?.resolvedThinkingLevel).toBeUndefined();
+  });
+});

package/src/shared/lib/omp/subagent/parse.ts

@@ -81,6 +81,8 @@ export function parseSubagentProgress(value: unknown): SubagentProgress | undefi
   if (modelRole !== undefined) out.modelRole = modelRole;
   const resolvedModel = asString(value.resolvedModel);
   if (resolvedModel !== undefined) out.resolvedModel = resolvedModel;
+  const resolvedThinkingLevel = asString(value.resolvedThinkingLevel);
+  if (resolvedThinkingLevel !== undefined) out.resolvedThinkingLevel = resolvedThinkingLevel;
   if (typeof value.resolvedModelIsFallback === 'boolean') out.resolvedModelIsFallback = value.resolvedModelIsFallback;
   if (isRecord(value.retryState)) {
     const attempt = asNumber(value.retryState.attempt);
@@ -180,6 +182,21 @@ export function parseSubagentLifecycle(value: unknown): SubagentInfo | undefined
   return info;
 }
 
+/**
+ * Read a progress frame's payload: `SubagentProgressPayload` nests the
+ * AgentProgress it reports under `progress`, while a bare AgentProgress (and a
+ * `get_subagents` snapshot's own field) is the object itself. Both shapes reach
+ * the same listeners, so unwrap here rather than at each call site — the outer
+ * wrapper's `id`/`index` fill in what the nested snapshot omits.
+ */
+export function readSubagentProgressFrame(payload: unknown): SubagentProgress | undefined {
+  const direct = parseSubagentProgress(payload);
+  if (!isRecord(payload) || !isRecord(payload.progress)) return direct;
+  const nested = parseSubagentProgress(payload.progress);
+  if (!nested) return direct;
+  return { ...nested, id: nested.id ?? direct?.id, index: nested.index ?? direct?.index };
+}
+
 /** Extract a compact live-activity entry from a subagent_event payload. */
 export function parseSubagentActivityEvent(value: unknown): SubagentActivityEvent | null {
   if (!isRecord(value)) return null;