@iseoane/agent-depot 0.2.0 → 0.3.0

package/dist/src/tui/installations-browse.js

@@ -0,0 +1,136 @@
+import { appName } from "./app-actions.js";
+import { startBulkHostAddition, startBulkUninstall } from "./bulk-actions.js";
+import { skillOf, sourceIdOf } from "./installations.js";
+import { leavesOf, targetOf } from "./installations-tree.js";
+import { startHostAddition, startUninstall } from "./manage-actions.js";
+import { startUnmanagedRemoval } from "./unmanaged-actions.js";
+import { navigateTree } from "./tree-navigation.js";
+import { toggleNode } from "./tree.js";
+import { toggledMark } from "./view-state.js";
+/** Why a key does nothing on a group row. */
+const GROUP_ROW_MESSAGE = {
+    A: "Adoption is not available for group rows",
+    u: "Uninstall is not available for group rows",
+    h: "Host changes are not available for group rows",
+    i: "Host changes are not available for group rows",
+};
+/** The marked leaves in display order; marks whose rows no longer exist are ignored. */
+function markedTargets(context) {
+    const roots = context.navigation.latestRoots();
+    return leavesOf(roots).filter((node) => context.marks.markedRef.current.has(node.id)).flatMap((node) => targetOf(node) ?? []);
+}
+function markRow(context, row) {
+    if (!row)
+        return;
+    if (row.node.data.kind === "group") {
+        context.setMessage({ kind: "error", text: "Mark skills, not group rows" });
+        return;
+    }
+    context.setMessage(undefined);
+    context.marks.setMarked(toggledMark(context.marks.markedRef.current, row.node.id));
+}
+/** `a`: marks every listed leaf, or unmarks them when they are all marked already. */
+function markAllListed(context, visible) {
+    const { markedRef, setMarked } = context.marks;
+    const leaves = visible.filter((candidate) => candidate.node.data.kind !== "group").map((candidate) => candidate.node.id);
+    if (leaves.length === 0) {
+        context.setMessage({ kind: "error", text: "There are no skills to select" });
+        return;
+    }
+    context.setMessage(undefined);
+    const all = leaves.every((id) => markedRef.current.has(id));
+    setMarked(all
+        ? new Set([...markedRef.current].filter((id) => !leaves.includes(id)))
+        : new Set([...markedRef.current, ...leaves]));
+}
+function actOnUnmanaged(context, group, input, key) {
+    if (input === "u")
+        startUnmanagedRemoval(context.manage, group);
+    else if (input === "A" || key.return)
+        context.startAdoption(group);
+    else
+        context.setMessage({ kind: "error", text: "Host changes are not available for unmanaged skills" });
+}
+function actOnInstallation(context, data, item, input, key) {
+    if (input === "A" || key.return) {
+        context.setMessage({ kind: "error", text: "Adoption applies to unmanaged skills; u uninstalls and h adds hosts here" });
+        return;
+    }
+    if (item.row.scope === "project") {
+        context.setMessage({ kind: "error", text: input === "u" ? "Project uninstall is not supported" : "Project installations are managed with the CLI" });
+        return;
+    }
+    const sourceId = sourceIdOf(item.row.selection, data.sources);
+    if (sourceId === undefined) {
+        context.setMessage({ kind: "error", text: "The Source of this installation is no longer registered" });
+        return;
+    }
+    const skill = skillOf(item.row, sourceId);
+    if (input === "u")
+        startUninstall(context.manage, skill);
+    else
+        startHostAddition(context.manage, skill);
+}
+/** `A`, Enter, `u`, `h` and `i` on the highlighted row. */
+function actOnRow(context, snapshot, row, input, key) {
+    const { data } = context;
+    if (!row || !data)
+        return;
+    const item = row.node.data;
+    if (item.kind === "group") {
+        if (key.return)
+            context.navigation.setExpanded(toggleNode(snapshot.open, row));
+        else
+            context.setMessage({ kind: "error", text: GROUP_ROW_MESSAGE[input] });
+        return;
+    }
+    context.setMessage(undefined);
+    if (item.kind === "unmanaged")
+        actOnUnmanaged(context, item.group, input, key);
+    else if (item.kind === "app") {
+        if (input === "A")
+            context.setMessage({ kind: "error", text: "Adoption applies to unmanaged Skills, not Apps" });
+        else if (key.return && item.row.inspection.status !== "needs approval") {
+            const { entry, inspection } = item.row;
+            const approved = inspection.status === "installed" || inspection.status === "not installed";
+            context.setMessage({
+                kind: approved ? "ok" : "error",
+                text: approved ? `${appName(entry)} is already approved` : inspection.reason ?? inspection.status,
+            });
+        }
+        else
+            context.startApps([item.row.entry], key.return ? "approve" : input);
+    }
+    else if (item.kind === "installation")
+        actOnInstallation(context, data, item, input, key);
+}
+/** Keys while browsing: navigation, marks, bulk actions and the per-row actions. */
+export function handleBrowseKey(context, input, key) {
+    const snapshot = context.navigation.latest();
+    if (navigateTree(context.navigation, snapshot, context.height, input, key))
+        return;
+    const row = snapshot.visible[snapshot.at];
+    const rowAction = input === "A" || key.return || input === "u" || input === "h" || input === "i";
+    const appMarks = leavesOf(context.navigation.latestRoots()).filter(node => context.marks.markedRef.current.has(node.id) && node.data.kind === "app");
+    if ((input === "u" || input === "h" || input === "i") && appMarks.length) {
+        if (markedTargets(context).length)
+            context.setMessage({ kind: "error", text: "Select Apps or Skills separately for bulk actions" });
+        else
+            context.startApps(appMarks.flatMap(node => node.data.kind === "app" ? [node.data.row.entry] : []), input);
+    }
+    else if (input === " ")
+        markRow(context, row);
+    else if (input === "a")
+        markAllListed(context, snapshot.visible);
+    else if ((input === "u" || input === "h" || input === "i") && context.data && markedTargets(context).length > 0) {
+        // Marks, including those on collapsed rows, turn the action into a bulk one.
+        context.setMessage(undefined);
+        const targets = markedTargets(context);
+        if (input === "u")
+            void startBulkUninstall(context.manage, targets);
+        else
+            startBulkHostAddition(context.manage, targets);
+    }
+    else if (rowAction)
+        actOnRow(context, snapshot, row, input, key);
+}

