@iseoane/agent-depot 0.2.0 → 0.3.0

package/dist/src/tui/catalog-flow.js

@@ -0,0 +1,107 @@
+import { BROWSE, describeSkills, HOST_CHOICES, SCOPE_CHOICES } from "./catalog-actions.js";
+import { prepareInstall, runInstall } from "./catalog-installs.js";
+import { skillKey } from "./catalog-tree.js";
+import { errorText, runBatch } from "./batch.js";
+import { answerYesNo, applyChecklistOutcome, hostChecklistKey, versionInputKey } from "./mode-keys.js";
+function cancel(context) {
+    context.setMessage({ kind: "ok", text: "Install cancelled" });
+    context.setAction(BROWSE);
+}
+async function startInstall(context, skills, choice) {
+    context.setAction({ kind: "busy", label: `Refreshing source and preparing install of ${describeSkills(skills)}...` });
+    const items = [];
+    for (const skill of skills) {
+        try {
+            items.push({ skill, prepared: await prepareInstall(context.operations, context.env, skill, choice) });
+        }
+        catch (error) {
+            items.push({ skill, error: errorText(error) });
+        }
+    }
+    if (!context.isMounted())
+        return;
+    if (items.every((item) => item.prepared === undefined)) {
+        const text = items.length === 1 ? items[0].error : items.map((item) => `Failed ${item.skill.name}: ${item.error}`).join("\n");
+        context.setMessage({ kind: "error", text });
+        context.setAction(BROWSE);
+        return;
+    }
+    context.setAction({ kind: "confirm-install", items });
+}
+/** Applies the prepared items one by one; a failure is reported for that item and the rest still run. */
+async function confirmInstall(context, items, exposure) {
+    context.setAction({ kind: "busy", label: `Installing ${describeSkills(items.map((item) => item.skill))}...` });
+    const outcomes = await runBatch(items, async ({ prepared, error }) => {
+        if (prepared === undefined)
+            throw new Error(error);
+        return (await runInstall(prepared, context.operations, exposure && prepared.additionalHostExposure)).join(" ");
+    }, ({ skill }, caught) => `Failed ${skill.name}: ${errorText(caught)}`);
+    const lines = outcomes.map((outcome) => outcome.line);
+    const failed = new Set(outcomes.filter((outcome) => !outcome.ok).map((outcome) => skillKey(outcome.item.skill)));
+    // Installed Skills leave the list; only the failed ones stay marked for another try.
+    context.keepMarked(failed);
+    await context.finish({ kind: failed.size > 0 ? "error" : "ok", text: lines.join("\n") });
+}
+function handleHostKey(context, mode, input, key) {
+    applyChecklistOutcome(hostChecklistKey(mode, HOST_CHOICES, input, key), {
+        cancel: () => cancel(context),
+        update: (state) => context.setAction({ ...mode, ...state }),
+        submit: (hosts) => context.setAction({ kind: "scope", skills: mode.skills, hosts }),
+        setMessage: context.setMessage,
+    });
+}
+function handleScopeKey(context, mode, input, key) {
+    const scope = SCOPE_CHOICES[Number(input) - 1];
+    if (key.escape)
+        cancel(context);
+    else if (scope)
+        context.setAction({ kind: "version", skills: mode.skills, hosts: mode.hosts, scope });
+}
+function handleVersionKey(context, mode, input, key) {
+    if (key.escape)
+        cancel(context);
+    else if (input === "1")
+        void startInstall(context, mode.skills, { hosts: mode.hosts, scope: mode.scope, version: { policy: "latest" } });
+    else if (input === "2")
+        context.setAction({ ...mode, kind: "fixed", value: "" });
+}
+function handleFixedKey(context, mode, input, key) {
+    const outcome = versionInputKey(mode.value, input, key);
+    if (outcome.kind === "cancel")
+        cancel(context);
+    else if (outcome.kind === "submit") {
+        void startInstall(context, mode.skills, { hosts: mode.hosts, scope: mode.scope, version: { policy: "fixed", version: mode.value } });
+    }
+    else if (outcome.kind === "edit")
+        context.setAction({ ...mode, value: outcome.value });
+}
+/** Handles a key in one of the install modes; `browse` and `busy` ignore keys. */
+export function handleCatalogActionKey(context, mode, input, key) {
+    switch (mode.kind) {
+        case "host":
+            handleHostKey(context, mode, input, key);
+            return;
+        case "scope":
+            handleScopeKey(context, mode, input, key);
+            return;
+        case "version":
+            handleVersionKey(context, mode, input, key);
+            return;
+        case "fixed":
+            handleFixedKey(context, mode, input, key);
+            return;
+        case "confirm-install":
+            answerYesNo(input, key, () => {
+                if (mode.items.some((item) => item.prepared?.additionalHostExposure))
+                    context.setAction({ ...mode, kind: "confirm-exposure" });
+                else
+                    void confirmInstall(context, mode.items, false);
+            }, () => cancel(context));
+            return;
+        case "confirm-exposure":
+            answerYesNo(input, key, () => void confirmInstall(context, mode.items, true), () => cancel(context));
+            return;
+        default:
+            return;
+    }
+}

