@lidtop/loadout 0.3.0 → 0.3.2

package/README.md

@@ -13,7 +13,11 @@ npm install -g @lidtop/loadout
 loadout
 ```
 
-Pick your kits, select **Continue**, and confirm. Run `loadout` again to change your selection.
+Pick your kits and select **Review changes**. Any kit questions and downloads happen automatically, then one compact review shows your kit changes and file totals for Repository and Global. Expand **Unchanged** to inspect your complete selection, or choose **View files** to browse paths and diffs. Choose **Apply changes** to save, or **Back to kits** to edit your selection. Inside a provider, choose **Back to providers** to keep browsing with your selections preserved. Run `loadout` again to change your selection.
+
+The destination selector above the tabs shows **Repository** in cyan (this repository only) and **Global** in magenta (your user configuration across repositories). Active controls and selection markers follow the destination's color. Press **Tab** to switch destinations instantly, or **Shift+Tab** to cycle backward. **←/→** switches between the Kits, Browse, and Installed sections. Each destination keeps its own selections, provider, search, and cursor position, ready to browse as soon as you switch. A **\*** marks destinations with unapplied selections; **Review changes** includes the session's changes across both. Descriptions appear beneath every provider and kit, with dependency or update notes when needed.
+
+Press **Esc** from review, questions, or downloads to return to your kits. Inside file details, **Esc** returns to the previous view. Your kit choices, completed answers, and picker position are preserved; completed downloads are reused during the session and file plans are rebuilt before review. In review, **↑/↓** scroll and **Tab** moves between actions. Press **Ctrl+C** to cancel setup, or **Esc twice quickly** from the picker. Nothing is applied until you choose **Apply changes**.
 
 Conflicting project instructions are skipped with a warning; the kit’s skills still install.
 

package/dist/cli.js

@@ -5,10 +5,9 @@ import { readFileSync, realpathSync } from 'node:fs';
 import os from 'node:os';
 import { discover } from './catalog.js';
 import { initialize } from './init.js';
-import { interactive, confirmApply, selectUpdates, confirmRetry, confirmAdoption, } from './interactive.js';
-import { apply, applyAll, hasChanges, plan } from './storage.js';
+import { interactive } from './setup.js';
+import { apply, hasChanges, plan } from './storage.js';
 import { renderWithExternal } from './external.js';
-import { DownloadCancelledError } from './retry.js';
 import { loadTarget } from './targets.js';
 import { configure, disableKits, reasons, resolveKits, setAnswers, } from './resolve.js';
 import { kitSource } from './schema.js';
@@ -134,49 +133,9 @@ async function generate(catalog, state, opts) {
 }
 async function setup() {
     const { targets, initial } = interactiveTargets();
-    const configured = await interactive(targets, initial);
     const offline = program.opts().offline;
-    const plans = [];
-    for (const { target, state } of configured) {
-        const catalog = target.catalog;
-        console.log(`\n${target.label} · ${target.root}`);
-        const update = await selectUpdates(catalog, state, offline);
-        const rendered = await renderWithExternal(catalog, state, {
-            offline,
-            update,
-            retry: confirmRetry,
-            onRetry: (id) => console.log(`Retrying ${id}…`),
-            onFetch: (id, source) => console.log(`Fetching ${id} from ${source.repo}…`),
-        });
-        for (const id of resolveKits(catalog, state.selected)) {
-            const kit = catalog.kits.get(id);
-            if (kit.external) {
-                const source = update.includes(id)
-                    ? kit.external
-                    : (kit.pinned ?? kit.external);
-                console.log(`${id}: ${source.repo}@${source.ref.slice(0, 12)} · license: ${source.license}`);
-            }
-        }
-        const result = plan(catalog, state, rendered, { adopt: true });
-        preview(result, update.length > 0 || !!result.adopted?.length);
-        if (result.adopted?.length && !(await confirmAdoption(result.adopted)))
-            throw new DownloadCancelledError();
-        plans.push(result);
-    }
-    if (!plans.some(hasChanges))
-        return;
-    if (await confirmApply()) {
-        applyAll(plans);
-        console.log('\nYour loadout is ready.');
-        for (const result of plans) {
-            if (!result.skippedInstructions?.length)
-                continue;
-            console.log(result.root);
-            showSkipped(result);
-        }
-    }
-    else
-        console.log('Cancelled. No kit selections or agent outputs saved.');
+    await interactive(targets, initial, { offline });
+    console.log('\nYour loadout is ready.');
 }
 program.action(setup);
 program

package/dist/external.d.ts

@@ -33,6 +33,7 @@ declare const storeSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type Snapshot = z.infer<typeof snapshotSchema>;
+export type SnapshotCache = Map<string, Snapshot>;
 export type ExternalStore = z.infer<typeof storeSchema>;
 export type FetchBytes = (url: string, limit: number, signal?: AbortSignal) => Promise<Buffer>;
 export declare function readExternal(root: string): {
@@ -47,5 +48,8 @@ export declare function renderWithExternal(catalog: Catalog, state: State, optio
     onFetch?: (id: string, source: ExternalSource) => void;
     onRetry?: (id: string) => void;
     retry?: (id: string, error: Error) => Promise<boolean>;
+    signal?: AbortSignal;
+    cache?: SnapshotCache;
+    onReady?: (id: string) => void;
 }): Promise<Rendered>;
 export {};

package/dist/external.js

@@ -30,6 +30,12 @@ const storeSchema = z
     kits: z.record(idSchema, snapshotSchema),
 })
     .strict();
+const sourceKey = (source) => JSON.stringify({
+    repo: source.repo,
+    ref: source.ref,
+    license: source.license,
+    skills: [...source.skills].sort(),
+});
 export function readExternal(root) {
     const raw = readOptional(root, '.loadout-personal/external.json');
     return {
@@ -215,6 +221,7 @@ async function download(source, get) {
     return complete;
 }
 export async function renderWithExternal(catalog, state, options = {}) {
+    options.signal?.throwIfAborted();
     const result = render(catalog, state);
     const enabled = resolveKits(catalog, state.selected);
     const { raw, store } = readExternal(catalog.root);
@@ -222,34 +229,46 @@ export async function renderWithExternal(catalog, state, options = {}) {
         if (!enabled.includes(id) || !catalog.kits.get(id)?.external)
             throw new Error(`Cannot update ${id}: choose an enabled external kit.`);
     for (const id of enabled) {
+        options.signal?.throwIfAborted();
         const kit = catalog.kits.get(id);
         const source = kit.external;
-        if (!source)
+        if (!source) {
+            options.onReady?.(id);
             continue;
+        }
         let snapshot = Object.hasOwn(store.kits, id) ? store.kits[id] : undefined;
         const unchanged = snapshot && sameSource(snapshot.source, source);
         if (!snapshot ||
             (options.update?.includes(id) && !(options.offline && unchanged))) {
-            if (options.offline)
+            const cached = options.cache?.get(sourceKey(source));
+            if (!cached && options.offline)
                 throw new Error(`${id} is not available at the requested revision offline. Run without --offline once to fetch it.`);
-            options.onFetch?.(id, source);
-            snapshot = await retryDownload(async () => {
-                const controller = new AbortController();
-                const requests = new Map();
-                const get = (url, limit) => {
-                    if (!requests.has(url))
-                        requests.set(url, (options.fetch ?? fetchBytes)(url, limit, controller.signal));
-                    return requests.get(url);
-                };
-                try {
-                    return await download(source, get);
-                }
-                finally {
-                    controller.abort();
-                    await Promise.allSettled(requests.values());
-                    requests.clear();
-                }
-            }, options.retry ? (error) => options.retry(id, error) : undefined, () => options.onRetry?.(id));
+            if (!cached)
+                options.onFetch?.(id, source);
+            snapshot =
+                cached ??
+                    (await retryDownload(async () => {
+                        const controller = new AbortController();
+                        const requests = new Map();
+                        const get = (url, limit) => {
+                            if (!requests.has(url))
+                                requests.set(url, (options.fetch ?? fetchBytes)(url, limit, options.signal
+                                    ? AbortSignal.any([options.signal, controller.signal])
+                                    : controller.signal));
+                            return requests.get(url);
+                        };
+                        try {
+                            return await download(source, get);
+                        }
+                        finally {
+                            controller.abort();
+                            await Promise.allSettled(requests.values());
+                            requests.clear();
+                        }
+                    }, options.retry ? (error) => options.retry(id, error) : undefined, () => options.onRetry?.(id), options.signal));
+            options.signal?.throwIfAborted();
+            validateSnapshot(snapshot, id);
+            options.cache?.set(sourceKey(source), snapshot);
             store.kits[id] = snapshot;
         }
         validateSnapshot(snapshot, id);
@@ -271,6 +290,7 @@ export async function renderWithExternal(catalog, state, options = {}) {
                 });
             }
         }
+        options.onReady?.(id);
     }
     if (raw || Object.keys(store.kits).length)
         result.external = {

package/dist/interactive.d.ts

@@ -1,10 +1,16 @@
 import { checkbox, confirm, select } from '@inquirer/prompts';
-import { type Catalog, type State } from './schema.js';
-import { type TargetSelection } from './picker.js';
+import { type Answer, type Catalog, type State } from './schema.js';
 import { type Target } from './targets.js';
-export declare function interactive(targets: Target[], initial?: number): Promise<TargetSelection[]>;
-export declare function configureSelection(target: Target, state: State, context?: Parameters<typeof confirm>[1]): Promise<State>;
-export declare function confirmApply(): Promise<boolean>;
-export declare function selectUpdates(catalog: Catalog, state: State, offline?: boolean, context?: Parameters<typeof checkbox>[1]): Promise<string[]>;
+export type PromptContext = NonNullable<Parameters<typeof confirm>[1]>;
+export declare class BackNavigation extends Error {
+}
+export declare function configureSelection(target: Target, state: State, context?: Parameters<typeof confirm>[1], onAnswer?: (kit: string, key: string, answer: Answer) => void): Promise<State>;
+export declare function confirmApply(context?: PromptContext, scopes?: string[]): Promise<boolean>;
+export declare function selectUpdates(catalog: Catalog, state: State, offline?: boolean, context?: Parameters<typeof checkbox>[1], options?: {
+    message?: string;
+    selected?: string[];
+    quiet?: boolean;
+}): Promise<string[]>;
 export declare function confirmRetry(id: string, error: Error, context?: Parameters<typeof select>[1]): Promise<boolean>;
-export declare function confirmAdoption(paths: string[], context?: Parameters<typeof confirm>[1]): Promise<boolean>;
+export declare function confirmAdoption(paths: string[], context?: Parameters<typeof confirm>[1], scope?: string): Promise<boolean>;
+export declare function retryReview(error: unknown, context?: PromptContext): Promise<boolean>;

package/dist/interactive.js

@@ -1,32 +1,46 @@
 import { checkbox, confirm, select } from '@inquirer/prompts';
 import { configure } from './resolve.js';
-import { validAnswer } from './schema.js';
-import { targetPicker } from './picker.js';
+import { validAnswer, } from './schema.js';
 import { availableUpdates, updateDescription } from './updates.js';
-export async function interactive(targets, initial = 0) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY)
-        throw new Error('Interactive setup needs a terminal. Use loadout enable <kit>, then loadout apply.');
-    const chosen = await targetPicker({
-        targets,
-        initial,
-    });
-    const configured = [];
-    for (const { target, state } of chosen) {
-        const value = await configureSelection(target, state);
-        configured.push({ target, state: value });
+import { prepareInput } from './terminal.js';
+export class BackNavigation extends Error {
+}
+async function backPrompt(prompt, context = {}) {
+    const input = context.input ?? process.stdin;
+    prepareInput(input);
+    const controller = new AbortController();
+    const back = (_text, key) => {
+        if (key.name === 'escape')
+            controller.abort(new BackNavigation());
+    };
+    input.on('keypress', back);
+    try {
+        return await prompt({
+            ...context,
+            signal: context.signal
+                ? AbortSignal.any([context.signal, controller.signal])
+                : controller.signal,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.cause instanceof BackNavigation)
+            throw error.cause;
+        throw error;
+    }
+    finally {
+        input.off('keypress', back);
     }
-    return configured;
 }
-export async function configureSelection(target, state, context) {
+export async function configureSelection(target, state, context, onAnswer) {
     const change = new Map();
-    return configure(target.catalog, state, async (kit, key, question, value) => {
+    const ask = async (kit, key, question, value) => {
         if (!change.has(kit)) {
             const hasSaved = Object.entries(target.catalog.kits.get(kit).questions).some(([name, q]) => validAnswer(q, state.answers[kit]?.[name]));
             change.set(kit, hasSaved
-                ? await confirm({
+                ? await backPrompt((context) => confirm({
                     message: `${target.label} · ${kit} · Change selection?`,
                     default: false,
-                }, context)
+                }, context), context)
                 : true);
         }
         const saved = state.answers[kit]?.[key];
@@ -34,47 +48,76 @@ export async function configureSelection(target, state, context) {
             return saved;
         const message = `${target.label} · ${kit} · ${question.message}`;
         if (question.type === 'boolean')
-            return confirm({ message, default: typeof value === 'boolean' ? value : false }, context);
-        return select({
+            return backPrompt((context) => confirm({ message, default: typeof value === 'boolean' ? value : false }, context), context);
+        return backPrompt((context) => select({
             message,
             choices: question.choices.map((v) => ({ name: v, value: v })),
             default: typeof value === 'string' ? value : undefined,
-        }, context);
+        }, context), context);
+    };
+    return configure(target.catalog, state, async (kit, key, question, value) => {
+        const answer = await ask(kit, key, question, value);
+        onAnswer?.(kit, key, answer);
+        return answer;
     });
 }
-export async function confirmApply() {
-    return confirm({ message: 'Apply changes?', default: true });
+export async function confirmApply(context, scopes = []) {
+    return backPrompt((context) => confirm({
+        message: scopes.length
+            ? `Apply changes to ${scopes.join(' and ')}?`
+            : 'Apply changes?',
+        default: true,
+    }, context), context);
 }
-export async function selectUpdates(catalog, state, offline = false, context) {
+export async function selectUpdates(catalog, state, offline = false, context, options = {}) {
     const updates = availableUpdates(catalog, state.selected);
     if (!updates.length)
         return [];
     if (offline) {
-        console.log(`${updates.length} catalog update(s) available. Run loadout online to review them; keeping saved versions.`);
+        if (!options.quiet)
+            console.log(`${updates.length} catalog update(s) available. Run loadout online to review them; keeping saved versions.`);
         return [];
     }
-    return checkbox({
-        message: 'Catalog updates available · choose kits to update (Enter skips)',
+    return backPrompt((context) => checkbox({
+        message: options.message ??
+            'Catalog updates available · choose kits to update (Enter skips)',
         choices: updates.map((kit) => ({
             name: kit.id,
             value: kit.id,
             description: updateDescription(kit),
+            checked: options.selected?.includes(kit.id) ?? false,
         })),
         required: false,
-    }, context);
+    }, context), context);
 }
 export async function confirmRetry(id, error, context) {
-    return select({
+    return backPrompt((context) => select({
         message: `${id}: ${error.message}`,
         choices: [
             { name: 'Retry download', value: true },
             { name: 'Cancel', value: false },
         ],
-    }, context);
+    }, context), context);
 }
-export async function confirmAdoption(paths, context) {
-    return confirm({
-        message: `Keep existing content and let Loadout manage ${paths.join(', ')}? Originals will be restored when disabled.`,
+export async function confirmAdoption(paths, context, scope) {
+    return backPrompt((context) => confirm({
+        message: `${scope ? `${scope} · ` : ''}Keep existing content and let Loadout manage ${paths.join(', ')}? Originals will be restored when disabled.`,
         default: true,
-    }, context);
+    }, context), context);
+}
+export async function retryReview(error, context) {
+    try {
+        return await backPrompt((context) => select({
+            message: `Could not finish: ${error instanceof Error ? error.message : String(error)}`,
+            choices: [
+                { name: 'Try again', value: true },
+                { name: 'Back to kits', value: false },
+            ],
+        }, context), context);
+    }
+    catch (failure) {
+        if (failure instanceof BackNavigation)
+            return false;
+        throw failure;
+    }
 }

package/dist/picker.d.ts

@@ -6,11 +6,32 @@ export type PickerConfig = {
     columns?: number;
     rows?: number;
 };
+declare const repositorySections: readonly ['Kits', 'Browse', 'Installed'];
+type Section = (typeof repositorySections)[number];
 export type TargetPickerConfig = {
     targets: Target[];
     initial?: number;
     columns?: number;
     rows?: number;
+    session?: PickerSession;
+};
+type PickerView = {
+    section: Section;
+    provider: string | undefined;
+    providerList: {
+        query: string;
+        active: number;
+    };
+    query: string;
+    active: number;
+};
+export type PickerSession = {
+    snapshot?: PickerView & {
+        targetIndex: number;
+        visited: number[];
+        selections: string[][];
+        views: PickerView[];
+    };
 };
 export type TargetSelection = {
     target: Target;
@@ -21,6 +42,7 @@ declare const renderPicker: import("@inquirer/type").Prompt<TargetSelection[], {
     initial?: number;
     columns?: number;
     rows?: number;
+    session?: PickerSession;
 } & TargetPickerConfig>;
 export declare function targetPicker(config: TargetPickerConfig, context?: Parameters<typeof renderPicker>[1]): Promise<TargetSelection[]>;
 export declare function kitPicker(config: PickerConfig, context?: Parameters<typeof targetPicker>[1]): Promise<string[]>;