ompchamber 0.3.0

package/src/shared/lib/chat/timeline/tool-phrases.ts

@@ -0,0 +1,224 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Phrase data for the generating indicator: the tool-name → activity-word
+ * tables and the per-tool subject extraction that names the call's object
+ * (path, command, pattern, agent, …).
+ *
+ * Data-only sibling of `tool-verbs.ts`, which owns the resolution logic
+ * (streaming event → phrase). Canonical tool names are omp's builtin list
+ * (`@oh-my-pi/pi-coding-agent` tools/builtin-names.ts).
+ */
+
+import { isRecord } from '@/shared/lib/util/guards';
+import { hashlineTargetPath } from '@/shared/lib/omp/session/hashline-patch';
+
+/** Longest subject kept in the indicator; the tail is elided. */
+export const MAX_SUBJECT = 72;
+
+/**
+ * Tool name → phrase stem. Every stem is a complete activity on its own, so a
+ * call whose arguments are not known yet (or never arrive) still reads as
+ * `Writing` rather than a dangling `Writing`. When a subject exists it is
+ * appended after a space and carries its own connector (`for "pat"`,
+ * `· init`), which keeps the join uniform.
+ */
+export const TOOL_VERBS: Record<string, string> = {
+  read: 'Reading',
+  write: 'Writing',
+  edit: 'Editing',
+  ast_edit: 'Rewriting AST',
+  ast_grep: 'Searching AST',
+  bash: 'Running',
+  grep: 'Searching',
+  glob: 'Finding',
+  task: 'Delegating',
+  todo: 'Updating plan',
+  hub: 'Hub',
+  eval: 'Running code',
+  lsp: 'Running LSP',
+  debug: 'Debugging',
+  github: 'GitHub',
+  web_search: 'Searching the web',
+  ask: 'Asking you',
+  checkpoint: 'Checkpointing',
+  rewind: 'Rewinding',
+  context_notes: 'Updating context notes',
+  new_context: 'Starting a fresh context',
+  security_scan: 'Scanning for vulnerabilities',
+  manage_skill: 'Updating skill',
+  learn: 'Recording a lesson',
+  retain: 'Retaining memory',
+  recall: 'Recalling memory',
+  reflect: 'Reflecting',
+  think: 'Thinking',
+  yield: 'Wrapping up',
+  goal: 'Tracking goal',
+};
+
+/** Legacy chamber/MOCK tool aliases → canonical omp builtin name. */
+export const TOOL_ALIASES: Record<string, string> = {
+  read_file: 'read',
+  view_file: 'read',
+  read_file_content: 'read',
+  edit_file: 'edit',
+  replace_file_content: 'edit',
+  multi_edit_file: 'edit',
+  write_to_file: 'write',
+  create_file: 'write',
+  search_fs: 'grep',
+  terminal: 'bash',
+  run_command: 'bash',
+};
+
+/** `xd://<device>` write phrases — the device, not `write`, names the action. */
+export const DEVICE_VERBS: Record<string, string> = {
+  lsp: 'Running LSP',
+  ast_edit: 'Rewriting AST',
+  ast_grep: 'Searching AST',
+  resolve: 'Applying edit proposal',
+  reject: 'Discarding edit proposal',
+  report_issue: 'Reporting tool issue',
+  debug: 'Debugging',
+  browser: 'Driving the browser',
+};
+
+/**
+ * Phrase shown while the model streams reasoning or prose rather than running a
+ * tool. A tool call always names itself from its own name (see
+ * `describeAssistantPhase`), so there is no in-between "preparing" state.
+ */
+export const PHASE_VERBS = {
+  thinking: 'Thinking',
+  writing: 'Writing response',
+} as const;
+
+export function asString(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+/** First string found for any key; array values yield their first string. */
+export function pick(args: Record<string, unknown>, keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = args[key];
+    const direct = asString(value);
+    if (direct) return direct;
+    if (Array.isArray(value)) {
+      const first = value.find((entry) => asString(entry) !== undefined);
+      if (first !== undefined) return asString(first);
+    }
+  }
+  return undefined;
+}
+
+export function truncate(value: string): string {
+  return value.length <= MAX_SUBJECT ? value : `${value.slice(0, MAX_SUBJECT - 1)}…`;
+}
+
+function quote(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  return /^["'`]/.test(value) ? value : `"${value}"`;
+}
+
+function taskSubject(args: Record<string, unknown>): string | undefined {
+  const name = asString(args.name);
+  const tasks = Array.isArray(args.tasks) ? args.tasks : [];
+  const first = tasks.find(isRecord);
+  const label = name ?? (first ? asString(first.name) : undefined);
+  const agent = asString(args.agent) ?? (first ? asString(first.agent) : undefined);
+  if (label && agent) return `to ${label} (${agent})`;
+  if (label) return `to ${label}`;
+  return agent ? `to ${agent}` : undefined;
+}
+
+function askSubject(args: Record<string, unknown>): string | undefined {
+  const questions = Array.isArray(args.questions) ? args.questions : [];
+  const first = questions.find(isRecord);
+  if (!first) return undefined;
+  return asString(first.header) ?? asString(first.question);
+}
+
+function retainSubject(args: Record<string, unknown>): string | undefined {
+  const items = Array.isArray(args.items) ? args.items : [];
+  const first = items.find(isRecord);
+  return first ? quote(asString(first.content)) : undefined;
+}
+
+/**
+ * Subject appended to the tool's stem. Each case owns whatever connector its
+ * stem needs (`for "pat"`, `to SidebarFix`, `· init`), so the caller joins with
+ * a bare space and the stem alone is always a valid phrase.
+ */
+export function subjectFor(name: string, args: Record<string, unknown>): string | undefined {
+  switch (name) {
+    case 'read':
+    case 'write':
+    case 'edit':
+      // omp's hashline `edit` has no `path` argument — the file lives in the
+      // patch header, so the phrase would otherwise degrade to the bare intent.
+      return pick(args, ['path', 'file', 'AbsolutePath', 'TargetFile']) ?? hashlineTargetPath(args);
+    case 'ast_edit':
+      return pick(args, ['paths', 'path']);
+    case 'ast_grep': {
+      const pattern = quote(pick(args, ['pat']));
+      return pattern ? `for ${pattern}` : undefined;
+    }
+    case 'bash':
+      return pick(args, ['command', 'cmd', 'CommandLine']);
+    case 'grep': {
+      const pattern = pick(args, ['pattern']);
+      const scope = pick(args, ['path', 'paths']);
+      if (!pattern) return scope;
+      return scope ? `for ${quote(pattern)} in ${scope}` : `for ${quote(pattern)}`;
+    }
+    case 'glob':
+      return pick(args, ['path', 'pattern']);
+    case 'web_search': {
+      const query = quote(pick(args, ['query']));
+      return query ? `for ${query}` : undefined;
+    }
+    case 'task':
+      return taskSubject(args);
+    case 'hub':
+      return [pick(args, ['op']), pick(args, ['name'])].filter(Boolean).join(' ') || undefined;
+    case 'todo': {
+      const op = pick(args, ['op']);
+      // `·` (not `:`) — the caller joins with a space, so a leading colon would
+      // render as "Updating plan : init".
+      return op ? `· ${op}` : undefined;
+    }
+    case 'eval': {
+      const language = pick(args, ['language']);
+      return language ? `in ${language}` : undefined;
+    }
+    case 'lsp':
+      return [pick(args, ['action']), pick(args, ['symbol', 'file'])].filter(Boolean).join(' ') || undefined;
+    case 'debug':
+      return pick(args, ['action', 'program']);
+    case 'github':
+      return [pick(args, ['op']), pick(args, ['repo', 'pr', 'query'])].filter(Boolean).join(' ') || undefined;
+    case 'ask':
+      return askSubject(args);
+    case 'checkpoint':
+      return pick(args, ['goal']);
+    case 'manage_skill':
+      return pick(args, ['name']);
+    case 'recall':
+      return quote(pick(args, ['query']));
+    case 'reflect': {
+      const query = quote(pick(args, ['query']));
+      return query ? `on ${query}` : undefined;
+    }
+    case 'security_scan':
+      return pick(args, ['target_kind', 'include_paths']);
+    case 'retain':
+      return retainSubject(args);
+    default:
+      return pick(args, ['path', 'command', 'query', 'pattern', 'name', 'target', 'prose']);
+  }
+}

package/src/shared/lib/chat/timeline/tool-verbs.ts

@@ -0,0 +1,160 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Activity phrases for the generating indicator, derived from the tool call the
+ * agent is actually executing — so the docked row reads `Editing app/x.ts`
+ * instead of a generic "Deep reasoning" while files are being written.
+ *
+ * Both render paths feed this module:
+ *   - live omp events   → lib/chat/omp/agent-events.ts
+ *                         (tool_execution_start + message_update.assistantMessageEvent)
+ *   - mock SSE / reload → lib/chat/timeline/stream-callbacks.ts (ToolCallData)
+ *
+ * Word tables and subject extraction live in the data-only sibling
+ * `tool-phrases.ts`; this module owns the resolution logic. A `write xd://<tool>`
+ * call resolves through the inner device, so the phrase is `Running LSP …`
+ * rather than `Writing xd://lsp`.
+ */
+
+import type { ToolCallData } from '@/shared/types';
+import { isRecord } from '@/shared/lib/util/guards';
+import { DEVICE_VERBS, PHASE_VERBS, TOOL_ALIASES, TOOL_VERBS, asString, pick, subjectFor, truncate } from '@/shared/lib/chat/timeline/tool-phrases';
+
+export interface ToolActivity {
+  /** Canonical omp tool name; legacy chamber aliases are normalized. */
+  name?: string;
+  /** Raw tool arguments (live event stream) — the richest subject source. */
+  args?: unknown;
+  /** Raw tool arguments from a chamber ToolCallData. */
+  input?: unknown;
+  /** Pre-extracted command/target from a chamber ToolCallData. */
+  command?: string;
+  target?: string;
+  /** omp's `i` field: the model's own one-line intent, used as a fallback. */
+  intent?: string;
+}
+
+/** Build the args record for a call, backfilling from chamber ToolCallData fields. */
+function argsOf(tool: ToolActivity): Record<string, unknown> {
+  const source = isRecord(tool.args) ? tool.args : isRecord(tool.input) ? tool.input : {};
+  const args: Record<string, unknown> = { ...source };
+  if (tool.command && asString(args.command) === undefined && asString(args.cmd) === undefined) {
+    args.command = tool.command;
+  }
+  if (tool.target && asString(args.path) === undefined) args.path = tool.target;
+  return args;
+}
+
+/** Inner `xd://<device>` name carried by a write call, if any. */
+function xdDeviceOf(args: Record<string, unknown>, tool: ToolActivity): string | undefined {
+  const candidate = pick(args, ['path', 'target']) ?? asString(tool.target) ?? asString(tool.command);
+  if (!candidate || !candidate.startsWith('xd://')) return undefined;
+  const device = candidate.slice('xd://'.length).split(/[/?#\s]/)[0];
+  return device || undefined;
+}
+
+/** Inner device arguments: a `write xd://…` payload is JSON in `content`.
+ *  The transport keys are always dropped so the phrase never echoes the
+ *  device URL; prose payloads (resolve/reject/report_issue) surface their
+ *  first line as the subject instead. */
+function deviceArgs(args: Record<string, unknown>): Record<string, unknown> {
+  const { path: _path, target: _target, command: _command, i: _i, ...rest } = args;
+  const content = args.content;
+  if (typeof content !== 'string') return rest;
+  try {
+    const parsed: unknown = JSON.parse(content);
+    if (isRecord(parsed)) return { ...rest, ...parsed };
+  } catch {
+    // Not JSON: fall through to the prose form.
+  }
+  const firstLine = content.trim().split('\n', 1)[0]?.trim();
+  return firstLine ? { ...rest, prose: firstLine } : rest;
+}
+
+/** Phrase for the tool call the agent is executing right now. */
+export function describeToolActivity(tool: ToolActivity): string {
+  const rawName = asString(tool.name) ?? '';
+  const name = TOOL_ALIASES[rawName.toLowerCase()] ?? rawName.toLowerCase();
+  const args = argsOf(tool);
+  // The model's own one-liner (omp's `i` field, or the intent it resolved for
+  // the execution event) is a better subject than anything derived here.
+  const intent = asString(tool.intent) ?? pick(args, ['i']);
+
+  const device = xdDeviceOf(args, tool);
+  if (device) {
+    const mcpTool = device.startsWith('mcp__') ? device.slice(5) : undefined;
+    const verb = mcpTool
+      ? `Running ${mcpTool}`
+      : DEVICE_VERBS[device] ?? `Running ${device}`;
+    const subject = subjectFor(mcpTool ?? device, deviceArgs(args));
+    if (subject) return truncate(`${verb} ${subject}`);
+    if (intent) return truncate(intent);
+    return truncate(verb);
+  }
+
+  const stem = TOOL_VERBS[name];
+  const verb = stem ?? (name ? `Running ${name}` : 'Working');
+  const subject = subjectFor(name, args);
+  if (subject) return truncate(`${verb} ${subject}`);
+  if (intent) return truncate(intent);
+  // Stems are complete activities, so an unknown subject never dangles: a tool
+  // call that has not streamed its arguments yet still reads `Writing`.
+  return truncate(verb);
+}
+
+/** Phrase for a chamber ToolCallData row (mock SSE path and reloaded history). */
+export function describeToolCall(tool: ToolCallData): string {
+  return describeToolActivity({
+    name: tool.name ?? tool.type,
+    input: tool.input,
+    command: tool.command,
+    target: tool.target,
+    intent: tool.intent,
+  });
+}
+
+/**
+ * Tool call block a streaming `toolcall_start` / `toolcall_delta` event is
+ * building. The event's own `toolCall` field only lands on `toolcall_end`; while
+ * the call streams, the block lives at `partial.content[contentIndex]` — and it
+ * already carries `name`, which is what lets the indicator name the action
+ * immediately instead of showing an intermediate "preparing" state.
+ */
+function streamingToolCall(event: Record<string, unknown>): Record<string, unknown> | undefined {
+  const partial = event.partial;
+  if (!isRecord(partial)) return undefined;
+  const content = partial.content;
+  if (!Array.isArray(content)) return undefined;
+  const index = typeof event.contentIndex === 'number' ? event.contentIndex : content.length - 1;
+  const block = content[index];
+  if (!isRecord(block) || block.type !== 'toolCall') return undefined;
+  return block;
+}
+
+/**
+ * Phrase for an `AssistantMessageEvent` riding a `message_update` frame —
+ * `thinking_*` → Thinking, `text_*` → Writing response, and `toolcall_*` → the
+ * tool's own phrase (`Writing`, `Running`, `Reading`) from the moment the call
+ * starts streaming, then with its object once the arguments are known.
+ */
+export function describeAssistantPhase(event: unknown): string | undefined {
+  if (!isRecord(event)) return undefined;
+  const type = asString(event.type);
+  if (!type) return undefined;
+  if (type.startsWith('thinking')) return PHASE_VERBS.thinking;
+  if (type.startsWith('text')) return PHASE_VERBS.writing;
+  if (type === 'toolcall_start' || type === 'toolcall_delta') {
+    const block = streamingToolCall(event);
+    if (!block) return undefined;
+    return describeToolActivity({ name: asString(block.name), args: block.arguments });
+  }
+  if (type === 'toolcall_end') {
+    const call = event.toolCall;
+    if (!isRecord(call)) return undefined;
+    return describeToolActivity({ name: asString(call.name), args: call.arguments });
+  }
+  return undefined;
+}

package/src/shared/lib/chat/timeline/turns.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Turn-matching helpers shared by the chamber chat loader and the in-place
+ * rewind endpoint: identifying raw composer input and deciding whether a
+ * JSONL-derived user turn and a stored DB-copy turn are the same request
+ * (omp rewrites delivered prompts, so equality is not enough).
+ */
+
+/** Whether a stored content string is raw composer input (slash command or
+ *  @mention) rather than the prompt omp actually delivered. */
+export function isRawComposerInput(content: string): boolean {
+  return /^\s*\//.test(content) || /(^|\s)@[A-Za-z0-9_-]+/.test(content);
+}
+
+/** Whether a JSONL-derived user turn (a) and a stored one (b) are the same
+ *  request despite omp rewriting the delivered prompt. */
+export function userTurnsRelate(a: string, b: string): boolean {
+  if (a === b || a.startsWith(b) || b.startsWith(a)) return true;
+  // `@agent` is delivered to omp as a task-tool delegation prompt.
+  if (a.startsWith('Use the task tool to delegate this request') && /(^|\s)@[A-Za-z0-9_-]+/.test(b)) {
+    return true;
+  }
+  // `/skill:<name> <args>`: the JSONL only records a synthesized `/skill:<name>`.
+  const token = a.split(' ')[0];
+  return a.startsWith('/skill:') && Boolean(token) && b.startsWith(token);
+}