@kabmo-labs/kabmo 0.0.0-stage → 0.0.1

package/src/shared/lib/chat/ask-questions.ts

@@ -0,0 +1,284 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Pure helpers for omp's `ask` tool: read its `questions` payload, pair the
+ * per-question dialogs omp raises for them back to the question they belong to,
+ * and read the recorded answers out of the tool result.
+ *
+ * The pairing is load-bearing, and there are TWO shapes to pair against.
+ * `configureChild` opts the child into the rich dialog with
+ * `set_ask_dialog {enabled:true}`, so omp's `AskTool` takes its `askDialog`
+ * path and a multi-question ask arrives as ONE frame (`method:"ask"`) carrying
+ * every question — matched by the question IDS it shares with the tool call's
+ * arguments, which is what `ask-frames.ts` does.
+ *
+ * The per-question loop is still reachable (a host that never opted in, or a
+ * build without the command), and there a multi-question ask reaches the
+ * Kabmo as ONE blocking `select` frame per question, in order. That frame
+ * carries the question as its `title` (plus a ` (2/3)` progress suffix and a
+ * `(2 selected) ` prefix for multi-select questions), which is what lets the
+ * inline card put each frame back on the question it asked. Both shapes must
+ * keep working: the frame-ownership split knows each one.
+ */
+
+import type { ToolCallData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+
+export interface AskOption {
+  label: string;
+  description?: string;
+  preview?: string;
+}
+
+export interface AskQuestion {
+  id?: string;
+  /** Short chip omp shows above the question ("Authentication"). */
+  header?: string;
+  question: string;
+  options: AskOption[];
+  multi: boolean;
+  /** Index of the option omp marks ` (Recommended)`. */
+  recommended?: number;
+}
+
+export interface AskAnswer {
+  selectedOptions: string[];
+  customInput?: string;
+  /** omp auto-selected the answer after `ask.timeout` elapsed. */
+  timedOut?: boolean;
+}
+
+/** The free-text escape hatch omp appends to every question's option list. */
+const OTHER_OPTION = /^other\b/i;
+/** Trailing ` (2/3)` omp adds while looping over several questions. */
+const PROGRESS_SUFFIX = /\s+\(\d+\s*\/\s*\d+\)$/;
+/** Leading `(2 selected) ` omp prepends to a multi-select question's title. */
+const SELECTED_COUNT_PREFIX = /^\(\d+\s+selected\)\s*/;
+
+/** True for the literal "Other (type your own)" row, which is a prompt to type
+ *  an answer rather than an answer itself. */
+export function isOtherOption(label: string): boolean {
+  return OTHER_OPTION.test(label.trim());
+}
+
+/** Normalized question text, with the decorations omp adds to a live dialog
+ *  title stripped, so a frame can be matched against the question that raised it. */
+export function normalizeAskText(value: string): string {
+  return value
+    .replace(SELECTED_COUNT_PREFIX, '')
+    .replace(PROGRESS_SUFFIX, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function readOption(raw: unknown): AskOption | null {
+  if (typeof raw === 'string') {
+    const label = raw.trim();
+    return label ? { label } : null;
+  }
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const label = typeof record.label === 'string' ? record.label.trim() : '';
+  if (!label) return null;
+  return {
+    label,
+    description: typeof record.description === 'string' ? record.description : undefined,
+    preview: typeof record.preview === 'string' ? record.preview : undefined,
+  };
+}
+
+/** True for a tool call that is omp's `ask` tool. */
+export function isAskToolCall(tool: ToolCallData): boolean {
+  const name = typeof tool.name === 'string' && tool.name ? tool.name : tool.type;
+  return name === 'ask' || tool.title === 'ask';
+}
+
+/**
+ * True for an ask omp has given up on — its dialog was withdrawn (a validation
+ * failure, an abort), so no live frame can belong to it and its card renders no
+ * control. Deliberately NOT `success`: a session reloaded mid-ask reads its
+ * still-blocking call back from the JSONL as `success`, since omp writes no
+ * result until the question is answered, and that card must stay answerable.
+ *
+ * Two modules must agree on this (the frame-ownership split and the card
+ * itself), which is why it is not an inline comparison at either.
+ */
+export function isAskSettled(tool: ToolCallData): boolean {
+  return tool.status === 'error' || tool.status === 'aborted' || tool.status === 'skipped';
+}
+
+/**
+ * The `questions` array from an `ask` tool call's arguments. Empty when the tool
+ * is not an ask call or its arguments were truncated — callers fall back to the
+ * raw arguments/output rendering in that case.
+ */
+export function parseAskQuestions(tool: ToolCallData): AskQuestion[] {
+  const input = tool.input;
+  const record = typeof input === 'object' && input !== null ? (input as Record<string, unknown>) : null;
+  const raw = record && Array.isArray(record.questions) ? record.questions : [];
+  const questions: AskQuestion[] = [];
+
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object') continue;
+    const question = entry as Record<string, unknown>;
+    const text = typeof question.question === 'string' ? question.question.trim() : '';
+    if (!text) continue;
+    questions.push({
+      id: typeof question.id === 'string' ? question.id : undefined,
+      header: typeof question.header === 'string' && question.header.trim() ? question.header.trim() : undefined,
+      question: text,
+      options: Array.isArray(question.options)
+        ? question.options.map(readOption).filter((option): option is AskOption => option !== null)
+        : [],
+      multi: question.multi === true,
+      recommended: typeof question.recommended === 'number' ? question.recommended : undefined,
+    });
+  }
+
+  return questions;
+}
+
+function readAnswer(row: Record<string, unknown>): AskAnswer {
+  return {
+    selectedOptions: Array.isArray(row.selectedOptions)
+      ? row.selectedOptions.filter((value): value is string => typeof value === 'string')
+      : [],
+    customInput: typeof row.customInput === 'string' && row.customInput ? row.customInput : undefined,
+    timedOut: row.timedOut === true,
+  };
+}
+
+/** One `<id>: <answer>` line of a multi-question result. */
+const ANSWER_LINE = /^([\w.-]+):\s*(.+)$/;
+/** The single-question result's two prose shapes. */
+const SELECTED_LINE = /^User selected:\s*(.+)$/m;
+const CUSTOM_LINE = /^User provided custom input:\s*([\s\S]+)$/m;
+
+/** `value` as omp renders it: a quoted string is typed input, a bare one is a
+ *  picked label (comma-joined when the question allows several). */
+function toAnswer(value: string, multi: boolean): AskAnswer {
+  const text = value.trim();
+  if (/^"[\s\S]*"$/.test(text)) return { selectedOptions: [], customInput: text.slice(1, -1) };
+  const labels = multi && text.includes(', ') ? text.split(', ') : [text];
+  return { selectedOptions: labels.map((label) => label.trim()).filter(Boolean) };
+}
+
+/**
+ * Answers recovered from the tool's rendered text, used when `details` never
+ * reached this client. `details` is the richer source, but it is dropped by the
+ * live `tool_execution_end` frame on some omp builds; the text is the one part
+ * of a settled result every path carries, and it names each answer by question
+ * id (`language: Python`) or as a single sentence for a one-question ask.
+ */
+function parseAskOutputAnswers(output: string, questions: AskQuestion[]): (AskAnswer | null)[] {
+  const answers = questions.map((): AskAnswer | null => null);
+  const text = output.trim();
+  if (!text) return answers;
+
+  const byId = new Map<string, AskAnswer>();
+  for (const line of text.split('\n')) {
+    const match = ANSWER_LINE.exec(line.trim());
+    if (match) byId.set(match[1], toAnswer(match[2], questions.some((question) => question.multi)));
+  }
+  if (byId.size > 0) {
+    const ordered = [...byId.values()];
+    for (let index = 0; index < questions.length; index += 1) {
+      // The question id is the key omp prints; position is what is left when a
+      // payload carries no ids at all (omp requires them, so this is defensive).
+      const id = questions[index].id;
+      answers[index] = (id ? byId.get(id) : undefined) ?? ordered[index] ?? null;
+    }
+    return answers;
+  }
+
+  const selected = SELECTED_LINE.exec(text);
+  if (selected) {
+    answers[0] = toAnswer(selected[1], questions[0].multi);
+    return answers;
+  }
+  const custom = CUSTOM_LINE.exec(text);
+  if (custom) {
+    answers[0] = { selectedOptions: [], customInput: custom[1].trim() };
+    return answers;
+  }
+  if (questions.length === 1 && !text.includes('\n')) {
+    answers[0] = { selectedOptions: [text] };
+  }
+  return answers;
+}
+
+/**
+ * Answers recorded in an `ask` tool result, positionally aligned with
+ * `questions`. omp returns `details.results[]` for a multi-question ask and the
+ * bare answer fields for a single-question one; the rendered text backs both up.
+ */
+export function parseAskResult(tool: ToolCallData, questions: AskQuestion[]): (AskAnswer | null)[] {
+  const answers = questions.map((): AskAnswer | null => null);
+  if (questions.length === 0) return answers;
+
+  const details = tool.details ?? {};
+  const results = Array.isArray(details.results) ? (details.results as Record<string, unknown>[]) : null;
+  if (results) {
+    for (let index = 0; index < answers.length; index += 1) {
+      const row = results[index];
+      if (row && typeof row === 'object') answers[index] = readAnswer(row);
+    }
+    return answers;
+  }
+
+  if (typeof details.selectedOptions !== 'undefined' || typeof details.customInput === 'string') {
+    answers[0] = readAnswer(details);
+    return answers;
+  }
+
+  // A failed/cancelled ask answers nothing; its text is the reason, which would
+  // otherwise read as an answer for whichever id its first sentence names.
+  if (isAskSettled(tool) || tool.isError) return answers;
+
+  return parseAskOutputAnswers(typeof tool.output === 'string' ? tool.output : '', questions);
+}
+
+/**
+ * Bucket the ask's dialogs by question index.
+ *
+ * Assignment follows omp's own order rather than pure title matching: a frame
+ * whose title names a question moves the cursor onto it, and any other frame
+ * (the `editor`/`input` dialog omp opens after "Other (type your own)") belongs
+ * to whichever question was last named. A title that names an EARLIER question
+ * is ignored — omp walks the questions forward and never re-asks one, so a
+ * repeat can only be a multi-select re-render of the question already in hand.
+ */
+export function groupAskFrames(
+  questions: AskQuestion[],
+  frames: ExtensionUiDialogRequest[],
+): ExtensionUiDialogRequest[][] {
+  const groups = questions.map((): ExtensionUiDialogRequest[] => []);
+  if (questions.length === 0) return groups;
+  const titles = questions.map((question) => normalizeAskText(question.question));
+
+  let cursor = 0;
+  for (const frame of frames) {
+    const title = typeof frame.title === 'string' ? normalizeAskText(frame.title) : '';
+    const index = titles.indexOf(title);
+    if (index > cursor) {
+      cursor = index;
+    } else if (
+      index === -1 &&
+      frame.method === 'select' &&
+      groups[cursor].some((held) => held.method === 'select') &&
+      cursor + 1 < groups.length
+    ) {
+      // Title matching is the authority, but a question is asked by exactly one
+      // `select` — a second one that matches nothing is the NEXT question with
+      // decorations this build does not know about, not a repeat.
+      cursor += 1;
+    }
+    groups[cursor].push(frame);
+  }
+
+  return groups;
+}

package/src/shared/lib/chat/attachments.test.ts

@@ -0,0 +1,240 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Attachment metadata across the two representations the composer handles.
+ *
+ * A LIVE attachment carries `file: File`; a REPLAYED one — out of the queue row
+ * or back out of committed history — does not, because `JSON.stringify(new
+ * File(…))` is `{}`. Every accessor and every assembly path must therefore work
+ * from the persisted display fields, which is what used to break: a queued or
+ * retried send read `a.file.name` and threw, and the image payload filter
+ * matched on a `data:` preview the composer never produces.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import type { Attachment } from '@/shared/types';
+import {
+  applyTextAttachmentBudget,
+  attachmentHasPayload,
+  attachmentImage,
+  attachmentName,
+  attachmentSize,
+  attachmentType,
+  composeMessageWithTextAttachments,
+  isImageAttachment,
+  isTextAttachment,
+  looksLikeTextFile,
+  prepareQueuedAttachments,
+  readTextAttachments,
+} from '@/shared/lib/chat/attachments';
+
+function liveFile(name: string, body: string, type = ''): File {
+  return new File([body], name, { type });
+}
+
+function liveAttachment(overrides: Partial<Attachment> & { id: string }): Attachment {
+  return { preview: '', ...overrides };
+}
+
+/** What the queue row and committed history actually hold. */
+function replayed(attachments: Attachment[]): Attachment[] {
+  return JSON.parse(JSON.stringify(attachments)) as Attachment[];
+}
+
+describe('attachment metadata accessors', () => {
+  test('read a live file, and fall back to the persisted fields', () => {
+    const live = liveAttachment({ id: 'a', name: 'notes.md', type: 'text/markdown', size: 99, file: liveFile('notes.md', '# hi', 'text/markdown') });
+    expect(attachmentName(live)).toBe('notes.md');
+    expect(attachmentType(live)).toBe('text/markdown');
+    expect(attachmentSize(live)).toBe(4); // the live handle is authoritative
+
+    const replay = replayed([live])[0];
+    // `JSON.stringify` renders a File as an empty object — not as undefined —
+    // so the replay path must treat a truthiness check as unreliable and read
+    // the display fields first.
+    expect(replay.file as unknown).toEqual({});
+    expect(attachmentName(replay)).toBe('notes.md');
+    expect(attachmentType(replay)).toBe('text/markdown');
+    expect(attachmentSize(replay)).toBe(99);
+  });
+
+  test('never throw on an attachment with neither a file nor a name', () => {
+    const bare = { id: 'x', preview: '' } as Attachment;
+    expect(attachmentName(bare)).toBe('attachment');
+    expect(attachmentType(bare)).toBe('');
+    expect(attachmentSize(bare)).toBe(0);
+    expect(isTextAttachment(bare)).toBe(false);
+    expect(attachmentImage(bare)).toBeNull();
+  });
+});
+
+describe('text vs image classification', () => {
+  test('code files with no browser MIME type still inline', () => {
+    // `File.type` is empty for most source files, so the extension decides.
+    for (const name of ['script.py', 'app.tsx', 'query.sql', 'Dockerfile.json', 'data.yaml']) {
+      expect(isTextAttachment({ name, type: '', file: liveFile(name, 'x') })).toBe(true);
+    }
+  });
+
+  test('a browser-reported text MIME type is enough on its own', () => {
+    expect(isTextAttachment({ name: 'LICENSE', type: 'text/plain', file: liveFile('LICENSE', 'x', 'text/plain') })).toBe(true);
+    expect(isTextAttachment({ name: 'blob.bin', type: 'application/json', file: liveFile('blob.bin', '{}', 'application/json') })).toBe(true);
+  });
+
+  test('binaries and images never consume the inline budget', () => {
+    expect(isTextAttachment({ name: 'app.dmg', type: 'application/octet-stream', file: liveFile('app.dmg', 'x', 'application/octet-stream') })).toBe(false);
+    // An image whose name happens to look textual is still an image.
+    expect(isTextAttachment({ name: 'trap.md', type: 'image/png', file: liveFile('trap.md', 'x', 'image/png') })).toBe(false);
+    expect(isImageAttachment({ name: 'trap.md', type: 'image/png', file: liveFile('trap.md', 'x', 'image/png') })).toBe(true);
+  });
+});
+
+describe('image payloads', () => {
+  test('carry the omp ImageContent type and the persisted MIME type', () => {
+    const payload = attachmentImage({
+      type: 'image/png',
+      dataBase64: 'iVBORw0KGgo=',
+    });
+    expect(payload).toEqual({ type: 'image', data: 'iVBORw0KGgo=', mimeType: 'image/png' });
+  });
+
+  test('a replay with a blob preview still yields its payload', () => {
+    // The old server-side filter matched `preview.startsWith('data:image/')`
+    // and so found nothing: the composer's preview is a blob URL.
+    const [replay] = replayed([
+      liveAttachment({ id: 'i', name: 's.png', type: 'image/png', preview: 'blob:http://x/1', dataBase64: 'AAAA', file: liveFile('s.png', 'x', 'image/png') }),
+    ]);
+    expect(attachmentImage(replay)?.data).toBe('AAAA');
+  });
+
+  test('an unread image yields nothing rather than a blank payload', () => {
+    expect(attachmentImage({ type: 'image/png', dataBase64: '' })).toBeNull();
+    expect(attachmentImage({ type: 'image/png' })).toBeNull();
+  });
+
+  test('a committed row whose preview IS the bytes still yields a payload', () => {
+    // Committed history and the session loader set `preview` to a data URL and
+    // never set `dataBase64`, so a retry or a seeded new chat had no image to
+    // send. The preview is the only copy of the bytes on that path.
+    const payload = attachmentImage({ type: 'image/png', preview: 'data:image/png;base64,QUJD' });
+    expect(payload).toEqual({ type: 'image', data: 'QUJD', mimeType: 'image/png' });
+  });
+
+  test('a non-base64 or empty preview yields nothing', () => {
+    expect(attachmentImage({ type: 'image/png', preview: 'blob:http://x/1' })).toBeNull();
+    expect(attachmentImage({ type: 'image/png', preview: 'data:image/png;base64,' })).toBeNull();
+  });
+});
+
+describe('attachmentHasPayload', () => {
+  test('a replayed image with only a data-URL preview still counts as sendable', () => {
+    // The composer used to test `content || dataBase64`, so a seeded or
+    // replayed image — whose bytes live only in the preview — was refused and
+    // the send aborted with "unreadable attachments".
+    expect(attachmentHasPayload({ id: 'i', preview: 'data:image/png;base64,QUJD', type: 'image/png' })).toBe(true);
+  });
+
+  test('an image with no bytes at all is not sendable', () => {
+    expect(attachmentHasPayload({ id: 'i', preview: 'blob:http://x/1', type: 'image/png' })).toBe(false);
+  });
+
+  test('a text file counts through its inlined content', () => {
+    expect(attachmentHasPayload({ id: 't', preview: '', name: 'a.md', type: 'text/markdown', content: '# hi' })).toBe(true);
+    expect(attachmentHasPayload({ id: 't', preview: '', name: 'a.md', type: 'text/markdown', content: '' })).toBe(false);
+  });
+});
+
+describe('text contents', () => {
+  test('are read from a live file, and from `content` on a replay', async () => {
+    const live = [liveAttachment({ id: 't', name: 'notes.md', type: 'text/markdown', file: liveFile('notes.md', '# hi', 'text/markdown') })];
+    expect((await readTextAttachments(live)).map((f) => f.content)).toEqual(['# hi']);
+
+    const replay = replayed(await prepareQueuedAttachments(live));
+    expect(replay[0].file).toBeUndefined();
+    expect(replay[0].content).toBe('# hi');
+    expect((await readTextAttachments(replay)).map((f) => f.content)).toEqual(['# hi']);
+  });
+
+  test('a replay without a persisted copy is flagged, not silently dropped', async () => {
+    // It used to be filtered out, which sent a prompt naming a file whose
+    // contents never arrived — with nothing in the UI to say so.
+    const files = await readTextAttachments([
+      { id: 't', name: 'notes.md', type: 'text/markdown', preview: '' },
+    ]);
+    expect(files.map((f) => ({ name: f.name, missing: f.missing, content: f.content }))).toEqual([
+      { name: 'notes.md', missing: true, content: '' },
+    ]);
+  });
+
+  test('carry their attachment id so the caller can map them back', async () => {
+    const files = await readTextAttachments([
+      { id: 'keep', name: 'a.md', type: 'text/markdown', preview: '', content: 'a' },
+      { id: 'drop', name: 'b.bin', type: 'application/octet-stream', preview: '', content: 'b' },
+    ]);
+    expect(files.map((f) => f.id)).toEqual(['keep']);
+  });
+
+  test('are fenced with a language that matches the file', () => {
+    const py = [{ name: 'script.py', mimeType: 'text/x-python', content: 'x=1', size: 3 }];
+    expect(composeMessageWithTextAttachments('go', py)).toContain('```python');
+  });
+});
+
+describe('inline budget', () => {
+  test('counts replayed attachments, so repeated drops stop at the cap', () => {
+    const existing = Array.from({ length: 10 }, (_, i) => ({ name: `f${i}.md`, type: 'text/markdown', size: 10, content: 'x' }));
+    const { accepted, skipped } = applyTextAttachmentBudget([liveFile('extra.md', 'x', 'text/markdown')], existing);
+    expect(accepted).toEqual([]);
+    expect(skipped.map((f) => f.name)).toEqual(['extra.md']);
+  });
+
+  test('lets an image through when the text budget is spent', () => {
+    const existing = Array.from({ length: 10 }, (_, i) => ({ name: `f${i}.md`, type: 'text/markdown', size: 10, content: 'x' }));
+    const { accepted, skipped } = applyTextAttachmentBudget([liveFile('shot.png', 'x', 'image/png')], existing);
+    expect(accepted.map((f) => f.name)).toEqual(['shot.png']);
+    expect(skipped).toEqual([]);
+  });
+});
+
+describe('content sniffing for unclassified files', () => {
+  test('a file whose name and MIME say nothing is recognised as text', async () => {
+    // A promised-file drag from another app arrives like this: real bytes, a
+    // generic name, no usable type. Deciding from metadata alone left it
+    // attached but never inlined.
+    expect(await looksLikeTextFile(liveFile('document', 'IMPORTANT\ncode: ABC'))).toBe(true);
+    expect(await looksLikeTextFile(liveFile('file', '# Title\n\nBody'))).toBe(true);
+  });
+
+  test('binary content is refused', async () => {
+    const png = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    expect(await looksLikeTextFile(new File([png], 'download'))).toBe(false);
+    // A NUL byte is decisive: no text encoding this app handles contains one.
+    expect(await looksLikeTextFile(new File([new Uint8Array([65, 66, 0, 67])], 'blob'))).toBe(false);
+  });
+
+  test('an empty file is not treated as text', async () => {
+    expect(await looksLikeTextFile(liveFile('empty', ''))).toBe(false);
+  });
+
+  test('a sniffed attachment keeps its content through the read path', async () => {
+    // The sniffer's verdict is recorded on the attachment at attach time, so the
+    // send path must honour it even though the name still says nothing — and a
+    // bare `content` string must NOT be enough to smuggle a binary through.
+    const sniffed: Attachment = {
+      id: 'x',
+      name: 'document',
+      type: '',
+      size: 20,
+      preview: '',
+      content: 'IMPORTANT\ncode: ABC',
+      sniffedText: true,
+    };
+    const read = await readTextAttachments([sniffed]);
+    expect(read.map((f) => ({ name: f.name, content: f.content }))).toEqual([
+      { name: 'document', content: 'IMPORTANT\ncode: ABC' },
+    ]);
+  });
+});