@open-agent-toolkit/cli 0.1.19 → 0.1.20

package/dist/commands/project/archive/push-runner.js

@@ -0,0 +1,151 @@
+import { basename, isAbsolute, join } from 'node:path';
+import { buildCommandContext } from '../../../app/command-context.js';
+import { resolveProjectsRoot } from '../../shared/oat-paths.js';
+import { readOatConfig, readOatLocalConfig, } from '../../../config/oat-config.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { archiveProjectOnCompletion, assertDurableArchiveProjectTarget, buildArchiveSnapshotName, buildProjectArchiveS3Uri, resolveArchiveProjectTarget, resolvePrimaryRepoRoot, } from './archive-utils.js';
+export function defaultProjectArchivePushCommandDependencies() {
+    return {
+        buildCommandContext,
+        resolveProjectRoot,
+        readOatConfig,
+        readOatLocalConfig,
+        resolveProjectsRoot,
+        resolvePrimaryRepoRoot,
+        resolveArchiveProjectTarget,
+        archiveProjectOnCompletion,
+        processEnv: process.env,
+        timestamp: () => new Date().toISOString(),
+    };
+}
+function resolveRepoAbsolutePath(repoRoot, targetPath) {
+    return isAbsolute(targetPath) ? targetPath : join(repoRoot, targetPath);
+}
+async function resolveArchiveTarget(dependencies, repoRoot, projectPathArg) {
+    const rawProjectPath = projectPathArg?.trim();
+    const projectPath = rawProjectPath && rawProjectPath.length > 0
+        ? rawProjectPath
+        : (await dependencies.readOatLocalConfig(repoRoot)).activeProject?.trim();
+    if (!projectPath) {
+        throw new CliError('No project path provided and no active project is configured. Pass a project path or set `activeProject`.');
+    }
+    const absoluteProjectPath = resolveRepoAbsolutePath(repoRoot, projectPath);
+    const projectName = basename(absoluteProjectPath);
+    if (!projectName) {
+        throw new CliError(`Unable to determine project name from \`${projectPath}\`.`);
+    }
+    return {
+        projectName,
+        projectPath: absoluteProjectPath,
+    };
+}
+function buildArchiveOptions(repoRoot, config, projectsRoot, target) {
+    return {
+        repoRoot,
+        projectPath: target.projectPath,
+        projectName: target.projectName,
+        projectsRoot,
+        s3Uri: config.archive?.s3Uri,
+        s3SyncOnComplete: config.archive?.s3SyncOnComplete ?? false,
+        summaryExportPath: config.archive?.summaryExportPath,
+        awsProfile: config.archive?.awsProfile,
+        awsRegion: config.archive?.awsRegion,
+    };
+}
+async function buildDryRunReport(dependencies, repoRoot, config, target, archiveTarget) {
+    const snapshotName = buildArchiveSnapshotName(target.projectName, dependencies.timestamp());
+    const remoteRepoRoot = await dependencies.resolvePrimaryRepoRoot(repoRoot);
+    const s3Path = config.archive?.s3Uri && config.archive.s3SyncOnComplete === true
+        ? buildProjectArchiveS3Uri(config.archive.s3Uri, remoteRepoRoot, snapshotName)
+        : null;
+    const summaryExportFile = config.archive?.summaryExportPath
+        ? join(repoRoot, config.archive.summaryExportPath, `${snapshotName}.md`)
+        : null;
+    return {
+        status: 'ok',
+        mode: 'dry-run',
+        projectName: target.projectName,
+        projectPath: target.projectPath,
+        archivePath: archiveTarget.archivePath,
+        s3Path,
+        summaryExportFile,
+        warnings: [],
+    };
+}
+function emitArchivePushText(report, summaryExportPath, logger) {
+    for (const warning of report.warnings) {
+        logger.warn(warning);
+    }
+    if (report.mode === 'dry-run') {
+        logger.info(`Dry-run: would archive project \`${report.projectName}\` from \`${report.projectPath}\` to \`${report.archivePath}\`.`);
+        if (report.s3Path) {
+            logger.info(`S3 archive: ${report.s3Path}`);
+        }
+        if (summaryExportPath) {
+            logger.info(`Summary export path: ${summaryExportPath}`);
+        }
+        return;
+    }
+    logger.info(`Archived project \`${report.projectName}\` to \`${report.archivePath}\`.`);
+    if (report.s3Path) {
+        logger.info(`S3 archive: ${report.s3Path}`);
+    }
+    if (report.summaryExportFile) {
+        logger.info(`Summary export: ${report.summaryExportFile}`);
+    }
+}
+function emitArchivePushReport(report, summaryExportPath, context) {
+    if (context.json) {
+        context.logger.json(report);
+        return;
+    }
+    emitArchivePushText(report, summaryExportPath, context.logger);
+}
+export async function runArchivePushCommand(dependencies, projectPathArg, options, context) {
+    try {
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const config = await dependencies.readOatConfig(repoRoot);
+        const projectsRoot = await dependencies.resolveProjectsRoot(repoRoot, dependencies.processEnv);
+        const target = await resolveArchiveTarget(dependencies, repoRoot, projectPathArg);
+        const archiveTarget = await dependencies.resolveArchiveProjectTarget({
+            repoRoot,
+            projectsRoot,
+            projectName: target.projectName,
+        }, {
+            env: dependencies.processEnv,
+            timestamp: dependencies.timestamp,
+        });
+        assertDurableArchiveProjectTarget(archiveTarget);
+        const dryRun = options.dryRun === true || context.dryRun;
+        if (dryRun) {
+            const report = await buildDryRunReport(dependencies, repoRoot, config, target, archiveTarget);
+            emitArchivePushReport(report, config.archive?.summaryExportPath, context);
+            process.exitCode = 0;
+            return;
+        }
+        const result = await dependencies.archiveProjectOnCompletion(buildArchiveOptions(repoRoot, config, projectsRoot, target));
+        const report = {
+            status: 'ok',
+            mode: 'apply',
+            projectName: target.projectName,
+            projectPath: target.projectPath,
+            archivePath: result.archivePath,
+            s3Path: result.s3Path,
+            summaryExportFile: result.summaryExportFile,
+            warnings: result.warnings,
+        };
+        emitArchivePushReport(report, config.archive?.summaryExportPath, context);
+        process.exitCode = 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = error instanceof CliError ? error.exitCode : 1;
+    }
+}

