@open-agent-toolkit/cli 0.0.10

package/dist/commands/cleanup/artifacts/artifacts.js

@@ -0,0 +1,381 @@
+import { readdir, readFile, rename, rm, stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { confirmAction, selectManyOrEmpty, } from '../../shared/shared.prompts.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { readOatLocalConfig } from '../../../config/oat-config.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { ensureDir } from '../../../fs/io.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+import { createCleanupPayload, toRepoRelativePath } from '../cleanup.utils.js';
+import { buildArchiveTargetPath, filterArtifactCandidates, findDuplicateChains, findReferenceHits, selectLatestFromChain, } from './artifacts.utils.js';
+function defaultRunDependencies() {
+    return {
+        runInteractiveStaleTriage,
+    };
+}
+function defaultCommandDependencies() {
+    return {
+        buildCommandContext,
+        resolveProjectRoot,
+        runCleanupArtifacts,
+    };
+}
+async function pathIsDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function collectMarkdownFiles(root) {
+    if (!(await pathIsDirectory(root))) {
+        return [];
+    }
+    const files = [];
+    const queue = [root];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        const entries = await readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files;
+}
+export function planDuplicatePruneActions(candidates) {
+    const actions = [];
+    const chains = findDuplicateChains(candidates);
+    for (const chain of chains) {
+        const latest = selectLatestFromChain(chain);
+        for (const entry of chain.entries) {
+            if (entry.target === latest) {
+                continue;
+            }
+            actions.push({
+                type: 'delete',
+                target: entry.target,
+                reason: `duplicate chain prune (latest kept: ${latest})`,
+                phase: 'duplicate-prune',
+                result: 'planned',
+            });
+        }
+    }
+    return actions;
+}
+export async function discoverArtifactCandidates(repoRoot, excludedTargets = []) {
+    const roots = [
+        join(repoRoot, '.oat/repo/reviews'),
+        join(repoRoot, '.oat/repo/reference/external-plans'),
+    ];
+    const files = (await Promise.all(roots.map((root) => collectMarkdownFiles(root)))).flat();
+    const candidates = files
+        .map((filePath) => toRepoRelativePath(repoRoot, filePath))
+        .sort((left, right) => left.localeCompare(right));
+    return filterArtifactCandidates(candidates, new Set(excludedTargets));
+}
+async function collectReferenceContents(repoRoot) {
+    const contents = [];
+    const repoReferenceFiles = await collectMarkdownFiles(join(repoRoot, '.oat/repo/reference'));
+    let activeProjectFiles = [];
+    try {
+        const localConfig = await readOatLocalConfig(repoRoot);
+        const activeProjectPath = localConfig.activeProject?.trim();
+        if (activeProjectPath) {
+            const resolvedActiveProject = join(repoRoot, activeProjectPath);
+            activeProjectFiles = await collectMarkdownFiles(resolvedActiveProject);
+        }
+    }
+    catch {
+        activeProjectFiles = [];
+    }
+    for (const filePath of [...repoReferenceFiles, ...activeProjectFiles]) {
+        try {
+            contents.push(await readFile(filePath, 'utf8'));
+        }
+        catch {
+            // Ignore unreadable files and continue scanning.
+        }
+    }
+    return contents;
+}
+export async function findReferencedArtifactCandidates(repoRoot, candidates) {
+    const contents = await collectReferenceContents(repoRoot);
+    return findReferenceHits(candidates, contents);
+}
+export function planNonInteractiveArtifactActions(candidates, options) {
+    if (!options.allCandidates || !options.yes) {
+        return candidates.map((candidate) => ({
+            type: 'skip',
+            target: candidate.target,
+            reason: 'non-interactive stale deletion skipped; pass --all-candidates --yes to enable deletion',
+            phase: 'safety-gates',
+            result: 'skipped',
+        }));
+    }
+    return candidates.map((candidate) => {
+        if (candidate.referenced) {
+            return {
+                type: 'block',
+                target: candidate.target,
+                reason: 'candidate is referenced and blocked from non-interactive deletion',
+                phase: 'safety-gates',
+                result: 'blocked',
+            };
+        }
+        return {
+            type: 'delete',
+            target: candidate.target,
+            reason: 'non-interactive stale deletion approved (--all-candidates --yes)',
+            phase: 'safety-gates',
+            result: 'planned',
+        };
+    });
+}
+export function planArchiveActions(targets, existingTargets, timestamp) {
+    return targets.map((target) => {
+        const archiveTarget = buildArchiveTargetPath(target, existingTargets, timestamp);
+        existingTargets.add(archiveTarget);
+        return {
+            type: 'archive',
+            target: archiveTarget,
+            reason: `archive stale artifact from ${target}`,
+            phase: 'archive',
+            result: 'planned',
+        };
+    });
+}
+function defaultInteractiveDependencies() {
+    return {
+        selectManyOrEmpty,
+        confirmAction,
+    };
+}
+export async function runInteractiveStaleTriage(candidates, ctx, overrides = {}) {
+    const dependencies = {
+        ...defaultInteractiveDependencies(),
+        ...overrides,
+    };
+    const candidateMap = new Map(candidates.map((candidate) => [candidate.target, candidate]));
+    const baseChoices = candidates.map((candidate) => ({
+        label: candidate.target,
+        value: candidate.target,
+        description: candidate.referenced ? 'referenced' : 'unreferenced',
+    }));
+    const archive = await dependencies.selectManyOrEmpty('Select stale artifacts to archive', baseChoices, ctx);
+    const remaining = candidates.filter((candidate) => !archive.includes(candidate.target));
+    const deleteChoices = remaining.map((candidate) => ({
+        label: candidate.target,
+        value: candidate.target,
+        description: candidate.referenced ? 'referenced' : 'unreferenced',
+    }));
+    let toDelete = await dependencies.selectManyOrEmpty('Select stale artifacts to delete', deleteChoices, ctx);
+    const referencedSelectedForDelete = toDelete.filter((target) => candidateMap.get(target)?.referenced === true);
+    if (referencedSelectedForDelete.length > 0) {
+        const confirmed = await dependencies.confirmAction('Some selected delete targets are referenced. Delete anyway?', ctx);
+        if (!confirmed) {
+            toDelete = toDelete.filter((target) => !referencedSelectedForDelete.includes(target));
+        }
+    }
+    const keep = candidates
+        .map((candidate) => candidate.target)
+        .filter((target) => !archive.includes(target) && !toDelete.includes(target))
+        .sort((left, right) => left.localeCompare(right));
+    return {
+        keep,
+        archive: [...archive].sort((left, right) => left.localeCompare(right)),
+        delete: [...toDelete].sort((left, right) => left.localeCompare(right)),
+    };
+}
+async function collectArchiveTargets(repoRoot) {
+    const files = await collectMarkdownFiles(join(repoRoot, '.oat/repo/archive'));
+    return new Set(files.map((filePath) => toRepoRelativePath(repoRoot, filePath)));
+}
+function buildDryRunStaleActions(candidates) {
+    return candidates.map((candidate) => candidate.referenced
+        ? {
+            type: 'block',
+            target: candidate.target,
+            reason: 'candidate is referenced and requires explicit operator decision',
+            phase: 'stale-candidates',
+            result: 'blocked',
+        }
+        : {
+            type: 'delete',
+            target: candidate.target,
+            reason: 'stale candidate detected (dry-run)',
+            phase: 'stale-candidates',
+            result: 'planned',
+        });
+}
+function buildInteractiveDeleteActions(targets) {
+    return targets.map((target) => ({
+        type: 'delete',
+        target,
+        reason: 'interactive stale triage delete selection',
+        phase: 'interactive-triage',
+        result: 'planned',
+    }));
+}
+function buildInteractiveKeepActions(targets) {
+    return targets.map((target) => ({
+        type: 'skip',
+        target,
+        reason: 'interactive stale triage keep selection',
+        phase: 'interactive-triage',
+        result: 'skipped',
+    }));
+}
+function parseArchiveSourceTarget(action) {
+    const prefix = 'archive stale artifact from ';
+    if (!action.reason.startsWith(prefix)) {
+        throw new CliError(`Invalid archive action metadata for target ${action.target}`, 2);
+    }
+    return action.reason.slice(prefix.length);
+}
+async function applyArtifactAction(repoRoot, action) {
+    if (action.result !== 'planned') {
+        return action;
+    }
+    if (action.type === 'delete') {
+        await rm(join(repoRoot, action.target), { force: true });
+        return { ...action, result: 'applied' };
+    }
+    if (action.type === 'archive') {
+        const sourceTarget = parseArchiveSourceTarget(action);
+        const sourcePath = join(repoRoot, sourceTarget);
+        const archivePath = join(repoRoot, action.target);
+        await ensureDir(dirname(archivePath));
+        await rename(sourcePath, archivePath);
+        return { ...action, result: 'applied' };
+    }
+    return action;
+}
+function formatCleanupArtifactsPlan(payload) {
+    const lines = [
+        `cleanup artifacts (${payload.mode})`,
+        `status: ${payload.status}`,
+        `summary: scanned=${payload.summary.scanned}, issues=${payload.summary.issuesFound}, planned=${payload.summary.planned}, applied=${payload.summary.applied}, skipped=${payload.summary.skipped}, blocked=${payload.summary.blocked}`,
+    ];
+    if (payload.actions.length === 0) {
+        lines.push('actions: none');
+        return lines.join('\n');
+    }
+    lines.push('actions:');
+    for (const action of payload.actions) {
+        lines.push(`- ${action.type} ${action.target} (${action.reason})`);
+    }
+    return lines.join('\n');
+}
+export async function runCleanupArtifacts({ repoRoot, dryRun = false, allCandidates = false, yes = false, interactive = false, timestamp = new Date()
+    .toISOString()
+    .replace(/[-:T.Z]/g, '')
+    .slice(0, 14), }, overrides = {}) {
+    const dependencies = {
+        ...defaultRunDependencies(),
+        ...overrides,
+    };
+    const allCandidateTargets = await discoverArtifactCandidates(repoRoot);
+    const duplicatePruneActions = planDuplicatePruneActions(allCandidateTargets);
+    const staleTargets = await discoverArtifactCandidates(repoRoot, duplicatePruneActions.map((action) => action.target));
+    const referenceHits = await findReferencedArtifactCandidates(repoRoot, staleTargets);
+    const staleCandidates = staleTargets.map((target) => ({
+        target,
+        referenced: referenceHits.has(target),
+    }));
+    let staleActions = [];
+    if (dryRun) {
+        staleActions = buildDryRunStaleActions(staleCandidates);
+    }
+    else if (interactive && !allCandidates && !yes) {
+        const triage = await dependencies.runInteractiveStaleTriage(staleCandidates, { interactive });
+        const existingArchiveTargets = await collectArchiveTargets(repoRoot);
+        staleActions = [
+            ...planArchiveActions(triage.archive, existingArchiveTargets, timestamp),
+            ...buildInteractiveDeleteActions(triage.delete),
+            ...buildInteractiveKeepActions(triage.keep),
+        ];
+    }
+    else {
+        staleActions = planNonInteractiveArtifactActions(staleCandidates, {
+            allCandidates,
+            yes,
+        });
+    }
+    const plannedActions = [...duplicatePruneActions, ...staleActions];
+    const issuesFound = duplicatePruneActions.length + staleCandidates.length;
+    const scanned = allCandidateTargets.length;
+    if (dryRun) {
+        return createCleanupPayload({
+            status: issuesFound > 0 ? 'drift' : 'ok',
+            dryRun: true,
+            scanned,
+            issuesFound,
+            actions: plannedActions,
+        });
+    }
+    const appliedActions = [];
+    for (const action of plannedActions) {
+        appliedActions.push(await applyArtifactAction(repoRoot, action));
+    }
+    const unresolved = appliedActions.some((action) => action.result !== 'applied');
+    return createCleanupPayload({
+        status: unresolved ? 'drift' : 'ok',
+        dryRun: false,
+        scanned,
+        issuesFound,
+        actions: appliedActions,
+    });
+}
+export function createCleanupArtifactsCommand(overrides = {}) {
+    const dependencies = {
+        ...defaultCommandDependencies(),
+        ...overrides,
+    };
+    return new Command('artifacts')
+        .description('Cleanup stale review and external-plan artifacts')
+        .option('--dry-run', 'Preview cleanup without applying')
+        .option('--all-candidates', 'Allow non-interactive stale cleanup candidates')
+        .option('--yes', 'Confirm non-interactive stale cleanup mutations')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const payload = await dependencies.runCleanupArtifacts({
+                repoRoot,
+                dryRun: options.dryRun ?? false,
+                allCandidates: options.allCandidates ?? false,
+                yes: options.yes ?? false,
+                interactive: context.interactive,
+            });
+            if (context.json) {
+                context.logger.json(payload);
+            }
+            else {
+                context.logger.info(formatCleanupArtifactsPlan(payload));
+            }
+            process.exitCode = payload.status === 'ok' ? 0 : 1;
+        }
+        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 : 2;
+        }
+    });
+}

