ompchamber 3.1.1 → 3.2.0

package/src/server/routes/fs/git.ts

@@ -1,65 +1,26 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `GET /api/fs/git` — the Source Control panel's data, and the file-diff /
+ * commit-history endpoints the diff panel and commit modal read.
+ *
+ * Repository discovery (`?reposOnly=1`) is a background walk over the scoped
+ * root; see `lib/fs/git-repos.ts`. This module owns the request shapes.
+ */
+
 import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
 import fs from 'fs';
 import path from 'path';
 import { resolveRoot } from '@/server/lib/fs/root';
 import { runShell } from '@/server/lib/fs/shell';
+import { discoveredRepos, rescanRepos, startRepoScan } from '@/server/lib/fs/git-repos';
 import { fetchFileDiff, fetchGitCommits } from '@/server/lib/fs/git-log';
 import { fetchWorkingFileDiff } from '@/server/lib/fs/git-diff';
 import { gitSyncCount, invalidateRemoteRefs, markRemoteRefsFresh, refreshRemoteRefs } from '@/server/lib/fs/git-sync';
 
-const MAX_GIT_DEPTH = 8;
-
-async function getRepos(rootDir: string): Promise<string[]> {
-  try {
-    // Search deep enough to discover nested/child git repos inside a monorepo
-    // workspace (e.g. projects/<name>/<sub>/.git) while pruning node_modules.
-    const result = await runShell(
-      `find . -maxdepth ${MAX_GIT_DEPTH} -name node_modules -prune -o -name .git -type d -print`,
-      { cwd: rootDir, timeout: 12000, maxBuffer: 1024 * 1024 }
-    );
-    const discovered = result.stdout
-      .trim()
-      .split('\n')
-      .filter(Boolean)
-      .map(line => {
-        const cleaned = line.replace(/^\.\//, '').replace(/\/\.git$/, '');
-        return cleaned === '.git' || !cleaned ? '.' : cleaned;
-      });
-
-    const uniqueRepos = Array.from(new Set(discovered));
-    if (uniqueRepos.includes('.')) {
-      return ['.', ...uniqueRepos.filter(r => r !== '.')];
-    }
-    return uniqueRepos.length ? uniqueRepos : ['.'];
-  } catch {
-    return ['.'];
-  }
-}
-
-// Nested-repo discovery is expensive (find over a deep workspace), so it runs
-// in the background after the loader returns the root status. Results are
-// cached per scoped root and the client polls `?reposOnly=1` until ready.
-interface RepoDiscovery {
-  repos: string[];
-  done: boolean;
-}
-const repoDiscovery = new Map<string, RepoDiscovery>();
-
-function startRepoScan(rootDir: string): void {
-  if (repoDiscovery.has(rootDir)) return;
-  const d: RepoDiscovery = { repos: ['.'], done: false };
-  repoDiscovery.set(rootDir, d);
-  void getRepos(rootDir)
-    .then(repos => { d.repos = repos; d.done = true; })
-    .catch(() => { d.repos = ['.']; d.done = true; });
-}
-
-function discoveredRepos(rootDir: string): { repos: string[]; pending: boolean } {
-  const d = repoDiscovery.get(rootDir);
-  if (!d) return { repos: ['.'], pending: false };
-  return { repos: d.done ? d.repos : ['.'], pending: !d.done };
-}
-
 export async function loader({ request }: LoaderFunctionArgs) {
   const url = new URL(request.url);
   const rootDir = await resolveRoot(url.searchParams.get('root'), process.cwd());
@@ -68,10 +29,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
   // whatever is already cached. `rescan=1` invalidates the cache so a fresh
   // discovery pass starts (used by the repo-switcher refresh button).
   const rescan = url.searchParams.get('rescan') === '1';
-  if (rescan) {
-    repoDiscovery.delete(rootDir);
-  }
-  startRepoScan(rootDir);
+  if (rescan) rescanRepos(rootDir);
+  else startRepoScan(rootDir);
   const { repos, pending } = discoveredRepos(rootDir);
 
   // Lightweight polling endpoint: just the discovered repos, no git status.
@@ -98,7 +57,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
     if (targetFile) {
       const staged = url.searchParams.get('staged') === '1' || url.searchParams.get('staged') === 'true';
       const statusParam = url.searchParams.get('status') || undefined;
-      const diffData = await fetchWorkingFileDiff(targetDir, targetFile, staged, statusParam);
+      const fullContext = url.searchParams.get('fullContext') === '1';
+      const diffData = await fetchWorkingFileDiff(targetDir, targetFile, staged, statusParam, fullContext);
       return json({ success: true, ...diffData });
     }
   }
@@ -133,23 +93,54 @@ export async function loader({ request }: LoaderFunctionArgs) {
     const statusOut = (await runShell('git status --porcelain=v1 -uall', { cwd: targetDir, maxBuffer: 1024 * 1024 })).stdout;
 
     let branch = 'main';
-    let branches: string[] = ['main'];
-    let remoteBranches: string[] = [];
+    // Seeded empty, not `['main']`: the seed used to be pushed as a real local
+    // branch, so a repository whose only branch is `main` listed it twice.
+    const branches: string[] = [];
+    const remoteBranches: string[] = [];
     try {
-      const branchOut = await runShell('git rev-parse --abbrev-ref HEAD', { cwd: targetDir });
-      branch = branchOut.stdout.trim() || 'main';
-
-      const localOut = await runShell('git branch --format="%(refname:short)"', { cwd: targetDir });
-      branches = localOut.stdout.trim().split('\n').filter(Boolean);
-
-      const remoteOut = await runShell('git branch -r --format="%(refname:short)"', { cwd: targetDir });
-      remoteBranches = remoteOut.stdout.trim().split('\n').filter(Boolean).filter(b => b.includes('/') && !b.endsWith('/HEAD'));
-      if (!branches.includes(branch)) {
-        branches.unshift(branch);
+      // One `for-each-ref` answers all three questions the three previous
+      // spawns asked separately (`rev-parse --abbrev-ref HEAD`, `branch`,
+      // `branch -r`): `%(HEAD)` marks the checked-out branch with `*`, and the
+      // two refspecs cover local and remote in one listing. Measured 8.15 ms
+      // against 19.63 ms for the three-call form, on a 5s poll.
+      //
+      // Classification reads the FULL refname: `%(refname:short)` maps
+      // `refs/remotes/origin/HEAD` to the bare `origin`, which has no slash and
+      // would otherwise be listed as a local branch.
+      const refsOut = (await runShell(
+        'git for-each-ref --format="%(refname)%09%(refname:short)%09%(HEAD)" refs/heads refs/remotes',
+        { cwd: targetDir },
+      )).stdout;
+      let sawHead = false;
+      for (const line of refsOut.split('\n')) {
+        const [full, short, head] = line.split('\t');
+        if (!full || !short) continue;
+        // `refs/remotes/origin/HEAD` is a symbolic alias, not a branch.
+        if (full.endsWith('/HEAD')) continue;
+        if (full.startsWith('refs/remotes/')) {
+          remoteBranches.push(short);
+          continue;
+        }
+        branches.push(short);
+        if (head === '*') {
+          branch = short;
+          sawHead = true;
+        }
+      }
+      // Detached HEAD: no local ref is marked, and the branch is the sha
+      // `rev-parse --abbrev-ref HEAD` prints. Ask for it rather than reporting
+      // a branch the checkout is not on.
+      if (!sawHead) {
+        const headOut = await runShell('git rev-parse --abbrev-ref HEAD', { cwd: targetDir });
+        branch = headOut.stdout.trim() || 'main';
       }
     } catch {
       // ignore branch resolution errors
     }
+    // `main` remains the answer only when nothing could be read (a non-repo
+    // directory, git missing) — a real listing always supplies its own refs.
+    if (branches.length === 0) branches.push('main');
+    else if (!branches.includes(branch)) branches.unshift(branch);
 
     const changes = statusOut
       .split('\n')

package/src/server/routes/omp/session-stats.ts

@@ -22,7 +22,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const resolved = await resolveSessionFileOr404(sessionId);
   if ('response' in resolved) return resolved.response;
   const { filePath } = resolved;
-  const stats = readSessionStats(filePath);
+  const stats = await readSessionStats(filePath);
   if (!stats) {
     return json({ error: 'Session could not be parsed' }, { status: 500 });
   }

package/src/server/routes/telemetry/tokens.ts

@@ -4,7 +4,7 @@ import { methodNotAllowed } from '@/server/lib/route-adapter';
 import { BREAKDOWN_DATA, MOCK_CHART_SERIES, MOCK_CUSTOM_RANGE_DATA, MOCK_RANGE_DATA, TIME_RANGES } from '@/client/data/mock/token-usage';
 import { isMockMode } from '@/server/mock.server';
 import { loadModelsDevCatalog } from '@/shared/lib/models/catalog';
-import { aggregateUsage, type UsageWindow } from '@/server/lib/omp/session/usage/aggregate';
+import { aggregateUsageWindows, PRESET_RANGES, type UsageWindow } from '@/server/lib/omp/session/usage/aggregate';
 import { buildChartSeries, toBreakdownRows, toMetricSet } from '@/server/lib/omp/session/usage/shaping';
 import type { BreakdownRow, BreakdownTab, CadenceType, ChartSeriesPoint, TimeRangeType, TokenUsageMetricSet } from '@/shared/types';
 
@@ -22,7 +22,6 @@ const REAL_ZERO_METRIC: TokenUsageMetricSet = {
   usageRecords: 0,
 };
 
-const PRESET_RANGES: Exclude<TimeRangeType, 'custom'>[] = ['today', '7d', '30d', '90d', 'all'];
 const CADENCES: CadenceType[] = ['daily', 'weekly', 'monthly'];
 const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -104,12 +103,15 @@ export async function loader({ request }: LoaderFunctionArgs) {
 
   // Real Mode: aggregate actual token/cost usage from omp session files.
   try {
+    // One scan, every window: the tree read is the expensive part (measured
+    // 795 ms over 455 transcripts), and folding six windows from one scan
+    // replaced six separate reads — 3.3 s cold on this machine.
+    const { ranges, active: activeAggregate } = await aggregateUsageWindows(window);
     const realRangeData = {} as Record<Exclude<TimeRangeType, 'custom'>, TokenUsageMetricSet>;
     for (const range of PRESET_RANGES) {
-      realRangeData[range] = toMetricSet(await aggregateUsage({ kind: 'preset', range }), cadence);
+      realRangeData[range] = toMetricSet(ranges[range], cadence);
     }
 
-    const activeAggregate = await aggregateUsage(window);
     const realBreakdown: Record<BreakdownTab, BreakdownRow[]> = {
       model: toBreakdownRows(activeAggregate, 'model'),
       day: toBreakdownRows(activeAggregate, 'day', cadence),

package/src/server/routes/terminal/run.ts

@@ -14,18 +14,14 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const url = new URL(request.url);
   const rootDir = await resolveRoot(url.searchParams.get('root'), process.cwd());
   const targetDir = await scopeToRepo(rootDir, url.searchParams.get('repo'));
-  let bunVersion = '';
+  // The server IS the Bun being reported, so the version is already in this
+  // process. Spawning `bun --version` through a shell cost 10.4 ms per header
+  // load to read a constant `Bun.version` answers in 0.05 ms.
+  const bunVersion = Bun.version;
   // `process.version` is the Node version Bun emulates, not a real Node binary.
   const nodeVersion = process.version;
   let gitBranch = 'main';
 
-  try {
-    const bunOut = await runShell('bun --version', { cwd: targetDir });
-    bunVersion = bunOut.stdout.trim();
-  } catch {
-    bunVersion = Bun.version;
-  }
-
   try {
     const branchOut = await runShell('git rev-parse --abbrev-ref HEAD', { cwd: targetDir });
     gitBranch = branchOut.stdout.trim() || 'main';

package/src/server/routes/terminal/ws.ts

@@ -66,9 +66,24 @@ export const terminalWsRoutes = new Elysia({ prefix: '/api/terminal' }).ws('/:te
       viewer: {
         send(frame) {
           try {
-            ws.send(frame);
+            // Bun returns -1 when the frame was dropped rather than queued
+            // (the socket is over its high-water mark). Reporting it lets the
+            // session close this viewer instead of buffering a PTY's output
+            // into a socket nobody is reading.
+            return ws.send(frame) !== -1;
           } catch {
             // Socket closed mid-send; the close handler detaches.
+            return false;
+          }
+        },
+        drop() {
+          // The terminal session removed this viewer; close the socket so the
+          // client reconnects and replays the scrollback rather than sitting
+          // on a stream with a hole in it.
+          try {
+            ws.close();
+          } catch {
+            // Already gone.
           }
         },
       },
@@ -114,7 +129,14 @@ export const terminalWsRoutes = new Elysia({ prefix: '/api/terminal' }).ws('/:te
       // Ordering is safe without sequence numbers: attach captured the history
       // and registered this viewer in one synchronous block, so nothing can be
       // delivered between this frame and the replay that follows it.
-      if (replay.length > 0) ws.send(replay);
+      //
+      // The replay goes through the viewer, so a socket that cannot take the
+      // scrollback is closed rather than left attached to a terminal whose
+      // first screenful was silently dropped.
+      if (replay.length > 0 && !attachment.viewer.send(replay)) {
+        detachTerminal(attachment.viewer, attachment.id);
+        attachment.viewer.drop();
+      }
     } catch (error) {
       const code = error instanceof TerminalRuntimeError ? error.code : 'unknown';
       const message = error instanceof Error ? error.message : String(error);

package/src/shared/lib/chat/omp/agent-events.test.ts

@@ -27,12 +27,14 @@ function makeDeps() {
   const activity: string[] = [];
   const commandOutputs: string[] = [];
   let settledCount = 0;
+  let runEnds = 0;
   let state: OmpAgentState = { isGenerating: false, connected: true, error: null };
   const callbacks: OmpAgentCallbacks = {
     onMessageEnd: (msg) => ended.push(msg),
     onActivity: (verb) => activity.push(verb),
     onPromptSettled: () => { settledCount += 1; },
     onCommandOutput: (text) => commandOutputs.push(text),
+    onAgentEnd: () => { runEnds += 1; },
   };
   const deps: OmpAgentFoldDeps = {
     sessionId: 's1',
@@ -47,7 +49,7 @@ function makeDeps() {
     currentThinkingLevelRef: { current: undefined },
     fileMutatingCallsRef: { current: new Set<string>() },
   };
-  return { deps, ended, activity, commandOutputs, settled: () => settledCount, state: () => state };
+  return { deps, ended, activity, commandOutputs, settled: () => settledCount, runEnds: () => runEnds, state: () => state };
 }
 
 describe('toChatMessage error derivation', () => {
@@ -185,4 +187,34 @@ describe('foldAgentEvent agent_end', () => {
     foldAgentEvent({ type: 'agent_end', messages: [{ ...ABORTED_TURN, stopReason: 'end_turn' }] }, deps);
     expect(ended).toHaveLength(0);
   });
+
+  test('a non-terminal agent_end keeps the run generating and does not fire onAgentEnd', () => {
+    // omp's shape when the turn yields with work still alive — a detached
+    // subagent, a compaction, a background job. Measured on omp 18.3.2: with an
+    // async subagent, this frame lands ~14s BEFORE the subagent finishes, and
+    // treating it as the run end blanked the generating indicator for the whole
+    // stretch the roster was still showing a live child.
+    const { deps, state, runEnds } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    expect(state().isGenerating).toBe(true);
+
+    foldAgentEvent({ type: 'agent_end', isTerminal: false, messages: [] }, deps);
+    expect(state().isGenerating).toBe(true);
+    expect(runEnds()).toBe(0);
+
+    // The continuation ends the run for real; only now may the UI settle.
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    foldAgentEvent({ type: 'agent_end', isTerminal: true, messages: [] }, deps);
+    expect(state().isGenerating).toBe(false);
+    expect(runEnds()).toBe(1);
+  });
+
+  test('an agent_end with no isTerminal field is treated as terminal', () => {
+    // The field is optional: a frame that omits it is a normal run end.
+    const { deps, state, runEnds } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    foldAgentEvent({ type: 'agent_end', messages: [] }, deps);
+    expect(state().isGenerating).toBe(false);
+    expect(runEnds()).toBe(1);
+  });
 });

package/src/shared/lib/chat/omp/agent-events.ts

@@ -225,6 +225,16 @@ export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): voi
     }
 
     case 'agent_end': {
+      // A NON-TERMINAL `agent_end` is not the end of the run: omp emits it when
+      // the turn yields but work is still alive — a detached subagent, a
+      // compaction, a background job, or a stop-time reminder — and a later
+      // `agent_start` opens the continuation. Measured on omp 18.3.2: with an
+      // async subagent, `agent_end isTerminal=false` arrives ~13s BEFORE the
+      // subagent's terminal frame, and clearing the generating state there
+      // blanked the indicator for the whole stretch the roster was still
+      // showing a live child. The server's own fold gates on the same field
+      // (frame-fold.ts), so the two ends now agree.
+      if (data.isTerminal === false) break;
       deps.setState((prev) => ({ ...prev, isGenerating: false }));
       deps.activityRef.current = '';
       const terminal = materializeTerminalMessages(data, deps, callbacks ?? undefined);

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