zidane-ui 9.0.4 → 9.1.3

package/src/session/headless/diff-tree.ts

@@ -1,167 +0,0 @@
-/**
- * The Diffs file list as a tree: folders hold their files, a chain of
- * folders with one child folder and no files shares one row
- * (`src/components/panel`), and each folder carries its files' totals so a
- * collapsed one still says what is in it.
- *
- * Folders sort before files, both by name, like the Files tab. The diff
- * column follows `fileOrder` so the files on screen form runs in the tree
- * and stepping walks the tree's order.
- */
-
-/** One changed file, as a diff source lists it. */
-export interface DiffListFile {
-  /** Stable id: the file's path as the diff source knows it (new path for a rename). */
-  key: string;
-  /** Lines added. */
-  added: number;
-  /** Lines removed. */
-  removed: number;
-  /** Old path of a rename. */
-  prevPath?: string;
-}
-
-/** A folder row of the tree. */
-export interface DiffTreeDir {
-  /** A folder. */
-  kind: 'dir';
-  /** Full folder path, the collapse key. */
-  path: string;
-  /** Row label: the folder name, or a merged chain (`src/components`). */
-  name: string;
-  /** Nesting level, 0 at the root. */
-  depth: number;
-  /** Lines added by the files below. */
-  added: number;
-  /** Lines removed by the files below. */
-  removed: number;
-  /** Every file below, for totals and highlighting. */
-  fileKeys: string[];
-  /** Folders, then files, by name. */
-  children: DiffTreeNode[];
-}
-
-/** A file row of the tree. */
-export interface DiffTreeFile {
-  /** A file. */
-  kind: 'file';
-  /** The file's {@link DiffListFile.key}. */
-  key: string;
-  /** Path below the tree root (cwd-relative when the file is inside it). */
-  path: string;
-  /** Row label: the file name. */
-  name: string;
-  /** Nesting level, 0 at the root. */
-  depth: number;
-  /** Lines added. */
-  added: number;
-  /** Lines removed. */
-  removed: number;
-  /** Old path of a rename. */
-  prevPath?: string;
-}
-
-/** A row of the Diffs file tree: a folder or a file. */
-export type DiffTreeNode = DiffTreeDir | DiffTreeFile;
-
-/**
- * `key` relative to `root` when inside it; untouched otherwise.
- *
- * @param root - The session's folder, or `null`.
- * @param key - A file's path.
- */
-export function relativeTo(root: string | null, key: string): string {
-  if (!root || !key.startsWith('/')) return key;
-  const base = root.endsWith('/') ? root : `${root}/`;
-  return key.startsWith(base) ? key.slice(base.length) : key;
-}
-
-/**
- * Builds the tree of the changed files: folders before files, both by name, a
- * chain of single-folder folders merged into one row, totals on each folder.
- *
- * @param files - The changed files.
- * @param root - The session's folder: paths inside it show relative to it.
- */
-export function buildDiffTree(files: readonly DiffListFile[], root: string | null): DiffTreeNode[] {
-  interface Draft {
-    dirs: Map<string, Draft>;
-    files: DiffTreeFile[];
-  }
-  const top: Draft = { dirs: new Map(), files: [] };
-  for (const f of files) {
-    const path = relativeTo(root, f.key);
-    const absolute = path.startsWith('/');
-    const parts = (absolute ? path.slice(1) : path).split('/');
-    const name = parts.pop()!;
-    let at = top;
-    parts.forEach((part, i) => {
-      const seg = i === 0 && absolute ? `/${part}` : part;
-      let next = at.dirs.get(seg);
-      if (!next) {
-        next = { dirs: new Map(), files: [] };
-        at.dirs.set(seg, next);
-      }
-      at = next;
-    });
-    at.files.push({
-      kind: 'file',
-      key: f.key,
-      path,
-      name,
-      depth: 0,
-      added: f.added,
-      removed: f.removed,
-      ...(f.prevPath ? { prevPath: relativeTo(root, f.prevPath) } : {}),
-    });
-  }
-
-  const byName = (a: { name: string }, b: { name: string }) => a.name.localeCompare(b.name);
-  const finish = (draft: Draft, parent: string, depth: number): DiffTreeNode[] => {
-    const dirs: DiffTreeDir[] = [];
-    for (const [seg, sub] of draft.dirs) {
-      // Merge a chain of lone folders into one row.
-      let name = seg;
-      let node = sub;
-      while (node.files.length === 0 && node.dirs.size === 1) {
-        const [childSeg, child] = [...node.dirs][0]!;
-        name = `${name}/${childSeg}`;
-        node = child;
-      }
-      const path = parent ? `${parent}/${name}` : name;
-      const children = finish(node, path, depth + 1);
-      const fileKeys = children.flatMap((c) => (c.kind === 'file' ? [c.key] : c.fileKeys));
-      let added = 0;
-      let removed = 0;
-      for (const c of children) {
-        added += c.added;
-        removed += c.removed;
-      }
-      dirs.push({ kind: 'dir', path, name, depth, added, removed, fileKeys, children });
-    }
-    const leaves = draft.files.map((f) => ({ ...f, depth }));
-    return [...dirs.sort(byName), ...leaves.sort(byName)];
-  };
-  return finish(top, '', 0);
-}
-
-/**
- * Files in tree order, collapsed folders included.
- *
- * @param tree - The tree from {@link buildDiffTree}.
- */
-export function fileOrder(tree: readonly DiffTreeNode[]): DiffTreeFile[] {
-  return tree.flatMap((n) => (n.kind === 'file' ? [n] : fileOrder(n.children)));
-}
-
-/**
- * The rows on screen: a collapsed folder hides what is below it.
- *
- * @param tree - The tree from {@link buildDiffTree}.
- * @param collapsed - Paths of the collapsed folders.
- */
-export function visibleRows(tree: readonly DiffTreeNode[], collapsed: ReadonlySet<string>): DiffTreeNode[] {
-  return tree.flatMap((n) =>
-    n.kind === 'file' || collapsed.has(n.path) ? [n] : [n, ...visibleRows(n.children, collapsed)],
-  );
-}

