@open-agent-toolkit/cli 0.0.10

package/dist/commands/status/index.js

@@ -0,0 +1,340 @@
+import { basename, join, relative } from 'node:path';
+import { buildCommandContext, } from '../../app/command-context.js';
+import { adoptStrayToCanonical, isAdoptionConflictError, } from '../shared/adopt-stray.js';
+import { detectCodexRoleStrays, regenerateCodexAfterAdoption, } from '../shared/codex-strays.js';
+import { confirmAction, selectManyWithAbort, } from '../shared/shared.prompts.js';
+import { readGlobalOptions, resolveConcreteScopes, } from '../shared/shared.utils.js';
+import { detectDrift, detectStrays } from '../../drift/index.js';
+import { scanCanonical } from '../../engine/index.js';
+import { normalizeToPosixPath, resolveProjectRoot, resolveScopeRoot, } from '../../fs/paths.js';
+import { loadManifest, saveManifest } from '../../manifest/manager.js';
+import { claudeAdapter } from '../../providers/claude/index.js';
+import { codexAdapter } from '../../providers/codex/index.js';
+import { applyCodexProjectExtensionPlan, computeCodexProjectExtensionPlan, } from '../../providers/codex/codec/sync-extension.js';
+import { copilotAdapter } from '../../providers/copilot/index.js';
+import { cursorAdapter } from '../../providers/cursor/index.js';
+import { geminiAdapter } from '../../providers/gemini/index.js';
+import { getActiveAdapters, getSyncMappings, } from '../../providers/shared/index.js';
+import { SCOPE_CONTENT_TYPES, } from '../../shared/types.js';
+import { formatStatusTable } from '../../ui/output.js';
+import { Command } from 'commander';
+const DEFAULT_REMEDIATION = 'Run "oat init" to adopt stray entries.';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    async resolveScopeRoot(scope, context) {
+        if (scope === 'project') {
+            return resolveProjectRoot(context.cwd);
+        }
+        return resolveScopeRoot(scope, context.cwd, context.home);
+    },
+    loadManifest,
+    saveManifest,
+    scanCanonical,
+    getAdapters() {
+        return [
+            claudeAdapter,
+            cursorAdapter,
+            codexAdapter,
+            copilotAdapter,
+            geminiAdapter,
+        ];
+    },
+    getActiveAdapters,
+    getSyncMappings,
+    detectDrift,
+    detectStrays,
+    detectCodexRoleStrays,
+    computeCodexProjectExtensionPlan,
+    applyCodexProjectExtensionPlan,
+    selectManyWithAbort,
+    confirmAction,
+    adoptStray: adoptStrayDefault,
+    formatStatusTable,
+};
+function entryInsideMapping(entryProviderPath, mappingProviderDir) {
+    const normalizedEntryPath = normalizeToPosixPath(entryProviderPath);
+    const normalizedProviderDir = normalizeToPosixPath(mappingProviderDir);
+    return (normalizedEntryPath === normalizedProviderDir ||
+        normalizedEntryPath.startsWith(`${normalizedProviderDir}/`));
+}
+function canonicalInsideMapping(canonicalPath, mappingCanonicalDir) {
+    const normalizedCanonicalPath = normalizeToPosixPath(canonicalPath);
+    const normalizedCanonicalDir = normalizeToPosixPath(mappingCanonicalDir);
+    return (normalizedCanonicalPath === normalizedCanonicalDir ||
+        normalizedCanonicalPath.startsWith(`${normalizedCanonicalDir}/`));
+}
+function contentTypeAllowed(contentType, scope) {
+    return SCOPE_CONTENT_TYPES[scope].includes(contentType);
+}
+function summarizeReports(reports) {
+    const summary = {
+        total: reports.length,
+        inSync: 0,
+        drifted: 0,
+        missing: 0,
+        stray: 0,
+    };
+    for (const report of reports) {
+        if (report.state.status === 'in_sync') {
+            summary.inSync += 1;
+            continue;
+        }
+        if (report.state.status === 'drifted') {
+            summary.drifted += 1;
+            continue;
+        }
+        if (report.state.status === 'missing') {
+            summary.missing += 1;
+            continue;
+        }
+        summary.stray += 1;
+    }
+    return summary;
+}
+async function adoptStrayDefault(scopeRoot, stray, manifest, options) {
+    return adoptStrayToCanonical(scopeRoot, stray, manifest, options);
+}
+function formatPathForScope(scope, providerPath) {
+    if (scope === 'project') {
+        return providerPath;
+    }
+    if (providerPath.startsWith('./')) {
+        return `~/${providerPath.slice(2)}`;
+    }
+    if (providerPath.startsWith('.')) {
+        return `~/${providerPath}`;
+    }
+    return `~/${providerPath}`;
+}
+function formatStrayChoiceLabel(scope, providerPath, provider) {
+    return `[${scope}] ${basename(providerPath)} (${provider})`;
+}
+async function collectScopeReports(scope, context, dependencies) {
+    const scopeRoot = await dependencies.resolveScopeRoot(scope, context);
+    const manifestPath = join(scopeRoot, '.oat', 'sync', 'manifest.json');
+    const manifest = await dependencies.loadManifest(manifestPath);
+    const canonicalEntries = await dependencies.scanCanonical(scopeRoot, scope);
+    const adapters = dependencies.getAdapters();
+    const activeAdapters = await dependencies.getActiveAdapters(adapters, scopeRoot);
+    const reports = [];
+    const strayCandidates = [];
+    const trackedCanonicalByProvider = new Set(manifest.entries.map((entry) => `${entry.provider}|${normalizeToPosixPath(entry.canonicalPath)}`));
+    for (const adapter of activeAdapters) {
+        const mappings = dependencies.getSyncMappings(adapter, scope);
+        const mappingContentTypes = new Set(mappings.map((mapping) => mapping.contentType));
+        for (const entry of manifest.entries) {
+            if (entry.provider !== adapter.name) {
+                continue;
+            }
+            if (!mappingContentTypes.has(entry.contentType)) {
+                continue;
+            }
+            if (!contentTypeAllowed(entry.contentType, scope)) {
+                continue;
+            }
+            if (!mappings.some((mapping) => entryInsideMapping(entry.providerPath, mapping.providerDir))) {
+                continue;
+            }
+            reports.push(await dependencies.detectDrift(entry, scopeRoot));
+        }
+        for (const mapping of mappings) {
+            for (const canonicalEntry of canonicalEntries) {
+                if (canonicalEntry.type !== mapping.contentType) {
+                    continue;
+                }
+                const canonicalPath = normalizeToPosixPath(relative(scopeRoot, canonicalEntry.canonicalPath));
+                if (!canonicalInsideMapping(canonicalPath, mapping.canonicalDir)) {
+                    continue;
+                }
+                const trackedKey = `${adapter.name}|${canonicalPath}`;
+                if (trackedCanonicalByProvider.has(trackedKey)) {
+                    continue;
+                }
+                reports.push({
+                    canonical: canonicalPath,
+                    provider: adapter.name,
+                    providerPath: normalizeToPosixPath(join(mapping.providerDir, canonicalEntry.name)),
+                    state: { status: 'missing' },
+                });
+            }
+        }
+        for (const mapping of mappings) {
+            const providerDir = join(scopeRoot, mapping.providerDir);
+            const strays = await dependencies.detectStrays(adapter.name, providerDir, manifest, canonicalEntries, mapping);
+            reports.push(...strays);
+            for (const stray of strays) {
+                if (stray.state.status !== 'stray') {
+                    continue;
+                }
+                strayCandidates.push({
+                    provider: adapter.name,
+                    report: stray,
+                    mapping,
+                });
+            }
+        }
+    }
+    if (scope === 'project' &&
+        activeAdapters.some((adapter) => adapter.name === 'codex')) {
+        const codexExtensionPlan = await dependencies.computeCodexProjectExtensionPlan(scopeRoot, canonicalEntries);
+        for (const operation of codexExtensionPlan.operations) {
+            if (operation.action === 'skip') {
+                continue;
+            }
+            if (operation.target === 'role') {
+                reports.push({
+                    canonical: operation.roleName
+                        ? `.agents/agents/${operation.roleName}.md`
+                        : null,
+                    provider: 'codex',
+                    providerPath: operation.path,
+                    state: operation.action === 'create'
+                        ? { status: 'missing' }
+                        : { status: 'drifted', reason: 'modified' },
+                });
+            }
+            else {
+                reports.push({
+                    canonical: null,
+                    provider: 'codex',
+                    providerPath: operation.path,
+                    state: { status: 'drifted', reason: 'modified' },
+                });
+            }
+        }
+        const codexStrays = await dependencies.detectCodexRoleStrays(scopeRoot, canonicalEntries);
+        for (const codexStray of codexStrays) {
+            const report = {
+                canonical: null,
+                provider: 'codex',
+                providerPath: codexStray.providerPath,
+                state: { status: 'stray' },
+            };
+            reports.push(report);
+            strayCandidates.push({
+                provider: 'codex',
+                report,
+                mapping: {
+                    contentType: 'agent',
+                    canonicalDir: '.agents/agents',
+                    providerDir: '.codex/agents',
+                    nativeRead: false,
+                },
+                adoption: {
+                    kind: 'codex_role',
+                    roleName: codexStray.roleName,
+                    description: codexStray.description,
+                },
+            });
+        }
+    }
+    return {
+        scope,
+        scopeRoot,
+        manifestPath,
+        manifest,
+        reports,
+        strayCandidates,
+    };
+}
+async function runStatusCommand(context, dependencies) {
+    const reports = [];
+    const scopeCollections = [];
+    for (const scope of resolveConcreteScopes(context.scope)) {
+        const scopeReportCollection = await collectScopeReports(scope, context, dependencies);
+        reports.push(...scopeReportCollection.reports);
+        scopeCollections.push(scopeReportCollection);
+    }
+    const summary = summarizeReports(reports);
+    const hasIssues = summary.total > 0 && summary.inSync !== summary.total;
+    if (context.json) {
+        const payload = {
+            scope: context.scope,
+            reports,
+            summary,
+        };
+        if (!context.interactive && summary.stray > 0) {
+            payload.remediation = DEFAULT_REMEDIATION;
+        }
+        context.logger.json(payload);
+    }
+    else {
+        context.logger.info(dependencies.formatStatusTable(reports));
+    }
+    if (summary.stray > 0) {
+        if (context.interactive) {
+            for (const scopeCollection of scopeCollections) {
+                if (scopeCollection.strayCandidates.length === 0) {
+                    continue;
+                }
+                let manifestChanged = false;
+                const selectedValues = await dependencies.selectManyWithAbort(`Select stray entries to adopt [${scopeCollection.scope}]`, scopeCollection.strayCandidates.map((strayCandidate, index) => ({
+                    label: formatStrayChoiceLabel(scopeCollection.scope, strayCandidate.report.providerPath, strayCandidate.provider),
+                    value: String(index),
+                    description: formatPathForScope(scopeCollection.scope, strayCandidate.report.providerPath),
+                })), { interactive: context.interactive });
+                const selectedIndices = new Set((selectedValues ?? []).map((value) => Number.parseInt(value, 10)));
+                let adoptedCount = 0;
+                let codexStrayAdopted = false;
+                for (const [index, strayCandidate,] of scopeCollection.strayCandidates.entries()) {
+                    if (!selectedIndices.has(index)) {
+                        continue;
+                    }
+                    try {
+                        scopeCollection.manifest = await dependencies.adoptStray(scopeCollection.scopeRoot, strayCandidate, scopeCollection.manifest);
+                        adoptedCount += 1;
+                        manifestChanged = true;
+                        codexStrayAdopted =
+                            codexStrayAdopted || strayCandidate.provider === 'codex';
+                    }
+                    catch (error) {
+                        if (!isAdoptionConflictError(error)) {
+                            throw error;
+                        }
+                        const shouldReplace = await dependencies.confirmAction(`Conflict detected for ${formatPathForScope(scopeCollection.scope, strayCandidate.report.providerPath)}. Replace canonical with stray content?`, { interactive: context.interactive });
+                        if (!shouldReplace) {
+                            context.logger.warn(`Skipped adopting conflicting stray [${scopeCollection.scope}] ${formatPathForScope(scopeCollection.scope, strayCandidate.report.providerPath)}.`);
+                            continue;
+                        }
+                        scopeCollection.manifest = await dependencies.adoptStray(scopeCollection.scopeRoot, strayCandidate, scopeCollection.manifest, { replaceCanonical: true });
+                        adoptedCount += 1;
+                        manifestChanged = true;
+                        codexStrayAdopted =
+                            codexStrayAdopted || strayCandidate.provider === 'codex';
+                    }
+                }
+                if (codexStrayAdopted && scopeCollection.scope === 'project') {
+                    await regenerateCodexAfterAdoption({
+                        scopeRoot: scopeCollection.scopeRoot,
+                        scanCanonical: async () => dependencies.scanCanonical(scopeCollection.scopeRoot, scopeCollection.scope),
+                        computeExtensionPlan: dependencies.computeCodexProjectExtensionPlan,
+                        applyExtensionPlan: dependencies.applyCodexProjectExtensionPlan,
+                    });
+                }
+                if (manifestChanged) {
+                    await dependencies.saveManifest(scopeCollection.manifestPath, scopeCollection.manifest);
+                    context.logger.success(`Adopted ${adoptedCount} stray entr${adoptedCount === 1 ? 'y' : 'ies'} [${scopeCollection.scope}].`);
+                }
+                else {
+                    context.logger.info(`No stray entries adopted [${scopeCollection.scope}].`);
+                }
+            }
+        }
+        else if (!context.json) {
+            context.logger.warn(DEFAULT_REMEDIATION);
+        }
+    }
+    process.exitCode = hasIssues ? 1 : 0;
+}
+export function createStatusCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    return new Command('status')
+        .description('Report provider sync and drift status')
+        .action(async (_options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runStatusCommand(context, dependencies);
+    });
+}

