zidane-ui 9.0.4 → 9.1.3

package/src/chat/headless/composer/ghost-autocomplete.ts

@@ -1,381 +0,0 @@
-/**
- * Inline (ghost-text) autocomplete for the rich composer: the pure
- * trigger/accept/dismiss state machine. TUI parity throughout; every
- * semantic cites its source in `src/tui/prompt/`. The provider engine runs
- * host-side (`ComposerHost.autocomplete`); the ProseMirror decoration plugin
- * and the editor's text/caret mapping are `chat/rich-composer/ghost-plugin.ts`.
- */
-import type { InlineGhost } from 'zidane/chat/pure';
-
-/** Debounce between an edit and the provider query — TUI parity (`INLINE_GHOST_DEBOUNCE_MS`, src/tui/prompt/use-inline-ghost-query.ts). */
-export const GHOST_DEBOUNCE_MS = 120;
-
-export type GhostComposerMode = 'normal' | 'shell' | 'search';
-
-export interface GhostGate {
-  /** The `inlineAutocomplete` setting (live). */
-  enabled: boolean;
-  /** Full plain-text buffer + caret offset (see `plainTextWithCursor`). */
-  text: string;
-  cursor: number;
-  /** Any mention/slash popover open — the popover owns Tab and ↑/↓ (TUI `useInlineGhostQuery`). */
-  popoverOpen: boolean;
-  /** Composer prompt mode — shell (`!`) and search (`?`) suppress (TUI `useInlineGhostQuery`). */
-  mode: GhostComposerMode;
-  /** Prompt-history recall in flight — browsing must not pop ghosts. */
-  historyRecall: boolean;
-  /** IME composition — never ghost mid-composition. */
-  composing: boolean;
-}
-
-/**
- * Should this buffer state trigger a provider query? Mirrors the TUI's
- * trigger effect gate (`useInlineGhostQuery`,
- * src/tui/prompt/use-inline-ghost-query.ts): setting on, no popover, no
- * shell/search mode, non-empty buffer, and the caret at a WORD BOUNDARY
- * (end of buffer, or the next character is whitespace) — completing
- * mid-word would suggest garbage for the token ENDING at the cursor.
- */
-export function ghostQueryAllowed(gate: GhostGate): boolean {
-  if (!gate.enabled || gate.popoverOpen || gate.mode !== 'normal' || gate.historyRecall || gate.composing) {
-    return false;
-  }
-
-  if (gate.text.length === 0) {
-    return false;
-  }
-
-  return gate.cursor === gate.text.length || /\s/.test(gate.text[gate.cursor]);
-}
-
-/**
- * Does the mention/slash popover own the keys (and therefore suppress
- * the ghost)? TUI parity (`PromptBlock`, src/tui/prompt/prompt-block.tsx):
- * `popupOpen` is true only
- * while the completion is active AND actually SHOWS items — an active
- * suggestion with zero matches leaves the gate open, so extension
- * providers (e.g. an LLM completing arbitrary prose) still ghost while
- * the user types an `@`/`#`-prefixed token with no popover matches.
- */
-export function mentionPopoverActive(itemCount: number): boolean {
-  return itemCount > 0;
-}
-
-/**
- * Single-row ghost — keep the first line of each candidate, drop empties
- * (TUI `useInlineGhostQuery`).
- */
-export function firstLineSuffixes(suffixes: readonly string[]): string[] {
-  return suffixes.map((s) => s.split('\n')[0]).filter((s) => s.length > 0);
-}
-
-/** A next-prompt suggestion (`Settings.promptSuggestions`) on offer for the empty composer. */
-export interface PromptGhostOffer {
-  /** `sessionId:runId` — one suggestion, for the dismissal memory and the counters. */
-  key: string;
-  text: string;
-}
-
-/**
- * The suggestion the empty composer may show, or null: the setting is on, no
- * run is going, the suggestion belongs to the composer's session (the store is
- * per session) and Escape hasn't dismissed it. Only its first line is kept.
- */
-export function promptGhostOffer(input: {
-  enabled: boolean;
-  running: boolean;
-  sessionId: string | null;
-  suggestion: { runId: string; text: string } | null;
-  dismissedKey: string | null;
-}): PromptGhostOffer | null {
-  const { enabled, running, sessionId, suggestion, dismissedKey } = input;
-
-  if (!enabled || running || !sessionId || !suggestion) {
-    return null;
-  }
-
-  const text = suggestion.text.split('\n')[0].trim();
-  const key = `${sessionId}:${suggestion.runId}`;
-
-  return text.length > 0 && key !== dismissedKey ? { key, text } : null;
-}
-
-/** The empty-buffer suggestion shows only on an empty doc in normal mode, no popover, no IME. */
-export function promptGhostAllowed(gate: GhostGate): boolean {
-  return gate.text.length === 0 && !gate.popoverOpen && gate.mode === 'normal' && !gate.composing;
-}
-
-export type GhostKeyAction =
-  /** Insert `insert` at the caret and clear the ghost (consume the key). */
-  | { type: 'accept'; insert: string }
-  /** Rotate to candidate `index` (consume the key). */
-  | { type: 'rotate'; index: number }
-  /**
-   * Clear the ghost. `consume: false` lets the key fall through to its
-   * normal behavior (caret movement, Esc reaching other handlers) —
-   * exactly the TUI's non-preventDefault dismissals.
-   */
-  | { type: 'dismiss'; consume: boolean; forSuggestion?: true }
-  | { type: 'none' };
-
-/**
- * Pure caret-movement keys — these move the caret WITHOUT a content
- * change, so the ghost must drop instead of dangling at the old caret
- * (TUI `handleInlineGhostKey`). `ArrowUp`/`ArrowDown` are handled by the
- * rotate branch first; they land here only with a single candidate.
- */
-const MOVEMENT_KEYS = new Set(['ArrowLeft', 'ArrowRight', 'Home', 'End', 'PageUp', 'PageDown', 'ArrowUp', 'ArrowDown']);
-
-/**
- * Keydown resolution while a ghost is visible — TUI parity
- * (`handleInlineGhostKey`, src/tui/prompt/prompt-key-handlers.ts):
- *   - modifier chords are never ghost keys;
- *   - Tab accepts, but only when the live buffer still matches the
- *     ghost's snapshot — a race with fast typing can never insert a
- *     stale suffix;
- *   - ↑/↓ rotate when there is more than one candidate;
- *   - Esc dismisses WITHOUT consuming — other Esc semantics still run;
- *   - pure movement keys dismiss without consuming;
- *   - everything else (typing) passes through — the transaction
- *     reconciliation handles it blink-free.
- *
- * A next-prompt suggestion (`opts.prompt`, empty buffer) differs: → with the
- * caret at the end accepts too, Esc dismisses it for good (`forSuggestion`),
- * and every other key passes through so ↑ still recalls history.
- */
-export function ghostKeyAction(
-  ghost: InlineGhost | null,
-  event: { key: string; ctrlKey: boolean; metaKey: boolean; altKey: boolean; shiftKey: boolean },
-  live: { text: string; cursor: number },
-  opts: { prompt?: boolean } = {},
-): GhostKeyAction {
-  if (!ghost) {
-    return { type: 'none' };
-  }
-
-  if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey) {
-    return { type: 'none' };
-  }
-
-  const snapshotMatches = live.text === ghost.text && live.cursor === ghost.cursor;
-
-  if (opts.prompt) {
-    const atEnd = live.cursor === live.text.length;
-
-    if (snapshotMatches && (event.key === 'Tab' || (event.key === 'ArrowRight' && atEnd))) {
-      return { type: 'accept', insert: ghost.suffixes[ghost.index] };
-    }
-
-    if (event.key === 'Escape') {
-      return { type: 'dismiss', consume: false, forSuggestion: true };
-    }
-
-    return { type: 'none' };
-  }
-
-  if (event.key === 'Tab') {
-    if (!snapshotMatches) {
-      // Stale ghost: drop it and let Tab do whatever it normally does —
-      // never insert a suffix for a buffer that moved on.
-      return { type: 'dismiss', consume: false };
-    }
-
-    return { type: 'accept', insert: ghost.suffixes[ghost.index] };
-  }
-
-  if ((event.key === 'ArrowUp' || event.key === 'ArrowDown') && ghost.suffixes.length > 1) {
-    const delta = event.key === 'ArrowDown' ? 1 : -1;
-
-    return { type: 'rotate', index: (ghost.index + delta + ghost.suffixes.length) % ghost.suffixes.length };
-  }
-
-  if (event.key === 'Escape') {
-    return { type: 'dismiss', consume: false };
-  }
-
-  if (MOVEMENT_KEYS.has(event.key)) {
-    return { type: 'dismiss', consume: false };
-  }
-
-  return { type: 'none' };
-}
-
-// ---------------------------------------------------------------------------
-// Query controller
-// ---------------------------------------------------------------------------
-
-export interface GhostControllerHost {
-  /** Live gate snapshot — buffer, caret, and every suppression flag. */
-  gate(): GhostGate;
-  /** Resolve suffix candidates for the snapshot (the IPC round trip). */
-  query(text: string, cursor: number): Promise<readonly string[] | null | undefined>;
-  /**
-   * Reply-time recheck: the live buffer still matches the queried
-   * snapshot and no gate flag flipped during the round trip. A `false`
-   * drops the reply without painting.
-   */
-  confirm(text: string, cursor: number): boolean;
-  /** Paint (or clear) the ghost; `prompt` is set when it is the empty-buffer next-prompt suggestion. */
-  apply(ghost: InlineGhost | null, prompt?: PromptGhostOffer): void;
-  /** The next-prompt suggestion on offer (see {@link promptGhostOffer}); an empty buffer shows it without a query. */
-  promptSuggestion?(): PromptGhostOffer | null;
-  debounceMs?: number;
-}
-
-export interface GhostController {
-  /**
-   * Re-evaluate the gate NOW and query/dismiss accordingly. Edits AND
-   * edit-less gate transitions both land here — TUI parity: the trigger
-   * effect re-runs on every gate dependency (`useInlineGhostQuery`), so a
-   * popover closing on Esc, a shell/search mode exiting with the buffer
-   * kept, or the setting flipping on all re-query WITHOUT a keystroke
-   * (and a gate closing dismisses the ghost immediately).
-   */
-  reevaluate(): void;
-  /** Drop any pending query; a stale in-flight reply is discarded. */
-  cancel(): void;
-  /**
-   * A local query is pending — debounce timer armed or an IPC round
-   * trip in flight whose reply will still be honored. The remote-mirror
-   * path uses this as the "active typist" test: a daemon-fanned
-   * suggestion is only applied when it arrived WITHOUT a local pending
-   * request (see {@link remoteGhostUpdate}).
-   */
-  hasPending(): boolean;
-}
-
-/**
- * Debounced latest-wins query loop — the renderer half of the TUI's
- * abort-on-change effect (`useInlineGhostQuery`,
- * src/tui/prompt/use-inline-ghost-query.ts). Every `reevaluate`
- * bumps the sequence, so at most one query is pending and a reply that
- * lost the race is dropped. Host errors collapse to "no ghost".
- */
-export function createGhostController(host: GhostControllerHost): GhostController {
-  let seq = 0;
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  // Seq of the query currently awaiting its IPC reply, or null. Compared
-  // against `seq` so a cancel/reevaluate (which bumps `seq`) implicitly
-  // marks the in-flight reply as no longer pending.
-  let inflightSeq: number | null = null;
-  const debounce = host.debounceMs ?? GHOST_DEBOUNCE_MS;
-
-  const cancel = () => {
-    seq += 1;
-
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  };
-
-  return {
-    cancel,
-    hasPending: () => timer !== null || inflightSeq === seq,
-    reevaluate() {
-      cancel();
-
-      const gate = host.gate();
-      const offer = promptGhostAllowed(gate) ? (host.promptSuggestion?.() ?? null) : null;
-
-      if (offer) {
-        host.apply({ suffixes: [offer.text], index: 0, text: '', cursor: 0 }, offer);
-
-        return;
-      }
-
-      if (!ghostQueryAllowed(gate)) {
-        host.apply(null);
-
-        return;
-      }
-
-      const mySeq = seq;
-      const { text, cursor } = gate;
-
-      timer = setTimeout(() => {
-        timer = null;
-        inflightSeq = mySeq;
-
-        host
-          .query(text, cursor)
-          .then((suffixes) => {
-            if (mySeq !== seq || !host.confirm(text, cursor)) {
-              return;
-            }
-
-            const lines = firstLineSuffixes(suffixes ?? []);
-
-            host.apply(lines.length > 0 ? { suffixes: lines, index: 0, text, cursor } : null);
-          })
-          .catch(() => undefined)
-          .finally(() => {
-            if (inflightSeq === mySeq) {
-              inflightSeq = null;
-            }
-          });
-      }, debounce);
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Remote mirror (daemon mode)
-// ---------------------------------------------------------------------------
-
-/** The wire payload of a daemon-fanned `suggest:changed` signal. */
-export interface RemoteGhostSignal {
-  /** Buffer text the suggestion was computed against. */
-  basis: string;
-  caret: number;
-  suggestion: string | null;
-  /**
-   * Full ordered candidate list (additive — older daemons omit it).
-   * When present, the mirrored ghost keeps ↑/↓ rotation instead of
-   * pinning to the single `suggestion`.
-   */
-  candidates?: string[];
-}
-
-/**
- * Reconcile a daemon-fanned remote suggestion against the live buffer —
- * the mirroring half of the shared-computation contract (the daemon
- * excludes the requesting peer, but every renderer WINDOW of one main
- * process receives the forward, so the typist is re-excluded here):
- *   - `localPending` (this window is the active typist — its own query
- *     answers) → ignore;
- *   - live buffer no longer equals `basis` (the standard staleness
- *     guard) → ignore;
- *   - otherwise the ghost to paint, or null to clear (the remote typist
- *     got no suggestion for this exact basis).
- *
- * Returns `undefined` for "ignore" so callers keep the existing ghost —
- * prefers-existing behavior when signals never flow is untouched.
- */
-export function remoteGhostUpdate(
-  signal: RemoteGhostSignal,
-  live: { text: string; cursor: number },
-  localPending: boolean,
-): InlineGhost | null | undefined {
-  if (localPending) {
-    return undefined;
-  }
-
-  if (live.text !== signal.basis) {
-    return undefined;
-  }
-
-  if (signal.suggestion === null) {
-    return null;
-  }
-
-  const lines = firstLineSuffixes(
-    signal.candidates && signal.candidates.length > 0 ? signal.candidates : [signal.suggestion],
-  );
-
-  if (lines.length === 0) {
-    return null;
-  }
-
-  return { suffixes: lines, index: 0, text: signal.basis, cursor: signal.caret };
-}

package/src/chat/headless/composer/host-chrome.ts

@@ -1,227 +0,0 @@
-/**
- * The members of `ComposerHost` the chrome around the editor reads: the
- * pickers' session writes (`controls`), the model catalogs (`models`), the
- * agent profiles (`agents`), the picks remembered across apps (`prefs`), the
- * context and cost meters (`context`), the run counters (`runs`) and the
- * extensions' status strip (`hud`). Every member is optional: leaving one out
- * hides what needs it.
- */
-import type { IpcParams, IpcResult } from 'zidane/ipc';
-import type { ContextBreakdown, ExtensionHudBadge } from 'zidane/chat/pure';
-import type { ThinkingLevel } from 'zidane/types';
-
-import type { ResourceSnapshot } from '../../../app/headless/resource';
-import type { Readable } from '../store';
-import type { ComposerModelEntry, ComposerModelOption, ImageModelRow, ModelPickRef } from './models';
-import type { RunMeterState } from './run-meter';
-
-export type { ResourceSnapshot };
-
-/** A reasoning effort level. */
-export type ComposerEffort = ThinkingLevel;
-
-/** A switch a picker would make: what its cache estimate is asked for. */
-export type ComposerCacheImpactChange = IpcParams<'sessions.cacheImpact'>['change'];
-
-/** What a switch would cost the session's prompt cache. */
-export type ComposerCacheImpact = NonNullable<IpcResult<'sessions.cacheImpact'>>;
-
-/** What the pickers read of a session (the desktop app's session rows fit it as they are). */
-export interface ComposerSessionView {
-  /** The session's id. */
-  id: string;
-  /** Its title. */
-  title?: string;
-  /** Its folder (`''`: none). */
-  cwd?: string;
-  /** The server it runs on, absent or `null` for this computer. */
-  hostId?: string | null;
-  /** Its agent profile. */
-  agentId?: string;
-  /** Its reasoning effort. */
-  effort?: ComposerEffort;
-  /** Its enabled model options. */
-  modelOptions?: Record<string, boolean>;
-  /** The stored account its model runs on. */
-  account?: string;
-  /** Its model's fallbacks, primary excluded. */
-  modelFallbacks?: readonly ModelPickRef[];
-}
-
-/** The pickers' writes on a session. Each one left out hides the control that needs it. */
-export interface ComposerControls {
-  /** Sets the session's model: `primary`, then `fallbacks` (replacing the chain). */
-  setModel?(sessionId: string, primary: ModelPickRef, fallbacks: readonly ModelPickRef[]): Promise<void>;
-  /** Sets the session's reasoning effort. */
-  setEffort?(sessionId: string, effort: ComposerEffort): Promise<void>;
-  /** Sets the session's enabled model options. */
-  setModelOptions?(sessionId: string, options: Record<string, boolean>): Promise<void>;
-  /** Sets the session's agent profile. */
-  setAgent?(sessionId: string, agentId: string): Promise<void>;
-  /** What a switch would cost the session's prompt cache, `null` when unknown. Absent: pickers show no cache hints. */
-  cacheImpact?(sessionId: string, change: ComposerCacheImpactChange): Promise<ComposerCacheImpact | null>;
-}
-
-/** The model catalogs, kept current. */
-export interface ComposerModels {
-  /** The chat models a folder (`cwd`, `undefined`: the host's default) on a host (`null`: this one) can run. */
-  catalog(cwd: string | undefined, hostId: string | null): Readable<ResourceSnapshot<readonly ComposerModelEntry[]>>;
-  /** The image models for a folder. Absent: the picker has no Image tab. */
-  images?(cwd: string | null): Readable<ResourceSnapshot<readonly ImageModelRow[]>>;
-  /** Every provider this computer knows, signed in or not (labels for model names). */
-  providers?(): Readable<ResourceSnapshot<readonly { key: string; label: string }[]>>;
-}
-
-/** An agent profile a folder offers. */
-export interface ComposerAgentProfile {
-  /** Stable id. */
-  id: string;
-  /** Its name. */
-  label: string;
-  /** What it does. */
-  description: string;
-  /** Its accent color (a theme color name or a CSS color). */
-  accent: string;
-}
-
-/** The agent profiles. Absent: the agent picker hides. */
-export interface ComposerAgents {
-  /** The profiles a folder offers (`''`: no folder). */
-  list(cwd: string): Promise<readonly ComposerAgentProfile[]>;
-  /** Calls `listener` when the offered profiles may have changed. Returns the unsubscribe. */
-  onChanged?(listener: () => void): () => void;
-}
-
-/** A model chain entry as remembered (`state.json`'s `lastModelChain`). */
-export interface ComposerRememberedModel {
-  /** The provider's key. */
-  provider: string;
-  /** The model's id. */
-  model: string;
-  /** The stored account it runs on. */
-  account?: string;
-}
-
-/** The picks remembered across apps (the TUI's `state.json`). */
-export interface ComposerPrefsState {
-  /** The last effort used with each model. */
-  lastEffortByModel?: Record<string, ComposerEffort>;
-  /** The last enabled options used with each model. */
-  lastModelOptionsByModel?: Record<string, Record<string, boolean>>;
-  /** The next new chat's model chain. */
-  lastModelChain?: ComposerRememberedModel[];
-  /** The provider of the last model picked as the next new chat's. */
-  lastProvider?: string;
-  /** The last model picked with each provider. */
-  lastModelByProvider?: Partial<Record<string, string>>;
-  /** The stored account last picked with each provider. */
-  lastAccountByProvider?: Partial<Record<string, string>>;
-}
-
-/** Where picks are remembered. Absent: they last for the page's life. */
-export interface ComposerPrefs {
-  /** The remembered picks, `null` when there are none. */
-  get(): Promise<ComposerPrefsState | null>;
-  /** Merges `patch` into them (top-level keys replace). */
-  set(patch: ComposerPrefsState): Promise<void>;
-}
-
-/** A session's context gauge and what its model offers. */
-export interface ComposerContextStatus {
-  /** The model the gauge measures. */
-  modelId: string;
-  /** Tokens in the last request. */
-  used: number;
-  /** The usable window. */
-  effectiveWindow: number;
-  /** `used / effectiveWindow`, 0 to 1. */
-  fraction: number;
-  /** `used`, formatted. */
-  usedLabel: string;
-  /** `effectiveWindow`, formatted. */
-  windowLabel: string;
-  /** The model has a reasoning effort knob. */
-  supportsReasoning: boolean;
-  /** The feature toggles the model declares. */
-  availableOptions: readonly ComposerModelOption[];
-  /** The session's enabled options. */
-  modelOptions: Record<string, boolean>;
-}
-
-/** A session's total cost as last settled. */
-export interface ComposerCostStatus {
-  /** Total in USD. */
-  totalCost: number;
-  /** Runs counted. */
-  runCount: number;
-  /** `totalCost` formatted, `null` when zero. */
-  label: string | null;
-}
-
-/** What `ContextBreakdown` renders. */
-export type ComposerContextBreakdown = ContextBreakdown;
-
-/** A session's meters. Each one left out hides what reads it. */
-export interface ComposerContext {
-  /** The session's context gauge (keyed by its model, so a switch refetches it). */
-  status?(
-    sessionId: string,
-    modelId: string | null,
-    providerKey: string | null,
-  ): Readable<ResourceSnapshot<ComposerContextStatus | null>>;
-  /** What fills the session's context, by category. */
-  breakdown?(sessionId: string): Readable<ResourceSnapshot<ComposerContextBreakdown | null>>;
-  /** The session's cost as its finished runs settled it. */
-  cost?(sessionId: string): Promise<ComposerCostStatus | null>;
-}
-
-/** A run joined midway, as its host counts it. */
-export interface ComposerRunProgress {
-  /** When it began (epoch ms). */
-  startedAt: number;
-  /** Output tokens of its settled turns. */
-  outputTokens: number;
-}
-
-/** The current run's counters per session. Absent: no run chip. */
-export interface ComposerRuns {
-  /** The session's counters (`createRunMeter` keeps them from the stream). */
-  meter(sessionId: string): Readable<RunMeterState>;
-  /** Reads a run this window joined midway, `null` for none. Absent: the chip counts from when this window saw it. */
-  progress?(sessionId: string): Promise<ComposerRunProgress | null>;
-  /** Records a run's start this window saw without a start stamp (the chip counts from now). */
-  noteSeen?(sessionId: string): void;
-  /** Records the joined run's progress, read during run `generation`. */
-  noteProgress?(sessionId: string, generation: number, progress: ComposerRunProgress): void;
-  /** Zeroes the accrued cost when a cost read issued during run `generation` settled it. */
-  settleCost?(sessionId: string, generation: number): void;
-}
-
-/** One extension's status line scoped to a session. */
-export interface ComposerHudStatus {
-  /** The extension's name. */
-  extension: string;
-  /** The status text. */
-  text: string;
-  /** Shows a spinner. */
-  loader: boolean;
-}
-
-/** One extension badge on a session's composer. */
-export type ComposerHudBadge = ExtensionHudBadge;
-
-/** What extensions show with each session. */
-export interface ComposerHudSnapshot {
-  /** Session id → its statuses. */
-  sessions: Record<string, readonly ComposerHudStatus[]>;
-  /** Session id → its badges. */
-  badges: Record<string, readonly ComposerHudBadge[]>;
-}
-
-/** The extensions' status strip. Absent: no extension badges. */
-export interface ComposerHud {
-  /** The snapshot now. Absent: the strip fills on the first push. */
-  get?(): Promise<ComposerHudSnapshot | null>;
-  /** Calls `listener` with each new snapshot. Returns the unsubscribe. */
-  onState(listener: (snapshot: ComposerHudSnapshot) => void): () => void;
-}