package/dist/commands/cleanup/artifacts/artifacts.types.d.ts

@@ -0,0 +1,13 @@
+export interface ArtifactCleanupCandidate {
+    target: string;
+    referenced: boolean;
+}
+export interface ArtifactDuplicateEntry {
+    target: string;
+    version: number;
+}
+export interface ArtifactDuplicateChain {
+    chainKey: string;
+    entries: ArtifactDuplicateEntry[];
+}
+//# sourceMappingURL=artifacts.types.d.ts.map

package/dist/commands/cleanup/artifacts/artifacts.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.types.d.ts","sourceRoot":"","sources":["../../../../src/commands/cleanup/artifacts/artifacts.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,sBAAsB,EAAE,CAAC;CACnC"}

package/dist/commands/cleanup/artifacts/artifacts.types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/cleanup/artifacts/artifacts.utils.d.ts

@@ -0,0 +1,14 @@
+import type { ArtifactDuplicateChain } from './artifacts.types.js';
+interface ParsedArtifactVersion {
+    chainKey: string;
+    version: number;
+}
+export declare function parseArtifactVersion(target: string): ParsedArtifactVersion;
+export declare function findDuplicateChains(targets: string[]): ArtifactDuplicateChain[];
+export declare function selectLatestFromChain(chain: ArtifactDuplicateChain): string;
+export declare function filterArtifactCandidates(candidates: string[], excludedTargets: Set<string>): string[];
+export declare function findReferenceHits(candidates: string[], referenceContents: string[]): Set<string>;
+export declare function resolveArchiveBasePath(sourcePath: string): string;
+export declare function buildArchiveTargetPath(sourcePath: string, existingTargets: Set<string>, timestamp: string): string;
+export {};
+//# sourceMappingURL=artifacts.utils.d.ts.map

