ompchamber 0.3.0

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

@@ -0,0 +1,290 @@
+import { escapeCode, getHighlighterSync } from '@/shared/lib/code/highlighter';
+import { SHIKI_THEMES } from '@/shared/lib/code/shiki-themes';
+
+/** 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));
+}
+
+/** Syntax highlight code string safely with fallback */
+export function highlightCode(code: string, language = 'javascript'): string {
+  if (!code) return '';
+  const hl = getHighlighterSync();
+  if (!hl) return escapeCode(code);
+  const lang = hl.getLoadedLanguages().includes(language) ? language : 'javascript';
+  try {
+    return `<span class="shiki">${hl.codeToHtml(code, {
+      lang,
+      themes: SHIKI_THEMES,
+      defaultColor: false,
+      structure: 'inline',
+    })}</span>`;
+  } catch {
+    return escapeCode(code);
+  }
+}
+
+export interface JsonDetectionResult {
+  isValid: boolean;
+  data?: any;
+  pretty?: string;
+  linesCount?: number;
+}
+
+/** Check if input is valid JSON (or object/array) and return pretty-printed string with line count */
+export function tryParseJson(input: unknown): JsonDetectionResult {
+  if (input === null || input === undefined) return { isValid: false };
+
+  // 1. If already an object or array (and not primitive)
+  if (typeof input === 'object') {
+    try {
+      const pretty = JSON.stringify(input, null, 2);
+      const linesCount = pretty.split('\n').length;
+      return { isValid: true, data: input, pretty, linesCount };
+    } catch {
+      return { isValid: false };
+    }
+  }
+
+  if (typeof input !== 'string') return { isValid: false };
+
+  let text = input.trim();
+  if (!text) return { isValid: false };
+
+  // 2. If wrapped in markdown code fence ```json ... ``` or ``` ... ```
+  const codeBlockMatch = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  if (codeBlockMatch) {
+    text = codeBlockMatch[1].trim();
+  }
+
+  // 3. Strip common prefixes like "User selected: { ... }" or "User response: { ... }"
+  const prefixMatch = text.match(/^(?:user\s+(?:selected|responded|answered|response)|response|result|output):\s*([\s\S]+)$/i);
+  if (prefixMatch) {
+    const candidate = prefixMatch[1].trim();
+    if ((candidate.startsWith('{') && candidate.endsWith('}')) || (candidate.startsWith('[') && candidate.endsWith(']'))) {
+      text = candidate;
+    }
+  }
+
+  // 4. Handle double-stringified / quoted JSON strings, e.g. "\"{\\\"a\\\":1}\"" or '"{...}"'
+  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+    try {
+      const unquoted = JSON.parse(text);
+      if (typeof unquoted === 'object' && unquoted !== null) {
+        const pretty = JSON.stringify(unquoted, null, 2);
+        return { isValid: true, data: unquoted, pretty, linesCount: pretty.split('\n').length };
+      }
+      if (typeof unquoted === 'string') {
+        const nested = tryParseJson(unquoted);
+        if (nested.isValid) return nested;
+      }
+    } catch {
+      // not double-quoted JSON, continue
+    }
+  }
+
+  // 5. Check if starts with { or [
+  if (text.startsWith('{') || text.startsWith('[')) {
+    try {
+      const data = JSON.parse(text);
+      if (data !== null && typeof data === 'object') {
+        const pretty = JSON.stringify(data, null, 2);
+        const linesCount = pretty.split('\n').length;
+        return { isValid: true, data, pretty, linesCount };
+      }
+    } catch {
+      // not direct JSON
+    }
+  }
+
+  // 6. Look for embedded JSON object/array within text: e.g. "Response: {...}"
+  const firstBrace = text.indexOf('{');
+  const lastBrace = text.lastIndexOf('}');
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    const candidate = text.slice(firstBrace, lastBrace + 1);
+    try {
+      const data = JSON.parse(candidate);
+      if (data !== null && typeof data === 'object') {
+        const pretty = JSON.stringify(data, null, 2);
+        return { isValid: true, data, pretty, linesCount: pretty.split('\n').length };
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  const firstBracket = text.indexOf('[');
+  const lastBracket = text.lastIndexOf(']');
+  if (firstBracket !== -1 && lastBracket > firstBracket) {
+    const candidate = text.slice(firstBracket, lastBracket + 1);
+    try {
+      const data = JSON.parse(candidate);
+      if (Array.isArray(data)) {
+        const pretty = JSON.stringify(data, null, 2);
+        return { isValid: true, data, pretty, linesCount: pretty.split('\n').length };
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return { isValid: false };
+}
+
+/** Syntax highlight JSON string */
+export function highlightJson(code: string): string {
+  return highlightCode(code, 'json');
+}
+
+/**
+ * Highlight code and return one HTML fragment per line, aligned 1:1 with
+ * `code.split('\n')`. Tokenizes the whole input at once so multi-line grammar
+ * state (block comments, template literals) survives, unlike per-line calls.
+ */
+export function highlightLines(code: string, language = 'javascript'): string[] {
+  const rawLines = code.split('\n');
+  if (!code) return rawLines;
+  const hl = getHighlighterSync();
+  if (!hl) return rawLines.map(escapeCode);
+  const lang = hl.getLoadedLanguages().includes(language) ? language : 'javascript';
+  try {
+    const { tokens } = hl.codeToTokens(code, {
+      lang,
+      themes: SHIKI_THEMES,
+      defaultColor: false,
+    });
+    if (tokens.length !== rawLines.length) return rawLines.map(escapeCode);
+    return tokens.map((lineTokens) =>
+      lineTokens
+        .map((tok) => {
+          const content = escapeCode(tok.content);
+          if (!tok.htmlStyle) return content;
+          const style = Object.entries(tok.htmlStyle)
+            .map(([key, value]) => `${key}:${value}`)
+            .join(';');
+          return style ? `<span style="${style}">${content}</span>` : content;
+        })
+        .join('')
+    );
+  } catch {
+    return rawLines.map(escapeCode);
+  }
+}

package/src/shared/lib/db/transaction.server.ts

@@ -0,0 +1,20 @@
+import type { DbClient } from '@/server/lib/db/client';
+
+/**
+ * Run `fn` inside a BEGIN…COMMIT block.
+ *
+ * `bun:sqlite` is synchronous, so the promise-chain mutex the old async driver
+ * needed is gone: a transaction block runs to completion before any other
+ * JavaScript executes, which makes `BEGIN`…`COMMIT` atomic by construction.
+ */
+export function withTransaction<T>(db: DbClient, fn: () => T): T {
+  db.raw.exec('BEGIN');
+  try {
+    const result = fn();
+    db.raw.exec('COMMIT');
+    return result;
+  } catch (error) {
+    db.raw.exec('ROLLBACK');
+    throw error;
+  }
+}

package/src/shared/lib/format/number.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Shared number formatters. Every compact-label / cost / byte / price display
+ * in the chamber funnels through here so the wire format stays identical
+ * everywhere.
+ *
+ * `formatCompactTokens` absorbs the former `formatContextWindow` (the most
+ * complete of the token formatters — it accepts a raw number, an already
+ * formatted string, or null/undefined). Call sites that always need a string
+ * pass a `?? '0'` fallback.
+ */
+
+/**
+ * Compact token/context label using decimal (1000-based) units:
+ * 1500 → "1.5K", 1048576 → "1.0M", 131072 → "131.1K". Strings pass through
+ * unchanged (already formatted); non-finite or non-positive numbers return
+ * `undefined`.
+ */
+export function formatCompactTokens(value: number | string | undefined | null): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'string') return value;
+  if (!Number.isFinite(value) || value <= 0) return undefined;
+
+  if (value >= 1_000_000) {
+    const m = value / 1_000_000;
+    return `${Number.isInteger(m) ? m : m.toFixed(1)}M`;
+  }
+  if (value >= 1_000) {
+    const k = value / 1_000;
+    return `${Number.isInteger(k) ? k : k.toFixed(1)}K`;
+  }
+  return String(value);
+}
+
+/**
+ * Dollar amount (`$1.23`). Non-finite or non-positive values return an empty
+ * string so call sites can omit the cost entirely; callers that need a zero
+ * label (chart axes) fall back with `|| '$0.00'`. `fractionDigits` defaults to
+ * the 2-decimal display and is raised by subagent rows that report sub-cent
+ * costs.
+ */
+export function formatCost(value: number | undefined | null, fractionDigits = 2): string {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) return '';
+  return `$${value.toFixed(fractionDigits)}`;
+}
+
+/**
+ * Byte size label: 0 → "0 B", 512 → "512 B", 2048 → "2.0 KB", 2 MiB → "2.00 MB".
+ * Undefined, non-finite, or negative values return an empty string.
+ */
+export function formatBytes(bytes: number | undefined | null): string {
+  if (typeof bytes !== 'number' || !Number.isFinite(bytes) || bytes < 0) return '';
+  if (bytes < 1024) return `${Math.round(bytes)} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+/**
+ * Per-1M-token price label (`$3.00`). Undefined/non-finite/negative values
+ * return an empty string so a partially specified model renders one side blank.
+ */
+export function formatPrice(value: number | undefined): string {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) return '';
+  return `$${value.toFixed(2)}`;
+}

package/src/shared/lib/format/time.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Shared time formatters for the chat timeline: the live-stream path carries a
+ * preformatted "Today, 10:30 AM" label that `new Date()` cannot parse, so both
+ * the footer display and the run-duration math resolve it against today's date.
+ */
+
+/** "10:30 AM" — 12-hour clock used by every message timestamp. */
+export function formatClock(value: Date | number = new Date()): string {
+  return new Date(value).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+}
+
+/**
+ * Resolve a preformatted `"Today, <time>"` label to epoch ms against the
+ * current day. Returns null when the label is not a "Today," value or its time
+ * part cannot be parsed.
+ */
+export function parseTodayLabel(raw: string): number | null {
+  if (!raw.startsWith('Today,')) return null;
+  const time = raw.slice('Today,'.length).trim();
+  const parsed = new Date(`${new Date().toDateString()} ${time}`);
+  return Number.isNaN(parsed.getTime()) ? null : parsed.getTime();
+}
+
+/**
+ * Best-effort tool-detail timestamp: epoch-ms renders as the runtime's default
+ * locale time, a string passes through, anything else renders empty.
+ */
+export function formatTimestamp(value: unknown): string {
+  if (typeof value === 'number') {
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? '' : d.toLocaleTimeString();
+  }
+  return typeof value === 'string' ? value : '';
+}

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

@@ -0,0 +1,135 @@
+export interface DiffLine {
+  type: 'add' | 'del' | 'context' | 'meta';
+  text: string;
+  oldLineNumber?: number;
+  newLineNumber?: number;
+}
+
+export interface SplitDiffRow {
+  left?: {
+    type: 'del' | 'context';
+    text: string;
+    lineNumber: number;
+  };
+  right?: {
+    type: 'add' | 'context';
+    text: string;
+    lineNumber: number;
+  };
+  isMeta?: boolean;
+  metaText?: string;
+}
+
+export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = false): {
+  lines: DiffLine[];
+  splitRows: SplitDiffRow[];
+  additions: number;
+  deletions: number;
+} {
+  const lines: DiffLine[] = [];
+  const splitRows: SplitDiffRow[] = [];
+  let additions = 0;
+  let deletions = 0;
+
+  if (!rawDiff || !rawDiff.trim()) {
+    return { lines, splitRows, additions, deletions };
+  }
+
+  const rawLines = rawDiff.split(/\r?\n/);
+  const hasHunk = rawLines.some((l) => l.startsWith('@@'));
+  const linesToProcess = hasHunk
+    ? rawLines
+    : [`@@ -1,${rawLines.length} +1,${rawLines.length} @@`, ...rawLines];
+
+  let oldCounter = 1;
+  let newCounter = 1;
+
+  // Buffer for pairing consecutive deletions and additions in split view
+  let delBuffer: { text: string; lineNumber: number }[] = [];
+  let addBuffer: { text: string; lineNumber: number }[] = [];
+
+  const flushBuffers = () => {
+    const maxLen = Math.max(delBuffer.length, addBuffer.length);
+    for (let i = 0; i < maxLen; i++) {
+      splitRows.push({
+        left: delBuffer[i] ? { type: 'del', text: delBuffer[i].text, lineNumber: delBuffer[i].lineNumber } : undefined,
+        right: addBuffer[i] ? { type: 'add', text: addBuffer[i].text, lineNumber: addBuffer[i].lineNumber } : undefined,
+      });
+    }
+    delBuffer = [];
+    addBuffer = [];
+  };
+
+  for (const rawLine of linesToProcess) {
+    if (
+      rawLine.startsWith('diff --git') ||
+      rawLine.startsWith('index ') ||
+      rawLine.startsWith('---') ||
+      rawLine.startsWith('+++') ||
+      rawLine.startsWith('new file mode') ||
+      rawLine.startsWith('deleted file mode') ||
+      rawLine.startsWith('similarity index') ||
+      rawLine.startsWith('old mode') ||
+      rawLine.startsWith('new mode') ||
+      rawLine.startsWith('\\ No newline')
+    ) {
+      continue;
+    }
+
+    if (rawLine.startsWith('@@')) {
+      flushBuffers();
+      const match = rawLine.match(/@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+      if (match) {
+        oldCounter = parseInt(match[1], 10);
+        newCounter = parseInt(match[2], 10);
+      }
+      lines.push({ type: 'meta', text: rawLine });
+      splitRows.push({ isMeta: true, metaText: rawLine });
+      continue;
+    }
+
+    if (rawLine.startsWith('+')) {
+      const text = rawLine.slice(1);
+      const normalizedText = ignoreWhitespace ? text.trim() : text;
+      additions++;
+      lines.push({
+        type: 'add',
+        text: normalizedText,
+        newLineNumber: newCounter,
+      });
+      addBuffer.push({ text: normalizedText, lineNumber: newCounter });
+      newCounter++;
+    } else if (rawLine.startsWith('-')) {
+      const text = rawLine.slice(1);
+      const normalizedText = ignoreWhitespace ? text.trim() : text;
+      deletions++;
+      lines.push({
+        type: 'del',
+        text: normalizedText,
+        oldLineNumber: oldCounter,
+      });
+      delBuffer.push({ text: normalizedText, lineNumber: oldCounter });
+      oldCounter++;
+    } else {
+      flushBuffers();
+      const text = rawLine.startsWith(' ') ? rawLine.slice(1) : rawLine;
+      const normalizedText = ignoreWhitespace ? text.trim() : text;
+      lines.push({
+        type: 'context',
+        text: normalizedText,
+        oldLineNumber: oldCounter,
+        newLineNumber: newCounter,
+      });
+      splitRows.push({
+        left: { type: 'context', text: normalizedText, lineNumber: oldCounter },
+        right: { type: 'context', text: normalizedText, lineNumber: newCounter },
+      });
+      oldCounter++;
+      newCounter++;
+    }
+  }
+
+  flushBuffers();
+
+  return { lines, splitRows, additions, deletions };
+}

package/src/shared/lib/fs/file-tree.ts

@@ -0,0 +1,26 @@
+export function setChildrenAt(nodes: any[], path: string, children: any[]): any[] {
+  return nodes.map(node => {
+    if (node.path === path) return { ...node, children, is_expanded: 1 };
+    if (Array.isArray(node.children)) {
+      const nested = setChildrenAt(node.children, path, children);
+      if (nested !== node.children) return { ...node, children: nested };
+    }
+    return node;
+  });
+}
+
+export function rehydrateTree(nodes: any[], cache: Record<string, any[]>, expanded: Set<string>): any[] {
+  return nodes.map(node => {
+    if (node.type !== 'folder') return node;
+    const cached = cache[node.path];
+    const wasExpanded = expanded.has(node.path);
+    if (cached) {
+      return {
+        ...node,
+        children: rehydrateTree(cached, cache, expanded),
+        is_expanded: wasExpanded ? 1 : 0,
+      };
+    }
+    return node;
+  });
+}