package/dist/commands/project/archive/sync-runner.d.ts

@@ -0,0 +1,47 @@
+import { rm } from 'node:fs/promises';
+import { buildCommandContext, type CommandContext } from '../../../app/command-context.js';
+import { type OatConfig } from '../../../config/oat-config.js';
+import { buildProjectArchiveS3Uri, buildRepoArchiveS3Uri, ensureS3ArchiveAccess, type ExecFileLike, resolveLocalArchiveProjectPath, resolvePrimaryRepoRoot } from './archive-utils.js';
+export interface ArchiveSyncOptions {
+    dryRun?: boolean;
+    force?: boolean;
+    profile?: string;
+    region?: string;
+}
+export interface ProjectArchiveCommandDependencies {
+    buildCommandContext: (options: Parameters<typeof buildCommandContext>[0]) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    readOatConfig: (repoRoot: string) => Promise<OatConfig>;
+    resolveProjectsRoot: (repoRoot: string, env: NodeJS.ProcessEnv) => Promise<string>;
+    ensureS3ArchiveAccess: typeof ensureS3ArchiveAccess;
+    buildRepoArchiveS3Uri: typeof buildRepoArchiveS3Uri;
+    buildProjectArchiveS3Uri: typeof buildProjectArchiveS3Uri;
+    resolveLocalArchiveProjectPath: typeof resolveLocalArchiveProjectPath;
+    resolvePrimaryRepoRoot: typeof resolvePrimaryRepoRoot;
+    execFile: ExecFileLike;
+    removeDirectory: typeof rm;
+    processEnv: NodeJS.ProcessEnv;
+}
+export declare function defaultProjectArchiveCommandDependencies(): ProjectArchiveCommandDependencies;
+export declare function resolveLocalArchiveRoot(projectsRoot: string): string;
+export declare function resolveSyncAwsEnv(processEnv: NodeJS.ProcessEnv, options: ArchiveSyncOptions, config: OatConfig): {
+    env: NodeJS.ProcessEnv;
+    awsProfile: string | undefined;
+    awsRegion: string | undefined;
+};
+export declare function buildArchiveSyncArgs(source: string, target: string, options: ArchiveSyncOptions): string[];
+export declare function runArchiveSync(repoRoot: string, source: string, target: string, options: ArchiveSyncOptions, awsEnv: NodeJS.ProcessEnv, dependencies: ProjectArchiveCommandDependencies): Promise<void>;
+export interface ArchiveSnapshotEntry {
+    dateStamp: string | null;
+    projectName: string;
+    snapshotName: string;
+    source: string;
+    target: string;
+}
+export declare function listArchiveSnapshots(repoRoot: string, projectsRoot: string, s3Uri: string, awsEnv: NodeJS.ProcessEnv, dependencies: ProjectArchiveCommandDependencies): Promise<ArchiveSnapshotEntry[]>;
+export declare function compareSnapshotEntries(left: ArchiveSnapshotEntry, right: ArchiveSnapshotEntry): number;
+export declare function selectLatestSnapshots(snapshots: ArchiveSnapshotEntry[]): ArchiveSnapshotEntry[];
+export declare function readLocalSnapshotName(repoRoot: string, target: string): Promise<string | null>;
+export declare function syncArchiveSnapshot(repoRoot: string, snapshot: ArchiveSnapshotEntry, options: ArchiveSyncOptions, awsEnv: NodeJS.ProcessEnv, dependencies: ProjectArchiveCommandDependencies): Promise<boolean>;
+export declare function runArchiveSyncCommand(dependencies: ProjectArchiveCommandDependencies, projectName: string | undefined, options: ArchiveSyncOptions, context: CommandContext, commandLabel?: string): Promise<void>;
+//# sourceMappingURL=sync-runner.d.ts.map