package/dist/commands/cleanup/artifacts/artifacts.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.utils.d.ts","sourceRoot":"","sources":["../../../../src/commands/cleanup/artifacts/artifacts.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EAEvB,MAAM,mBAAmB,CAAC;AAE3B,UAAU,qBAAqB;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAID,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,CAgB1E;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EAAE,GAChB,sBAAsB,EAAE,CAqB1B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAE3E;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAAE,EACpB,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAC3B,MAAM,EAAE,CAEV;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAAE,EACpB,iBAAiB,EAAE,MAAM,EAAE,GAC1B,GAAG,CAAC,MAAM,CAAC,CAab;AAED,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAgBjE;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,EAC5B,SAAS,EAAE,MAAM,GAChB,MAAM,CAcR"}

package/dist/commands/cleanup/artifacts/artifacts.utils.js

@@ -0,0 +1,74 @@
+const VERSIONED_ARTIFACT_PATTERN = /^(.*)-v([0-9]+)(\.[^./]+)$/;
+export function parseArtifactVersion(target) {
+    const pathParts = target.split('/');
+    const fileName = pathParts[pathParts.length - 1] ?? target;
+    const match = fileName.match(VERSIONED_ARTIFACT_PATTERN);
+    if (!match) {
+        return { chainKey: target, version: 1 };
+    }
+    const stem = match[1] ?? '';
+    const extension = match[3] ?? '';
+    const chainFileName = `${stem}${extension}`;
+    const chainPath = [...pathParts.slice(0, -1), chainFileName].join('/');
+    return {
+        chainKey: chainPath,
+        version: Number.parseInt(match[2] ?? '1', 10),
+    };
+}
+export function findDuplicateChains(targets) {
+    const buckets = new Map();
+    for (const target of targets) {
+        const parsed = parseArtifactVersion(target);
+        const bucket = buckets.get(parsed.chainKey) ?? [];
+        bucket.push({ target, version: parsed.version });
+        buckets.set(parsed.chainKey, bucket);
+    }
+    return [...buckets.entries()]
+        .map(([chainKey, entries]) => ({
+        chainKey,
+        entries: [...entries].sort((left, right) => right.version - left.version ||
+            right.target.localeCompare(left.target)),
+    }))
+        .filter((chain) => chain.entries.length > 1)
+        .sort((left, right) => left.chainKey.localeCompare(right.chainKey));
+}
+export function selectLatestFromChain(chain) {
+    return chain.entries[0]?.target ?? '';
+}
+export function filterArtifactCandidates(candidates, excludedTargets) {
+    return candidates.filter((candidate) => !excludedTargets.has(candidate));
+}
+export function findReferenceHits(candidates, referenceContents) {
+    const hits = new Set();
+    for (const candidate of candidates) {
+        for (const content of referenceContents) {
+            if (content.includes(candidate)) {
+                hits.add(candidate);
+                break;
+            }
+        }
+    }
+    return hits;
+}
+export function resolveArchiveBasePath(sourcePath) {
+    if (sourcePath.startsWith('.oat/repo/reference/external-plans/')) {
+        return sourcePath.replace('.oat/repo/reference/external-plans/', '.oat/repo/archive/reference/external-plans/');
+    }
+    if (sourcePath.startsWith('.oat/repo/reviews/')) {
+        return sourcePath.replace('.oat/repo/reviews/', '.oat/repo/archive/reviews/');
+    }
+    return sourcePath;
+}
+export function buildArchiveTargetPath(sourcePath, existingTargets, timestamp) {
+    const basePath = resolveArchiveBasePath(sourcePath);
+    if (!existingTargets.has(basePath)) {
+        return basePath;
+    }
+    const dotIndex = basePath.lastIndexOf('.');
+    if (dotIndex <= basePath.lastIndexOf('/')) {
+        return `${basePath}-${timestamp}`;
+    }
+    const stem = basePath.slice(0, dotIndex);
+    const extension = basePath.slice(dotIndex);
+    return `${stem}-${timestamp}${extension}`;
+}

