zidane-ui 9.0.4 → 9.1.3

package/src/chat/headless/composer/conversation-badges.ts

@@ -1,222 +0,0 @@
-/**
- * The composer's badges for one conversation, as data (`ConversationBadges`
- * adds the clicks and the user's order):
- *
- *   inbox     a plan or questions wait on the user: highlighted, first
- *   todos     the agent's list, done of total (`Settings.showTodoIndicator`)
- *   queue     messages sent during the run, waiting for it to end
- *   work      tool calls and background tasks you can stop (Running work)
- *   extension badges (`ctx.composer.setBadge`), their default slot 100
- *   session statuses (`ctx.tui.setStatus` with `sessionId`), last
- *
- * Built-ins keep their side panel tab's icon, and a click opens that tab;
- * Running opens the Running work dialog instead (`opensWork`). React-free,
- * so it is tested in the node environment; the words are the composer's
- * labels.
- */
-import type { InteractionRequest, TodosSnapshot } from 'zidane/chat';
-import { INBOX_PANEL_ID, QUEUE_PANEL_ID, TODOS_PANEL_ID } from 'zidane/chat/pure';
-import type { RunningWorkItem } from 'zidane/ipc';
-
-import type { ComposerHudBadge, ComposerHudStatus } from './host-chrome';
-import type { ComposerChromeLabels } from './labels-chrome';
-
-/** One badge of the strip, as data (the kit's `ComposerBadge` without its click). */
-export interface ConversationBadgeData {
-  /** Stable id: keys the badge and the user's order. */
-  id: string;
-  /** What it says. */
-  label: string;
-  /** Its icon class. */
-  icon?: string;
-  /** A spinner in place of the icon. */
-  loader?: boolean;
-  /** Its count. */
-  count?: string;
-  /** How the count speaks. */
-  countTone?: 'neutral';
-  /** Its tone. */
-  tone?: 'muted' | 'subtle' | 'accent' | 'success' | 'warn' | 'danger';
-  /** It asks for attention. */
-  highlight?: boolean;
-  /** Its tooltip. */
-  title?: string;
-  /** Its default slot. */
-  order?: number;
-}
-
-/** A badge and what a click opens: a panel, the Running work dialog, or nothing (`panel: null`). */
-export interface ConversationBadge extends ConversationBadgeData {
-  /** The panel a click opens, `null` for none. */
-  panel: string | null;
-  /** A click opens the Running work dialog. */
-  opensWork?: true;
-}
-
-/** What the Inbox badge reads of the conversation's pending requests. */
-export interface InboxSummary {
-  /** How many requests wait. */
-  count: number;
-  /** The oldest: the one the badge names. */
-  head: InteractionRequest;
-  /** Raised by a run going on now, not rehydrated from an earlier process. */
-  live: boolean;
-}
-
-/** What the strip is built from. */
-export interface ConversationBadgeInput {
-  /** The pending requests, `null` for none. */
-  inbox: InboxSummary | null;
-  /** The agent's todo list. */
-  todos: TodosSnapshot | null;
-  /** `Settings.showTodoIndicator`. */
-  showTodos: boolean;
-  /** Messages in the conversation's queue. */
-  queued: number;
-  /** Its running work, as the badge shows it (`useSustainedWork`). */
-  work: readonly RunningWorkItem[];
-  /** The extensions' statuses scoped to the conversation. */
-  statuses: readonly ComposerHudStatus[];
-  /** The extensions' badges. */
-  extensionBadges: readonly ComposerHudBadge[];
-  /** The conversation's panels (the catalog's ids): an extension badge opens one of them or nothing. */
-  panels: ReadonlySet<string>;
-}
-
-/** Default slots: the built-ins lead, extensions sit at the kit's default (100), statuses close the strip. */
-const BADGE_ORDER = { inbox: 0, todos: 10, queue: 20, work: 30, status: 200 } as const;
-
-/**
- * The badges to show, in their default order (the kit's
- * `orderComposerBadges` applies the user's).
- *
- * @param input - The conversation's state.
- * @param labels - The words.
- */
-export function conversationBadges(input: ConversationBadgeInput, labels: ComposerChromeLabels): ConversationBadge[] {
-  const out: ConversationBadge[] = [];
-  if (input.inbox) out.push(inboxBadge(input.inbox, labels));
-  const todos = input.showTodos && input.todos ? todosBadge(input.todos, labels) : null;
-  if (todos) out.push(todos);
-  if (input.queued > 0) {
-    out.push({
-      id: 'queue',
-      label: labels.badgeQueued,
-      icon: 'i-ph-queue',
-      count: String(input.queued),
-      title: labels.badgeQueuedTitle(input.queued),
-      order: BADGE_ORDER.queue,
-      panel: QUEUE_PANEL_ID,
-    });
-  }
-  if (input.work.length > 0) out.push(workBadge(input.work, labels));
-  for (const badge of input.extensionBadges) out.push(extensionBadge(badge, input.panels));
-  for (const status of input.statuses) {
-    out.push({
-      id: `status:${status.extension}`,
-      label: status.text,
-      ...(status.loader ? { loader: true } : { icon: 'i-ph-puzzle-piece' }),
-      title: status.extension,
-      order: BADGE_ORDER.status,
-      panel: null,
-    });
-  }
-  return out;
-}
-
-function workBadge(work: readonly RunningWorkItem[], labels: ComposerChromeLabels): ConversationBadge {
-  const names = work.slice(0, 3).map((item) => item.label);
-  const more = work.length - names.length;
-  return {
-    id: 'work',
-    label: labels.badgeRunning,
-    icon: 'i-ph-lightning',
-    tone: 'accent',
-    count: String(work.length),
-    title: labels.badgeRunningTitle(names, more, work.length),
-    order: BADGE_ORDER.work,
-    panel: null,
-    opensWork: true,
-  };
-}
-
-function inboxBadge({ count, head, live }: InboxSummary, labels: ComposerChromeLabels): ConversationBadge {
-  const { label, title } =
-    head.kind === 'plan'
-      ? { label: labels.badgePlan, title: labels.badgePlanTitle(head.payload.title) }
-      : head.kind === 'question'
-        ? {
-            label: labels.badgeQuestions(head.payload.questions.length),
-            title: labels.badgeQuestionsTitle(head.payload.questions.length),
-          }
-        : { label: labels.badgeWaiting, title: labels.badgeWaitingTitle };
-  return {
-    id: 'inbox',
-    label,
-    icon: 'i-ph-tray',
-    highlight: true,
-    // One request reads in the label; more are counted.
-    ...(count > 1 ? { count: String(count) } : {}),
-    title: live ? title : labels.badgeFromPrevious(title),
-    order: BADGE_ORDER.inbox,
-    panel: INBOX_PANEL_ID,
-  };
-}
-
-function todosBadge(snap: TodosSnapshot, labels: ComposerChromeLabels): ConversationBadge | null {
-  // The live list, else the last one (kept after the agent clears it).
-  const archived = snap.todos.length === 0;
-  const list = archived ? snap.archive : snap.todos;
-  if (list.length === 0) return null;
-  const done = list.filter((t) => t.status === 'completed' || t.status === 'cancelled').length;
-  const progress = labels.badgeTodosProgress(done, list.length);
-  const current = archived
-    ? null
-    : (snap.inProgress ?? list.find((t) => t.status === 'in_progress') ?? list.find((t) => t.status === 'pending'));
-  return {
-    id: 'todos',
-    label: labels.badgeTodos,
-    icon: 'i-ph-list-checks',
-    count: `${done}/${list.length}`,
-    title: current ? labels.badgeTodosCurrent(current.content, progress) : labels.badgeTodosLast(progress),
-    order: BADGE_ORDER.todos,
-    panel: TODOS_PANEL_ID,
-  };
-}
-
-function extensionBadge(badge: ComposerHudBadge, panels: ReadonlySet<string>): ConversationBadge {
-  return {
-    // Namespaced: never the id of a built-in or of another extension's badge.
-    id: `${badge.extension}/${badge.id}`,
-    label: badge.label,
-    ...(badge.count ? { count: badge.count } : {}),
-    // An extension's count is its own (`neutral`); a highlight speaks in `attention`.
-    ...(badge.highlight ? { highlight: true } : { countTone: 'neutral' as const }),
-    ...(badge.icon?.gui ? { icon: badge.icon.gui } : {}),
-    ...(badge.tone ? { tone: badge.tone } : {}),
-    ...(badge.loader ? { loader: true } : {}),
-    title: badge.title ?? badge.extension,
-    ...(badge.order !== undefined ? { order: badge.order } : {}),
-    panel: resolveBadgePanel(badge.panel, badge.extension, panels),
-  };
-}
-
-/**
- * The panel an extension badge names, among the conversation's panels: the
- * extension's own (a bare id), a full `<extension>/<id>`, or a built-in.
- * `null` when it names none of them.
- *
- * @param panel - What the badge named.
- * @param extension - The extension that set the badge.
- * @param panels - The conversation's panel ids.
- */
-export function resolveBadgePanel(
-  panel: string | undefined,
-  extension: string,
-  panels: ReadonlySet<string>,
-): string | null {
-  if (!panel) return null;
-  const own = `${extension}/${panel}`;
-  if (!panel.includes('/') && panels.has(own)) return own;
-  return panels.has(panel) ? panel : null;
-}