package/dist/commands/project/archive/sync-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-runner.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/archive/sync-runner.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAIhD,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEhF,OAAO,EAAE,KAAK,SAAS,EAAiB,MAAM,oBAAoB,CAAC;AAInE,OAAO,EAIL,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,YAAY,EAEjB,8BAA8B,EAC9B,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAIzB,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iCAAiC;IAChD,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,qBAAqB,EAAE,OAAO,qBAAqB,CAAC;IACpD,qBAAqB,EAAE,OAAO,qBAAqB,CAAC;IACpD,wBAAwB,EAAE,OAAO,wBAAwB,CAAC;IAC1D,8BAA8B,EAAE,OAAO,8BAA8B,CAAC;IACtE,sBAAsB,EAAE,OAAO,sBAAsB,CAAC;IACtD,QAAQ,EAAE,YAAY,CAAC;IACvB,eAAe,EAAE,OAAO,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B;AAED,wBAAgB,wCAAwC,IAAI,iCAAiC,CAe5F;AAED,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,CAAC,UAAU,EAC7B,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,SAAS,GAChB;IACD,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,CAsBA;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,kBAAkB,GAC1B,MAAM,EAAE,CAYV;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,MAAM,CAAC,UAAU,EACzB,YAAY,EAAE,iCAAiC,GAC9C,OAAO,CAAC,IAAI,CAAC,CASf;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,CAAC,UAAU,EACzB,YAAY,EAAE,iCAAiC,GAC9C,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAqCjC;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,oBAAoB,EAC1B,KAAK,EAAE,oBAAoB,GAC1B,MAAM,CAcR;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,oBAAoB,EAAE,GAChC,oBAAoB,EAAE,CAWxB;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAWxB;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,MAAM,CAAC,UAAU,EACzB,YAAY,EAAE,iCAAiC,GAC9C,OAAO,CAAC,OAAO,CAAC,CA0BlB;AAED,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,iCAAiC,EAC/C,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,cAAc,EACvB,YAAY,SAA0B,GACrC,OAAO,CAAC,IAAI,CAAC,CAqJf"}

package/dist/commands/project/archive/sync-runner.js