package/dist/commands/cleanup/cleanup.types.d.ts

@@ -0,0 +1,26 @@
+export type CleanupStatus = 'ok' | 'drift' | 'error';
+export type CleanupMode = 'dry-run' | 'apply';
+export type CleanupActionType = 'delete' | 'archive' | 'create' | 'update' | 'clear' | 'regenerate' | 'skip' | 'block';
+export type CleanupActionResult = 'planned' | 'applied' | 'skipped' | 'blocked';
+export interface CleanupSummary {
+    scanned: number;
+    issuesFound: number;
+    planned: number;
+    applied: number;
+    skipped: number;
+    blocked: number;
+}
+export interface CleanupActionRecord {
+    type: CleanupActionType;
+    target: string;
+    reason: string;
+    phase: string;
+    result: CleanupActionResult;
+}
+export interface CleanupJsonPayload {
+    status: CleanupStatus;
+    mode: CleanupMode;
+    summary: CleanupSummary;
+    actions: CleanupActionRecord[];
+}
+//# sourceMappingURL=cleanup.types.d.ts.map

package/dist/commands/cleanup/cleanup.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.types.d.ts","sourceRoot":"","sources":["../../../src/commands/cleanup/cleanup.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC;AAErD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAE9C,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,YAAY,GACZ,MAAM,GACN,OAAO,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEhF,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,iBAAiB,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,mBAAmB,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAkB;IAEjC,MAAM,EAAE,aAAa,CAAC;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,mBAAmB,EAAE,CAAC;CAChC"}

