zidane-ui 9.1.1 → 9.1.4

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);
-}