package/dist/commands/sync/apply.d.ts

@@ -0,0 +1,4 @@
+import type { CommandContext } from '../../app/command-context.js';
+import type { ScopeSyncPlan, SyncCommandDependencies } from './sync.types.js';
+export declare function runSyncApply(context: CommandContext, scopePlans: ScopeSyncPlan[], dependencies: SyncCommandDependencies): Promise<void>;
+//# sourceMappingURL=apply.d.ts.map

package/dist/commands/sync/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AAgEtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CAwEf"}

package/dist/commands/sync/apply.js

@@ -0,0 +1,100 @@
+import { countPlannedOperations } from './sync.utils.js';
+function countSkippedEntries(scopePlans) {
+    return scopePlans.reduce((total, scopePlan) => {
+        const codexSkipped = scopePlan.codexExtension?.operations.filter((operation) => operation.action === 'skip').length ?? 0;
+        return (total +
+            scopePlan.plan.entries.filter((entry) => entry.operation === 'skip')
+                .length +
+            codexSkipped);
+    }, 0);
+}
+function buildSummary(scopePlans, applied, failed) {
+    return {
+        plannedOperations: countPlannedOperations(scopePlans),
+        applied,
+        failed,
+        skipped: countSkippedEntries(scopePlans),
+    };
+}
+function formatAppliedOutput(scopePlans, dependencies) {
+    if (scopePlans.length === 0) {
+        return dependencies.formatSyncPlan({
+            scope: 'project',
+            entries: [],
+            removals: [],
+        }, true);
+    }
+    return scopePlans
+        .map((scopePlan) => {
+        const syncOutput = dependencies.formatSyncPlan(scopePlan.plan, true);
+        const codexExtension = scopePlan.codexExtension;
+        if (!codexExtension) {
+            return `Scope: ${scopePlan.scope}\n${syncOutput}`;
+        }
+        const codexLines = codexExtension.operations.map((operation) => {
+            const role = operation.roleName ? ` (${operation.roleName})` : '';
+            return `- codex:${operation.target}:${operation.action} ${operation.path}${role} (${operation.reason})`;
+        });
+        return `Scope: ${scopePlan.scope}\n${syncOutput}\n\nCodex extension (applied)\n${codexLines.join('\n')}`;
+    })
+        .join('\n\n');
+}
+export async function runSyncApply(context, scopePlans, dependencies) {
+    let applied = 0;
+    let failed = 0;
+    for (const scopePlan of scopePlans) {
+        const hasSyncEntries = scopePlan.plan.entries.length > 0 || scopePlan.plan.removals.length > 0;
+        const hasCodexPlannedOperations = scopePlan.codexExtensionPlan?.operations.some((operation) => operation.action !== 'skip') ?? false;
+        if (!hasSyncEntries && !hasCodexPlannedOperations) {
+            continue;
+        }
+        if (hasSyncEntries) {
+            const result = await dependencies.executeSyncPlan(scopePlan.plan, scopePlan.manifest, scopePlan.manifestPath);
+            applied += result.applied;
+            failed += result.failed;
+        }
+        if (scopePlan.codexExtensionPlan && hasCodexPlannedOperations) {
+            const codexResult = await dependencies.applyCodexProjectExtensionPlan(scopePlan.scopeRoot, scopePlan.codexExtensionPlan);
+            applied += codexResult.applied;
+            failed += codexResult.failed;
+            if (scopePlan.codexExtension) {
+                scopePlan.codexExtension = {
+                    ...scopePlan.codexExtension,
+                    applied: codexResult.applied,
+                    failed: codexResult.failed,
+                    skipped: codexResult.skipped,
+                };
+            }
+        }
+    }
+    const summary = buildSummary(scopePlans, applied, failed);
+    const providerMismatches = scopePlans
+        .map((scopePlan) => scopePlan.providerMismatches)
+        .filter((mismatch) => mismatch !== undefined);
+    const codexExtensions = scopePlans
+        .map((scopePlan) => scopePlan.codexExtension)
+        .filter((extension) => extension !== undefined);
+    if (context.json) {
+        context.logger.json({
+            scope: context.scope,
+            dryRun: false,
+            plans: scopePlans.map((scopePlan) => scopePlan.plan),
+            summary,
+            providerMismatches,
+            codexExtensions,
+        });
+    }
+    else {
+        context.logger.info(formatAppliedOutput(scopePlans, dependencies));
+        if (summary.plannedOperations === 0) {
+            context.logger.info('\nNo changes required.');
+        }
+        else if (failed > 0) {
+            context.logger.warn('\nSync completed with partial failures.');
+        }
+        else {
+            context.logger.success('\nSync applied successfully.');
+        }
+    }
+    process.exitCode = failed > 0 ? 1 : 0;
+}