package/dist/commands/cleanup/cleanup.types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/cleanup/cleanup.utils.d.ts

@@ -0,0 +1,17 @@
+import type { CleanupActionRecord, CleanupJsonPayload, CleanupMode, CleanupStatus, CleanupSummary } from './cleanup.types.js';
+export declare function toRepoRelativePath(repoRoot: string, targetPath: string): string;
+interface BuildCleanupSummaryArgs {
+    scanned: number;
+    issuesFound: number;
+    actions: CleanupActionRecord[];
+}
+interface CreateCleanupPayloadArgs extends BuildCleanupSummaryArgs {
+    status: CleanupStatus;
+    dryRun: boolean;
+}
+export declare function toCleanupMode(dryRun: boolean): CleanupMode;
+export declare function normalizeCleanupActions(actions: CleanupActionRecord[]): CleanupActionRecord[];
+export declare function buildCleanupSummary({ scanned, issuesFound, actions, }: BuildCleanupSummaryArgs): CleanupSummary;
+export declare function createCleanupPayload({ status, dryRun, scanned, issuesFound, actions, }: CreateCleanupPayloadArgs): CleanupJsonPayload;
+export {};
+//# sourceMappingURL=cleanup.utils.d.ts.map

package/dist/commands/cleanup/cleanup.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.utils.d.ts","sourceRoot":"","sources":["../../../src/commands/cleanup/cleanup.utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,aAAa,EACb,cAAc,EACf,MAAM,iBAAiB,CAAC;AAEzB,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,MAAM,CAER;AAED,UAAU,uBAAuB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,mBAAmB,EAAE,CAAC;CAChC;AAED,UAAU,wBAAyB,SAAQ,uBAAuB;IAChE,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,GAAG,WAAW,CAE1D;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,mBAAmB,EAAE,GAC7B,mBAAmB,EAAE,CAUvB;AAED,wBAAgB,mBAAmB,CAAC,EAClC,OAAO,EACP,WAAW,EACX,OAAO,GACR,EAAE,uBAAuB,GAAG,cAAc,CAe1C;AAED,wBAAgB,oBAAoB,CAAC,EACnC,MAAM,EACN,MAAM,EACN,OAAO,EACP,WAAW,EACX,OAAO,GACR,EAAE,wBAAwB,GAAG,kBAAkB,CAY/C"}