package/src/chat/headless/composer/draft-sync.ts

@@ -1,199 +0,0 @@
-/**
- * Shared-draft sync helpers (daemon mode). Pure functions — the Chatbox
- * wires them to `window.api.drafts.*`; keeping the guard + conversion
- * logic here makes the apply-vs-echo semantics unit-testable without a
- * TipTap editor.
- *
- * Echo model: the daemon excludes the origin window from its own
- * broadcasts, so every `drafts:changed` we receive is a genuine remote
- * edit and is applied unconditionally — the ONLY guard needed is a
- * value-equality check so a no-op apply doesn't churn the editor (and
- * so the apply→publish round trip can't form a render loop).
- */
-import type { ChatAttachment as WireAttachment } from '../host';
-import type { ComposerAttachment as ChatAttachment, PromptAttachment } from './host';
-import { editorJsonToMarkdown, type JsonNode } from './editor-markdown';
-
-/** The wire-visible half of the composer draft: markdown text + shell flag. */
-export interface DraftSnapshot {
-  text: string;
-  shell: boolean;
-}
-
-export function draftsEqual(a: DraftSnapshot, b: DraftSnapshot): boolean {
-  return a.text === b.text && a.shell === b.shell;
-}
-
-/**
- * Whether an incoming remote draft should mutate the editor. Remote
- * events for our own edits never arrive (origin-excluded broadcast),
- * so "differs from what's in the buffer" is the complete condition.
- */
-export function shouldApplyRemoteDraft(current: DraftSnapshot, incoming: DraftSnapshot): boolean {
-  return !draftsEqual(current, incoming);
-}
-
-/**
- * Remote draft text → TipTap doc JSON for the SYNC apply path: one
- * paragraph per line, the document typing builds (Shift+Enter starts a
- * paragraph). A remote draft must look exactly like the same text typed
- * here: one paragraph holding `hardBreak`s spaced its lines wider than
- * typed paragraphs (`text-box: trim-both` trims each paragraph's edges),
- * so every apply visibly reflowed the prompt.
- *
- * With the WYSIWYG wire form (`draftWireText`, one `\n` per paragraph)
- * `draftWireText(draftTextToDocJson(t))` is `t` for ALL plain text, the
- * identity the echo guard depends on. (Under the submit serializer a
- * paragraph gap is `\n\n`, which is why this must never be serialized
- * with it for sync.)
- */
-export function draftTextToDocJson(text: string): JsonNode {
-  return {
-    type: 'doc',
-    content: text.split('\n').map((line) => ({
-      type: 'paragraph',
-      ...(line.length > 0 ? { content: [{ type: 'text', text: line }] } : {}),
-    })),
-  };
-}
-
-/**
- * THE canonical draft wire form of an editor document — the publish
- * path, the pre-apply comparison, and the post-apply baseline must all
- * read the buffer through this one function, or the echo guard
- * re-publishes every remote apply (the draft-spam feedback loop).
- *
- * Serialized WYSIWYG (`blockGap: '\n'`): the editor renders adjacent
- * paragraphs with no visible gap, so one visual line break crosses the
- * wire as ONE `\n` — what a TUI shows is exactly what the GUI shows.
- * Every block emits one trailing gap, so a document always carries
- * exactly one spurious `\n` at the end; stripping ONLY that suffix
- * (never `.trim()`) keeps intentional trailing spaces and blank lines
- * byte-faithful.
- */
-export function draftWireText(doc: JsonNode): string {
-  const serialized = editorJsonToMarkdown(doc, { blockGap: '\n' });
-
-  return serialized.endsWith('\n') ? serialized.slice(0, -1) : serialized;
-}
-
-const DATA_URL_RE = /^data:([^;]+);base64,(.+)$/;
-
-/**
- * Staged composer attachments → wire `PromptAttachment` shape. Entries
- * whose data URL can't be parsed are dropped silently — same policy as
- * the send flow's `promptAttachments` (`send-flow.ts`; the text half still syncs).
- */
-export function chatAttachmentsToWire(attachments: readonly ChatAttachment[]): PromptAttachment[] {
-  const out: PromptAttachment[] = [];
-
-  for (const att of attachments) {
-    const match = DATA_URL_RE.exec(att.dataUrl);
-
-    if (!match) {
-      continue;
-    }
-
-    out.push({ mediaType: match[1] ?? att.mediaType, data: match[2] ?? '', name: att.name });
-  }
-
-  return out;
-}
-
-/**
- * Wire attachments → staged `ChatAttachment`s. `size` is derived from
- * the base64 payload (the wire shape doesn't carry it); `name` falls
- * back to '' so the round trip through `chatAttachmentsToWire` is
- * key-stable (see `attachmentsWireKey`).
- */
-export function wireToChatAttachments(attachments: readonly PromptAttachment[]): ChatAttachment[] {
-  return attachments.map((att, index) => ({
-    id: `sync-${index}-${att.data.length}-${att.name ?? ''}`,
-    name: att.name ?? '',
-    mediaType: att.mediaType,
-    size: Math.floor((att.data.length * 3) / 4),
-    dataUrl: `data:${att.mediaType};base64,${att.data}`,
-  }));
-}
-
-/**
- * What a session switch does to the composer buffer. `promote` marks a send
- * from the new-chat screen: the switch to the session it created keeps the
- * buffer (text typed while the session was being created belongs to it).
- */
-export function sessionSwitchAction(prev: string | null, next: string | null, promote: boolean): 'clear' | 'keep' {
-  if (prev === next) {
-    return 'keep';
-  }
-
-  return promote && prev === null && next !== null ? 'keep' : 'clear';
-}
-
-/**
- * Canonical equality key for a wire attachment list — used as the
- * publish/apply echo guard. `name` normalizes `undefined` → '' so a
- * remote list survives the ChatAttachment round trip with the same key.
- */
-export function attachmentsWireKey(attachments: readonly PromptAttachment[]): string {
-  // Not the whole payload: stringifying multi-MB base64 per change cost tens of ms. Type, name,
-  // length and both ends of the data tell two images apart as well in practice.
-  return JSON.stringify(
-    attachments.map((att) => [
-      att.mediaType,
-      att.name ?? '',
-      att.data.length,
-      att.data.slice(0, 64),
-      att.data.slice(-64),
-    ]),
-  );
-}
-
-function bytesToBase64(bytes: Uint8Array): string {
-  let binary = '';
-  const CHUNK = 0x8000;
-  for (let i = 0; i < bytes.length; i += CHUNK) {
-    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
-  }
-  return btoa(binary);
-}
-
-/**
- * A sent prompt's attachments → staged `ChatAttachment`s, for a draft that
- * re-stages them (Edit message). Data URLs stage as they are; a `zg-media:`
- * address (a PDF or text file served from the saved turn) is fetched and
- * re-encoded under the attachment's own media type, since the send path only
- * reads data URLs. Metadata-only chips (no address) and failed fetches drop.
- *
- * @param attachments - The sent prompt's attachments.
- * @param fetchImpl - How a `zg-media:` address is read (default: `fetch`).
- */
-export async function wireAttachmentsToChat(
-  attachments: readonly WireAttachment[],
-  fetchImpl: (url: string) => Promise<Response> = (url) => fetch(url),
-): Promise<ChatAttachment[]> {
-  const staged = await Promise.all(
-    attachments.map(async (att, index): Promise<ChatAttachment | null> => {
-      const src = att.dataUrl;
-      if (!src) return null;
-      const id = `draft-${index}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-      if (src.startsWith('data:')) {
-        return { id, name: att.name, mediaType: att.mediaType, size: att.size, dataUrl: src };
-      }
-      try {
-        const res = await fetchImpl(src);
-        if (!res.ok) return null;
-        const bytes = new Uint8Array(await res.arrayBuffer());
-        return {
-          id,
-          name: att.name,
-          mediaType: att.mediaType,
-          size: bytes.length,
-          dataUrl: `data:${att.mediaType};base64,${bytesToBase64(bytes)}`,
-        };
-      } catch {
-        return null;
-      }
-    }),
-  );
-  return staged.filter((att): att is ChatAttachment => att !== null);
-}

package/src/chat/headless/composer/editor-markdown.ts

@@ -1,137 +0,0 @@
-/**
- * TipTap doc JSON → markdown, shared by the Chatbox's submit path,
- * prompt-history stash, and the shared-draft sync (daemon mode). Living
- * outside the component keeps the serializer round trip unit-testable —
- * the draft echo guard DEPENDS on `editorJsonToMarkdown(draftTextToDocJson(t))`
- * being `t` plus exactly one trailing block gap (see draft-sync.ts).
- */
-export interface JsonNode {
-  type?: string;
-  text?: string;
-  marks?: Array<{ type: string; attrs?: Record<string, unknown> }>;
-  attrs?: Record<string, unknown>;
-  content?: JsonNode[];
-}
-
-/**
- * TipTap doc → markdown serializer used at submit time. We keep this
- * inline (instead of pulling in `tiptap-markdown`) because the surface
- * we need is small and well-defined: paragraphs, hard breaks, inline code,
- * lists, fenced code, blockquote, and the custom mention nodes (which
- * serialize back to `@<path>` / `/<name>` / `#<chat>`).
- *
- * Block boundaries emit `blockGap` (default `\n\n`, markdown paragraph
- * semantics — the submit path); trailing whitespace is normalized by
- * the caller. List items contain paragraphs whose trailing newlines are
- * stripped so a list reads as one item per line.
- *
- * `blockGap: '\n'` is the WYSIWYG form for the shared-draft wire: the
- * editor renders adjacent paragraphs with no visible gap, so one visual
- * line break must cross the wire as ONE `\n` — with the markdown gap, a
- * GUI draft that looks single-spaced arrived double-spaced in every
- * other window (and vice-versa asymmetry on the way back).
- */
-export interface MarkdownSerializeOptions {
-  /** Emitted after each block. `'\n\n'` = markdown/submit; `'\n'` = draft wire (WYSIWYG). */
-  blockGap?: '\n' | '\n\n';
-}
-
-export function editorJsonToMarkdown(doc: JsonNode, options: MarkdownSerializeOptions = {}): string {
-  const blockGap = options.blockGap ?? '\n\n';
-  const walkInline = (nodes: JsonNode[] | undefined): string => {
-    if (!nodes) return '';
-
-    let out = '';
-
-    for (const node of nodes) {
-      out += renderInline(node);
-    }
-
-    return out;
-  };
-
-  const renderInline = (node: JsonNode): string => {
-    if (node.type === 'text') {
-      const text = node.text ?? '';
-      const markTypes = (node.marks ?? []).map((m) => m.type);
-
-      // Inline code is the only mark we serialize. Bold, italic and strike are
-      // disabled in the StarterKit config (`use-composer-editor.ts`), so they
-      // do not appear in the doc.
-      return markTypes.includes('code') ? `\`${text}\`` : text;
-    }
-
-    if (node.type === 'mention') {
-      return `@${(node.attrs?.id as string) ?? ''}`;
-    }
-
-    if (node.type === 'mentionSkill') {
-      return `/${(node.attrs?.id as string) ?? ''}`;
-    }
-
-    if (node.type === 'mentionChat') {
-      return `#${(node.attrs?.id as string) ?? ''}`;
-    }
-
-    // Extension providers' chips (`mentionExtension<idx>`): their id, as their `renderText` reads.
-    if (node.type?.startsWith('mentionExtension')) {
-      return (node.attrs?.id as string) ?? '';
-    }
-
-    if (node.type === 'hardBreak') {
-      return '\n';
-    }
-
-    return walkInline(node.content);
-  };
-
-  const walkBlock = (node: JsonNode | undefined): string => {
-    if (!node) return '';
-
-    switch (node.type) {
-      case 'doc':
-        return (node.content ?? []).map(walkBlock).join('');
-
-      case 'paragraph':
-        return `${walkInline(node.content)}${blockGap}`;
-
-      case 'codeBlock': {
-        const lang = (node.attrs?.language as string | null | undefined) ?? '';
-        const inner = walkInline(node.content);
-        return `\`\`\`${lang}\n${inner}\n\`\`\`${blockGap}`;
-      }
-
-      case 'blockquote': {
-        const inner = (node.content ?? []).map(walkBlock).join('').trimEnd();
-        const quoted = inner
-          .split('\n')
-          .map((line) => (line.length > 0 ? `> ${line}` : '>'))
-          .join('\n');
-        return `${quoted}${blockGap}`;
-      }
-
-      // List items each end with '\n' already — append only the gap's remainder.
-      case 'bulletList':
-        return `${(node.content ?? []).map((item) => walkListItem(item, '-')).join('')}${blockGap.slice(1)}`;
-
-      case 'orderedList': {
-        const start = (node.attrs?.start as number | undefined) ?? 1;
-        return `${(node.content ?? []).map((item, i) => walkListItem(item, `${start + i}.`)).join('')}${blockGap.slice(1)}`;
-      }
-
-      default:
-        return walkInline(node.content ? [node] : []);
-    }
-  };
-
-  const walkListItem = (item: JsonNode, marker: string): string => {
-    const inner = (item.content ?? []).map(walkBlock).join('').trimEnd();
-    // Indent continuation lines so a paragraph break inside a list item stays nested.
-    const lines = inner.split('\n');
-    const head = lines.shift() ?? '';
-    const tail = lines.map((line) => (line.length > 0 ? `  ${line}` : line)).join('\n');
-    return `${marker} ${head}${tail ? `\n${tail}` : ''}\n`;
-  };
-
-  return walkBlock(doc);
-}