package/dist/commands/sync/dry-run.d.ts

@@ -0,0 +1,4 @@
+import type { CommandContext } from '../../app/command-context.js';
+import type { ScopeSyncPlan, SyncCommandDependencies } from './sync.types.js';
+export declare function runSyncDryRun(context: CommandContext, scopePlans: ScopeSyncPlan[], dependencies: SyncCommandDependencies): void;
+//# sourceMappingURL=dry-run.d.ts.map

package/dist/commands/sync/dry-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dry-run.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/dry-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AA+DtB,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,IAAI,CA6BN"}

package/dist/commands/sync/dry-run.js

@@ -0,0 +1,74 @@
+import { countPlannedOperations } from './sync.utils.js';
+function summarize(scopePlans) {
+    return {
+        plannedOperations: countPlannedOperations(scopePlans),
+        applied: 0,
+        failed: 0,
+        skipped: scopePlans.reduce((total, scopePlan) => {
+            const codexSkipped = scopePlan.codexExtension?.operations.filter((operation) => operation.action === 'skip').length ?? 0;
+            return (total +
+                scopePlan.plan.entries.filter((entry) => entry.operation === 'skip')
+                    .length +
+                codexSkipped);
+        }, 0),
+    };
+}
+function formatCodexExtension(scopePlan) {
+    const codexExtension = scopePlan.codexExtension;
+    if (!codexExtension) {
+        return '';
+    }
+    const lines = codexExtension.operations.map((operation) => {
+        const role = operation.roleName ? ` (${operation.roleName})` : '';
+        return `- codex:${operation.target}:${operation.action} ${operation.path}${role} (${operation.reason})`;
+    });
+    return `Codex extension (dry-run)\n${lines.join('\n')}`;
+}
+function formatDryRunOutput(scopePlans, dependencies) {
+    if (scopePlans.length === 0) {
+        return dependencies.formatSyncPlan({
+            scope: 'project',
+            entries: [],
+            removals: [],
+        }, false);
+    }
+    return scopePlans
+        .map((scopePlan) => {
+        const syncOutput = dependencies.formatSyncPlan(scopePlan.plan, false);
+        const codexOutput = formatCodexExtension(scopePlan);
+        return codexOutput
+            ? `Scope: ${scopePlan.scope}\n${syncOutput}\n\n${codexOutput}`
+            : `Scope: ${scopePlan.scope}\n${syncOutput}`;
+    })
+        .join('\n\n');
+}
+export function runSyncDryRun(context, scopePlans, dependencies) {
+    const summary = summarize(scopePlans);
+    const providerMismatches = scopePlans
+        .map((scopePlan) => scopePlan.providerMismatches)
+        .filter((mismatch) => mismatch !== undefined);
+    const codexExtensions = scopePlans
+        .map((scopePlan) => scopePlan.codexExtension)
+        .filter((extension) => extension !== undefined);
+    if (context.json) {
+        context.logger.json({
+            scope: context.scope,
+            dryRun: true,
+            plans: scopePlans.map((scopePlan) => scopePlan.plan),
+            summary,
+            providerMismatches,
+            codexExtensions,
+        });
+    }
+    else {
+        context.logger.info(formatDryRunOutput(scopePlans, dependencies));
+        context.logger.warn('\nDry-run only: no filesystem changes were made.');
+        if (summary.plannedOperations > 0) {
+            context.logger.info('Run without --dry-run to apply changes.');
+        }
+        else {
+            context.logger.info('No changes to apply.');
+        }
+    }
+    process.exitCode = 0;
+}

package/dist/commands/sync/index.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { SyncCommandDependencies } from './sync.types.js';
+export declare function createSyncCommand(overrides?: Partial<SyncCommandDependencies>): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/sync/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/index.ts"],"names":[],"mappings":"AAqCA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EAEV,uBAAuB,EAExB,MAAM,cAAc,CAAC;AAyRtB,wBAAgB,iBAAiB,CAC/B,SAAS,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC/C,OAAO,CAeT"}