package/dist/commands/cleanup/cleanup.utils.js

@@ -0,0 +1,44 @@
+import { relative } from 'node:path';
+export function toRepoRelativePath(repoRoot, targetPath) {
+    return relative(repoRoot, targetPath).replaceAll('\\', '/');
+}
+export function toCleanupMode(dryRun) {
+    return dryRun ? 'dry-run' : 'apply';
+}
+export function normalizeCleanupActions(actions) {
+    return [...actions].sort((left, right) => {
+        return (left.target.localeCompare(right.target) ||
+            left.phase.localeCompare(right.phase) ||
+            left.type.localeCompare(right.type) ||
+            left.result.localeCompare(right.result) ||
+            left.reason.localeCompare(right.reason));
+    });
+}
+export function buildCleanupSummary({ scanned, issuesFound, actions, }) {
+    const normalizedActions = normalizeCleanupActions(actions);
+    return {
+        scanned,
+        issuesFound,
+        planned: normalizedActions.filter((action) => action.result === 'planned')
+            .length,
+        applied: normalizedActions.filter((action) => action.result === 'applied')
+            .length,
+        skipped: normalizedActions.filter((action) => action.result === 'skipped')
+            .length,
+        blocked: normalizedActions.filter((action) => action.result === 'blocked')
+            .length,
+    };
+}
+export function createCleanupPayload({ status, dryRun, scanned, issuesFound, actions, }) {
+    const normalizedActions = normalizeCleanupActions(actions);
+    return {
+        status,
+        mode: toCleanupMode(dryRun),
+        summary: buildCleanupSummary({
+            scanned,
+            issuesFound,
+            actions: normalizedActions,
+        }),
+        actions: normalizedActions,
+    };
+}

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createCleanupCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/cleanup/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,oBAAoB,IAAI,OAAO,CAK9C"}