package/dist/src/tui/installations-mode.js

@@ -0,0 +1 @@
+export const BROWSE = { kind: "browse" };

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

@@ -0,0 +1,27 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { HOST_CHOICES } from "./catalog-actions.js";
+import { ManagePanel } from "./manage-panel.js";
+import { HostChecklist, PreviewLines } from "./panel-parts.js";
+import { theme } from "./theme.js";
+/** The prompt of the adoption and manage modes; browsing shows nothing. */
+export function ModePanel({ mode }) {
+    switch (mode.kind) {
+        case "browse":
+            return null;
+        case "pick":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Adopt ", mode.entry.name, ": several Source Skills match. j/k move, Enter select, Esc cancel:"] }), mode.candidates.map((skill, position) => (_jsxs(Text, { children: [position === mode.cursor ? "> " : "  ", skill.path, "  ", skill.sourceId] }, `${skill.sourceId}:${skill.path}`)))] }));
+        case "host":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Adopt ", mode.entry.name, " as ", mode.skill.path, ". Host (space/1-4 toggle, j/k move, Enter continue, Esc cancel):"] }), _jsx(HostChecklist, { choices: HOST_CHOICES, cursor: mode.cursor, selected: mode.selected })] }));
+        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":
+            return mode.adoption.verdict.adoptable ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(PreviewLines, { lines: mode.adoption.prepared.preview }), mode.adoption.prepared.runsExternalCommand ? _jsx(Text, { color: theme.warning, children: "This install runs an external command (see above)." }) : null, _jsxs(Text, { children: ["Adopt ", mode.entry.name, "? y/n"] })] })) : (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.error, children: mode.adoption.verdict.reason }), _jsx(Text, { children: "Enter/Esc to go back" })] }));
+        case "confirm-exposure":
+            return (_jsxs(Text, { color: theme.warning, children: ["Adopting ", mode.entry.name, " adds the missing Host location and exposes it to more hosts; this needs separate confirmation (CLI: --confirm-additional-host). Confirm? y/n"] }));
+        default:
+            return _jsx(ManagePanel, { mode: mode });
+    }
+}

