ompchamber 0.3.0

package/src/shared/lib/chat/title-case.ts

@@ -0,0 +1,293 @@
+/** Nama brand/teknologi yang harus dipertahankan casing-nya. */
+const OVERRIDES: Record<string, string> = {
+  github: 'GitHub',
+  openai: 'OpenAI',
+  gitlab: 'GitLab',
+  sqlite: 'SQLite',
+  postgresql: 'PostgreSQL',
+  mysql: 'MySQL',
+  mongodb: 'MongoDB',
+  redis: 'Redis',
+  docker: 'Docker',
+  kubernetes: 'Kubernetes',
+  vercel: 'Vercel',
+  bun: 'Bun',
+  node: 'Node',
+  deno: 'Deno',
+  react: 'React',
+  vue: 'Vue',
+  svelte: 'Svelte',
+  angular: 'Angular',
+  next: 'Next',
+  nuxt: 'Nuxt',
+  remix: 'Remix',
+  tailwind: 'Tailwind',
+  prisma: 'Prisma',
+  zod: 'Zod',
+  axios: 'Axios',
+  express: 'Express',
+  fastify: 'Fastify',
+  koa: 'Koa',
+  hono: 'Hono',
+  elysia: 'Elysia',
+  drizzle: 'Drizzle',
+  kysely: 'Kysely',
+  biome: 'Biome',
+  oxc: 'Oxc',
+  rolldown: 'Rolldown',
+  turbopack: 'Turbopack',
+  vite: 'Vite',
+  webpack: 'Webpack',
+  rollup: 'Rollup',
+  esbuild: 'Esbuild',
+  babel: 'Babel',
+  swc: 'SWC',
+  typescript: 'TypeScript',
+  javascript: 'JavaScript',
+  coffeescript: 'CoffeeScript',
+  dart: 'Dart',
+  kotlin: 'Kotlin',
+  swift: 'Swift',
+  rust: 'Rust',
+  python: 'Python',
+  ruby: 'Ruby',
+  php: 'PHP',
+  perl: 'Perl',
+  lua: 'Lua',
+  scala: 'Scala',
+  haskell: 'Haskell',
+  elixir: 'Elixir',
+  erlang: 'Erlang',
+  clojure: 'Clojure',
+  ocaml: 'OCaml',
+  zig: 'Zig',
+  nim: 'Nim',
+  crystal: 'Crystal',
+  julia: 'Julia',
+  groovy: 'Groovy',
+  powershell: 'PowerShell',
+  bash: 'Bash',
+  zsh: 'Zsh',
+  fish: 'Fish',
+  grep: 'Grep',
+  find: 'Find',
+  glob: 'Glob',
+  ls: 'Ls',
+  cat: 'Cat',
+  echo: 'Echo',
+  mkdir: 'Mkdir',
+  rm: 'Rm',
+  cp: 'Cp',
+  mv: 'Mv',
+  touch: 'Touch',
+  chmod: 'Chmod',
+  chown: 'Chown',
+  sudo: 'Sudo',
+  apt: 'Apt',
+  brew: 'Brew',
+  npm: 'Npm',
+  pnpm: 'Pnpm',
+  yarn: 'Yarn',
+  playwright: 'Playwright',
+  cypress: 'Cypress',
+  puppeteer: 'Puppeteer',
+  selenium: 'Selenium',
+  jest: 'Jest',
+  vitest: 'Vitest',
+  mocha: 'Mocha',
+  chai: 'Chai',
+  sinon: 'Sinon',
+  karma: 'Karma',
+  jasmine: 'Jasmine',
+  qunit: 'QUnit',
+  ava: 'Ava',
+  tape: 'Tape',
+  lodash: 'Lodash',
+  underscore: 'Underscore',
+  ramda: 'Ramda',
+  rxjs: 'RxJS',
+  redux: 'Redux',
+  zustand: 'Zustand',
+  jotai: 'Jotai',
+  recoil: 'Recoil',
+  mobx: 'MobX',
+  xstate: 'XState',
+  framer: 'Framer',
+  motion: 'Motion',
+  gsap: 'GSAP',
+  anime: 'Anime',
+  three: 'Three',
+  babylon: 'Babylon',
+  pixi: 'Pixi',
+  phaser: 'Phaser',
+  matter: 'Matter',
+  planck: 'Planck',
+  rapier: 'Rapier',
+  cannon: 'Cannon',
+  ammo: 'Ammo',
+  bullet: 'Bullet',
+  box2d: 'Box2D',
+  chipmunk: 'Chipmunk',
+  verlet: 'Verlet',
+  ode: 'ODE',
+  physx: 'PhysX',
+  havok: 'Havok',
+  unity: 'Unity',
+  unreal: 'Unreal',
+  godot: 'Godot',
+  bevy: 'Bevy',
+  amethyst: 'Amethyst',
+  macroquad: 'Macroquad',
+  miniquad: 'Miniquad',
+  sdl: 'SDL',
+  sfml: 'SFML',
+  glfw: 'GLFW',
+  opengl: 'OpenGL',
+  vulkan: 'Vulkan',
+  directx: 'DirectX',
+  metal: 'Metal',
+  webgpu: 'WebGPU',
+  webgl: 'WebGL',
+  canvas: 'Canvas',
+  webaudio: 'WebAudio',
+  webmidi: 'WebMIDI',
+  webrtc: 'WebRTC',
+  websocket: 'WebSocket',
+  sse: 'SSE',
+  eventsource: 'EventSource',
+  fetch: 'Fetch',
+  xhr: 'XHR',
+  ky: 'Ky',
+  got: 'Got',
+  undici: 'Undici',
+  superagent: 'Superagent',
+  request: 'Request',
+  needle: 'Needle',
+  bent: 'Bent',
+  r2: 'R2',
+  s3: 'S3',
+  gcs: 'GCS',
+  azure: 'Azure',
+  blob: 'Blob',
+  storage: 'Storage',
+  firebase: 'Firebase',
+  supabase: 'Supabase',
+  pocketbase: 'PocketBase',
+  appwrite: 'Appwrite',
+  nhost: 'Nhost',
+  hasura: 'Hasura',
+  graphql: 'GraphQL',
+  rest: 'REST',
+  grpc: 'gRPC',
+  trpc: 'tRPC',
+  soap: 'SOAP',
+  mqtt: 'MQTT',
+  amqp: 'AMQP',
+  kafka: 'Kafka',
+  rabbitmq: 'RabbitMQ',
+  pubsub: 'PubSub',
+  nats: 'NATS',
+  zeromq: 'ZeroMQ',
+  dds: 'DDS',
+  coap: 'CoAP',
+  ble: 'BLE',
+  zigbee: 'Zigbee',
+  lora: 'LoRa',
+  nbiot: 'NB-IoT',
+  lte: 'LTE',
+  wifi: 'Wi-Fi',
+  ethernet: 'Ethernet',
+  usb: 'USB',
+  hdmi: 'HDMI',
+  displayport: 'DisplayPort',
+  thunderbolt: 'Thunderbolt',
+  pcie: 'PCIe',
+  nvme: 'NVMe',
+  sata: 'SATA',
+  ddr: 'DDR',
+  ecc: 'ECC',
+  xmp: 'XMP',
+  docsis: 'DOCSIS',
+  gpon: 'GPON',
+  epon: 'EPON',
+  pon: 'PON',
+  olt: 'OLT',
+  ont: 'ONT',
+  onu: 'ONU',
+  odn: 'ODN',
+  p2mp: 'P2MP',
+  p2p: 'P2P',
+  ftth: 'FTTH',
+  fttb: 'FTTB',
+  fttc: 'FTTC',
+  fttn: 'FTTN',
+  hfc: 'HFC',
+  dsl: 'DSL',
+  adsl: 'ADSL',
+  vdsl: 'VDSL',
+  sdsl: 'SDSL',
+  shdsl: 'SHDSL',
+  isdn: 'ISDN',
+  pstn: 'PSTN',
+  pots: 'POTS',
+  voip: 'VoIP',
+  sip: 'SIP',
+  rtp: 'RTP',
+  rtcp: 'RTCP',
+  rtsp: 'RTSP',
+  hls: 'HLS',
+  dash: 'DASH',
+  mpeg: 'MPEG',
+  av1: 'AV1',
+  vp9: 'VP9',
+  vp8: 'VP8',
+  hevc: 'HEVC',
+  avc: 'AVC',
+  mp4: 'MP4',
+  mkv: 'MKV',
+  avi: 'AVI',
+  mov: 'MOV',
+  wmv: 'WMV',
+  flv: 'FLV',
+  webm: 'WebM',
+  ogg: 'OGG',
+  mp3: 'MP3',
+  wav: 'WAV',
+  flac: 'FLAC',
+  aac: 'AAC',
+  midi: 'MIDI',
+  opus: 'OPUS',
+  alac: 'ALAC',
+  ape: 'APE',
+  wavpack: 'WavPack',
+};
+
+/** Akronim yang selalu uppercase. */
+const ACRONYMS = new Set([
+  'MCP', 'AST', 'LSP', 'DAP', 'RPC', 'SSH', 'TTS', 'STT', 'URL', 'API',
+  'JSON', 'SQL', 'CSS', 'HTML', 'JS', 'TS', 'PDF', 'PR', 'UI', 'UX',
+  'DB', 'CLI', 'TUI', 'IDE', 'HTTP', 'HTTPS', 'OAUTH', 'YAML', 'XML',
+  'CSV', 'PNG', 'SVG', 'WASM', 'AI', 'ML', 'LLM', 'RAG', 'SDK', 'GUI',
+  'DOM', 'ESM', 'CJS', 'UMD', 'IIFE', 'XHR', 'TCP', 'UDP', 'DNS', 'IP',
+  'GPU', 'CPU', 'RAM', 'SSD', 'HDD', 'FIFO', 'PTY', 'TTY', 'WEB',
+]);
+
+/** Title case nama tool: `web_search` → `Web Search`, `mcp__filesystem_read` → `MCP Filesystem Read`. */
+export function toTitleCase(name: string): string {
+  if (!name) return name;
+  const parts = name.split('__');
+  const head = parts.length > 1 ? parts[0] : null;
+  const rest = parts[parts.length - 1];
+  const words = rest.split(/[_\-\s]+/).filter(Boolean);
+  const titled = words
+    .map((word) => {
+      const lower = word.toLowerCase();
+      const override = OVERRIDES[lower];
+      if (override) return override;
+      const upper = word.toUpperCase();
+      if (ACRONYMS.has(upper)) return upper;
+      return word.charAt(0).toUpperCase() + word.slice(1);
+    })
+    .join(' ');
+  return head ? `${head.toUpperCase()} ${titled}` : titled;
+}