package/dist/src/tui/catalog-installs.js

@@ -0,0 +1,193 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { defaultProjectManifestPath, parseProjectManifest, PROJECT_HOSTS, ProjectManifestStore, } from "../project-manifest.js";
+import { defaultProjectSkillTreeAccess, executeSingleInstall, needsAdditionalHostExposure, outputSingleInstallPreview, planSingleInstall, } from "../skill-install.js";
+import { executeHostAddition, executeHostRemoval, planHostAddition, planHostRemoval, } from "../skill-hosts.js";
+import { executeSkillRemoval, planSkillRemoval, SkillSelectionError, userGlobalRemovalOptions, } from "../skill-removal.js";
+import { scanUserGlobalSkillInventory } from "../user-global-skill-inventory.js";
+export const NO_INSTALLED = { global: [], project: [], sources: [], unmanagedNames: new Set() };
+function homeOf(environment) {
+    return path.resolve(environment.homeDirectory ?? homedir());
+}
+function manifestStoreOf(environment) {
+    return environment.projectManifestStore ??
+        new ProjectManifestStore(defaultProjectManifestPath(path.resolve(environment.projectRoot ?? process.cwd())));
+}
+/** Loads user-global and project installations; anything unavailable or unreadable yields no markers. */
+export async function loadInstalledSkills(operations, environment) {
+    const [global, project, sources] = await Promise.all([
+        operations.listUserGlobalInstallations?.().catch(() => []) ?? [],
+        manifestStoreOf(environment).load().then((manifest) => manifest.skills, () => []),
+        operations.listSources().catch(() => []),
+    ]);
+    const unmanagedNames = await scanUserGlobalSkillInventory({
+        homeDirectory: homeOf(environment),
+        appEnvironment: environment.appEnvironment,
+        managedInstallations: global,
+    }).then((inventory) => new Set([...inventory.unmanaged, ...inventory.symlinks].map((entry) => entry.name)), () => new Set());
+    return { global, project, sources, unmanagedNames };
+}
+/** Whether an unmanaged copy with the Skill's directory name exists on disk (the name an install would use). */
+export function hasUnmanagedCopy(skill, installed) {
+    return installed.unmanagedNames.has(path.posix.basename(skill.path));
+}
+function matchesSource(source, sourceId, sources) {
+    if (source.kind === "builtin")
+        return source.id === sourceId;
+    if (!("url" in source))
+        return false;
+    return sources.some((candidate) => candidate.kind === "git" && candidate.id === sourceId && candidate.url === source.url);
+}
+function recordsFor(records, skill, sources) {
+    return records.filter((record) => record.path === skill.path && matchesSource(record.source, skill.sourceId, sources));
+}
+/** Whether the Skill is installed user-global or in the project manifest (same Source and path). */
+export function isInstalled(skill, installed) {
+    return [installed.global, installed.project].some((records) => recordsFor(records, skill, installed.sources).length > 0);
+}
+/** Plan step: refreshes the Source, resolves and inspects the install and renders the same preview the CLI prints. */
+export async function prepareInstall(operations, environment, skill, choice) {
+    const request = {
+        scope: choice.scope,
+        sourceId: skill.sourceId,
+        skillPath: skill.path,
+        hosts: choice.hosts,
+        version: choice.version,
+        // Confirming the preview is the review the CLI asks for with --portable-v1.
+        portableV1: true,
+        // Planning with confirmed set refreshes a Git Source before resolving, so
+        // the preview shows exactly what y installs (the CLI does this on --yes).
+        confirmed: true,
+        overwrite: false,
+        confirmAdditionalHostExposure: false,
+    };
+    const sourceAccess = environment.sourceAccess ?? defaultProjectSkillTreeAccess();
+    const base = { operations, sourceAccess, environment };
+    let plan;
+    let manifestStore;
+    if (choice.scope === "user-global") {
+        if (!operations.listUserGlobalInstallations || !operations.addUserGlobalInstallation) {
+            throw new Error("Configured Source operations cannot manage user-global installation state");
+        }
+        plan = await planSingleInstall(request, {
+            ...base,
+            root: homeOf(environment),
+            existing: await operations.listUserGlobalInstallations(),
+            recordedIn: "user-global state",
+        });
+    }
+    else {
+        manifestStore = manifestStoreOf(environment);
+        plan = await planSingleInstall(request, {
+            ...base,
+            root: path.resolve(environment.projectRoot ?? process.cwd()),
+            existing: (await manifestStore.load()).skills,
+            recordedIn: manifestStore.path,
+        });
+    }
+    const lines = [];
+    outputSingleInstallPreview(plan, (line) => lines.push(line));
+    // The TUI confirms interactively, so the CLI's --yes wording does not apply.
+    const preview = lines.filter((line) => !line.startsWith("  confirmation:"));
+    const additionalHostExposure = needsAdditionalHostExposure(plan.inspection, choice.hosts);
+    if (additionalHostExposure) {
+        preview.push("  ADDITIONAL HOST EXPOSURE: an identical Skill already exists; installing adds the missing Host location (equivalent to --confirm-additional-host) and needs a separate confirmation");
+    }
+    return { plan, manifestStore, preview, runsExternalCommand: plan.resolved.method !== undefined, additionalHostExposure };
+}
+/** Execute step: installs and persists the record; returns the result lines. */
+export async function runInstall(prepared, operations, confirmAdditionalHostExposure = false) {
+    const lines = [];
+    const { manifestStore } = prepared;
+    const plan = confirmAdditionalHostExposure
+        ? { ...prepared.plan, request: { ...prepared.plan.request, confirmAdditionalHostExposure: true } }
+        : prepared.plan;
+    const persist = manifestStore
+        ? async (record) => {
+            // Read at persist time: a batch installs several Skills, and each record must keep the ones saved before it.
+            const current = (await manifestStore.load()).skills;
+            await manifestStore.save(parseProjectManifest({ version: 1, skills: [...current, record] }));
+        }
+        : (record) => operations.addUserGlobalInstallation(record);
+    await executeSingleInstall(plan, persist, (line) => lines.push(line));
+    return lines;
+}
+/** Why a preparation that is not `ready` refuses, in the words the TUI shows. */
+export const UNINSTALL_REFUSALS = {
+    unsupported: "Uninstall is not supported by the configured operations",
+    "not-installed": "Skill is not installed",
+    "project-only": "Project uninstall is not supported",
+};
+/** Plan step for removing the highlighted Skill's user-global installation. */
+export async function prepareUninstall(operations, environment, skill, installed) {
+    if (!operations.listUserGlobalInstallations || !operations.removeUserGlobalInstallations) {
+        return { kind: "unsupported" };
+    }
+    const installations = await operations.listUserGlobalInstallations();
+    const matches = recordsFor(installations, skill, installed.sources);
+    if (matches.length === 0) {
+        return { kind: recordsFor(installed.project, skill, installed.sources).length > 0 ? "project-only" : "not-installed" };
+    }
+    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    const record = matches[0];
+    const plan = await planSkillRemoval([record], options);
+    const scopeNote = `  removes the whole user-global installation, from hosts: ${record.hosts.join(", ")}`;
+    return { kind: "ready", plan: { ...plan, preview: [...plan.preview, scopeNote] }, installations };
+}
+/** Execute step: rechecks the plan, then removes files and records. */
+export async function runUninstall(prepared, operations, environment) {
+    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    await executeSkillRemoval(prepared.plan, operations, options, prepared.installations);
+}
+/** The user-global record of the Skill, when it is installed there. */
+export function globalRecord(skill, installed) {
+    return recordsFor(installed.global, skill, installed.sources)[0];
+}
+/** Hosts a user-global record does not serve yet, in checklist order. */
+export function missingHosts(record) {
+    return PROJECT_HOSTS.filter((host) => !record.hosts.includes(host));
+}
+/** Reads the current records so a host change never acts on a stale checklist. */
+async function currentGlobalRecord(operations, skill, installed) {
+    if (!operations.listUserGlobalInstallations || !operations.updateUserGlobalInstallation || !operations.removeUserGlobalInstallations) {
+        throw new Error("Configured Source operations cannot manage user-global installation state");
+    }
+    const installations = await operations.listUserGlobalInstallations();
+    const record = recordsFor(installations, skill, installed.sources)[0];
+    if (!record)
+        throw new Error("Skill is not installed");
+    return { record, installations };
+}
+/** A selection problem is a normal message for the TUI, like any other failed step. */
+function asMessage(error) {
+    throw error instanceof SkillSelectionError ? new Error(error.message) : error;
+}
+/** Plan step for exposing an installed user-global Skill to more hosts. */
+export async function prepareHostAddition(operations, environment, skill, installed, hosts) {
+    const { record, installations } = await currentGlobalRecord(operations, skill, installed);
+    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    const plan = await planHostAddition(record, hosts, options).catch(asMessage);
+    return { plan, installations, preview: plan.preview };
+}
+/** Execute step: the TUI's separate exposure confirmation stands in for `--confirm-additional-host`. */
+export async function runHostAddition(prepared, operations, environment) {
+    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    await executeHostAddition(prepared.plan, operations, options, prepared.installations, true);
+    return `Added hosts ${prepared.plan.hosts.join(", ")} to ${prepared.plan.selection.path}`;
+}
+/** Plan step for removing some hosts of a user-global Skill; removing all of them is a full removal. */
+export async function prepareHostRemoval(operations, environment, skill, installed, hosts) {
+    const { record, installations } = await currentGlobalRecord(operations, skill, installed);
+    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    const plan = await planHostRemoval(record, hosts, options).catch(asMessage);
+    return { plan, installations, preview: plan.kind === "full" ? plan.plan.preview : plan.preview };
+}
+/** Execute step: rechecks, removes only the chosen hosts' locations, then reconciles the record. */
+export async function runHostRemoval(prepared, operations, environment, skill) {
+    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    await executeHostRemoval(prepared.plan, operations, options, prepared.installations);
+    const { plan } = prepared;
+    return plan.kind === "full"
+        ? `Removed ${skill.name} (${skill.path})`
+        : `Removed hosts ${plan.removed.join(", ")} from ${plan.selection.path}`;
+}