package/dist/src/tui/installations-rows.js

@@ -0,0 +1,11 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+import { describeDetails, describeLinks, describeNode, markersOf } from "./installations-tree.js";
+import { rowStyle, theme } from "./theme.js";
+/** One line of the Installations tree: cursor, indent, mark box, label and the leaf's details. */
+export function TreeRowLine({ row, selected, marked }) {
+    const item = row.node.data;
+    const leaf = !row.expandable && item.kind !== "group";
+    const prefix = `${selected ? "> " : "  "}${"  ".repeat(row.depth)}${leaf ? (marked ? "[x] " : "[ ] ") : ""}`;
+    return (_jsxs(Text, { ...rowStyle(selected), color: item.kind === "group" ? theme.group : undefined, children: [prefix, describeNode(row), item.kind === "installation" ? (_jsxs(Text, { color: theme.marker, children: ["  ", describeDetails(item.row), markersOf(item.row) === "" ? "" : `  ${markersOf(item.row)}`] })) : null, item.kind === "unmanaged" && describeLinks(item.group) !== "" ? (_jsxs(Text, { color: theme.marker, children: ["  ", describeLinks(item.group)] })) : null] }));
+}

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

@@ -0,0 +1,80 @@
+/** Managed installations of one scope, grouped by Source in first-seen order. */
+function sourceNodes(scope, rows) {
+    const bySource = new Map();
+    for (const row of rows)
+        bySource.set(row.source, [...(bySource.get(row.source) ?? []), row]);
+    return [...bySource].map(([source, members]) => ({
+        id: `source:${scope}:${source}`,
+        data: { kind: "group", label: `${source} (${members.length})` },
+        children: members.map((row) => ({
+            id: `installation:${scope}:${source}:${row.selection.installation?.path ?? row.selection.path}`,
+            data: { kind: "installation", row },
+        })),
+    }));
+}
+/** Scope, then Source, then Skills; Unmanaged is its own group. Counts come from data already loaded. */
+export function buildTree(data) {
+    const roots = [];
+    if (data.global !== undefined) {
+        roots.push({
+            id: "scope:user-global",
+            data: { kind: "group", label: `Managed (user-global) (${data.global.length})` },
+            children: sourceNodes("user-global", data.global),
+        });
+    }
+    roots.push({
+        id: "scope:project",
+        data: { kind: "group", label: `Managed (project) (${data.project.length})` },
+        children: sourceNodes("project", data.project),
+    });
+    roots.push({
+        id: "scope:unmanaged",
+        data: {
+            kind: "group",
+            label: `Unmanaged (user-global) (${data.unmanaged.length})${data.unmanagedWarnings?.length ? ` — ${data.unmanagedWarnings.join("; ")}` : ""}`,
+        },
+        children: data.unmanaged.map((group) => ({ id: `unmanaged:${group.name}`, data: { kind: "unmanaged", group } })),
+    });
+    if (data.apps?.length || data.appsError)
+        roots.push({
+            id: "scope:apps", data: { kind: "group", label: `Apps (user-global) (${data.apps?.length ?? 0})${data.appsError ? ` — ${data.appsError}` : ""}` },
+            children: (data.apps ?? []).map(row => ({ id: `app:${row.entry.file}`, data: { kind: "app", row } })),
+        });
+    return roots;
+}
+/** Version, policy and hosts of a leaf; `adopted` / `modified` only when true (the legend explains them). */
+export function describeDetails({ selection, policy, installed }) {
+    return `${installed} (${policy})  [${selection.hosts.join(", ")}]`;
+}
+export function markersOf({ adopted, modified }) {
+    return [adopted ? "adopted" : "", modified ? "modified" : ""].filter((flag) => flag !== "").join(" ");
+}
+/** Every leaf of the tree in display order, whether or not its group is open. */
+export function leavesOf(roots) {
+    return roots.flatMap((node) => (node.children === undefined ? (node.data.kind === "group" ? [] : [node]) : leavesOf(node.children)));
+}
+export function targetOf(node) {
+    const { data } = node;
+    if (data.kind === "installation")
+        return { id: node.id, leaf: { kind: "installation", row: data.row } };
+    if (data.kind === "unmanaged")
+        return { id: node.id, leaf: { kind: "unmanaged", group: data.group } };
+    return undefined;
+}
+export function describeNode(row) {
+    const { data } = row.node;
+    if (data.kind === "group")
+        return `${row.expandable ? (row.expanded ? "▾" : "▸") : " "} ${data.label}`;
+    if (data.kind === "installation")
+        return data.row.selection.path;
+    if (data.kind === "app") {
+        const { entry, inspection } = data.row;
+        return `${entry.recipe?.name ?? entry.file}  ${inspection.status === "invalid" ? `invalid recipe: ${inspection.reason}` : inspection.installedVersion ?? inspection.status}`;
+    }
+    return `${data.group.name} [${data.group.hosts.join(", ")}]`;
+}
+/** `symlink → <target>` for the locations that are links, one entry per distinct target. */
+export function describeLinks(group) {
+    const targets = [...new Set(group.locations.flatMap((location) => location.linkTarget === undefined ? [] : [location.linkTarget]))];
+    return targets.length === 0 ? "" : `symlink → ${targets.join(", ")}`;
+}

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