package/src/session/headless/fixture-host.ts

@@ -1,331 +0,0 @@
-/**
- * A `SessionHost` held in memory, for docs, demos, galleries and an app's own
- * tests: todo lists you can edit, a queue you can add to, edit, push and
- * drop, artifacts you can remove, running work you can cancel, turns you can
- * fork, edit and delete, the details actions, and usage. `control` changes the data from
- * outside, as an agent or another window would.
- */
-import type { QueuedItem, TodoItem, TodoTally } from 'zidane/chat';
-
-import type {
-  QueueAddDelivery,
-  QueuePushDelivery,
-  RunningWorkItem,
-  SessionArtifactRow,
-  SessionHost,
-  SessionTurn,
-  PromptAttachment,
-  TodosSnapshot,
-} from './host';
-import { createArtifactsState, groupArtifactRows } from './artifacts';
-import { createQueueState } from './queue';
-import { createRunningWorkState } from './running-work';
-import { createTodosState } from './todos';
-import type { ProviderUsageSnapshot, UsageRange, UsageSummary } from './usage';
-
-/** A queued entry the fixture holds, with its attachments' bytes. */
-export interface FixtureQueuedEntry {
-  /** The entry's id. */
-  id: string;
-  /** The message text. */
-  text: string;
-  /** Its attachments, with their bytes. */
-  attachments?: PromptAttachment[];
-}
-
-/** What a fixture session host starts with, per session id. */
-export interface SessionFixture {
-  /** The todo list per session. */
-  todos?: Readonly<Record<string, readonly TodoItem[]>>;
-  /** The queued messages per session. */
-  queue?: Readonly<Record<string, readonly FixtureQueuedEntry[]>>;
-  /** The artifacts per session, newest first. */
-  artifacts?: Readonly<Record<string, readonly SessionArtifactRow[]>>;
-  /** An artifact kind's group label. Default: the raw kind. */
-  kindLabel?: (kind: string) => string;
-  /** The running work per session. */
-  work?: Readonly<Record<string, readonly RunningWorkItem[]>>;
-  /** The stored turns per session. */
-  turns?: Readonly<Record<string, readonly SessionTurn[]>>;
-  /** The usage summary per range. Absent: no `usage.summary`. */
-  usage?: Partial<Record<UsageRange, UsageSummary>>;
-  /** The providers' subscription snapshots. Absent: no `usage.providers`. */
-  providerUsage?: readonly ProviderUsageSnapshot[];
-  /** GitHub's API limits. Absent: no `usage.github`. */
-  githubUsage?: readonly ProviderUsageSnapshot[];
-  /** Each session's side chat id, by the parent's id. Absent: no `side`. */
-  sides?: Readonly<Record<string, string>>;
-}
-
-/** Changes a fixture's data from outside and announces it, as the agent or another window would. */
-export interface FixtureSessionControl {
-  /** Replaces a session's todo list. */
-  setTodos(sessionId: string, items: readonly TodoItem[]): void;
-  /** Replaces a session's queue. */
-  setQueue(sessionId: string, entries: readonly FixtureQueuedEntry[]): void;
-  /** Records an artifact (newest first). */
-  recordArtifact(sessionId: string, row: SessionArtifactRow): void;
-  /** Replaces a session's running work. */
-  setWork(sessionId: string, items: readonly RunningWorkItem[]): void;
-}
-
-/** The fixture host: a full `SessionHost` plus its `control`. */
-export interface FixtureSessionHost extends SessionHost {
-  /** Changes the data from outside. */
-  control: FixtureSessionControl;
-}
-
-/**
- * Counts todo items by status.
- *
- * @param items - The todo list.
- */
-export function tallyTodos(items: readonly TodoItem[]): TodoTally {
-  const tally: TodoTally = { pending: 0, in_progress: 0, completed: 0, cancelled: 0 };
-  for (const item of items) tally[item.status]++;
-  return tally;
-}
-
-/**
- * A todo snapshot of a list, as a backend broadcasts it.
- *
- * @param items - The live list.
- * @param archive - The last non-empty list (shown read-only when the live one is empty).
- */
-export function todosSnapshotOf(items: readonly TodoItem[], archive: readonly TodoItem[] = []): TodosSnapshot {
-  return {
-    runId: 'fixture',
-    todos: [...items],
-    archive: [...archive],
-    inProgress: items.find((t) => t.status === 'in_progress') ?? null,
-    tally: tallyTodos(items),
-  };
-}
-
-/**
- * Creates a {@link FixtureSessionHost} over the fixture's data.
- *
- * @param fixture - The data per session.
- */
-export function createFixtureSessionHost(fixture: SessionFixture = {}): FixtureSessionHost {
-  const todoLists = new Map(Object.entries(fixture.todos ?? {}).map(([id, items]) => [id, [...items]]));
-  const archives = new Map<string, TodoItem[]>();
-  const queues = new Map(Object.entries(fixture.queue ?? {}).map(([id, entries]) => [id, [...entries]]));
-  const artifacts = new Map(Object.entries(fixture.artifacts ?? {}).map(([id, rows]) => [id, [...rows]]));
-  const work = new Map(Object.entries(fixture.work ?? {}).map(([id, list]) => [id, [...list]]));
-  const turnLists = new Map(Object.entries(fixture.turns ?? {}).map(([id, list]) => [id, [...list]]));
-  let nextId = 0;
-  const workState = createRunningWorkState(async (sessionId) => work.get(sessionId) ?? []);
-  const writeWork = (sessionId: string, items: readonly RunningWorkItem[]) => {
-    work.set(sessionId, [...items]);
-    workState.push(sessionId, items);
-  };
-  const turnsOf = (sessionId: string) => turnLists.get(sessionId) ?? [];
-  const { usage: summaries, providerUsage, githubUsage } = fixture;
-  const sides = fixture.sides ? new Map(Object.entries(fixture.sides)) : null;
-  let sideSeq = 0;
-
-  const snapshotOf = (sessionId: string): TodosSnapshot | null => {
-    const items = todoLists.get(sessionId);
-    return items ? todosSnapshotOf(items, archives.get(sessionId)) : null;
-  };
-  const items = (sessionId: string): QueuedItem[] =>
-    (queues.get(sessionId) ?? []).map((e) => ({
-      id: e.id,
-      text: e.text,
-      ...(e.attachments?.length
-        ? { attachments: e.attachments.map((a) => ({ mediaType: a.mediaType, ...(a.name ? { name: a.name } : {}) })) }
-        : {}),
-    }));
-
-  const todos = createTodosState(async (sessionId) => snapshotOf(sessionId));
-  const writeTodos = (sessionId: string, next: readonly TodoItem[]) => {
-    const prev = todoLists.get(sessionId) ?? [];
-    if (next.length === 0 && prev.length > 0) archives.set(sessionId, prev);
-    todoLists.set(sessionId, [...next]);
-    todos.push(sessionId, snapshotOf(sessionId)!);
-  };
-
-  const writeQueue = (sessionId: string, entries: FixtureQueuedEntry[]) => {
-    queues.set(sessionId, entries);
-    queue.replace(sessionId, items(sessionId));
-  };
-  const queue = createQueueState({
-    list: async (sessionId) => items(sessionId),
-    async remove(sessionId, id) {
-      writeQueue(
-        sessionId,
-        (queues.get(sessionId) ?? []).filter((e) => e.id !== id),
-      );
-    },
-    async update(sessionId, id, text, attachments) {
-      writeQueue(
-        sessionId,
-        (queues.get(sessionId) ?? []).map((e) =>
-          e.id === id
-            ? {
-                id,
-                text,
-                ...((attachments ?? e.attachments)?.length ? { attachments: attachments ?? e.attachments } : {}),
-              }
-            : e,
-        ),
-      );
-    },
-  });
-
-  const artifactsState = createArtifactsState(async (sessionId) =>
-    groupArtifactRows(artifacts.get(sessionId) ?? [], fixture.kindLabel),
-  );
-
-  return {
-    todos: {
-      snapshot: todos.snapshot,
-      refresh: todos.refresh,
-      async set(sessionId, next) {
-        writeTodos(sessionId, next);
-        return true;
-      },
-      async retry() {},
-    },
-    queue: {
-      items: queue.items,
-      refresh: queue.refresh,
-      async add(sessionId, text, options): Promise<QueueAddDelivery> {
-        const entry: FixtureQueuedEntry = {
-          id: `fixture-q${++nextId}`,
-          text,
-          ...(options?.attachments?.length ? { attachments: options.attachments } : {}),
-        };
-        writeQueue(sessionId, [...(queues.get(sessionId) ?? []), entry]);
-        return 'queued';
-      },
-      remove: queue.drop,
-      update: queue.edit,
-      async attachments(sessionId, id) {
-        const entry = queues.get(sessionId)?.find((e) => e.id === id);
-        return entry ? [...(entry.attachments ?? [])] : null;
-      },
-      async pushNow(sessionId, id): Promise<QueuePushDelivery> {
-        const entries = queues.get(sessionId) ?? [];
-        if (!entries.some((e) => e.id === id)) return 'missing';
-        writeQueue(
-          sessionId,
-          entries.filter((e) => e.id !== id),
-        );
-        return 'send';
-      },
-    },
-    artifacts: {
-      groups: artifactsState.groups,
-      refresh: artifactsState.refresh,
-      async remove(sessionId, artifactId) {
-        artifacts.set(
-          sessionId,
-          (artifacts.get(sessionId) ?? []).filter((r) => r.artifact.id !== artifactId),
-        );
-        artifactsState.wake(sessionId);
-        return true;
-      },
-      async refreshRow() {},
-    },
-    runningWork: {
-      items: workState.items,
-      refresh: workState.refresh,
-      ensure: workState.ensure,
-      async cancel(sessionId, id) {
-        const before = work.get(sessionId) ?? [];
-        const after = id === 'all' ? [] : before.filter((item) => item.id !== id);
-        writeWork(sessionId, after);
-        return after.length < before.length;
-      },
-    },
-    turns: {
-      get: async (sessionId, turnId) => turnsOf(sessionId).find((t) => t.id === turnId) ?? null,
-      async fork(sessionId, turnId) {
-        const list = turnsOf(sessionId);
-        const id = `fixture-fork-${++nextId}`;
-        turnLists.set(id, list.slice(0, list.findIndex((t) => t.id === turnId) + 1));
-        return id;
-      },
-      async editText(sessionId, turnId, text) {
-        turnLists.set(
-          sessionId,
-          turnsOf(sessionId).map((t) =>
-            t.id === turnId
-              ? { ...t, content: [...t.content.filter((b) => b.type !== 'text'), { type: 'text', text }] }
-              : t,
-          ),
-        );
-      },
-      async delete(sessionId, turnId) {
-        turnLists.set(
-          sessionId,
-          turnsOf(sessionId).filter((t) => t.id !== turnId),
-        );
-      },
-    },
-    details: {
-      titleStatus: async () => ['manual'],
-      generateTitle: async () => 'Archive old sessions',
-      export: async (sessionId, format) => `/tmp/${sessionId}.${format === 'markdown' ? 'md' : 'json'}`,
-      async compact() {},
-      async setFolder() {},
-      cacheReport: async () => ({
-        rows: [
-          { turn: 1, promptTokens: 12_400, cachedPct: 0, rereadTokens: 0, ttftMs: 820 },
-          { turn: 2, promptTokens: 13_100, cachedPct: 94.2, rereadTokens: 0, ttftMs: 410 },
-          { turn: 3, promptTokens: 48_900, cachedPct: 26.3, rereadTokens: 35_000, ttftMs: 1_350 },
-        ],
-        totalRequests: 3,
-        uncachedPct: 52.1,
-        breaks: 1,
-        expiresAt: null,
-      }),
-    },
-    ...(summaries || providerUsage || githubUsage
-      ? {
-          usage: {
-            ...(summaries
-              ? {
-                  async summary(range: UsageRange) {
-                    const summary = summaries[range];
-                    if (!summary) throw new Error(`No usage summary for ${range}`);
-                    return summary;
-                  },
-                }
-              : {}),
-            ...(providerUsage ? { providers: async () => providerUsage } : {}),
-            ...(githubUsage ? { github: async () => githubUsage } : {}),
-          },
-        }
-      : {}),
-    ...(sides
-      ? {
-          side: {
-            lookup: async (parentId: string) => ({
-              side: sides.has(parentId) ? { id: sides.get(parentId)! } : null,
-              parent: { id: parentId },
-            }),
-            async create(parentId: string) {
-              const id = `side-${parentId}-${++sideSeq}`;
-              sides.set(parentId, id);
-              return { id };
-            },
-            async remove(sideId: string) {
-              for (const [parentId, id] of sides) if (id === sideId) sides.delete(parentId);
-            },
-          },
-        }
-      : {}),
-    control: {
-      setWork: writeWork,
-      setTodos: writeTodos,
-      setQueue: (sessionId, entries) => writeQueue(sessionId, [...entries]),
-      recordArtifact(sessionId, row) {
-        artifacts.set(sessionId, [row, ...(artifacts.get(sessionId) ?? [])]);
-        artifactsState.wake(sessionId);
-      },
-    },
-  };
-}