package/src/shared/lib/chat/todo-parser.ts

@@ -0,0 +1,257 @@
+import type { ToolCallData } from '@/shared/types';
+
+export interface ParsedTask {
+  text: string;
+  status: 'done' | 'in_progress' | 'pending';
+  phase?: string;
+}
+
+export interface ParsedPhaseGroup {
+  phase: string;
+  tasks: ParsedTask[];
+}
+
+export interface TodoDataSummary {
+  groups: ParsedPhaseGroup[];
+  totalDone: number;
+  totalInProgress: number;
+  totalPending: number;
+  totalTasks: number;
+  opBadge?: string;
+  summaryText: string;
+}
+
+function cleanPhaseName(raw: string): string {
+  let name = raw.replace(/:$/, '').trim();
+  // Strip "Active phase 1/1" or "Active phase" or "Phase 1:" prefix
+  name = name.replace(/^active\s+phase(?:\s+\d+\/\d+)?(?:\s*[:\-]\s*|\s+)?/i, '');
+  // Strip quotes around phase name: "Coverage" -> Coverage
+  name = name.replace(/^["']|["']$/g, '');
+  // Strip trailing parentheticals like (0/4 done) or (4 tasks) or (Coverage)
+  name = name.replace(/\s*\(\d+(?:\/\d+)?\s*(?:done|remaining|tasks)?\)$/i, '');
+  // If wrapped in parentheses like (Coverage)
+  name = name.replace(/^\((.+)\)$/, '$1');
+  return name.trim() || 'Tasks';
+}
+
+function mergePhaseGroups(rawGroups: ParsedPhaseGroup[]): ParsedPhaseGroup[] {
+  const map = new Map<string, ParsedPhaseGroup>();
+
+  for (const g of rawGroups) {
+    if (!g.tasks.length) continue;
+    const phaseName = cleanPhaseName(g.phase);
+    const key = phaseName.toLowerCase();
+
+    const existing = map.get(key);
+    if (!existing) {
+      map.set(key, { phase: phaseName, tasks: [...g.tasks] });
+    } else {
+      // Use the larger group as the base list order
+      const baseTasks = g.tasks.length >= existing.tasks.length ? g.tasks : existing.tasks;
+      const otherTasks = baseTasks === g.tasks ? existing.tasks : g.tasks;
+
+      const taskMap = new Map<string, ParsedTask>();
+      for (const t of baseTasks) {
+        taskMap.set(t.text.toLowerCase().trim(), { ...t, phase: phaseName });
+      }
+      for (const t of otherTasks) {
+        const tKey = t.text.toLowerCase().trim();
+        const prev = taskMap.get(tKey);
+        if (!prev) {
+          taskMap.set(tKey, { ...t, phase: phaseName });
+        } else {
+          // Status priority: done > in_progress > pending
+          if (t.status === 'done') {
+            prev.status = 'done';
+          } else if (t.status === 'in_progress' && prev.status !== 'done') {
+            prev.status = 'in_progress';
+          }
+        }
+      }
+
+      existing.phase = phaseName;
+      existing.tasks = Array.from(taskMap.values());
+    }
+  }
+
+  const groupsList = Array.from(map.values());
+  const result: ParsedPhaseGroup[] = [];
+
+  for (let i = 0; i < groupsList.length; i++) {
+    const gA = groupsList[i];
+    const aTexts = gA.tasks.map((t) => t.text.toLowerCase().trim());
+
+    let isSubset = false;
+    for (let j = 0; j < groupsList.length; j++) {
+      if (i === j) continue;
+      const gB = groupsList[j];
+      const bTexts = new Set(gB.tasks.map((t) => t.text.toLowerCase().trim()));
+
+      if (gB.tasks.length >= gA.tasks.length && aTexts.every((txt) => bTexts.has(txt))) {
+        for (const tA of gA.tasks) {
+          const tB = gB.tasks.find((t) => t.text.toLowerCase().trim() === tA.text.toLowerCase().trim());
+          if (tB) {
+            if (tA.status === 'done') tB.status = 'done';
+            else if (tA.status === 'in_progress' && tB.status !== 'done') tB.status = 'in_progress';
+          }
+        }
+        isSubset = true;
+        break;
+      }
+    }
+
+    if (!isSubset) {
+      result.push(gA);
+    }
+  }
+
+  return result;
+}
+
+export function parseTodoData(tool: ToolCallData): TodoDataSummary {
+  const input = tool.input;
+  const inputObj = typeof input === 'object' && input !== null ? (input as Record<string, any>) : undefined;
+  const output = tool.output || '';
+
+  let opBadge: string | undefined;
+  if (inputObj?.op === 'done' && inputObj.task) {
+    opBadge = `Completed: ${inputObj.task}`;
+  } else if (inputObj?.op === 'init') {
+    opBadge = 'Initialized Todo List';
+  }
+
+  const lines = output.split(/\r?\n/);
+  const rawGroups: ParsedPhaseGroup[] = [];
+  let currentGroup: ParsedPhaseGroup = { phase: 'Tasks', tasks: [] };
+  let inChecklistSection = false;
+
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) continue;
+
+    // Detect section start: "Active phase ...", "Coverage:", etc.
+    if (trimmed.endsWith(':') && !trimmed.startsWith('Overall') && !trimmed.startsWith('Remaining')) {
+      const phaseName = cleanPhaseName(trimmed);
+      if (currentGroup.tasks.length > 0) {
+        rawGroups.push(currentGroup);
+      }
+      currentGroup = { phase: phaseName, tasks: [] };
+      inChecklistSection = true;
+      continue;
+    }
+
+    // Detect checklist items: - [X] or [X] or - [ ] or [ ] or * [X]
+    const checkMatch = trimmed.match(/^(?:[-*]\s*)?\[([ xX])\]\s*(.+)$/);
+    if (checkMatch) {
+      const mark = checkMatch[1].toLowerCase();
+      let text = checkMatch[2].trim();
+      let status: 'done' | 'in_progress' | 'pending' = mark === 'x' ? 'done' : 'pending';
+
+      if (text.includes('(in progress)') || text.includes('[in_progress]')) {
+        status = 'in_progress';
+        text = text.replace(/\(in progress\)/gi, '').replace(/\[in_progress\]/gi, '').trim();
+      }
+
+      currentGroup.tasks.push({ text, status, phase: currentGroup.phase });
+      continue;
+    }
+
+    // Fallback: parse lines like "  - Add Think renderer [in_progress] (Coverage)"
+    const itemMatch = trimmed.match(/^-\s*(.+?)\s*\[(in_progress|pending|done)\](?:\s*\((.+?)\))?$/);
+    if (itemMatch && !inChecklistSection) {
+      const text = itemMatch[1].trim();
+      const status = itemMatch[2] as 'done' | 'in_progress' | 'pending';
+      const phase = cleanPhaseName(itemMatch[3]?.trim() || 'Tasks');
+
+      let targetGrp = rawGroups.find((g) => cleanPhaseName(g.phase).toLowerCase() === phase.toLowerCase());
+      if (!targetGrp) {
+        targetGrp = { phase, tasks: [] };
+        rawGroups.push(targetGrp);
+      }
+      targetGrp.tasks.push({ text, status, phase });
+    }
+  }
+
+  if (currentGroup.tasks.length > 0 && !rawGroups.includes(currentGroup)) {
+    rawGroups.push(currentGroup);
+  }
+
+  // If nothing parsed from output, check input.list
+  if (rawGroups.length === 0 && Array.isArray(inputObj?.list)) {
+    for (const p of inputObj.list) {
+      const phaseName = cleanPhaseName(p.phase || 'Tasks');
+      const tasks: ParsedTask[] = (p.items || []).map((it: string) => ({
+        text: it,
+        status: 'pending',
+        phase: phaseName,
+      }));
+      rawGroups.push({ phase: phaseName, tasks });
+    }
+  }
+
+  // Merge & deduplicate all phase groups
+  const groups = mergePhaseGroups(rawGroups);
+
+  // If tool was an op: 'done', ensure the task is marked as done
+  if (inputObj?.op === 'done' && inputObj.task) {
+    const doneText = String(inputObj.task).toLowerCase().trim();
+    for (const g of groups) {
+      const target = g.tasks.find((t) => t.text.toLowerCase().trim() === doneText);
+      if (target) {
+        target.status = 'done';
+      }
+    }
+  }
+
+  // Calculate totals across parsed tasks
+  let totalDone = 0;
+  let totalInProgress = 0;
+  let totalPending = 0;
+
+  for (const g of groups) {
+    for (const t of g.tasks) {
+      if (t.status === 'done') totalDone++;
+      else if (t.status === 'in_progress') totalInProgress++;
+      else totalPending++;
+    }
+  }
+
+  let totalTasks = totalDone + totalInProgress + totalPending;
+
+  // Check if output has explicit overall count
+  const overallMatch = output.match(/Overall:\s*(\d+)\/(\d+)\s*done/i)
+    || output.match(/(\d+)\s+of\s+(\d+)\s+completed/i);
+  if (overallMatch) {
+    const parsedDone = parseInt(overallMatch[1], 10);
+    const parsedTotal = parseInt(overallMatch[2], 10);
+    if (parsedTotal >= totalTasks) {
+      totalDone = parsedDone;
+      totalTasks = parsedTotal;
+      totalPending = Math.max(0, totalTasks - totalDone - totalInProgress);
+    }
+  }
+
+  const summaryParts: string[] = [];
+  if (totalDone > 0) summaryParts.push(`${totalDone} complete`);
+  if (totalInProgress > 0) summaryParts.push(`${totalInProgress} in progress`);
+  if (totalPending > 0) summaryParts.push(`${totalPending} pending`);
+  const summaryText = summaryParts.length > 0 ? summaryParts.join(' · ') : (totalTasks > 0 ? `${totalTasks} items` : '');
+
+  return {
+    groups,
+    totalDone,
+    totalInProgress,
+    totalPending,
+    totalTasks,
+    opBadge,
+    summaryText,
+  };
+}
+
+export function getTodoSummary(tool: ToolCallData): string | undefined {
+  const summary = parseTodoData(tool);
+  if (summary.totalTasks > 0 || summary.groups.length > 0) {
+    return summary.summaryText;
+  }
+  return undefined;
+}