@@ -0,0 +1,154 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createAppOperations } from "../app-flow.js";
+import { handleAppKey, isAppMode, startAppAction } from "./app-actions.js";
+import { loadInstallations } from "./installations.js";
+import { BROWSE } from "./installations-mode.js";
+import { errorText } from "./batch.js";
+import { handleAdoptionKey, startAdoption } from "./adoption-actions.js";
+import { handleBrowseKey } from "./installations-browse.js";
+import { handleManageKey } from "./manage-actions.js";
+import { ModePanel } from "./installations-panel.js";
+import { TreeRowLine } from "./installations-rows.js";
+import { buildTree, leavesOf, markersOf } from "./installations-tree.js";
+import { ListFooter } from "./panel-parts.js";
+import { useTreeNavigation } from "./tree-navigation.js";
+import { defaultExpanded } from "./tree.js";
+import { theme } from "./theme.js";
+import { useMarks, useMounted } from "./view-state.js";
+import { computeWindow, useListHeight } from "./window.js";
+import { useKeys } from "./keys.js";
+const NO_ENVIRONMENT = {};
+const LEGEND = "adopted: tracked in place · modified: changed on disk";
+export function InstallationsView({ operations, environment, onCapturingChange, listHeight }) {
+    const height = useListHeight(listHeight, 7);
+    const env = environment ?? NO_ENVIRONMENT;
+    const apps = useMemo(() => createAppOperations({ homeDirectory: env.homeDirectory, ...env.appEnvironment }), [env]);
+    const [state, setState] = useState({ status: "loading" });
+    const [mode, setModeState] = useState(BROWSE);
+    // Mirrors the mode synchronously so later keystrokes and the shell never see stale state.
+    const modeRef = useRef(BROWSE);
+    const marks = useMarks();
+    const mounted = useMounted();
+    const [message, setMessage] = useState();
+    const setMode = (next) => {
+        modeRef.current = next;
+        onCapturingChange?.(next.kind !== "browse");
+        setModeState(next);
+    };
+    const loadGeneration = useRef(0);
+    const reload = useCallback(async () => {
+        const generation = ++loadGeneration.current;
+        try {
+            const data = await loadInstallations(operations, env, apps);
+            if (mounted.current && generation === loadGeneration.current)
+                setState({ status: "ready", data });
+        }
+        catch (error) {
+            if (mounted.current && generation === loadGeneration.current)
+                setState({ status: "error", message: errorText(error) });
+        }
+    }, [operations, env, apps, mounted]);
+    useEffect(() => {
+        void reload();
+    }, [reload]);
+    const data = state.status === "ready" ? state.data : undefined;
+    const roots = useMemo(() => (data ? buildTree(data) : []), [data]);
+    const navigation = useTreeNavigation(roots, defaultExpanded);
+    const { rows, index } = navigation;
+    const checked = useRef(new Set());
+    const highlighted = rows[index]?.node.data;
+    useEffect(() => {
+        if (highlighted?.kind !== "app")
+            return;
+        const { entry } = highlighted.row;
+        const identity = `${entry.file}:${entry.hash}`;
+        if (checked.current.has(identity))
+            return;
+        checked.current.add(identity);
+        const generation = loadGeneration.current;
+        void apps.inspect(entry).then(inspection => {
+            if (!mounted.current || generation !== loadGeneration.current)
+                return;
+            setState(previous => previous.status !== "ready" ? previous : {
+                ...previous,
+                data: {
+                    ...previous.data,
+                    apps: previous.data.apps?.map(row => row.entry.file === entry.file && row.entry.hash === entry.hash
+                        ? { entry, inspection } : row),
+                },
+            });
+        }).catch(error => {
+            if (!mounted.current || generation !== loadGeneration.current)
+                return;
+            checked.current.delete(identity);
+            setMessage({ kind: "error", text: errorText(error) });
+        });
+    }, [highlighted, apps, mounted]);
+    const installed = useMemo(() => ({
+        global: (data?.global ?? []).map((row) => row.selection),
+        project: (data?.project ?? []).map((row) => row.selection),
+        sources: data?.sources ?? [],
+        unmanagedNames: new Set(),
+    }), [data]);
+    const manage = {
+        operations,
+        env,
+        installed,
+        setMode,
+        browse: () => setMode(BROWSE),
+        setMessage,
+        isMounted: () => mounted.current,
+        unmark: (ids) => marks.setMarked(new Set([...marks.markedRef.current].filter((id) => !ids.includes(id)))),
+        finish: async (result) => {
+            checked.current.clear();
+            await reload();
+            if (!mounted.current)
+                return;
+            setMessage(result);
+            setMode(BROWSE);
+        },
+    };
+    const adoption = {
+        operations,
+        env,
+        setMode,
+        browse: manage.browse,
+        setMessage,
+        isMounted: manage.isMounted,
+        reload,
+    };
+    const browse = {
+        navigation,
+        height,
+        marks,
+        data,
+        manage,
+        startAdoption: (group) => void startAdoption(adoption, group),
+        setMessage,
+        startApps: (entries, input) => void startAppAction({ apps, manage }, entries, input),
+    };
+    useKeys((input, key) => {
+        const current = modeRef.current;
+        if (current.kind === "browse")
+            handleBrowseKey(browse, input, key);
+        else if (isAppMode(current))
+            handleAppKey({ apps, manage }, current, input, key);
+        else if (!handleManageKey(manage, current, input, key))
+            handleAdoptionKey(adoption, current, input, key);
+    });
+    if (state.status === "loading")
+        return _jsx(Text, { children: "Loading installations..." });
+    if (state.status === "error")
+        return _jsxs(Text, { color: theme.error, children: ["Error: ", state.message] });
+    const ready = state.data;
+    const window = computeWindow(rows.length, index, height);
+    const listed = rows.slice(window.start, window.end);
+    const markedLeaves = leavesOf(roots).filter(node => marks.marked.has(node.id));
+    const selectedCount = markedLeaves.length;
+    const markedApps = markedLeaves.filter(node => node.data.kind === "app").length;
+    // The legend explains the markers, so it shows only while a rendered row carries one.
+    const legendNeeded = listed.some((row) => row.node.data.kind === "installation" && markersOf(row.node.data.row) !== "");
+    return (_jsxs(Box, { flexDirection: "column", children: [ready.global === undefined ? _jsx(Text, { children: "User-global installations are not supported by the configured operations" }) : null, ready.projectError === undefined ? null : _jsxs(Text, { color: theme.error, children: ["Error: ", ready.projectError] }), listed.map((row, offset) => (_jsx(TreeRowLine, { row: row, selected: window.start + offset === index, marked: marks.marked.has(row.node.id) }, row.node.id))), _jsx(ListFooter, { indicator: window.indicator, selectedCount: selectedCount, message: message }), markedApps > 0 ? _jsxs(Text, { color: theme.muted, children: [markedApps, " Apps marked"] }) : null, legendNeeded ? _jsx(Text, { color: theme.muted, children: LEGEND }) : null, _jsx(ModePanel, { mode: mode })] }));
+}