package/dist/commands/cleanup/index.js

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import { createCleanupArtifactsCommand } from './artifacts/artifacts.js';
+import { createCleanupProjectCommand } from './project/project.js';
+export function createCleanupCommand() {
+    return new Command('cleanup')
+        .description('Cleanup OAT project and artifact hygiene issues')
+        .addCommand(createCleanupProjectCommand())
+        .addCommand(createCleanupArtifactsCommand());
+}

package/dist/commands/cleanup/project/project.d.ts

@@ -0,0 +1,20 @@
+import { type CommandContext, type GlobalOptions } from '../../../app/command-context.js';
+import { Command } from 'commander';
+import type { CleanupJsonPayload } from '../cleanup.types.js';
+export interface CleanupProjectRunOptions {
+    repoRoot: string;
+    dryRun?: boolean;
+    today?: string;
+}
+interface CleanupProjectCommandDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    runCleanupProject: (options: CleanupProjectRunOptions) => Promise<CleanupJsonPayload>;
+}
+interface CleanupProjectRunDependencies {
+    refreshDashboard: (repoRoot: string) => Promise<void>;
+}
+export declare function runCleanupProject({ repoRoot, dryRun, today, }: CleanupProjectRunOptions, overrides?: Partial<CleanupProjectRunDependencies>): Promise<CleanupJsonPayload>;
+export declare function createCleanupProjectCommand(overrides?: Partial<CleanupProjectCommandDependencies>): Command;
+export {};
+//# sourceMappingURL=project.d.ts.map

package/dist/commands/cleanup/project/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../src/commands/cleanup/project/project.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EAAuB,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAShF,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,iCAAiC;IACzC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,iBAAiB,EAAE,CACjB,OAAO,EAAE,wBAAwB,KAC9B,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAClC;AAED,UAAU,6BAA6B;IACrC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD;AAwND,wBAAsB,iBAAiB,CACrC,EACE,QAAQ,EACR,MAAc,EACd,KAA6C,GAC9C,EAAE,wBAAwB,EAC3B,SAAS,GAAE,OAAO,CAAC,6BAA6B,CAAM,GACrD,OAAO,CAAC,kBAAkB,CAAC,CA0C7B;AAsBD,wBAAgB,2BAA2B,CACzC,SAAS,GAAE,OAAO,CAAC,iCAAiC,CAAM,GACzD,OAAO,CAqCT"}