package/src/shared/lib/chat/tool-status.ts

@@ -0,0 +1,20 @@
+import type { ToolCallData } from '@/shared/types';
+
+/**
+ * Checks if a tool call was skipped, aborted, or synthetic (not actually executed).
+ * Skipped tools should not auto-expand or trigger error-state highlights.
+ */
+export function isSkippedTool(tool: ToolCallData): boolean {
+  if (tool.synthetic === true || tool.status === 'skipped' || tool.status === 'aborted') {
+    return true;
+  }
+  const details = tool.details as Record<string, any> | undefined;
+  if (
+    details?.__synthetic === true ||
+    details?.source === 'assistant_stop_skipped' ||
+    details?.executed === false
+  ) {
+    return true;
+  }
+  return false;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * ANSI escape stripper for chat timeline tool output.
+ *
+ * Timeline cards render with Shiki (`Bash`, `FallbackOutput`), which treats
+ * raw `\x1b[…m` sequences as literal text — so escapes are dropped here
+ * first and the clean text goes to the highlighter. True terminal colors
+ * stay available in the realtime xterm panel, which parses ANSI natively.
+ */
+
+/** Any ANSI escape: OSC hyperlink, charset select, or CSI sequence. */
+const ANSI_ESCAPE_RE =
+  /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][0-9A-B]|\x1b\[[0-9;?]*[A-Za-z]/g;
+
+/** Drop every ANSI escape and normalize carriage returns to newlines. */
+export function stripAnsiCodes(text: string): string {
+  if (!text) return '';
+  if (!text.includes('\x1b')) return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  return text.replace(ANSI_ESCAPE_RE, '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}

package/src/shared/lib/code/editor-utils.ts

@@ -0,0 +1,16 @@
+export function getDefaultContent(name: string) {
+  if (name.endsWith('.md')) {
+    return `# ${name.replace('.md', '')}\n\nThis is a mock markdown file.\n\n- You can edit this text\n- Click the eye icon above to toggle preview`;
+  }
+  if (name.endsWith('.tsx') || name.endsWith('.ts')) {
+    const compName = name.split('.')[0].replace(/[^a-zA-Z0-9]/g, '');
+    return `import React from 'react';\n\nexport default function ${compName || 'Component'}() {\n  return (\n    <div>\n      Hello World\n    </div>\n  );\n}`;
+  }
+  if (name.endsWith('.json')) {
+    return `{\n  "name": "omp-project",\n  "version": "1.0.0"\n}`;
+  }
+  if (name.endsWith('.css')) {
+    return `.container {\n  display: flex;\n  flex-direction: column;\n}`;
+  }
+  return `Content for ${name}`;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { formatCompactTokens } from '@/shared/lib/format/number';
+
+/**
+ * Format a raw token count into a compact human label (e.g. 131072 → "128K",
+ * 1048576 → "1M"). Strings are passed through unchanged (already formatted).
+ *
+ * Thin alias kept for the server model registry, which imports this path; the
+ * single implementation lives in `@/shared/lib/format/number`.
+ */
+export function formatContextWindow(value: number | string | undefined | null): string | undefined {
+  return formatCompactTokens(value);
+}