package/dist/src/tui/installations.js

@@ -0,0 +1,172 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { createAppOperations } from "../app-flow.js";
+import { defaultProjectManifestPath, ProjectManifestStore, } from "../project-manifest.js";
+import { formatVersionPolicy } from "../skill-install.js";
+import { inspectSkillRemovals, userGlobalRemovalOptions } from "../skill-removal.js";
+import { scanUserGlobalSkillInventory, } from "../user-global-skill-inventory.js";
+import { errorText } from "./batch.js";
+import { prepareInstall } from "./catalog-installs.js";
+/** Hosts in display order; the Claude root serves Claude Code, the shared root serves the others. */
+const HOST_DISPLAY_ORDER = ["claude", "pi", "codex", "opencode"];
+const ROOT_HOSTS = {
+    agents: ["pi", "codex", "opencode"],
+    claude: ["claude"],
+};
+/**
+ * Groups the unmanaged directories, the unmanaged symlinks and the Claude links that
+ * expose an unmanaged canonical directory by Skill name. Hosts come from the root kinds.
+ */
+export function groupUnmanaged(inventory) {
+    const byName = new Map();
+    const add = (name, location) => byName.set(name, [...(byName.get(name) ?? []), location]);
+    for (const entry of inventory.unmanaged)
+        add(entry.name, { path: entry.path, root: entry.root, entry });
+    for (const link of inventory.symlinks)
+        add(link.name, { path: link.path, root: link.root, linkTarget: link.target });
+    const unmanagedPaths = new Set(inventory.unmanaged.map((entry) => path.resolve(entry.path)));
+    for (const exposure of inventory.exposures) {
+        if (unmanagedPaths.has(path.resolve(exposure.target))) {
+            add(exposure.name, { path: exposure.path, root: exposure.root, linkTarget: exposure.target });
+        }
+    }
+    return [...byName]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, locations]) => {
+        const ordered = [...locations].sort((left, right) => Number(left.root === "claude") - Number(right.root === "claude"));
+        const hosts = HOST_DISPLAY_ORDER.filter((host) => ordered.some((location) => ROOT_HOSTS[location.root].includes(host)));
+        return { name, locations: ordered, hosts };
+    });
+}
+export function homeOf(environment) {
+    return path.resolve(environment.homeDirectory ?? homedir());
+}
+function projectRootOf(environment) {
+    return path.resolve(environment.projectRoot ?? process.cwd());
+}
+function sourceLabel(source) {
+    if (source.kind === "builtin")
+        return source.id;
+    return "url" in source ? `${source.url}${source.ref === undefined ? "" : `@${source.ref}`}` : source.path;
+}
+/** Short label of version evidence: the package version or the first commit characters. */
+export function formatVersionEvidence(evidence) {
+    if (!evidence)
+        return "unknown";
+    return evidence.kind === "builtin-package" ? evidence.version : evidence.commit.slice(0, 7);
+}
+function installedVersion(selection) {
+    return formatVersionEvidence(selection.installation?.resolvedVersion);
+}
+async function toRow(scope, selection, inspectionOptions) {
+    const modified = await inspectSkillRemovals([selection], inspectionOptions).then((plan) => plan.inspections[0]?.modified, () => undefined);
+    return {
+        scope,
+        selection,
+        source: sourceLabel(selection.source),
+        policy: formatVersionPolicy(selection.version),
+        installed: installedVersion(selection),
+        adopted: selection.installation?.adopted === true,
+        ...(modified === undefined ? {} : { modified }),
+    };
+}
+/** Loads both scopes and the unmanaged user-global inventory the CLI's `update check` uses. */
+export async function loadInstallations(operations, environment, appOperations = createAppOperations({ homeDirectory: homeOf(environment), ...environment.appEnvironment })) {
+    const home = homeOf(environment);
+    let apps = [];
+    let appsError;
+    try {
+        const tracked = await appOperations.trackedApps();
+        apps = await Promise.all((await appOperations.load()).filter(entry => entry.applicable).map(async (entry) => ({
+            entry,
+            inspection: await appOperations.inspect(entry, {
+                installedVersion: tracked.find(record => record.name === entry.recipe?.name
+                    && record.recipeFile === entry.canonicalFile)?.installedVersion,
+            }),
+        })));
+    }
+    catch (error) {
+        appsError = errorText(error);
+    }
+    const globalRecords = operations.listUserGlobalInstallations
+        ? await operations.listUserGlobalInstallations()
+        : undefined;
+    const globalOptions = userGlobalRemovalOptions(home, environment.installationOptions);
+    const global = globalRecords
+        ? await Promise.all(globalRecords.map((record) => toRow("user-global", record, globalOptions)))
+        : undefined;
+    const store = environment.projectManifestStore ??
+        new ProjectManifestStore(defaultProjectManifestPath(projectRootOf(environment)));
+    let projectRecords = [];
+    let projectError;
+    try {
+        projectRecords = (await store.load()).skills;
+    }
+    catch (error) {
+        projectError = error instanceof Error ? error.message : String(error);
+    }
+    const projectOptions = {
+        projectRoot: projectRootOf(environment),
+        sourceAccess: { readSkillTree: async () => [] },
+        ...environment.installationOptions,
+    };
+    const project = await Promise.all(projectRecords.map((record) => toRow("project", record, projectOptions)));
+    const unmanagedWarnings = [];
+    const unmanaged = globalRecords
+        ? groupUnmanaged(await scanUserGlobalSkillInventory({
+            homeDirectory: home,
+            managedInstallations: globalRecords,
+            appEnvironment: environment.appEnvironment,
+            reportWarning: warning => unmanagedWarnings.push(warning),
+        }))
+        : [];
+    const sources = await operations.listSources().catch(() => []);
+    return { unmanagedWarnings, global, project, ...(projectError === undefined ? {} : { projectError }), unmanaged, sources, apps, ...(appsError === undefined ? {} : { appsError }) };
+}
+/** Source id of an installation's Source, when that Source is still registered. */
+export function sourceIdOf(selection, sources) {
+    const source = selection.source;
+    if (source.kind === "builtin")
+        return source.id;
+    if (!("url" in source))
+        return undefined;
+    return sources.find((candidate) => candidate.kind === "git" && candidate.url === source.url)?.id;
+}
+/** The Skill of an installation, as the shared manage flows expect it. */
+export function skillOf(row, sourceId) {
+    return { sourceId, path: row.selection.path, name: path.posix.basename(row.selection.path), description: "" };
+}
+/** Source Skills whose directory name equals the unmanaged Skill's, across every registered Source. */
+export async function findAdoptionCandidates(operations, entry) {
+    if (!operations.discoverSkills)
+        throw new Error("Discovery is not supported by the configured operations");
+    const ids = (await operations.listSources()).map((source) => source.id);
+    return (await operations.discoverSkills(ids)).filter((skill) => path.posix.basename(skill.path) === entry.name);
+}
+/** Hosts that already read the unmanaged Skill's location, so adopting it exposes nothing new. */
+export function defaultAdoptionHosts(entry) {
+    return entry.host === "claude" ? ["claude"] : ["pi", "codex", "opencode"];
+}
+/**
+ * Adoption keeps the existing location, so it only applies when that exact
+ * location's content is identical to the selected Source Skill (the CLI's rule).
+ */
+export function adoptionVerdict(prepared, entry) {
+    const { inspection } = prepared.plan;
+    const location = path.resolve(entry.path);
+    const identical = inspection.locations.some((candidate) => candidate.status === "identical" && path.resolve(candidate.path) === location);
+    if (identical)
+        return { adoptable: true };
+    const collision = inspection.collision ?? inspection.locations.find((candidate) => candidate.collision)?.collision;
+    return {
+        adoptable: false,
+        reason: collision
+            ? `Cannot adopt ${entry.path}: it does not match the selected Source Skill (${collision.reason} at ${collision.path}); nothing was changed`
+            : `Cannot adopt ${entry.path}: no identical existing copy was found, so an install would create a new copy instead; nothing was changed`,
+    };
+}
+/** Plan step: the shared install plan (refreshing the Source) plus the adoption verdict. Changes nothing. */
+export async function prepareAdoption(operations, environment, entry, skill, choice) {
+    const prepared = await prepareInstall(operations, environment, skill, { ...choice, scope: "user-global" });
+    return { prepared, verdict: adoptionVerdict(prepared, entry) };
+}