package/dist/src/tui/catalog-panel.js

@@ -0,0 +1,47 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { describeSkills, HOST_CHOICES, SCOPE_CHOICES } from "./catalog-actions.js";
+import { skillKey } from "./catalog-tree.js";
+import { hasUnmanagedCopy } from "./catalog-installs.js";
+import { describeRow, UNMANAGED_MARKER } from "./catalog-tree.js";
+import { HostChecklist, PreviewLines } from "./panel-parts.js";
+import { rowStyle } from "./theme.js";
+import { theme } from "./theme.js";
+/** Scope and counts, the filter line, and why the list may be empty. */
+export function CatalogHeader({ scope, listed, installable, total, filter }) {
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.muted, children: ["Scope: ", scope, "  ", listed, " of ", installable] }), filter.editing || filter.query !== "" ? (_jsxs(Text, { children: ["Filter: ", filter.query, filter.editing ? "_" : ""] })) : null, total === 0 ? _jsx(Text, { children: "No skills" }) : null, total > 0 && installable === 0 ? _jsx(Text, { children: "All skills are installed" }) : null, installable > 0 && listed === 0 ? _jsx(Text, { children: "No matching skills" }) : null] }));
+}
+/** One line of the Catalog tree: cursor, indent, mark box, label and the unmanaged-copy marker. */
+export function CatalogRowLine({ row, selected, marked, installed }) {
+    const { data } = row.node;
+    const isSource = data.kind === "source";
+    return (_jsxs(Text, { ...rowStyle(selected), color: isSource ? theme.group : undefined, children: [selected ? "> " : "  ", "  ".repeat(row.depth), isSource ? "" : marked ? "[x] " : "[ ] ", describeRow(row), data.kind === "skill" && hasUnmanagedCopy(data.skill, installed)
+                ? _jsxs(Text, { color: theme.marker, children: ["  ", UNMANAGED_MARKER] })
+                : null] }));
+}
+/** The prompt of the install flow; browsing shows nothing. */
+export function ActionPanel({ mode }) {
+    switch (mode.kind) {
+        case "browse":
+            return null;
+        case "host":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Install ", describeSkills(mode.skills), ". Host (space/1-4 toggle, j/k move, Enter continue, Esc cancel):"] }), _jsx(HostChecklist, { choices: HOST_CHOICES, cursor: mode.cursor, selected: mode.selected })] }));
+        case "scope":
+            return _jsxs(Text, { children: ["Scope: ", SCOPE_CHOICES.map((scope, i) => `${i + 1} ${scope}`).join("  "), "  (Esc cancel)"] });
+        case "version":
+            return _jsx(Text, { children: "Version: 1 latest  2 fixed  (Esc cancel)" });
+        case "fixed":
+            return _jsxs(Text, { children: ["Fixed version: ", mode.value, "_  (Enter confirm, Esc cancel)"] });
+        case "confirm-install": {
+            const ready = mode.items.filter((item) => item.prepared !== undefined);
+            const single = mode.items.length === 1;
+            return (_jsxs(Box, { flexDirection: "column", children: [mode.items.map(({ skill, prepared, error }) => prepared === undefined ? (_jsxs(Text, { color: theme.error, children: ["Cannot install ", skill.name, ": ", error] }, skillKey(skill))) : (_jsxs(Box, { flexDirection: "column", children: [single ? null : _jsx(Text, { color: theme.group, children: skill.name }), _jsx(PreviewLines, { lines: prepared.preview })] }, skillKey(skill)))), ready.some((item) => item.prepared?.runsExternalCommand) ? _jsx(Text, { color: theme.warning, children: "This install runs an external command (see above)." }) : null, _jsxs(Text, { children: ["Install ", describeSkills(ready.map((item) => item.skill)), "? y/n"] })] }));
+        }
+        case "confirm-exposure": {
+            const names = mode.items.filter((item) => item.prepared?.additionalHostExposure).map((item) => item.skill.name);
+            return (_jsxs(Text, { color: theme.warning, children: [names.length === 1 ? `An identical ${names[0]} already exists` : `Identical copies of ${names.join(", ")} already exist`, "; adding the missing Host location needs separate confirmation (CLI: --confirm-additional-host). Confirm? y/n"] }));
+        }
+        case "busy":
+            return _jsx(Text, { children: mode.label });
+    }
+}