@@ -0,0 +1,232 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import { readFile, rm } from 'node:fs/promises';
+import { join, posix as path } from 'node:path';
+import { promisify } from 'node:util';
+import { buildCommandContext } from '../../../app/command-context.js';
+import { resolveProjectsRoot } from '../../shared/oat-paths.js';
+import { readOatConfig } from '../../../config/oat-config.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { ARCHIVE_SNAPSHOT_METADATA_FILENAME, S3_ARCHIVE_SYNC_EXCLUDES, buildAwsEnv, buildProjectArchiveS3Uri, buildRepoArchiveS3Uri, ensureS3ArchiveAccess, parseArchiveSnapshotName, resolveLocalArchiveProjectPath, resolvePrimaryRepoRoot, } from './archive-utils.js';
+const execFileAsync = promisify(execFileCallback);
+export function defaultProjectArchiveCommandDependencies() {
+    return {
+        buildCommandContext,
+        resolveProjectRoot,
+        readOatConfig,
+        resolveProjectsRoot,
+        ensureS3ArchiveAccess,
+        buildRepoArchiveS3Uri,
+        buildProjectArchiveS3Uri,
+        resolveLocalArchiveProjectPath,
+        resolvePrimaryRepoRoot,
+        execFile: execFileAsync,
+        removeDirectory: rm,
+        processEnv: process.env,
+    };
+}
+export function resolveLocalArchiveRoot(projectsRoot) {
+    return path.join(path.dirname(projectsRoot.replace(/\/+$/, '')), 'archived');
+}
+export function resolveSyncAwsEnv(processEnv, options, config) {
+    const flagProfile = typeof options.profile === 'string' && options.profile.trim().length > 0
+        ? options.profile.trim()
+        : undefined;
+    const flagRegion = typeof options.region === 'string' && options.region.trim().length > 0
+        ? options.region.trim()
+        : undefined;
+    const configProfile = config.archive?.awsProfile;
+    const configRegion = config.archive?.awsRegion;
+    const awsProfile = flagProfile ?? configProfile ?? undefined;
+    const awsRegion = flagRegion ?? configRegion ?? undefined;
+    const env = buildAwsEnv(processEnv, {
+        awsProfile,
+        awsRegion,
+    });
+    return { env, awsProfile, awsRegion };
+}
+export function buildArchiveSyncArgs(source, target, options) {
+    const args = ['s3', 'sync', source, target];
+    for (const pattern of S3_ARCHIVE_SYNC_EXCLUDES) {
+        args.push('--exclude', pattern);
+    }
+    if (options.dryRun) {
+        args.push('--dryrun');
+    }
+    return args;
+}
+export async function runArchiveSync(repoRoot, source, target, options, awsEnv, dependencies) {
+    await dependencies.execFile('aws', buildArchiveSyncArgs(source, target, options), {
+        cwd: repoRoot,
+        env: awsEnv,
+    });
+}
+export async function listArchiveSnapshots(repoRoot, projectsRoot, s3Uri, awsEnv, dependencies) {
+    const remoteRepoRoot = await dependencies.resolvePrimaryRepoRoot(repoRoot, {
+        gitExecFile: dependencies.execFile,
+        env: awsEnv,
+    });
+    const repoPrefix = `${dependencies.buildRepoArchiveS3Uri(s3Uri, remoteRepoRoot)}/`;
+    const { stdout } = await dependencies.execFile('aws', ['s3', 'ls', repoPrefix], {
+        cwd: repoRoot,
+        env: awsEnv,
+    });
+    return stdout
+        .split('\n')
+        .map((line) => line.match(/PRE\s+(.+?)\/?\s*$/)?.[1] ?? null)
+        .filter((snapshotName) => Boolean(snapshotName))
+        .map((snapshotName) => {
+        const parsed = parseArchiveSnapshotName(snapshotName);
+        return {
+            ...parsed,
+            source: dependencies.buildProjectArchiveS3Uri(s3Uri, remoteRepoRoot, snapshotName),
+            target: dependencies.resolveLocalArchiveProjectPath(projectsRoot, parsed.projectName),
+        };
+    });
+}
+export function compareSnapshotEntries(left, right) {
+    if (left.dateStamp && right.dateStamp && left.dateStamp !== right.dateStamp) {
+        return left.dateStamp.localeCompare(right.dateStamp);
+    }
+    if (left.dateStamp && !right.dateStamp) {
+        return 1;
+    }
+    if (!left.dateStamp && right.dateStamp) {
+        return -1;
+    }
+    return left.snapshotName.localeCompare(right.snapshotName);
+}
+export function selectLatestSnapshots(snapshots) {
+    const latestByProject = new Map();
+    for (const snapshot of snapshots) {
+        const current = latestByProject.get(snapshot.projectName);
+        if (!current || compareSnapshotEntries(snapshot, current) > 0) {
+            latestByProject.set(snapshot.projectName, snapshot);
+        }
+    }
+    return [...latestByProject.values()];
+}
+export async function readLocalSnapshotName(repoRoot, target) {
+    try {
+        const content = await readFile(join(repoRoot, target, ARCHIVE_SNAPSHOT_METADATA_FILENAME), 'utf8');
+        const parsed = JSON.parse(content);
+        return typeof parsed.snapshotName === 'string' ? parsed.snapshotName : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function syncArchiveSnapshot(repoRoot, snapshot, options, awsEnv, dependencies) {
+    const currentSnapshotName = await readLocalSnapshotName(repoRoot, snapshot.target);
+    if (!options.force && currentSnapshotName === snapshot.snapshotName) {
+        return false;
+    }
+    if (!options.dryRun) {
+        await dependencies.removeDirectory(join(repoRoot, snapshot.target), {
+            recursive: true,
+            force: true,
+        });
+    }
+    await runArchiveSync(repoRoot, snapshot.source, snapshot.target, options, awsEnv, dependencies);
+    return true;
+}
+export async function runArchiveSyncCommand(dependencies, projectName, options, context, commandLabel = 'oat repo archive sync') {
+    try {
+        if (options.force && !projectName) {
+            throw new CliError(`\`--force\` requires a project name for \`${commandLabel}\`.`);
+        }
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const config = await dependencies.readOatConfig(repoRoot);
+        const s3Uri = config.archive?.s3Uri;
+        if (!s3Uri) {
+            throw new CliError('Archive sync requires `archive.s3Uri` to be configured. Set it with `oat config set archive.s3Uri <s3://...>` and retry.');
+        }
+        const { env: awsEnv, awsProfile, awsRegion, } = resolveSyncAwsEnv(dependencies.processEnv, options, config);
+        await dependencies.ensureS3ArchiveAccess({
+            mode: 'sync',
+            s3Uri,
+            syncOnComplete: config.archive?.s3SyncOnComplete ?? false,
+            awsProfile,
+            awsRegion,
+        }, { env: awsEnv });
+        const projectsRoot = await dependencies.resolveProjectsRoot(repoRoot, dependencies.processEnv);
+        const snapshots = await listArchiveSnapshots(repoRoot, projectsRoot, s3Uri, awsEnv, dependencies);
+        const targets = projectName
+            ? snapshots.filter((snapshot) => snapshot.projectName === projectName ||
+                snapshot.snapshotName === projectName)
+            : selectLatestSnapshots(snapshots);
+        if (projectName && targets.length === 0) {
+            throw new CliError(`No archived snapshot found in S3 for project \`${projectName}\`.`);
+        }
+        const latestTarget = projectName
+            ? targets.reduce((latest, snapshot) => {
+                if (!latest) {
+                    return snapshot;
+                }
+                return compareSnapshotEntries(snapshot, latest) > 0
+                    ? snapshot
+                    : latest;
+            }, null)
+            : null;
+        const snapshotsToSync = projectName
+            ? latestTarget
+                ? [latestTarget]
+                : []
+            : targets;
+        const appliedTargets = [];
+        const appliedSources = [];
+        for (const snapshot of snapshotsToSync) {
+            if (!snapshot) {
+                continue;
+            }
+            const synced = await syncArchiveSnapshot(repoRoot, snapshot, options, awsEnv, dependencies);
+            if (synced) {
+                appliedTargets.push(snapshot.target);
+                appliedSources.push(snapshot.source);
+            }
+        }
+        const subject = projectName
+            ? `archived project \`${projectName}\``
+            : 'archived projects';
+        const targetSummary = appliedTargets.length > 0
+            ? appliedTargets.join(', ')
+            : resolveLocalArchiveRoot(projectsRoot);
+        const sourceSummary = appliedSources.length > 0
+            ? appliedSources.join(', ')
+            : dependencies.buildRepoArchiveS3Uri(s3Uri, await dependencies.resolvePrimaryRepoRoot(repoRoot, {
+                gitExecFile: dependencies.execFile,
+                env: awsEnv,
+            }));
+        if (context.json) {
+            context.logger.json({
+                status: 'ok',
+                mode: options.dryRun ? 'dry-run' : 'apply',
+                projectName: projectName ?? null,
+                sources: appliedSources,
+                targets: appliedTargets,
+                skipped: appliedTargets.length === 0,
+                force: options.force ?? false,
+            });
+        }
+        else if (options.dryRun) {
+            context.logger.info(`Dry-run: would sync ${subject} from ${sourceSummary} to ${targetSummary}.`);
+        }
+        else if (appliedTargets.length === 0) {
+            context.logger.info(`Skipped ${subject}; local archive is already using the latest remote snapshot.`);
+        }
+        else {
+            context.logger.info(`Synced ${subject} from ${sourceSummary} to ${targetSummary}.`);
+        }
+        process.exitCode = 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = error instanceof CliError ? error.exitCode : 1;
+    }
+}

package/dist/commands/repo/archive/index.d.ts

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

package/dist/commands/repo/archive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/repo/archive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,iCAAiC,EACvC,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,wBAAgB,wBAAwB,CACtC,SAAS,GAAE,OAAO,CAAC,iCAAiC,CAAM,GACzD,OAAO,CAyCT"}

package/dist/commands/repo/archive/index.js

@@ -0,0 +1,22 @@
+import { defaultProjectArchiveCommandDependencies, runArchiveSyncCommand, } from '../../project/archive/sync-runner.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { Command } from 'commander';
+export function createRepoArchiveCommand(overrides = {}) {
+    const dependencies = {
+        ...defaultProjectArchiveCommandDependencies(),
+        ...overrides,
+    };
+    return new Command('archive')
+        .description('Manage repository archive data')
+        .addCommand(new Command('sync')
+        .description('Sync archived project data from S3 into the local archive')
+        .argument('[project-name]', 'Archived project name to sync')
+        .option('--dry-run', 'Preview archive sync without downloading')
+        .option('--force', 'Replace the named local archive before syncing it from S3')
+        .option('--profile <profile>', 'AWS profile override for this sync')
+        .option('--region <region>', 'AWS region override for this sync')
+        .action(async (projectName, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runArchiveSyncCommand(dependencies, projectName, options, context, 'oat repo archive sync');
+    }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/repo/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,wBAAgB,iBAAiB,IAAI,OAAO,CAQ3C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/repo/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,iBAAiB,IAAI,OAAO,CAS3C"}

package/dist/commands/repo/index.js

@@ -1,7 +1,9 @@
 import { Command } from 'commander';
+import { createRepoArchiveCommand } from './archive/index.js';
 import { createPrCommentsCommand } from './pr-comments/index.js';
 export function createRepoCommand() {
     const cmd = new Command('repo').description('Repository-level analysis and insight tools');
+    cmd.addCommand(createRepoArchiveCommand());
     cmd.addCommand(createPrCommentsCommand());
     return cmd;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-agent-toolkit/cli",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "private": false,
   "description": "Open Agent Toolkit CLI",
   "homepage": "https://github.com/voxmedia/open-agent-toolkit/tree/main/packages/cli",
@@ -34,7 +34,7 @@
     "ora": "^9.0.0",
     "yaml": "2.8.2",
     "zod": "^3.25.76",
-    "@open-agent-toolkit/control-plane": "0.1.19"
+    "@open-agent-toolkit/control-plane": "0.1.20"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",