zidane-ui 9.1.1 → 9.1.4

package/src/terminal/headless/links.ts

@@ -1,227 +0,0 @@
-/**
- * Terminal links. The terminal library finds OSC 8 hyperlinks and URLs
- * with a scheme and hands them to `linkTarget`; `detectLinks` covers what
- * it can't know: scheme-less local servers (`localhost:5173`) and file
- * paths with an optional position. Pure: works on the line's text; the
- * surface maps string indices back to cells.
- */
-function basename(path: string): string {
-  const trimmed = path.replace(/[/\\]+$/, '');
-  const idx = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
-  return idx === -1 ? trimmed : trimmed.slice(idx + 1);
-}
-
-export type TerminalLink =
-  | { kind: 'url'; start: number; end: number; text: string; url: string }
-  | { kind: 'file'; start: number; end: number; text: string; path: string; line?: number; column?: number };
-
-const URL_RE = /\bhttps?:\/\/[^\s"'<>`]+/g;
-const LOCAL_RE = /(?<![\w./:@-])(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]):\d{2,5}(?:\/[^\s"'<>`]*)?/g;
-/*
- * A path: optional `./`, `../`, `/` or `~/` lead, segments of word chars,
- * dots, `@`, `+`, `-`; then an optional position as `:12`, `:12:5` or
- * `(12,5)` (tsc).
- */
-const PATH_RE =
-  /(?<![\w./@+~-])((?:\.{1,2}\/|~\/|\/)?(?:[\w.@+-]+\/)*[\w.@+-]+)(?::(\d+)(?::(\d+))?|\((\d+),(\d+)\))?/g;
-
-/** Extensions that make a bare name (no slash, no position) read as a file. */
-const FILE_EXTENSIONS = new Set(
-  (
-    'ts tsx js jsx mjs cjs mts cts json jsonc md mdx py rs go rb java kt kts swift c h cc cpp hpp cs css scss sass less ' +
-    'html htm vue svelte astro yml yaml toml lock sh bash zsh fish txt sql graphql gql proto xml ini env conf cfg ' +
-    'php ex exs erl hs ml zig nim lua dart scala clj r jl tf'
-  ).split(' '),
-);
-
-/** Trailing characters that end a sentence rather than an address. */
-function trimTrailing(text: string): string {
-  let out = text.replace(/[.,;:!?'"]+$/, '');
-  // A closing bracket belongs to the address only when it opened one.
-  for (const [open, close] of [
-    ['(', ')'],
-    ['[', ']'],
-    ['{', '}'],
-  ] as const) {
-    while (out.endsWith(close) && count(out, open) < count(out, close)) {
-      out = out.slice(0, -1).replace(/[.,;:!?'"]+$/, '');
-    }
-  }
-  return out;
-}
-
-function count(s: string, ch: string): number {
-  let n = 0;
-  for (const c of s) if (c === ch) n++;
-  return n;
-}
-
-function overlaps(taken: readonly TerminalLink[], start: number, end: number): boolean {
-  return taken.some((l) => start < l.end && end > l.start);
-}
-
-/**
- * Links on one line. URLs with a scheme are only used to keep paths out of
- * them (`https://x.dev/a/b.ts` is not a path): the library links those
- * itself, so they are not returned.
- */
-export function detectLinks(line: string): TerminalLink[] {
-  const out: TerminalLink[] = [];
-  const schemeUrls: TerminalLink[] = [];
-
-  for (const m of line.matchAll(URL_RE)) {
-    const text = trimTrailing(m[0]);
-    if (text.length <= 'https://'.length) continue;
-    schemeUrls.push({ kind: 'url', start: m.index, end: m.index + text.length, text, url: text });
-  }
-  const taken = () => [...schemeUrls, ...out];
-
-  for (const m of line.matchAll(LOCAL_RE)) {
-    const text = trimTrailing(m[0]);
-    const end = m.index + text.length;
-    if (overlaps(taken(), m.index, end)) continue;
-    out.push({ kind: 'url', start: m.index, end, text, url: `http://${text}` });
-  }
-
-  for (const m of line.matchAll(PATH_RE)) {
-    const raw = m[1];
-    const path = raw.replace(/[.,;:!?]+$/, '');
-    if (!path || !isPathLike(path, Boolean(m[2] || m[4]))) continue;
-    const hasPosition = path === raw && Boolean(m[2] || m[4]);
-    const text = hasPosition ? m[0] : path;
-    const end = m.index + text.length;
-    if (overlaps(taken(), m.index, end)) continue;
-    const line = hasPosition ? Number(m[2] ?? m[4]) : undefined;
-    const column = hasPosition && (m[3] ?? m[5]) ? Number(m[3] ?? m[5]) : undefined;
-    out.push({
-      kind: 'file',
-      start: m.index,
-      end,
-      text,
-      path,
-      ...(line !== undefined ? { line } : {}),
-      ...(column !== undefined ? { column } : {}),
-    });
-  }
-
-  return out.sort((a, b) => a.start - b.start);
-}
-
-function isPathLike(path: string, hasPosition: boolean): boolean {
-  if (/^\.+$/.test(path) || path === '/' || path === '~/') return false;
-  // Version numbers, IPs, times: all digits and dots.
-  if (/^[\d.]+$/.test(path.replace(/^\/+/, ''))) return false;
-  const base = basename(path);
-  const dot = base.lastIndexOf('.');
-  const ext = dot > 0 ? base.slice(dot + 1).toLowerCase() : '';
-  if (path.includes('/')) {
-    // `a/b` alone is too ambiguous (dates, fractions, "and/or"); a lead or an extension settles it.
-    return /^(?:\.{1,2}\/|~\/|\/)/.test(path) || /^[a-z][a-z0-9]*$/.test(ext) || hasPosition;
-  }
-  if (!ext) return false;
-  return FILE_EXTENSIONS.has(ext) || (hasPosition && /^[a-z][a-z0-9]*$/.test(ext));
-}
-
-/** Where a link the terminal library found (an OSC 8 hyperlink or a URL) should go. */
-export type LinkTarget =
-  | { kind: 'web'; url: string }
-  | { kind: 'file'; path: string; line?: number; column?: number }
-  | { kind: 'external'; url: string };
-
-/**
- * Classify a link from the terminal library: web pages (Browser tab),
- * `file://` hyperlinks (`ls --hyperlink`, compilers: Files panel, with an
- * optional `:line:col` or `#L12`), `mailto:` (the system, on request; the
- * main window's open handler allows only http(s) and mailto). `null` for
- * everything else (`javascript:`, `data:`, other schemes, unparsable).
- */
-export function linkTarget(uri: string): LinkTarget | null {
-  let url: URL;
-  try {
-    url = new URL(uri);
-  } catch {
-    return null;
-  }
-  switch (url.protocol) {
-    case 'http:':
-    case 'https:':
-      return { kind: 'web', url: url.href };
-    case 'file:': {
-      let path: string;
-      try {
-        path = decodeURIComponent(url.pathname);
-      } catch {
-        return null;
-      }
-      let line: number | undefined;
-      let column: number | undefined;
-      const hash = /^#L(\d+)(?:C(\d+))?$/i.exec(url.hash);
-      const suffix = /:(\d+)(?::(\d+))?$/.exec(path);
-      if (hash) {
-        line = Number(hash[1]);
-        if (hash[2]) column = Number(hash[2]);
-      } else if (suffix) {
-        path = path.slice(0, suffix.index);
-        line = Number(suffix[1]);
-        if (suffix[2]) column = Number(suffix[2]);
-      }
-      if (!path.startsWith('/')) return null;
-      return {
-        kind: 'file',
-        path,
-        ...(line !== undefined ? { line } : {}),
-        ...(column !== undefined ? { column } : {}),
-      };
-    }
-    case 'mailto:':
-      return { kind: 'external', url: url.href };
-    default:
-      return null;
-  }
-}
-
-/**
- * Absolute form of a path printed in a terminal whose shell is in `cwd`.
- * `~` needs the home directory; without one such paths are not resolved.
- */
-export function resolveTerminalPath(path: string, cwd: string, home?: string): string | null {
-  let abs: string;
-  if (path.startsWith('/')) abs = path;
-  else if (path.startsWith('~/')) {
-    if (!home) return null;
-    abs = `${home.replace(/\/+$/, '')}/${path.slice(2)}`;
-  } else {
-    if (!cwd) return null;
-    abs = `${cwd.replace(/\/+$/, '')}/${path}`;
-  }
-  const parts: string[] = [];
-  for (const part of abs.split('/')) {
-    if (!part || part === '.') continue;
-    if (part === '..') parts.pop();
-    else parts.push(part);
-  }
-  return `/${parts.join('/')}`;
-}
-
-const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '0.0.0.0', '[::1]']);
-
-/**
- * A server session's terminal runs on the server: a loopback address it
- * prints (`localhost:5173`) is the server's, and opening it here would reach
- * this computer instead. The tooltip saying so (`describe`, from the labels), or `null`
- * when the link is fine to open (any other address, or a terminal on this computer).
- */
-export function serverOnlyLink(
-  url: string,
-  serverName: string | null,
-  describe: (serverName: string) => string,
-): string | null {
-  if (!serverName) return null;
-  let host: string;
-  try {
-    host = new URL(url).hostname;
-  } catch {
-    return null;
-  }
-  return LOOPBACK_HOSTS.has(host) || host.endsWith('.localhost') ? describe(serverName) : null;
-}

package/src/terminal/headless/order.ts

@@ -1,28 +0,0 @@
-/**
- * The user's order for a session's terminal tabs (`session-layout`:
- * `terminalOrder`). The host lists terminals in creation order; the strip
- * shows them in the order the user dragged them to. Ids the order does not
- * know yet (a terminal opened since, one the agent started) follow in the
- * host's order, so a new terminal lands at the end; ids of closed terminals
- * are ignored.
- */
-import { moveTab } from 'zidane/chat/pure';
-
-export function orderTerminals<T extends { id: string }>(terminals: readonly T[], order: readonly string[]): T[] {
-  if (order.length === 0) return [...terminals];
-  const rank = new Map(order.map((id, i) => [id, i]));
-  const known = terminals.filter((t) => rank.has(t.id)).sort((a, b) => rank.get(a.id)! - rank.get(b.id)!);
-  return [...known, ...terminals.filter((t) => !rank.has(t.id))];
-}
-
-/** A new order for the shown tabs, written into the full one: tabs left out (the agent's, hidden) keep their slots. */
-export function mergeShownOrder(all: readonly string[], shown: readonly string[]): string[] {
-  const moved = new Set(shown);
-  const next = [...shown];
-  return all.map((id) => (moved.has(id) ? next.shift()! : id));
-}
-
-/** Move one tab `delta` slots (keyboard reorder), clamped at the ends. */
-export function moveTerminal(shown: readonly string[], id: string, delta: number): readonly string[] {
-  return moveTab(shown, shown, id, delta);
-}

package/src/terminal/headless/output-cursor.ts

@@ -1,66 +0,0 @@
-/**
- * Where a terminal view is in the host's output stream, and what to do
- * with the next chunk. Pure so the drop / overlap / gap rules are tested
- * without a terminal.
- *
- * Offsets are character counts from the start of the terminal's output.
- * A chunk starting at `offset` may repeat what the view already has (it
- * was in flight while the view attached): the repeated head is sliced off.
- * A chunk starting past the view's position means output went missing,
- * which the protocol does not produce; the view re-attaches.
- */
-
-import { modePrefixLength } from 'zidane/chat/pure';
-
-export type ChunkPlan =
-  /** Everything in it was already written. */
-  | { kind: 'drop' }
-  /** Output is missing before it: re-attach. */
-  | { kind: 'gap' }
-  /** Write `data` and move to `next`. */
-  | { kind: 'write'; data: string; next: number };
-
-export function planChunk(pos: number, offset: number, data: string): ChunkPlan {
-  const end = offset + data.length;
-  if (end <= pos) return { kind: 'drop' };
-  if (offset > pos) return { kind: 'gap' };
-  return { kind: 'write', data: offset < pos ? data.slice(pos - offset) : data, next: end };
-}
-
-export type ResetPlan =
-  /** Output the view lacks, then the rest: an ordinary chunk at `offset`. */
-  | { kind: 'append'; offset: number; data: string }
-  /** Start over from the snapshot. */
-  | { kind: 'replace' };
-
-/**
- * A reset (the host's capped history, after a client stalled) that overlaps
- * what the view already has only extends it: offsets name the same output,
- * so the view appends what it lacks and keeps its scrollback. The snapshot
- * starts with the modes in force at its cut, which are not output: overlap
- * is judged on what follows them. A view with nothing drawn (`fresh`) or
- * with a gap before the snapshot starts over.
- */
-export function planReset(fresh: boolean, pos: number, offset: number, data: string): ResetPlan {
-  if (fresh) return { kind: 'replace' };
-  const output = data.slice(modePrefixLength(data));
-  const start = offset - output.length;
-  return start <= pos && pos <= offset ? { kind: 'append', offset: start, data: output } : { kind: 'replace' };
-}
-
-/** Acks at most every `ACK_EVERY_MS`, or sooner once `ACK_EVERY_CHARS` piled up. */
-export const ACK_EVERY_MS = 50;
-export const ACK_EVERY_CHARS = 32 * 1024;
-
-export interface AckState {
-  /** Last offset acknowledged. */
-  acked: number;
-  /** When it was sent (ms). */
-  at: number;
-}
-
-/** Whether to acknowledge `pos` now; `false` leaves it for the trailing timer. */
-export function shouldAck(state: AckState, pos: number, now: number): boolean {
-  if (pos <= state.acked) return false;
-  return pos - state.acked >= ACK_EVERY_CHARS || now - state.at >= ACK_EVERY_MS;
-}

package/src/terminal/headless/recent.ts

@@ -1,20 +0,0 @@
-/**
- * The terminal views a placement keeps mounted: the ones shown most
- * recently. Switching back to one is instant; an older one unmounts (its
- * canvas and scrollback go) and replays its history when shown again.
- */
-
-/** Views a placement keeps mounted, the shown one included. */
-export const MAX_MOUNTED_VIEWS = 3;
-
-/**
- * The terminals shown most recently, newest last, after `id` is shown:
- * at most {@link MAX_MOUNTED_VIEWS}, only those still `live`.
- *
- * @param recent - The list so far, newest last.
- * @param id - The terminal shown now.
- * @param live - The scope's terminals: a closed one leaves the list.
- */
-export function showRecent(recent: readonly string[], id: string, live: ReadonlySet<string>): readonly string[] {
-  return [...recent.filter((r) => r !== id && live.has(r)), id].slice(-MAX_MOUNTED_VIEWS);
-}

package/src/terminal/headless/replay.ts

@@ -1,45 +0,0 @@
-/**
- * Time-boxed feeding for a terminal view: a history replay or a big batch
- * of live output is parsed in slices, with turns for the event loop in
- * between, so the renderer never blocks on one long write. What is kept and
- * replayed (`OutputHistory`) is the core's (`zidane/chat/pure`): the host
- * cuts its snapshots with the same rules.
- */
-import { sliceEnd } from 'zidane/chat/pure';
-
-/**
- * Writes `text` from `from` in slices of at most `size` chars (never
- * between surrogate halves) until it is all written or `deadline` (in
- * `now()` time) has passed. Returns where it stopped.
- */
-export function feedSlices(
-  text: string,
-  from: number,
-  size: number,
-  deadline: number,
-  write: (slice: string, end: number) => void,
-  now: () => number = () => performance.now(),
-): number {
-  let i = from;
-  while (i < text.length && now() < deadline) {
-    const end = sliceEnd(text, i, size);
-    write(text.slice(i, end), end);
-    i = end;
-  }
-  return i;
-}
-
-/** Gives the event loop a turn (input, paint) between slices of a long job. */
-export function yieldToEventLoop(): Promise<void> {
-  const scheduler = (globalThis as { scheduler?: { yield?: () => Promise<void> } }).scheduler;
-  if (scheduler?.yield) return scheduler.yield();
-  // A message task, unlike a nested setTimeout(0), is not clamped to 4 ms.
-  return new Promise((resolve) => {
-    const channel = new MessageChannel();
-    channel.port1.onmessage = () => {
-      channel.port1.close();
-      resolve();
-    };
-    channel.port2.postMessage(null);
-  });
-}

package/src/terminal/headless/scope.ts

@@ -1,60 +0,0 @@
-/**
- * Whose terminals: a session's (run in its environment), or without one a
- * folder's on the host's machine, optionally a new-chat draft's (they move
- * into the session the draft becomes). The desktop app's `Scope` has this
- * shape, so it passes its own.
- */
-
-/** Whose terminals a store entry, a drawer or a panel shows. */
-export interface TerminalScope {
-  /** The project root: a scope without session or draft is keyed by it. */
-  root: string;
-  /** Where a terminal without session opens. */
-  cwd: string;
-  /** The session the terminals are a session's. */
-  session?: string;
-  /** The new-chat draft (never together with `session`). */
-  draft?: string;
-}
-
-const DRAFT_PREFIX = 'draft:';
-const PROJECT_PREFIX = 'project:';
-
-/**
- * A scope's identity: the session id when bound, else `draft:<id>` or
- * `project:<root>` (a session id never starts with either).
- *
- * @param scope - The scope.
- */
-export function terminalScopeKey(scope: TerminalScope): string {
-  if (scope.session) return scope.session;
-  if (scope.draft) return `${DRAFT_PREFIX}${scope.draft}`;
-  return `${PROJECT_PREFIX}${scope.root}`;
-}
-
-/**
- * The key of a project's or a draft's list, as the host names it (`root`, `draftId`).
- *
- * @param signal - The project root and the draft, if any.
- */
-export function terminalProjectKey(signal: { root: string; draftId?: string }): string {
-  return terminalScopeKey({
-    root: signal.root,
-    cwd: signal.root,
-    ...(signal.draftId ? { draft: signal.draftId } : {}),
-  });
-}
-
-/**
- * The scope a key names when nothing better is known (a reload after a signal from an unknown scope).
- *
- * @param key - A `terminalScopeKey`.
- */
-export function scopeOfTerminalKey(key: string): TerminalScope {
-  if (key.startsWith(DRAFT_PREFIX)) return { root: '', cwd: '', draft: key.slice(DRAFT_PREFIX.length) };
-  if (key.startsWith(PROJECT_PREFIX)) {
-    const root = key.slice(PROJECT_PREFIX.length);
-    return { root, cwd: root };
-  }
-  return { root: '', cwd: '', session: key };
-}