@open-agent-toolkit/cli 0.2.50 → 0.2.52

package/dist/commands/sync/apply.js

@@ -1,24 +1,161 @@
-import { countPlannedOperations } from './sync.utils.js';
-function countSkippedEntries(scopePlans) {
+import { getProviderRegistrations, } from '../../providers/shared/registry.js';
+import { adviseProviderRefresh, } from '../../providers/shared/restart-adviser.js';
+import { buildCollectionLifecycle, countPlannedOperations, formatCollectionLifecycle, toSyncOutputPlan, } from './sync.utils.js';
+function extensionResultContentKind(registrations, result) {
+    const registration = registrations.find(({ adapter }) => adapter.name === result.provider);
+    const candidates = registration?.capabilities.filter(({ scope, support, projectionModes }) => scope === result.scope &&
+        support === 'supported' &&
+        projectionModes.includes('materialization-extension'));
+    // Extension operation identities do not carry a canonical asset kind.
+    // Attribute only when provider capability evidence gives one unambiguous
+    // content kind; otherwise leave the exact result unattributed.
+    return candidates?.length === 1 ? candidates[0].contentKind : undefined;
+}
+function buildProviderRefreshAdvice(input) {
+    const registrations = getProviderRegistrations();
+    const changed = [
+        ...input.operationResults
+            .filter(({ status }) => status === 'changed')
+            .map(({ scope, provider, contentKind }) => ({
+            scope,
+            provider,
+            contentKind,
+        })),
+        ...input.extensionResults
+            .filter(({ status }) => status === 'changed')
+            .flatMap((result) => {
+            const contentKind = extensionResultContentKind(registrations, result);
+            return contentKind === undefined
+                ? []
+                : [{ scope: result.scope, provider: result.provider, contentKind }];
+        }),
+    ];
+    const seen = new Set();
+    return changed.flatMap(({ scope, provider, contentKind }) => {
+        const key = `${scope}:${provider}:${contentKind}`;
+        if (seen.has(key))
+            return [];
+        seen.add(key);
+        const policy = registrations
+            .find(({ adapter }) => adapter.name === provider)
+            ?.capabilities.find((capability) => capability.scope === scope && capability.contentKind === contentKind)?.catalogRefresh ?? {
+            state: 'unknown',
+            reason: 'Provider or capability is not registered',
+        };
+        return [
+            {
+                scope,
+                provider,
+                contentKind,
+                materialization: 'changed',
+                visibility: adviseProviderRefresh({
+                    policy,
+                    materialization: 'changed',
+                }),
+            },
+        ];
+    });
+}
+function formatProviderRefreshAdvice(advice) {
+    return advice
+        .map(({ scope, provider, contentKind, visibility }) => {
+        const recovery = visibility.recovery[0]?.message;
+        return `Provider visibility [${scope}] ${provider}/${contentKind}: ${visibility.state} — ${recovery ?? visibility.reason}`;
+    })
+        .join('\n');
+}
+function countSkippedExtensionEntries(scopePlans) {
     return scopePlans.reduce((total, scopePlan) => {
         const extensionSkipped = scopePlan.materializationExtensions.reduce((count, extension) => count +
             extension.operations.filter((operation) => operation.action === 'skip')
                 .length, 0);
-        return (total +
-            scopePlan.plan.entries.filter((entry) => entry.operation === 'skip')
-                .length +
-            extensionSkipped);
+        return total + extensionSkipped;
     }, 0);
 }
-function buildSummary(scopePlans, applied, failed) {
+function buildSummary(scopePlans, coreApplied, coreFailed, coreSkipped, extensionApplied, extensionFailed) {
     return {
         plannedOperations: countPlannedOperations(scopePlans),
-        applied,
-        failed,
-        skipped: countSkippedEntries(scopePlans),
+        applied: coreApplied + extensionApplied,
+        failed: coreFailed + extensionFailed,
+        skipped: coreSkipped + countSkippedExtensionEntries(scopePlans),
     };
 }
-function formatAppliedOutput(scopePlans, dependencies) {
+function normalizeOperationResults(plan, result) {
+    if (result.operations) {
+        return result.operations;
+    }
+    const plannedOperations = [...plan.entries, ...plan.removals];
+    return plannedOperations.map((operation) => {
+        return {
+            scope: plan.scope,
+            provider: operation.provider,
+            contentKind: operation.canonical.type,
+            asset: operation.canonical.name,
+            action: operation.operation,
+            status: operation.operation === 'skip' ? 'current' : 'unknown',
+        };
+    });
+}
+function materializationOperationIdentity(operation) {
+    return JSON.stringify([
+        operation.provider,
+        operation.target,
+        operation.path,
+        operation.action,
+        operation.entryName ?? null,
+    ]);
+}
+function syncOperationIdentity(operation) {
+    return JSON.stringify([
+        operation.scope,
+        operation.provider,
+        operation.contentKind,
+        operation.asset,
+        operation.action,
+    ]);
+}
+function coreHumanStatus(status) {
+    switch (status) {
+        case 'changed':
+        case 'current':
+        case 'failed':
+        case 'missing':
+        case 'unknown':
+            return status;
+        default:
+            return 'unknown';
+    }
+}
+function formatCoreResults(plan, evidence, dependencies) {
+    const operations = [...plan.entries, ...plan.removals];
+    if (operations.length === 0) {
+        if ((plan.collections?.length ?? 0) > 0) {
+            return 'Core results\nNo per-entry operations.';
+        }
+        return dependencies.formatSyncPlan(plan, true);
+    }
+    const resultsByIdentity = new Map((evidence?.operationResults ?? []).map((result) => [
+        syncOperationIdentity(result),
+        result,
+    ]));
+    const lines = operations.map((operation) => {
+        const result = resultsByIdentity.get(syncOperationIdentity({
+            scope: plan.scope,
+            provider: operation.provider,
+            contentKind: operation.canonical.type,
+            asset: operation.canonical.name,
+            action: operation.operation,
+        }));
+        const status = coreHumanStatus(result?.status);
+        const failure = result?.failure ? ` — ${result.failure}` : '';
+        return `- ${plan.scope}:${operation.provider}:${operation.canonical.type}:${operation.operation} ${operation.canonical.name}\n  reason: ${operation.reason}\n  result: ${status}${failure}`;
+    });
+    const aggregate = evidence?.aggregateOnly
+        ? `\nCore aggregate result: applied ${evidence.aggregate.applied}, failed ${evidence.aggregate.failed}, skipped ${evidence.aggregate.skipped}; non-skip named outcomes remain unknown.`
+        : '';
+    return `Core results${aggregate}\n${lines.join('\n')}`;
+}
+function formatAppliedOutput(scopePlans, coreApplyEvidence, dependencies) {
     if (scopePlans.length === 0) {
         return dependencies.formatSyncPlan({
             scope: 'project',
@@ -28,28 +165,53 @@ function formatAppliedOutput(scopePlans, dependencies) {
     }
     return scopePlans
         .map((scopePlan) => {
-        const syncOutput = dependencies.formatSyncPlan(scopePlan.plan, true);
+        const syncOutput = formatCoreResults(scopePlan.plan, coreApplyEvidence.find((evidence) => evidence.plan === scopePlan.plan), dependencies);
+        const collectionOutput = formatCollectionLifecycle(buildCollectionLifecycle(scopePlan, coreApplyEvidence.find((evidence) => evidence.plan === scopePlan.plan)
+            ?.collectionResults));
         if (scopePlan.materializationExtensions.length === 0) {
-            return `Scope: ${scopePlan.scope}\n${syncOutput}`;
+            return [`Scope: ${scopePlan.scope}\n${syncOutput}`, collectionOutput]
+                .filter(Boolean)
+                .join('\n\n');
         }
         const extensionSections = scopePlan.materializationExtensions.map((extension) => {
+            const resultsByIdentity = new Map((extension.operationResults ?? []).map((result) => [
+                materializationOperationIdentity(result),
+                result,
+            ]));
             const lines = extension.operations.map((operation) => {
                 const entry = operation.entryName
                     ? ` (${operation.entryName})`
                     : '';
-                return `- ${operation.provider}:${operation.target}:${operation.action} ${operation.path}${entry} (${operation.reason})`;
+                const result = resultsByIdentity.get(materializationOperationIdentity(operation));
+                const status = result?.status ?? 'unknown';
+                const failure = result?.failure ? ` — ${result.failure}` : '';
+                return `- ${operation.provider}:${operation.target}:${operation.action} ${operation.path}${entry}\n  reason: ${operation.reason}\n  result: ${status}${failure}`;
             });
-            return `${extension.provider} extension (applied)\n${lines.join('\n')}`;
+            return `${extension.provider} extension results\n${lines.join('\n')}`;
         });
-        return `Scope: ${scopePlan.scope}\n${syncOutput}\n\n${extensionSections.join('\n\n')}`;
+        return [
+            `Scope: ${scopePlan.scope}\n${syncOutput}`,
+            collectionOutput,
+            extensionSections.join('\n\n'),
+        ]
+            .filter(Boolean)
+            .join('\n\n');
     })
         .join('\n\n');
 }
 export async function runSyncApply(context, scopePlans, dependencies) {
-    let applied = 0;
-    let failed = 0;
+    let extensionApplied = 0;
+    let extensionFailed = 0;
+    let coreApplied = 0;
+    let coreFailed = 0;
+    let coreSkipped = 0;
+    const operationResults = [];
+    const coreApplyEvidence = [];
+    const extensionOperationResults = [];
     for (const scopePlan of scopePlans) {
-        const hasSyncEntries = scopePlan.plan.entries.length > 0 || scopePlan.plan.removals.length > 0;
+        const hasSyncEntries = scopePlan.plan.entries.length > 0 ||
+            scopePlan.plan.removals.length > 0 ||
+            (scopePlan.plan.collections?.length ?? 0) > 0;
         const hasExtensionPlannedOperations = scopePlan.materializationExtensionPlans.some((plan) => plan.operations.some((operation) => operation.action !== 'skip'));
         // Derived from the same diagnostic that produced the pre-mutation advisory
         // (`detectVersionSkew` in ./index), so the restamp and the warning cannot
@@ -63,8 +225,18 @@ export async function runSyncApply(context, scopePlans, dependencies) {
         }
         if (hasSyncEntries || shouldRefreshManifestVersion) {
             const result = await dependencies.executeSyncPlan(scopePlan.plan, scopePlan.manifest, scopePlan.manifestPath);
-            applied += result.applied;
-            failed += result.failed;
+            coreApplied += result.applied;
+            coreFailed += result.failed;
+            coreSkipped += result.skipped;
+            const normalizedResults = normalizeOperationResults(scopePlan.plan, result);
+            operationResults.push(...normalizedResults);
+            coreApplyEvidence.push({
+                plan: scopePlan.plan,
+                operationResults: normalizedResults,
+                aggregateOnly: result.operations === undefined,
+                aggregate: result,
+                collectionResults: result.collectionResults ?? [],
+            });
         }
         for (const plan of scopePlan.materializationExtensionPlans) {
             if (!plan.operations.some((operation) => operation.action !== 'skip')) {
@@ -77,15 +249,22 @@ export async function runSyncApply(context, scopePlans, dependencies) {
                 throw new Error(`Materialization extension ${plan.provider} disappeared before apply.`);
             }
             const result = await dependencies.applyMaterializationExtensionPlan(extension, scopePlan.scopeRoot, plan);
-            applied += result.applied;
-            failed += result.failed;
+            extensionApplied += result.applied;
+            extensionFailed += result.failed;
+            extensionOperationResults.push(...(result.operations ?? []).map((operation) => ({
+                ...operation,
+                scope: scopePlan.scope,
+            })));
             const summary = scopePlan.materializationExtensions.find((candidate) => candidate.provider === plan.provider);
             if (summary) {
-                Object.assign(summary, result);
+                summary.applied = result.applied;
+                summary.failed = result.failed;
+                summary.skipped = result.skipped;
+                summary.operationResults = result.operations;
             }
         }
     }
-    const summary = buildSummary(scopePlans, applied, failed);
+    const summary = buildSummary(scopePlans, coreApplied, coreFailed, coreSkipped, extensionApplied, extensionFailed);
     const providerMismatches = scopePlans
         .map((scopePlan) => scopePlan.providerMismatches)
         .filter((mismatch) => mismatch !== undefined);
@@ -109,29 +288,41 @@ export async function runSyncApply(context, scopePlans, dependencies) {
         failed: extension.failed,
         skipped: extension.skipped,
     }));
+    const providerRefreshAdvice = buildProviderRefreshAdvice({
+        operationResults,
+        extensionResults: extensionOperationResults,
+    });
+    const collectionOperations = scopePlans.flatMap((scopePlan) => buildCollectionLifecycle(scopePlan, coreApplyEvidence.find((evidence) => evidence.plan === scopePlan.plan)
+        ?.collectionResults));
     if (context.json) {
         context.logger.json({
             scope: context.scope,
             dryRun: false,
-            plans: scopePlans.map((scopePlan) => scopePlan.plan),
+            plans: scopePlans.map(toSyncOutputPlan),
+            collectionOperations,
             summary,
             providerMismatches,
             versionSkew,
             materializationExtensions,
+            operationResults,
             codexExtensions,
+            providerRefreshAdvice,
         });
     }
     else {
-        context.logger.info(formatAppliedOutput(scopePlans, dependencies));
+        context.logger.info(formatAppliedOutput(scopePlans, coreApplyEvidence, dependencies));
         if (summary.plannedOperations === 0) {
             context.logger.info('\nNo changes required.');
         }
-        else if (failed > 0) {
+        else if (summary.failed > 0) {
             context.logger.warn('\nSync completed with partial failures.');
         }
         else {
             context.logger.success('\nSync applied successfully.');
         }
+        if (providerRefreshAdvice.length > 0) {
+            context.logger.info(`\n${formatProviderRefreshAdvice(providerRefreshAdvice)}`);
+        }
     }
-    process.exitCode = failed > 0 ? 1 : 0;
+    process.exitCode = summary.failed > 0 ? 1 : 0;
 }

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

@@ -1 +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;AAiEtB,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,IAAI,CA+CN"}
+{"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;AAG3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AAsGtB,wBAAgB,aAAa,CAC3B,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,IAAI,CAqDN"}

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

@@ -1,4 +1,4 @@
-import { countPlannedOperations } from './sync.utils.js';
+import { buildCollectionLifecycle, countPlannedOperations, formatCollectionLifecycle, toSyncOutputPlan, } from './sync.utils.js';
 function summarize(scopePlans) {
     return {
         plannedOperations: countPlannedOperations(scopePlans),
@@ -10,10 +10,21 @@ function summarize(scopePlans) {
             return (total +
                 scopePlan.plan.entries.filter((entry) => entry.operation === 'skip')
                     .length +
+                (scopePlan.plan.collections ?? []).filter(({ action }) => action === 'fallback-per-entry').length +
                 extensionSkipped);
         }, 0),
     };
 }
+function buildOperationResults(scopePlans) {
+    return scopePlans.flatMap((scopePlan) => [...scopePlan.plan.entries, ...scopePlan.plan.removals].map((operation) => ({
+        scope: scopePlan.scope,
+        provider: operation.provider,
+        contentKind: operation.canonical.type,
+        asset: operation.canonical.name,
+        action: operation.operation,
+        status: operation.operation === 'skip' ? 'current' : 'planned',
+    })));
+}
 function formatMaterializationExtensions(scopePlan) {
     return scopePlan.materializationExtensions
         .map((extension) => {
@@ -35,11 +46,20 @@ function formatDryRunOutput(scopePlans, dependencies) {
     }
     return scopePlans
         .map((scopePlan) => {
-        const syncOutput = dependencies.formatSyncPlan(scopePlan.plan, false);
+        const collectionOutput = formatCollectionLifecycle(buildCollectionLifecycle(scopePlan));
+        const syncOutput = collectionOutput &&
+            scopePlan.plan.entries.length === 0 &&
+            scopePlan.plan.removals.length === 0
+            ? 'Per-entry sync plan\nNo per-entry operations.'
+            : dependencies.formatSyncPlan(scopePlan.plan, false);
         const extensionOutput = formatMaterializationExtensions(scopePlan);
-        return extensionOutput
-            ? `Scope: ${scopePlan.scope}\n${syncOutput}\n\n${extensionOutput}`
-            : `Scope: ${scopePlan.scope}\n${syncOutput}`;
+        return [
+            `Scope: ${scopePlan.scope}\n${syncOutput}`,
+            collectionOutput,
+            extensionOutput,
+        ]
+            .filter(Boolean)
+            .join('\n\n');
     })
         .join('\n\n');
 }
@@ -52,6 +72,8 @@ export function runSyncDryRun(context, scopePlans, dependencies) {
         .map((scopePlan) => scopePlan.versionSkew)
         .filter((skew) => skew !== undefined);
     const materializationExtensions = scopePlans.flatMap((scopePlan) => scopePlan.materializationExtensions);
+    const operationResults = buildOperationResults(scopePlans);
+    const collectionOperations = scopePlans.flatMap((scopePlan) => buildCollectionLifecycle(scopePlan));
     const codexExtensions = materializationExtensions
         .filter((extension) => extension.provider === 'codex')
         .map((extension) => ({
@@ -69,11 +91,13 @@ export function runSyncDryRun(context, scopePlans, dependencies) {
         context.logger.json({
             scope: context.scope,
             dryRun: true,
-            plans: scopePlans.map((scopePlan) => scopePlan.plan),
+            plans: scopePlans.map(toSyncOutputPlan),
+            collectionOperations,
             summary,
             providerMismatches,
             versionSkew,
             materializationExtensions,
+            operationResults,
             codexExtensions,
         });
     }

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

@@ -1,4 +1,19 @@
+import { type SyncConfig } from '../../config/index.js';
+import { type ProviderScopeContext } from '../../providers/shared/index.js';
+import { type CanonicalScanTarget, type ConcreteScope } from '../../shared/types.js';
 import { Command } from 'commander';
-import type { SyncCommandDependencies } from './sync.types.js';
-export declare function createSyncCommand(overrides?: Partial<SyncCommandDependencies>): Command;
+import type { ScopeSyncPlan, SyncCommandDependencies } from './sync.types.js';
+type ContextualSyncDependencies = Omit<SyncCommandDependencies, 'computeSyncPlan' | 'scanCanonical'> & {
+    scanCanonical: (scopeRoot: string, scope: ConcreteScope, targets?: readonly CanonicalScanTarget[]) => ReturnType<SyncCommandDependencies['scanCanonical']>;
+    computeSyncPlan: (args: Parameters<SyncCommandDependencies['computeSyncPlan']>[0] & {
+        extensionOwnedCanonicalPathsByProvider?: Readonly<Record<string, readonly string[]>>;
+    }) => ReturnType<SyncCommandDependencies['computeSyncPlan']>;
+    resolveProviderScopeContext?: (input: {
+        scope: ScopeSyncPlan['scope'];
+        scopeRoot: string;
+        config: SyncConfig;
+    }) => Promise<ProviderScopeContext>;
+};
+export declare function createSyncCommand(overrides?: Partial<ContextualSyncDependencies>): Command;
+export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/index.ts"],"names":[],"mappings":"AA2CA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAI5C,OAAO,KAAK,EAGV,uBAAuB,EAGxB,MAAM,cAAc,CAAC;AAoZtB,wBAAgB,iBAAiB,CAC/B,SAAS,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC/C,OAAO,CAuDT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,UAAU,EAEhB,MAAM,eAAe,CAAC;AAUvB,OAAO,EAOL,KAAK,oBAAoB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAI5C,OAAO,KAAK,EACV,aAAa,EAEb,uBAAuB,EAGxB,MAAM,cAAc,CAAC;AAEtB,KAAK,0BAA0B,GAAG,IAAI,CACpC,uBAAuB,EACvB,iBAAiB,GAAG,eAAe,CACpC,GAAG;IACF,aAAa,EAAE,CACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,aAAa,EACpB,OAAO,CAAC,EAAE,SAAS,mBAAmB,EAAE,KACrC,UAAU,CAAC,uBAAuB,CAAC,eAAe,CAAC,CAAC,CAAC;IAC1D,eAAe,EAAE,CACf,IAAI,EAAE,UAAU,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;QAChE,sCAAsC,CAAC,EAAE,QAAQ,CAC/C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAClC,CAAC;KACH,KACE,UAAU,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC,CAAC;IAC5D,2BAA2B,CAAC,EAAE,CAAC,KAAK,EAAE;QACpC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;QAC9B,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,UAAU,CAAC;KACpB,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACrC,CAAC;AA2eF,wBAAgB,iBAAiB,CAC/B,SAAS,GAAE,OAAO,CAAC,0BAA0B,CAAM,GAClD,OAAO,CA+DT"}