@open-agent-toolkit/cli 0.2.35 → 0.2.37

package/dist/commands/tools/list/list-tools.js

@@ -1,9 +1,13 @@
 import { resolveConcreteScopes } from '../../shared/shared.utils.js';
+import { formatPackInventoryDetails } from '../../tools/shared/format-pack-inventory.js';
+import { inventoryPack, } from '../../tools/shared/pack-inventory.js';
+import { PACK_MANIFEST } from '../../tools/shared/pack-manifest.js';
 export async function runListTools(context, dependencies) {
     const { logger } = context;
     const scopes = resolveConcreteScopes(context.scope);
     const assetsRoot = await dependencies.resolveAssetsRoot();
     const allTools = [];
+    const roots = {};
     for (const scope of scopes) {
         const scopeRoot = await dependencies.resolveScopeRoot(scope, context.cwd, context.home);
         const tools = await dependencies.scanTools({
@@ -12,14 +16,28 @@ export async function runListTools(context, dependencies) {
             assetsRoot,
         });
         allTools.push(...tools);
+        roots[scope] = scopeRoot;
     }
+    const inspectPack = dependencies.inventoryPack ?? inventoryPack;
+    const packs = await Promise.all(PACK_MANIFEST.map(({ name }) => inspectPack({
+        pack: name,
+        assetsRoot,
+        projectRoot: roots.project,
+        userRoot: roots.user,
+    })));
     if (context.json) {
-        logger.json({ tools: allTools });
-        return { tools: allTools };
+        logger.json({ tools: allTools, packs });
+        return { tools: allTools, packs };
     }
     if (allTools.length === 0) {
         logger.info('No tools installed.');
-        return { tools: allTools };
+        logger.info('Pack inventory:');
+        for (const pack of packs) {
+            logger.info(`${pack.pack}: ${pack.placement}`);
+            for (const line of formatPackInventoryDetails(pack))
+                logger.info(line);
+        }
+        return { tools: allTools, packs };
     }
     logger.info('Installed tools:\n');
     const header = formatRow('NAME', 'TYPE', 'VERSION', 'PACK', 'SCOPE', 'STATUS');
@@ -29,7 +47,16 @@ export async function runListTools(context, dependencies) {
     for (const tool of allTools) {
         logger.info(formatRow(tool.name, tool.type, tool.version ?? '-', tool.pack, tool.scope, tool.status));
     }
-    return { tools: allTools };
+    logger.info('\nPack inventory:');
+    for (const pack of packs) {
+        const states = pack.scopes
+            .map(({ scope, completeness, intent }) => `${scope}=${completeness} (${intent.source})`)
+            .join(', ');
+        logger.info(`${pack.pack.padEnd(20)} ${pack.placement.padEnd(11)} ${states || 'not inspected'}`);
+        for (const line of formatPackInventoryDetails(pack))
+            logger.info(line);
+    }
+    return { tools: allTools, packs };
 }
 function formatRow(name, type, version, pack, scope, status) {
     return [

package/dist/commands/tools/migrate/index.d.ts

@@ -0,0 +1,26 @@
+import { type CommandContext, type GlobalOptions } from '../../../app/command-context.js';
+import { confirmAction } from '../../shared/shared.prompts.js';
+import { inventoryScopedPack } from '../../tools/shared/pack-inventory.js';
+import { resolveSharedOwnerRetentions, type ResolveSharedOwnerRetentionsInput } from '../../tools/shared/pack-reconcile.js';
+import type { ConcreteScope } from '../../../shared/types.js';
+import { Command } from 'commander';
+import { type CompleteMigrationSourceRemovalInput, type PackMigrationOutcome, type PackMigrationPreview, type PlanPackMigrationInput } from './migrate-pack.js';
+interface MigrationCommandRuntime {
+    context: CommandContext;
+    assetsRoot: string;
+}
+export interface MigrationCommandDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    resolveScopeRoot: (scope: ConcreteScope, cwd: string, home: string) => string;
+    resolveAssetsRoot: () => Promise<string>;
+    inventory: typeof inventoryScopedPack;
+    resolveSharedRetentions: (input: ResolveSharedOwnerRetentionsInput) => ReturnType<typeof resolveSharedOwnerRetentions>;
+    plan: (input: PlanPackMigrationInput) => PackMigrationPreview;
+    executeDestination: (preview: PackMigrationPreview, destinationRoot: string, runtime: MigrationCommandRuntime) => Promise<PackMigrationOutcome>;
+    completeSourceRemoval: (destination: PackMigrationOutcome, input: CompleteMigrationSourceRemovalInput, runtime: MigrationCommandRuntime) => Promise<PackMigrationOutcome>;
+    confirmAction: typeof confirmAction;
+}
+export declare function createToolsMigrateCommand(dependencies?: MigrationCommandDependencies): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/tools/migrate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/migrate/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAE5E,OAAO,EACL,4BAA4B,EAE5B,KAAK,iCAAiC,EACvC,MAAM,uCAAuC,CAAC;AAS/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAE5C,OAAO,EAIL,KAAK,mCAAmC,EACxC,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC5B,MAAM,gBAAgB,CAAC;AAExB,UAAU,uBAAuB;IAC/B,OAAO,EAAE,cAAc,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,4BAA4B;IAC3C,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,gBAAgB,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9E,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,SAAS,EAAE,OAAO,mBAAmB,CAAC;IACtC,uBAAuB,EAAE,CACvB,KAAK,EAAE,iCAAiC,KACrC,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAC;IACrD,IAAI,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,oBAAoB,CAAC;IAC9D,kBAAkB,EAAE,CAClB,OAAO,EAAE,oBAAoB,EAC7B,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,uBAAuB,KAC7B,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,qBAAqB,EAAE,CACrB,WAAW,EAAE,oBAAoB,EACjC,KAAK,EAAE,mCAAmC,EAC1C,OAAO,EAAE,uBAAuB,KAC7B,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,aAAa,EAAE,OAAO,aAAa,CAAC;CACrC;AAuOD,wBAAgB,yBAAyB,CACvC,YAAY,GAAE,4BAAkD,GAC/D,OAAO,CA0IT"}

package/dist/commands/tools/migrate/index.js

@@ -0,0 +1,312 @@
+import { execFile } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { confirmAction } from '../../shared/shared.prompts.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { inventoryScopedPack } from '../../tools/shared/pack-inventory.js';
+import { isPackName, PACK_NAMES } from '../../tools/shared/pack-manifest.js';
+import { resolveSharedOwnerRetentions, } from '../../tools/shared/pack-reconcile.js';
+import { hasScopedPackOwnershipEvidence, writeScopedPackIntent, } from '../../tools/shared/scoped-pack-intent.js';
+import { readOatConfig, writeOatConfig } from '../../../config/oat-config.js';
+import { CliError } from '../../../errors/index.js';
+import { resolveAssetsRoot } from '../../../fs/assets.js';
+import { resolveProjectRoot, resolveScopeRoot } from '../../../fs/paths.js';
+import { Command, Option } from 'commander';
+import { completeMigrationSourceRemoval, executeMigrationDestination, planPackMigration, } from './migrate-pack.js';
+async function runSync(input) {
+    const args = [
+        ...process.execArgv,
+        process.argv[1],
+        '--cwd',
+        input.context.cwd,
+        'sync',
+        '--scope',
+        input.scope,
+    ];
+    for (const path of input.installedCanonicalPaths ?? []) {
+        args.push('--install-canonical', path);
+    }
+    for (const path of input.removedCanonicalPaths ?? []) {
+        args.push('--remove-canonical', path);
+    }
+    await new Promise((resolve, reject) => {
+        execFile(process.execPath, args, { cwd: input.context.cwd }, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+async function writeGenerated(scopeRoot, operation) {
+    await mkdir(dirname(operation.destination), { recursive: true });
+    switch (operation.generation) {
+        case 'projects-root-default':
+            await writeFile(operation.destination, '.oat/projects/shared\n', 'utf8');
+            return;
+        case 'projects-config-default': {
+            const config = await readOatConfig(scopeRoot);
+            if (config.projects?.root?.trim())
+                return;
+            await writeOatConfig(scopeRoot, {
+                ...config,
+                projects: { root: '.oat/projects/shared' },
+            });
+            return;
+        }
+        case 'empty-file':
+            await writeFile(operation.destination, '', 'utf8');
+    }
+}
+async function defaultExecuteDestination(preview, destinationRoot, runtime) {
+    return executeMigrationDestination(preview, destinationRoot, {
+        applyDependencies: {
+            writeGenerated: async (operation) => writeGenerated(destinationRoot, operation),
+            writeIntent: async (operation) => writeScopedPackIntent({
+                pack: operation.pack,
+                scope: operation.scope,
+                scopeRoot: destinationRoot,
+                enabled: operation.enabled,
+            }),
+            inventory: async () => inventoryScopedPack({
+                pack: preview.pack,
+                scope: preview.to,
+                scopeRoot: destinationRoot,
+                assetsRoot: runtime.assetsRoot,
+            }),
+        },
+        sync: async ({ scope, canonicalPaths }) => runSync({
+            context: runtime.context,
+            scope,
+            installedCanonicalPaths: canonicalPaths,
+        }),
+    });
+}
+async function defaultCompleteSourceRemoval(destination, input, runtime) {
+    const preview = destination.preview;
+    return completeMigrationSourceRemoval(destination, input, {
+        inventory: async () => inventoryScopedPack({
+            pack: preview.pack,
+            scope: preview.from,
+            scopeRoot: input.sourceRoot,
+            assetsRoot: runtime.assetsRoot,
+        }),
+        applyDependencies: {
+            writeGenerated: async (operation) => writeGenerated(input.sourceRoot, operation),
+            writeIntent: async (operation) => writeScopedPackIntent({
+                pack: operation.pack,
+                scope: operation.scope,
+                scopeRoot: input.sourceRoot,
+                enabled: operation.enabled,
+            }),
+        },
+        resolveSourceRetentions: async () => resolveSharedOwnerRetentions({
+            packs: [preview.pack],
+            scope: preview.from,
+            scopeRoot: input.sourceRoot,
+            hasOwnershipEvidence: async (pack, scope, scopeRoot) => hasScopedPackOwnershipEvidence({ pack, scope, scopeRoot }),
+        }),
+        sync: async ({ scope, canonicalPaths }) => runSync({
+            context: runtime.context,
+            scope,
+            removedCanonicalPaths: canonicalPaths,
+        }),
+    });
+}
+const defaultDependencies = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveScopeRoot,
+    resolveAssetsRoot,
+    inventory: inventoryScopedPack,
+    resolveSharedRetentions: resolveSharedOwnerRetentions,
+    plan: planPackMigration,
+    executeDestination: defaultExecuteDestination,
+    completeSourceRemoval: defaultCompleteSourceRemoval,
+    confirmAction,
+};
+async function resolveMigrationScopeRoot(scope, context, dependencies) {
+    return scope === 'project'
+        ? dependencies.resolveProjectRoot(context.cwd)
+        : dependencies.resolveScopeRoot(scope, context.cwd, context.home);
+}
+function renderPreview(preview, context) {
+    context.logger.info(`Migration preview: ${preview.pack} (${preview.from} -> ${preview.to})`);
+    const groups = [
+        ['Additions', preview.additions],
+        ['Duplicates', preview.duplicates],
+        ['Conflicts', preview.conflicts],
+        ['Source removals', preview.removals],
+        ['Retained owner data', preview.retained],
+    ];
+    for (const [label, entries] of groups) {
+        context.logger.info(`${label}: ${entries.length}`);
+        for (const entry of entries) {
+            context.logger.info(`  - ${entry.assetId} [${entry.kind}] ${entry.scope} ${entry.status}: ${entry.path}${entry.reason ? ` (${entry.reason})` : ''}`);
+        }
+    }
+    for (const diagnostic of preview.diagnostics) {
+        context.logger.info(`Diagnostic ${diagnostic.code}: ${diagnostic.message} (${diagnostic.paths.join(', ')})`);
+    }
+}
+function emitOutcome(outcome, dryRun, context) {
+    if (context.json) {
+        context.logger.json({
+            operation: 'migrate',
+            dryRun,
+            ...outcome,
+        });
+        return;
+    }
+    if (outcome.status === 'migrated') {
+        context.logger.success(`Migrated ${outcome.preview.pack} from ${outcome.preview.from} to ${outcome.preview.to}.`);
+    }
+    else if (outcome.status === 'retained-both') {
+        context.logger.warn(`Destination is verified; ${outcome.preview.pack} remains installed at both scopes.`);
+    }
+    else if (outcome.status === 'blocked') {
+        context.logger.error('Migration is blocked by destination conflicts.');
+    }
+    else if (outcome.status === 'source-removal-failed' ||
+        outcome.status === 'source-sync-failed') {
+        context.logger.error(`Destination is verified, but ${outcome.preview.from} source removal did not complete.`);
+    }
+    else if (outcome.status === 'destination-sync-failed') {
+        context.logger.error(`Destination canonical files are verified, but provider sync did not complete; source was retained.`);
+    }
+    for (const recovery of outcome.recovery ?? []) {
+        context.logger.info(recovery);
+    }
+}
+function emitError(error, context, exitCode) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (context.json) {
+        context.logger.json({ status: 'error', operation: 'migrate', message });
+    }
+    else {
+        context.logger.error(message);
+    }
+    process.exitCode = error instanceof CliError ? error.exitCode : exitCode;
+}
+export function createToolsMigrateCommand(dependencies = defaultDependencies) {
+    return new Command('migrate')
+        .description('Move an installed tool pack between scopes safely')
+        .addOption(new Option('--pack <pack>', 'Pack to migrate')
+        .choices([...PACK_NAMES])
+        .makeOptionMandatory())
+        .addOption(new Option('--from <scope>', 'Source scope')
+        .choices(['project', 'user'])
+        .makeOptionMandatory())
+        .addOption(new Option('--to <scope>', 'Destination scope')
+        .choices(['project', 'user'])
+        .makeOptionMandatory())
+        .option('--dry-run', 'Preview migration without applying')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        const packValue = String(options.pack);
+        if (!isPackName(packValue)) {
+            emitError(new Error(`Unknown tool pack: ${packValue}`), context, 1);
+            return;
+        }
+        const pack = packValue;
+        const from = options.from;
+        const to = options.to;
+        let sourceRoot;
+        let destinationRoot;
+        let assetsRoot;
+        let preview;
+        try {
+            [sourceRoot, destinationRoot, assetsRoot] = await Promise.all([
+                resolveMigrationScopeRoot(from, context, dependencies),
+                resolveMigrationScopeRoot(to, context, dependencies),
+                dependencies.resolveAssetsRoot(),
+            ]);
+            const [sourceInventory, destinationInventory, sourceRetentions] = await Promise.all([
+                dependencies.inventory({
+                    pack,
+                    scope: from,
+                    scopeRoot: sourceRoot,
+                    assetsRoot,
+                }),
+                dependencies.inventory({
+                    pack,
+                    scope: to,
+                    scopeRoot: destinationRoot,
+                    assetsRoot,
+                }),
+                dependencies.resolveSharedRetentions({
+                    packs: [pack],
+                    scope: from,
+                    scopeRoot: sourceRoot,
+                    hasOwnershipEvidence: async (owner, scope, root) => hasScopedPackOwnershipEvidence({
+                        pack: owner,
+                        scope,
+                        scopeRoot: root,
+                    }),
+                }),
+            ]);
+            preview = dependencies.plan({
+                pack,
+                from,
+                to,
+                sourceRoot,
+                destinationRoot,
+                assetsRoot,
+                sourceInventory,
+                destinationInventory,
+                sourceRetentions,
+            });
+        }
+        catch (error) {
+            emitError(error, context, 1);
+            return;
+        }
+        if (options.dryRun) {
+            const outcome = {
+                preview,
+                status: preview.status === 'blocked' ? 'blocked' : 'previewed',
+            };
+            if (context.json)
+                emitOutcome(outcome, true, context);
+            else
+                renderPreview(preview, context);
+            process.exitCode = preview.status === 'blocked' ? 1 : 0;
+            return;
+        }
+        if (!context.json)
+            renderPreview(preview, context);
+        if (preview.status === 'blocked') {
+            const outcome = { preview, status: 'blocked' };
+            emitOutcome(outcome, false, context);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const runtime = { context, assetsRoot };
+            const destination = await dependencies.executeDestination(preview, destinationRoot, runtime);
+            if (destination.status === 'destination-sync-failed') {
+                emitOutcome(destination, false, context);
+                process.exitCode = 2;
+                return;
+            }
+            const confirmation = context.interactive
+                ? (await dependencies.confirmAction(`Destination verified. Remove ${pack} from ${from} scope?`, context))
+                    ? 'confirmed'
+                    : 'declined'
+                : 'non-interactive';
+            const outcome = await dependencies.completeSourceRemoval(destination, { confirmation, sourceRoot, assetsRoot }, runtime);
+            emitOutcome(outcome, false, context);
+            process.exitCode =
+                outcome.status === 'source-removal-failed' ||
+                    outcome.status === 'source-sync-failed'
+                    ? 2
+                    : confirmation === 'non-interactive'
+                        ? 1
+                        : 0;
+        }
+        catch (error) {
+            emitError(error, context, 2);
+        }
+    });
+}

package/dist/commands/tools/migrate/migrate-pack.d.ts

@@ -0,0 +1,81 @@
+import { applyPackReconcilePlan, type ApplyPackReconcileDependencies } from '../../tools/shared/apply-pack-reconcile.js';
+import { type ScopedPackInventory } from '../../tools/shared/pack-inventory.js';
+import { planPackReconcile, type PackSharedOwnerRetention, type PackReconcilePlan } from '../../tools/shared/pack-reconcile.js';
+import type { PackAssetKind, PackAssetStatus, PackName } from '../../tools/shared/types.js';
+import type { ConcreteScope } from '../../../shared/types.js';
+export interface MigrationAssetPreview {
+    assetId: string;
+    kind: PackAssetKind;
+    scope: ConcreteScope;
+    path: string;
+    status: PackAssetStatus;
+    reason?: string;
+}
+export interface PackMigrationPreview {
+    pack: PackName;
+    from: ConcreteScope;
+    to: ConcreteScope;
+    projectRoot: string;
+    sourceIntent: ScopedPackInventory['intent']['source'];
+    status: 'ready' | 'blocked';
+    additions: readonly MigrationAssetPreview[];
+    duplicates: readonly MigrationAssetPreview[];
+    conflicts: readonly MigrationAssetPreview[];
+    removals: readonly MigrationAssetPreview[];
+    retained: readonly MigrationAssetPreview[];
+    diagnostics: ScopedPackInventory['intent']['diagnostics'];
+    destinationPlan: PackReconcilePlan;
+}
+export interface MigrationPendingSync {
+    scope: ConcreteScope;
+    action: 'install' | 'remove';
+    projectRoot: string;
+    canonicalPaths: readonly string[];
+    command: string;
+}
+export interface PackMigrationOutcome {
+    preview: PackMigrationPreview;
+    status: 'previewed' | 'blocked' | 'destination-verified' | 'destination-sync-failed' | 'retained-both' | 'migrated' | 'source-removal-failed' | 'source-sync-failed';
+    destinationInventory?: ScopedPackInventory;
+    sourceInventory?: ScopedPackInventory;
+    recovery?: readonly string[];
+    pendingSync?: MigrationPendingSync;
+}
+export interface PlanPackMigrationInput {
+    pack: PackName;
+    from: ConcreteScope;
+    to: ConcreteScope;
+    sourceRoot: string;
+    destinationRoot: string;
+    assetsRoot: string;
+    sourceInventory: ScopedPackInventory;
+    destinationInventory: ScopedPackInventory;
+    sourceRetentions?: readonly PackSharedOwnerRetention[];
+}
+export interface MigrationSyncInput {
+    scope: ConcreteScope;
+    action: 'install' | 'remove';
+    canonicalPaths: readonly string[];
+}
+export interface ExecuteMigrationDestinationDependencies {
+    apply?: typeof applyPackReconcilePlan;
+    applyDependencies: ApplyPackReconcileDependencies;
+    sync?: (input: MigrationSyncInput) => Promise<void>;
+}
+export interface CompleteMigrationSourceRemovalInput {
+    confirmation: 'confirmed' | 'declined' | 'non-interactive';
+    sourceRoot: string;
+    assetsRoot: string;
+}
+export interface CompleteMigrationSourceRemovalDependencies {
+    inventory: () => Promise<ScopedPackInventory>;
+    plan?: typeof planPackReconcile;
+    apply?: typeof applyPackReconcilePlan;
+    applyDependencies: Omit<ApplyPackReconcileDependencies, 'inventory'>;
+    resolveSourceRetentions?: () => Promise<PackSharedOwnerRetention[]>;
+    sync?: (input: MigrationSyncInput) => Promise<void>;
+}
+export declare function planPackMigration(input: PlanPackMigrationInput): PackMigrationPreview;
+export declare function executeMigrationDestination(preview: PackMigrationPreview, destinationRoot: string, dependencies: ExecuteMigrationDestinationDependencies): Promise<PackMigrationOutcome>;
+export declare function completeMigrationSourceRemoval(destination: PackMigrationOutcome, input: CompleteMigrationSourceRemovalInput, dependencies: CompleteMigrationSourceRemovalDependencies): Promise<PackMigrationOutcome>;
+//# sourceMappingURL=migrate-pack.d.ts.map

package/dist/commands/tools/migrate/migrate-pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-pack.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/migrate/migrate-pack.ts"],"names":[],"mappings":"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"}