package/dist/src/tui/catalog-state.js

@@ -0,0 +1,92 @@
+import { useCallback, useEffect, useReducer, useRef, useState } from "react";
+import { filterReducer, initialFilter } from "./catalog-filter.js";
+import { loadInstalledSkills, NO_INSTALLED } from "./catalog-installs.js";
+/** Discovers the Skills of one Source, or of all of them, and again whenever those inputs change. */
+export function useCatalogSkills(operations, sourceId, all) {
+    const [state, setState] = useState({ status: "loading" });
+    useEffect(() => {
+        let cancelled = false;
+        if (!operations.discoverSkills) {
+            setState({ status: "error", message: "Discovery is not supported by the configured operations" });
+            return;
+        }
+        setState({ status: "loading" });
+        void (async () => {
+            try {
+                const ids = all || sourceId === undefined
+                    ? (await operations.listSources()).map((source) => source.id)
+                    : [sourceId];
+                const skills = await operations.discoverSkills(ids);
+                if (!cancelled)
+                    setState({ status: "ready", skills });
+            }
+            catch (error) {
+                if (!cancelled)
+                    setState({ status: "error", message: error instanceof Error ? error.message : String(error) });
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [operations, sourceId, all]);
+    return state;
+}
+/** The Skills already installed, loaded on mount and on demand. */
+export function useInstalledSkills(operations, env, mounted) {
+    const [installed, setInstalled] = useState(NO_INSTALLED);
+    const [installedReady, setInstalledReady] = useState(false);
+    const reloadInstalled = useCallback(async () => {
+        const loaded = await loadInstalledSkills(operations, env);
+        if (!mounted.current)
+            return;
+        setInstalled(loaded);
+        setInstalledReady(true);
+    }, [operations, env, mounted]);
+    useEffect(() => {
+        void reloadInstalled();
+    }, [reloadInstalled]);
+    return { installed, installedReady, reloadInstalled };
+}
+/**
+ * The filter box. Its state is mirrored in refs, updated first, so the shell
+ * never sees a stale capturing state and keystrokes delivered in one burst are not lost.
+ */
+export function useCatalogFilter(actionRef, onCapturingChange) {
+    const [filter, dispatchFilter] = useReducer(filterReducer, initialFilter);
+    const filterRef = useRef(initialFilter);
+    // The typed query, so keystrokes delivered in one burst are not lost to stale closures.
+    const typed = useRef("");
+    const queryRef = useRef(filter.query);
+    queryRef.current = filter.query;
+    const dispatch = (event) => {
+        filterRef.current = filterReducer(filterRef.current, event);
+        onCapturingChange?.(filterRef.current.editing || actionRef.current.kind !== "browse");
+        dispatchFilter(event);
+    };
+    const edit = (query, restartList) => {
+        typed.current = query;
+        restartList();
+        dispatch({ type: "edit", query });
+    };
+    const clear = (restartList) => {
+        typed.current = "";
+        queryRef.current = "";
+        restartList();
+        dispatch({ type: "clear" });
+    };
+    const open = () => {
+        typed.current = filterRef.current.query;
+        dispatch({ type: "open" });
+    };
+    const handleEditKey = (input, key, restartList) => {
+        if (key.escape)
+            clear(restartList);
+        else if (key.return)
+            dispatch({ type: "keep" });
+        else if (key.backspace || key.delete)
+            edit(typed.current.slice(0, -1), restartList);
+        else if (input !== "" && !key.ctrl && !key.meta)
+            edit(typed.current + input, restartList);
+    };
+    return { filter, filterRef, queryRef, open, clear, handleEditKey };
+}

package/dist/src/tui/catalog-tree.js

@@ -0,0 +1,35 @@
+import { defaultExpanded } from "./tree.js";
+const DESCRIPTION_LIMIT = 60;
+export const UNMANAGED_MARKER = "on disk, unmanaged · adopt it from Installations";
+export const skillKey = (skill) => `skill:${skill.sourceId}:${skill.path}`;
+function truncate(text) {
+    return text.length > DESCRIPTION_LIMIT ? `${text.slice(0, DESCRIPTION_LIMIT - 3)}...` : text;
+}
+/** Skills grouped by Source in first-seen order; a Source with no Skills never appears. */
+export function buildTree(skills) {
+    const bySource = new Map();
+    for (const skill of skills)
+        bySource.set(skill.sourceId, [...(bySource.get(skill.sourceId) ?? []), skill]);
+    return [...bySource].map(([sourceId, members]) => ({
+        id: `source:${sourceId}`,
+        data: { kind: "source", sourceId, count: members.length },
+        children: members.map((skill) => ({ id: skillKey(skill), data: { kind: "skill", skill } })),
+    }));
+}
+function allSourceIds(roots) {
+    return new Set(roots.filter((root) => (root.children?.length ?? 0) > 0).map((root) => root.id));
+}
+/** While a filter is set every matching source is open so the matches show; otherwise only the first. */
+export function openByDefault(nodes, query) {
+    return query === "" ? defaultExpanded(nodes) : allSourceIds(nodes);
+}
+export function describeRow(row) {
+    const { data } = row.node;
+    if (data.kind === "source")
+        return `${row.expanded ? "▾" : "▸"} ${data.sourceId} (${data.count})`;
+    return `${data.skill.name}  ${truncate(data.skill.description)}`;
+}
+/** The Skills under the tree's Sources, in display order. */
+export function leavesOf(roots) {
+    return roots.flatMap((root) => (root.children ?? []).flatMap((child) => child.data.kind === "skill" ? [child.data.skill] : []));
+}

package/dist/src/tui/catalog-view.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { BROWSE } from "./catalog-actions.js";
+import { handleCatalogBrowseKey } from "./catalog-browse.js";
+import { filterSkills } from "./catalog-filter.js";
+import { handleCatalogActionKey } from "./catalog-flow.js";
+import { isInstalled } from "./catalog-installs.js";
+import { ActionPanel, CatalogHeader, CatalogRowLine } from "./catalog-panel.js";
+import { ListFooter } from "./panel-parts.js";
+import { useCatalogFilter, useCatalogSkills, useInstalledSkills } from "./catalog-state.js";
+import { buildTree, leavesOf, openByDefault, skillKey } from "./catalog-tree.js";
+import { theme } from "./theme.js";
+import { useTreeNavigation } from "./tree-navigation.js";
+import { useMarks, useMounted } from "./view-state.js";
+import { computeWindow, useListHeight } from "./window.js";
+import { useKeys } from "./keys.js";
+const NO_ENVIRONMENT = {};
+export function CatalogView({ operations, sourceId, onCapturingChange, environment, listHeight }) {
+    const height = useListHeight(listHeight, 6);
+    const env = environment ?? NO_ENVIRONMENT;
+    const [all, setAll] = useState(sourceId === undefined);
+    const mounted = useMounted();
+    const marks = useMarks();
+    const [message, setMessage] = useState();
+    const [action, setActionState] = useState(BROWSE);
+    // Mirrors the action mode synchronously, like the filter, so later keystrokes and the shell never see stale state.
+    const actionRef = useRef(BROWSE);
+    const filter = useCatalogFilter(actionRef, onCapturingChange);
+    const state = useCatalogSkills(operations, sourceId, all);
+    const { installed, installedReady, reloadInstalled } = useInstalledSkills(operations, env, mounted);
+    const setAction = (next) => {
+        actionRef.current = next;
+        onCapturingChange?.(filter.filterRef.current.editing || next.kind !== "browse");
+        setActionState(next);
+    };
+    const skills = state.status === "ready" ? state.skills : [];
+    const installable = useMemo(() => skills.filter((skill) => !isInstalled(skill, installed)), [state, installed]);
+    const visible = useMemo(() => filterSkills(installable, filter.filter.query), [installable, filter.filter.query]);
+    const roots = useMemo(() => buildTree(visible), [visible]);
+    const navigation = useTreeNavigation(roots, (nodes) => openByDefault(nodes, filter.queryRef.current));
+    // Discovering again starts the list over.
+    const { restart } = navigation;
+    useEffect(restart, [operations, sourceId, all, restart]);
+    const { rows, index } = navigation;
+    const flow = {
+        operations,
+        env,
+        setAction,
+        setMessage,
+        isMounted: () => mounted.current,
+        keepMarked: marks.setMarked,
+        finish: async (result) => {
+            await reloadInstalled();
+            if (!mounted.current)
+                return;
+            setMessage(result);
+            setAction(BROWSE);
+        },
+    };
+    const browse = {
+        navigation,
+        height,
+        marks,
+        filter,
+        canWiden: sourceId !== undefined,
+        ready: state.status === "ready",
+        toggleAll: () => setAll((value) => !value),
+        setMessage,
+        setAction,
+    };
+    useKeys((input, key) => {
+        const mode = actionRef.current;
+        if (mode.kind !== "browse")
+            handleCatalogActionKey(flow, mode, input, key);
+        else if (filter.filterRef.current.editing)
+            filter.handleEditKey(input, key, navigation.restart);
+        else
+            handleCatalogBrowseKey(browse, input, key);
+    });
+    const scope = all || sourceId === undefined ? "all sources" : sourceId;
+    if (state.status === "loading" || (state.status === "ready" && !installedReady))
+        return _jsx(Text, { children: "Loading skills..." });
+    if (state.status === "error")
+        return _jsxs(Text, { color: theme.error, children: ["Error: ", state.message] });
+    const window = computeWindow(rows.length, index, height);
+    const selectedCount = leavesOf(roots).filter((skill) => marks.marked.has(skillKey(skill))).length;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(CatalogHeader, { scope: scope, listed: visible.length, installable: installable.length, total: skills.length, filter: filter.filter }), rows.slice(window.start, window.end).map((row, offset) => (_jsx(CatalogRowLine, { row: row, selected: window.start + offset === index, marked: marks.marked.has(row.node.id), installed: installed }, row.node.id))), _jsx(ListFooter, { indicator: window.indicator, selectedCount: selectedCount, message: message }), _jsx(ActionPanel, { mode: action })] }));
+}

package/dist/src/tui/environment.js

@@ -0,0 +1 @@
+export {};