package/dist/src/tui/keys.js

@@ -0,0 +1,31 @@
+import { useInput } from "ink";
+/** Plain printable characters only: control characters and escape sequences are never split. */
+const PRINTABLE = /^[^\p{Cc}]+$/u;
+/**
+ * Ink strips the ESC of sequences it does not resolve and hands over the rest
+ * (`[200~` paste markers, `[I` focus events, `[<0;10;5M` mouse reports). Splitting
+ * them would replay digits and letters as key presses, so they are kept whole.
+ * Only the final bytes xterm actually emits count (CSI: arrows, Home/End, focus, mouse,
+ * Shift+Tab, F1-F4, `~`; SS3: arrows, Home/End, F1-F4), so typed text such as `Ok` is not one.
+ */
+const ESCAPE_REMNANT = /^(?:\[[\d;<:?]*[A-DFHIMOPQRSZm~]|O[A-DFHPQRS])$/;
+const PASTE_MARKERS = new Set(["[200~", "[201~"]);
+/**
+ * `useInput` that treats several plain characters delivered in one write (fast
+ * typing, a paste) as the separate key presses they are, in order.
+ */
+export function useKeys(handler) {
+    useInput((input, key) => {
+        if (ESCAPE_REMNANT.test(input)) {
+            if (!PASTE_MARKERS.has(input))
+                handler(input, key);
+            return;
+        }
+        if (input.length > 1 && !key.ctrl && !key.meta && !key.escape && PRINTABLE.test(input)) {
+            for (const character of input)
+                handler(character, key);
+            return;
+        }
+        handler(input, key);
+    });
+}