zidane-ui 0.0.0-stage → 9.0.2

package/src/chat/composer/use-draft-target.ts

@@ -0,0 +1,284 @@
+/**
+ * Where the new-chat draft will run: a folder on this computer (or none,
+ * "just chat"), a saved server and its folder, or a machine's environment and
+ * its folder. Every pick is the current draft's only: it resets when the
+ * conversation moves to a session (the first send included), so the next new
+ * chat asks again. The folder rules are `draft-target.ts`
+ * (`zidane-ui/chat/headless`); the environment kinds come from the git host
+ * (`useEnvironmentChoices`). The app holds the folder new chats open in and
+ * the saved servers, and hears the draft's local folder (its draft scope).
+ *
+ * On a server, the draft offers the server's recent folders
+ * (`serverFolders`), its first root (`remoteRoot`) and a repository import
+ * there (`importRepoOnServer`). With no folder picked, a draft started from a
+ * project on this computer clones that project's repository there on send
+ * (`remoteClone`, `git/headless/remote-clone.ts`): the git host reads the
+ * local `origin` and lists the server's first root.
+ */
+import type { EnvironmentDescriptor } from 'zidane/chat';
+import { LOCAL_HOST_KEY } from 'zidane/chat/pure';
+import { useEffect, useMemo, useState } from 'react';
+
+import { useGitHost } from '../../git/GitProvider';
+import { resolveDraftDescriptor, type DraftEnvironment, type EnvironmentMachine } from '../../git/headless/environment';
+import type { GitFolderListing } from '../../git/headless/host';
+import { resolveRemoteClone, type DraftRemoteClone } from '../../git/headless/remote-clone';
+import { useImportRepo } from '../../git/ImportRepoDialog';
+import { useEnvironmentChoices } from '../../git/useEnvironmentChoices';
+import {
+  draftFolderPath,
+  draftLocalFolder,
+  recentHostFolders,
+  recentLocalFolders,
+  type DraftFolderSource,
+} from '../headless/draft-target';
+
+/** A saved server a draft can run on. */
+export interface DraftServer {
+  /** Its host id. */
+  id: string;
+  /** Its name. */
+  name: string;
+}
+
+/** What {@link useDraftTarget} reads from the app. */
+export interface DraftTargetOptions {
+  /** The open session (its folder, `''` for none); `null` for the new-chat draft. */
+  session: { id: string; cwd: string } | null;
+  /** The folder new chats open in (`null`: none picked yet). */
+  defaultFolder: string | null;
+  /** Makes `folder` the one new chats open in. */
+  setDefaultFolder(folder: string): void;
+  /** The session rows, most recently updated first: the folder menu's recent folders. */
+  sessions: readonly DraftFolderSource[];
+  /** The saved servers a draft can run on. */
+  servers: readonly DraftServer[];
+  /** Hears the draft's folder on this computer while the draft shows, `null` once it leaves. Absent: not told. */
+  onLocalFolder?(folder: string | null): void;
+}
+
+/** The draft's target and its picks, as the composer's where menu and folder pickers read them. */
+export interface DraftTarget {
+  /** `null`: no folder picked yet (the folder gate shows); `''`: none. */
+  folderPath: string | null;
+  /** This computer's recent folders. */
+  recentFolders: readonly string[];
+  /** "Start without a folder" for this draft. */
+  justChat(): void;
+  /** Picks a folder on this computer (the git host's dialog). */
+  pickFolder(): Promise<void>;
+  /** Picks one of {@link DraftTarget.recentFolders}. */
+  pickRecent(folder: string): void;
+  /** Imports a repository and opens the draft in it. */
+  importRepoIntoDraft(): Promise<void>;
+  /** The saved server the draft runs on (absent: this computer). */
+  server?: DraftServer;
+  /** Runs the draft on a saved server (`LOCAL_HOST_KEY`: this computer). */
+  setHostId(hostId: string): void;
+  /** The server's folder (`null`: its first root). */
+  remoteFolder: string | null;
+  /** Picks the server's folder. */
+  setRemoteFolder(folder: string | null): void;
+  /** The server's recent folders (its sessions' folders), most recent first. */
+  serverFolders: readonly string[];
+  /** The server's first workspace root (the default folder), once read. */
+  remoteRoot: string | null;
+  /** Clones a repository on the server and opens the draft in it. Absent: the server takes no clones. */
+  importRepoOnServer?: () => Promise<void>;
+  /** On a server with no folder picked: the local project's repository, cloned there on send. `null`: nothing to clone. */
+  remoteClone: DraftRemoteClone | null;
+  /** The send is cloning {@link DraftTarget.remoteClone}. */
+  cloning: boolean;
+  /** Marks the clone of a send as running or done. */
+  setCloning(cloning: boolean): void;
+  /** The draft's environment pick (`null`: the default). */
+  environment: DraftEnvironment | null;
+  /** Picks the draft's environment. */
+  setEnvironment(environment: DraftEnvironment | null): void;
+  /** The environment kinds the draft's host offers. */
+  environmentChoices: readonly EnvironmentDescriptor[];
+  /** The machine the picked environment runs on. */
+  machine?: EnvironmentMachine;
+  /** The machine's folder (`null`: its first one). */
+  machineFolder: string | null;
+  /** Picks the machine's folder. */
+  setMachineFolder(folder: string | null): void;
+  /** The host the machine's folders are browsed through. */
+  machineHost: string;
+  /** Why the last new chat could not be created (the prompt is back in the box). */
+  error: string | null;
+  /** Shows or clears {@link DraftTarget.error}. */
+  setError(error: string | null): void;
+}
+
+/**
+ * The new-chat draft's target, reset with the draft.
+ *
+ * @param options - The open session and the app's folder, sessions and servers.
+ */
+export function useDraftTarget(options: DraftTargetOptions): DraftTarget {
+  const { session, defaultFolder, setDefaultFolder, sessions, servers, onLocalFolder } = options;
+  const isNewSession = session == null;
+
+  const recentFolders = useMemo(() => recentLocalFolders(sessions), [sessions]);
+
+  // "Start without a folder", for this draft only.
+  const [folderlessDraft, setFolderlessDraft] = useState(false);
+  const [environment, setEnvironment] = useState<DraftEnvironment | null>(null);
+
+  // This computer unless a saved server is picked; then the environment and folder steps ask that server.
+  const [hostId, setHostId] = useState<string>(LOCAL_HOST_KEY);
+  const [remoteFolder, setRemoteFolder] = useState<string | null>(null);
+  const server = isNewSession && hostId !== LOCAL_HOST_KEY ? servers.find((host) => host.id === hostId) : undefined;
+
+  const [error, setError] = useState<string | null>(null);
+
+  // The picks reset while rendering (no effect, no frame with the stale pick).
+  const sessionId = session?.id;
+  const [resetKeys, setResetKeys] = useState({ sessionId, hostId, defaultFolder });
+  if (resetKeys.sessionId !== sessionId || resetKeys.hostId !== hostId || resetKeys.defaultFolder !== defaultFolder) {
+    const newSession = resetKeys.sessionId !== sessionId;
+    const newHost = resetKeys.hostId !== hostId;
+    setResetKeys({ sessionId, hostId, defaultFolder });
+    // Picking a folder elsewhere (a project's "+" in the sidebar) takes the draft out of "no folder" mode.
+    if (newSession || resetKeys.defaultFolder !== defaultFolder) setFolderlessDraft(false);
+    // The picked server's folders and environments are its own: a new host starts over.
+    if (newHost) setRemoteFolder(null);
+    if (newSession || newHost) {
+      setEnvironment(null);
+      setError(null);
+    }
+  }
+
+  // The picked server was removed: the draft is back on this computer, visibly.
+  if (hostId !== LOCAL_HOST_KEY && !servers.some((host) => host.id === hostId)) setHostId(LOCAL_HOST_KEY);
+
+  const folderState = {
+    ...(session ? { sessionCwd: session.cwd } : {}),
+    onServer: Boolean(server),
+    folderless: folderlessDraft,
+    defaultFolder,
+  };
+  const folderPath = draftFolderPath(folderState);
+  const environmentChoices = useEnvironmentChoices(
+    isNewSession ? (server ? (remoteFolder ?? '') : (folderPath ?? '')) : null,
+    server?.id,
+  );
+  // A machine's environment: its folder is on that machine, browsed through the draft's host.
+  const machine = isNewSession ? resolveDraftDescriptor(environmentChoices, environment)?.machine : undefined;
+  const [machineFolder, setMachineFolder] = useState<string | null>(null);
+  const machineHost = server?.id ?? LOCAL_HOST_KEY;
+  const machineKey = `${machine?.id ?? ''}\u0000${machineHost}`;
+  const [folderMachine, setFolderMachine] = useState(machineKey);
+  if (folderMachine !== machineKey) {
+    setFolderMachine(machineKey);
+    setMachineFolder(null);
+  }
+  // Only a folder on this computer makes the draft's scope.
+  const localFolder = draftLocalFolder({ ...folderState, onMachine: Boolean(machine) });
+  // Only while it shows the draft: a session telling its (null) folder would clear the draft's scope.
+  useEffect(() => {
+    if (isNewSession) onLocalFolder?.(localFolder);
+  }, [isNewSession, localFolder, onLocalFolder]);
+  useEffect(() => {
+    if (!isNewSession) return undefined;
+    return () => onLocalFolder?.(null);
+  }, [isNewSession, onLocalFolder]);
+
+  // The server's first root (where clones land, what "Default folder" means, what it lets clients do) and the
+  // local project's `origin` (clone on send). Each answer is kept with what it was read for, so a stale one never
+  // shows for another pick.
+  const git = useGitHost();
+  const originUrl = git?.originUrl;
+  const listFolders = git?.listFolders;
+  const canClone = Boolean(git?.cloneOnServer);
+  const rootKey = server && listFolders ? server.id : null;
+  const [rootRead, setRootRead] = useState<{ key: string; root: GitFolderListing | null } | null>(null);
+  useEffect(() => {
+    if (!rootKey || !listFolders) return undefined;
+    let cancelled = false;
+    listFolders({ hostId: rootKey })
+      .then((listed) => {
+        if (!cancelled) setRootRead({ key: rootKey, root: listed.ok ? listed.listing : null });
+      })
+      .catch(() => {
+        if (!cancelled) setRootRead({ key: rootKey, root: null });
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [rootKey, listFolders]);
+  const remoteRootListing = rootKey && rootRead?.key === rootKey ? rootRead.root : null;
+
+  const cloneSource = server && canClone && !folderlessDraft ? defaultFolder : null;
+  const [originRead, setOriginRead] = useState<{ key: string; origin: string | null } | null>(null);
+  useEffect(() => {
+    if (!cloneSource || !originUrl) return undefined;
+    let cancelled = false;
+    originUrl(cloneSource)
+      .then((origin) => {
+        if (!cancelled) setOriginRead({ key: cloneSource, origin });
+      })
+      .catch(() => {
+        if (!cancelled) setOriginRead({ key: cloneSource, origin: null });
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [cloneSource, originUrl]);
+  const origin = cloneSource && originRead?.key === cloneSource ? originRead.origin : null;
+  const remoteClone =
+    remoteFolder === null && remoteRootListing && origin ? resolveRemoteClone(origin, remoteRootListing) : null;
+  const [cloning, setCloning] = useState(false);
+  const serverFolders = useMemo(() => (server ? recentHostFolders(sessions, server.id) : []), [server, sessions]);
+
+  const pickLocal = (folder: string) => {
+    // A real folder supersedes a "start without a folder" draft.
+    setFolderlessDraft(false);
+    setDefaultFolder(folder);
+  };
+  const importRepo = useImportRepo();
+  const importOnServer = useImportRepo(server ? { hostId: server.id } : undefined);
+  const serverImports = Boolean(server && canClone && remoteRootListing?.allows?.clone);
+
+  return {
+    folderPath,
+    recentFolders,
+    justChat: () => setFolderlessDraft(true),
+    pickFolder: async () => {
+      const picked = (await git?.pickFolder?.()) ?? null;
+      if (picked) pickLocal(picked);
+    },
+    pickRecent: pickLocal,
+    importRepoIntoDraft: async () => {
+      const cloned = await importRepo();
+      if (cloned) pickLocal(cloned);
+    },
+    ...(server ? { server } : {}),
+    setHostId,
+    remoteFolder,
+    setRemoteFolder,
+    serverFolders,
+    remoteRoot: remoteRootListing?.path ?? null,
+    ...(serverImports
+      ? {
+          importRepoOnServer: async () => {
+            const cloned = await importOnServer();
+            if (cloned) setRemoteFolder(cloned);
+          },
+        }
+      : {}),
+    remoteClone,
+    cloning,
+    setCloning,
+    environment,
+    setEnvironment,
+    environmentChoices,
+    ...(machine ? { machine } : {}),
+    machineFolder,
+    setMachineFolder,
+    machineHost,
+    error,
+    setError,
+  };
+}

package/src/chat/composer/use-hud.ts

@@ -0,0 +1,38 @@
+/**
+ * What extensions show with a session (`ComposerHost.hud`): its statuses and
+ * its composer badges. A session's lists keep their identity until its own
+ * entries change, so the badge strip re-renders only for its session.
+ */
+import { useSyncExternalStore } from 'react';
+
+import type { ComposerHudBadge, ComposerHudStatus } from '../headless/composer/host-chrome';
+import { hudStoreOf } from '../headless/composer/hud';
+import { useComposerHost } from './ComposerHostProvider';
+
+const NO_STATUSES: readonly ComposerHudStatus[] = [];
+const NO_BADGES: readonly ComposerHudBadge[] = [];
+const noSubscribe = () => () => undefined;
+
+/**
+ * The extensions' statuses scoped to `sessionId`.
+ *
+ * @param sessionId - The session, `null` for none.
+ */
+export function useHudStatuses(sessionId: string | null): readonly ComposerHudStatus[] {
+  const hud = useComposerHost().hud;
+  const store = hud ? hudStoreOf(hud) : null;
+  const get = () => (store ? store.statuses(sessionId) : NO_STATUSES);
+  return useSyncExternalStore(store ? store.subscribe : noSubscribe, get, get);
+}
+
+/**
+ * The extension badges of `sessionId`'s composer.
+ *
+ * @param sessionId - The session, `null` for none.
+ */
+export function useHudBadges(sessionId: string | null): readonly ComposerHudBadge[] {
+  const hud = useComposerHost().hud;
+  const store = hud ? hudStoreOf(hud) : null;
+  const get = () => (store ? store.badges(sessionId) : NO_BADGES);
+  return useSyncExternalStore(store ? store.subscribe : noSubscribe, get, get);
+}

package/src/chat/composer/use-new-session-defaults.ts

@@ -0,0 +1,201 @@
+/**
+ * What a new session starts with: the folder (the one last used,
+ * `ComposerHost.folders`), the agent, the model pick and its knobs. The
+ * space's settings preset wins; else the model the host remembers
+ * (`ComposerHost.prefs`), else the built-in default.
+ */
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import type { Settings } from 'zidane/chat';
+import {
+  DEFAULT_MODEL_PICK,
+  defaultSessionAgent,
+  defaultSessionKnobs,
+  defaultSessionModel,
+  formatModelSetting,
+  parseModelSetting,
+  type SessionKnobs,
+} from 'zidane/chat/pure';
+
+import { defaultModelPatch, rememberedDefaultModel } from '../headless/composer/new-session-defaults';
+import { settledResource } from '../headless/composer/remember-model-pick';
+import type { ModelPickRef } from '../headless/composer/models';
+import { useComposerHost } from './ComposerHostProvider';
+
+/** Where the default model comes from. */
+export type NewSessionModelSource = 'preset' | 'remembered' | 'builtin';
+
+/** What a new session starts with, and the writers of each pick. */
+export interface NewSessionDefaults {
+  /** The project root of `defaultFolder`, `null` without a folder or a project. */
+  projectRoot: string | null;
+  /** The folder a new session opens in, `null` until known or when there is none. */
+  defaultFolder: string | null;
+  /** The agent: this chat's pick, else the space's, else `build`. */
+  defaultAgentId: string;
+  /** The effort and options the space's preset sets. */
+  newSessionKnobs: SessionKnobs;
+  /** The model's provider, `null` until resolved. */
+  defaultProviderKey: string | null;
+  /** The model, `null` until resolved. */
+  defaultModelId: string | null;
+  /** The stored account the model runs on, `null` for the active one. */
+  defaultAccount: string | null;
+  /** Where the model comes from, `null` until resolved. */
+  modelSource: NewSessionModelSource | null;
+  /** Sets the folder and remembers it (`null`: none, nothing remembered). */
+  setDefaultFolder: (path: string | null) => void;
+  /** Picks the agent for this chat (`null`: back to the space's). */
+  setDefaultAgentId: (id: string | null) => void;
+  /** Picks the model and remembers it, unless `persist` is `false`. */
+  setDefaultModel: (pick: ModelPickRef, opts?: { persist?: boolean }) => void;
+}
+
+interface ModelState {
+  providerKey: string | null;
+  modelId: string | null;
+  account: string | null;
+  source: NewSessionModelSource | null;
+}
+
+const UNRESOLVED: ModelState = { providerKey: null, modelId: null, account: null, source: null };
+const BUILTIN: ModelState = { ...DEFAULT_MODEL_PICK, account: null, source: 'builtin' };
+
+/**
+ * The new session's defaults in a space, over the provided `ComposerHost`.
+ *
+ * @param settings - The settings (the space presets).
+ * @param spaceId - The space new sessions go to.
+ */
+export function useNewSessionDefaults(settings: Settings, spaceId: string): NewSessionDefaults {
+  const { prefs, models, folders, completions } = useComposerHost();
+  const locationOf = completions?.locationOf;
+  const [defaultFolder, setDefaultFolderState] = useState<string | null>(null);
+  const [agentPick, setAgentPick] = useState<string | null>(null);
+  // What the host remembers (read when no preset applies), and a pick made under the preset in force then.
+  const [remembered, setRemembered] = useState<ModelState>(UNRESOLVED);
+  const [picked, setPicked] = useState<{ model: ModelState; presetKey: string | null } | null>(null);
+  const [located, setLocated] = useState<string | null>(null);
+
+  const preset = useMemo(() => defaultSessionModel(settings, spaceId), [settings, spaceId]);
+  const newSessionKnobs = useMemo(() => defaultSessionKnobs(settings, spaceId), [settings, spaceId]);
+  const presetKey = preset ? formatModelSetting(preset) : null;
+  const defaultAgentId = agentPick ?? defaultSessionAgent(settings, spaceId) ?? 'build';
+  const presetModel = useMemo<ModelState | null>(() => {
+    const parsed = parseModelSetting(presetKey ?? undefined);
+    return parsed
+      ? { providerKey: parsed.providerKey, modelId: parsed.modelId, account: parsed.account ?? null, source: 'preset' }
+      : null;
+  }, [presetKey]);
+  // A preset change resets a pick made under the previous one.
+  const model =
+    picked && picked.presetKey === presetKey ? picked.model : (presetModel ?? (prefs ? remembered : BUILTIN));
+
+  useEffect(() => {
+    if (presetModel || !prefs) return undefined;
+    let cancelled = false;
+    void prefs
+      .get()
+      .then((state) => {
+        if (cancelled) return;
+        const pick = rememberedDefaultModel(state);
+        if (!pick) {
+          setRemembered(BUILTIN);
+          return;
+        }
+        const { providerKey, modelId, account } = pick;
+        setRemembered({ providerKey, modelId, account: null, source: 'remembered' });
+        // The remembered account only when it still serves that provider.
+        if (account && models) {
+          void settledResource(models.catalog(undefined, null))
+            .then((catalog) => {
+              if (!cancelled && catalog.some((e) => e.providerKey === providerKey && e.account?.id === account)) {
+                setRemembered((now) =>
+                  now.providerKey === providerKey && now.modelId === modelId ? { ...now, account } : now,
+                );
+              }
+            })
+            .catch(() => undefined);
+        }
+      })
+      .catch(() => {
+        if (!cancelled) setRemembered(BUILTIN);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [presetModel, prefs, models]);
+
+  const setDefaultAgentId = useCallback((id: string | null) => setAgentPick(id), []);
+
+  const setDefaultModel = useCallback(
+    (pick: ModelPickRef, opts?: { persist?: boolean }) => {
+      setPicked({
+        model: {
+          providerKey: pick.providerKey,
+          modelId: pick.modelId,
+          account: pick.account ?? null,
+          source: 'remembered',
+        },
+        presetKey,
+      });
+      if (opts?.persist === false || !prefs) return;
+      void prefs
+        .get()
+        .then((current) => prefs.set(defaultModelPatch(current, pick)))
+        .catch(() => undefined);
+    },
+    [prefs, presetKey],
+  );
+
+  useEffect(() => {
+    if (!folders) return undefined;
+    let cancelled = false;
+    void folders
+      .lastUsed()
+      .then((last) => {
+        if (!cancelled) setDefaultFolderState(last);
+      })
+      .catch(() => undefined);
+    return () => {
+      cancelled = true;
+    };
+  }, [folders]);
+
+  useEffect(() => {
+    if (!defaultFolder || !locationOf) return undefined;
+    let cancelled = false;
+    void locationOf(defaultFolder)
+      .then((location) => {
+        if (!cancelled) setLocated(location?.projectRoot ?? null);
+      })
+      .catch(() => {
+        if (!cancelled) setLocated(null);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [defaultFolder, locationOf]);
+  const projectRoot = defaultFolder && locationOf ? located : null;
+
+  const setDefaultFolder = useCallback(
+    (path: string | null) => {
+      setDefaultFolderState(path);
+      if (path && folders) void folders.setLastUsed(path).catch(() => undefined);
+    },
+    [folders],
+  );
+
+  return {
+    projectRoot,
+    defaultFolder,
+    defaultAgentId,
+    newSessionKnobs,
+    defaultProviderKey: model.providerKey,
+    defaultModelId: model.modelId,
+    defaultAccount: model.account,
+    modelSource: model.source,
+    setDefaultFolder,
+    setDefaultAgentId,
+    setDefaultModel,
+  };
+}

package/src/chat/composer/use-provider-ready-poll.ts

@@ -0,0 +1,35 @@
+/**
+ * Whether a provider is ready (`ChatHost.providerReady`), read into a store
+ * the app shares (the sign-in pill, the Connect a provider card, the send's
+ * check): at mount and each time `paused` turns off. The app pauses it while
+ * a modal is open: Settings › Accounts and the setup wizard own the
+ * credential writes, so a read after they close is enough.
+ */
+import { useEffect } from 'react';
+
+import type { Writable } from '../headless/store';
+import { useChatHost } from '../ChatProvider';
+
+/**
+ * Keeps `store` on the chat host's provider check.
+ *
+ * @param store - Where the answer goes: `true` / `false`, `null` when the check failed (unknown, not "none": it must not block sends).
+ * @param paused - Skip reading while true; turning false reads again.
+ */
+export function useProviderReadyPoll(store: Writable<boolean | null>, paused = false): void {
+  const providerReady = useChatHost().providerReady;
+  useEffect(() => {
+    if (paused || !providerReady) return undefined;
+    let cancelled = false;
+    void providerReady()
+      .then((ready) => {
+        if (!cancelled) store.set(ready);
+      })
+      .catch(() => {
+        if (!cancelled) store.set(null);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [paused, providerReady, store]);
+}