@open-agent-toolkit/cli 0.0.10

package/dist/commands/cleanup/project/project.js

@@ -0,0 +1,263 @@
+import { readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { generateStateDashboard } from '../../state/generate.js';
+import { clearActiveProject, readOatLocalConfig } from '../../../config/oat-config.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { ensureDir, fileExists } from '../../../fs/io.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+import { createCleanupPayload, toRepoRelativePath } from '../cleanup.utils.js';
+import { projectNeedsLifecycleComplete, projectNeedsStateFile, renderProjectStateTemplate, upsertLifecycleCompleteFrontmatter, } from './project.utils.js';
+function defaultRunDependencies() {
+    return {
+        refreshDashboard: async (repoRoot) => {
+            await generateStateDashboard({ repoRoot });
+        },
+    };
+}
+function defaultCommandDependencies() {
+    return {
+        buildCommandContext,
+        resolveProjectRoot,
+        runCleanupProject,
+    };
+}
+async function discoverProjectDirectories(repoRoot) {
+    const roots = ['.oat/projects/shared', '.oat/projects/local'].map((root) => join(repoRoot, root));
+    const directories = [];
+    for (const root of roots) {
+        let rootIsDirectory = false;
+        try {
+            rootIsDirectory = (await stat(root)).isDirectory();
+        }
+        catch {
+            rootIsDirectory = false;
+        }
+        if (!rootIsDirectory) {
+            continue;
+        }
+        const entries = await readdir(root, { withFileTypes: true });
+        const sortedDirectoryNames = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+        for (const directoryName of sortedDirectoryNames) {
+            directories.push(join(root, directoryName));
+        }
+    }
+    return directories.sort((left, right) => left.localeCompare(right));
+}
+async function planActiveProjectPointerCleanup(repoRoot) {
+    const localConfig = await readOatLocalConfig(repoRoot);
+    const activeProjectPath = localConfig.activeProject?.trim();
+    if (!activeProjectPath) {
+        return [];
+    }
+    const resolvedPointer = join(repoRoot, activeProjectPath);
+    let pointerExists = false;
+    try {
+        pointerExists = (await stat(resolvedPointer)).isDirectory();
+    }
+    catch {
+        pointerExists = false;
+    }
+    const pointerStateExists = await fileExists(join(resolvedPointer, 'state.md'));
+    if (pointerExists && pointerStateExists) {
+        return [];
+    }
+    return [
+        {
+            type: 'clear',
+            target: '.oat/config.local.json',
+            reason: 'invalid activeProject in .oat/config.local.json',
+            phase: 'project-scan',
+            result: 'planned',
+        },
+    ];
+}
+async function planProjectDirectoryCleanup(repoRoot, projectDirectory) {
+    const actions = [];
+    const entries = await readdir(projectDirectory, { withFileTypes: true });
+    const fileNames = entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name);
+    if (projectNeedsStateFile(fileNames)) {
+        actions.push({
+            type: 'create',
+            target: toRepoRelativePath(repoRoot, join(projectDirectory, 'state.md')),
+            reason: 'state.md missing while lifecycle artifacts exist',
+            phase: 'project-scan',
+            result: 'planned',
+        });
+        return actions;
+    }
+    if (!fileNames.includes('state.md') || !fileNames.includes('plan.md')) {
+        return actions;
+    }
+    const [planContent, stateContent] = await Promise.all([
+        readFile(join(projectDirectory, 'plan.md'), 'utf8'),
+        readFile(join(projectDirectory, 'state.md'), 'utf8'),
+    ]);
+    if (projectNeedsLifecycleComplete(planContent, stateContent)) {
+        actions.push({
+            type: 'update',
+            target: toRepoRelativePath(repoRoot, join(projectDirectory, 'state.md')),
+            reason: 'completed project missing oat_lifecycle: complete',
+            phase: 'project-scan',
+            result: 'planned',
+        });
+    }
+    return actions;
+}
+async function collectPlannedActions(repoRoot) {
+    const projectDirectories = await discoverProjectDirectories(repoRoot);
+    const pointerActions = await planActiveProjectPointerCleanup(repoRoot);
+    const nestedActions = await Promise.all(projectDirectories.map((projectDirectory) => planProjectDirectoryCleanup(repoRoot, projectDirectory)));
+    return {
+        scanned: projectDirectories.length,
+        actions: [...pointerActions, ...nestedActions.flat()],
+    };
+}
+function fallbackStateTemplate(projectName, today) {
+    return [
+        '---',
+        'oat_current_task: null',
+        'oat_last_commit: null',
+        'oat_blockers: []',
+        'oat_phase: discovery',
+        'oat_phase_status: in_progress',
+        'oat_workflow_mode: spec-driven',
+        'oat_workflow_origin: native',
+        'oat_generated: false',
+        '---',
+        '',
+        `# Project State: ${projectName}`,
+        '',
+        `**Started:** ${today}`,
+        `**Last Updated:** ${today}`,
+    ].join('\n');
+}
+async function loadStateTemplate(repoRoot, projectName, today) {
+    const templatePath = join(repoRoot, '.oat', 'templates', 'state.md');
+    if (!(await fileExists(templatePath))) {
+        return fallbackStateTemplate(projectName, today);
+    }
+    const templateContent = await readFile(templatePath, 'utf8');
+    return renderProjectStateTemplate(templateContent, projectName, today);
+}
+async function applyCleanupAction(repoRoot, action, today) {
+    const targetPath = join(repoRoot, action.target);
+    if (action.type === 'clear') {
+        if (action.target === '.oat/config.local.json') {
+            await clearActiveProject(repoRoot);
+            return { ...action, result: 'applied' };
+        }
+        await rm(targetPath, { force: true });
+        return { ...action, result: 'applied' };
+    }
+    if (action.type === 'create') {
+        const projectName = basename(dirname(targetPath));
+        const renderedState = await loadStateTemplate(repoRoot, projectName, today);
+        await ensureDir(dirname(targetPath));
+        await writeFile(targetPath, renderedState, 'utf8');
+        return { ...action, result: 'applied' };
+    }
+    if (action.type === 'update') {
+        const content = await readFile(targetPath, 'utf8');
+        const updatedContent = upsertLifecycleCompleteFrontmatter(content);
+        await writeFile(targetPath, updatedContent, 'utf8');
+        return { ...action, result: 'applied' };
+    }
+    return { ...action, result: 'applied' };
+}
+export async function runCleanupProject({ repoRoot, dryRun = false, today = new Date().toISOString().slice(0, 10), }, overrides = {}) {
+    const dependencies = {
+        ...defaultRunDependencies(),
+        ...overrides,
+    };
+    const { scanned, actions: plannedActions } = await collectPlannedActions(repoRoot);
+    if (dryRun) {
+        return createCleanupPayload({
+            status: plannedActions.length > 0 ? 'drift' : 'ok',
+            dryRun: true,
+            scanned,
+            issuesFound: plannedActions.length,
+            actions: plannedActions,
+        });
+    }
+    const appliedActions = [];
+    for (const action of plannedActions) {
+        appliedActions.push(await applyCleanupAction(repoRoot, action, today));
+    }
+    if (appliedActions.length > 0) {
+        await dependencies.refreshDashboard(repoRoot);
+        appliedActions.push({
+            type: 'regenerate',
+            target: '.oat/state.md',
+            reason: 'refresh dashboard after apply mutations',
+            phase: 'project-apply',
+            result: 'applied',
+        });
+    }
+    return createCleanupPayload({
+        status: 'ok',
+        dryRun: false,
+        scanned,
+        issuesFound: plannedActions.length,
+        actions: appliedActions,
+    });
+}
+function formatCleanupProjectPlan(payload) {
+    const lines = [
+        `cleanup project (${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 function createCleanupProjectCommand(overrides = {}) {
+    const dependencies = {
+        ...defaultCommandDependencies(),
+        ...overrides,
+    };
+    return new Command('project')
+        .description('Cleanup project pointers, state, and lifecycle drift')
+        .option('--dry-run', 'Preview cleanup without applying')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const payload = await dependencies.runCleanupProject({
+                repoRoot,
+                dryRun: options.dryRun ?? false,
+            });
+            if (context.json) {
+                context.logger.json(payload);
+            }
+            else {
+                context.logger.info(formatCleanupProjectPlan(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/project/project.utils.d.ts

@@ -0,0 +1,8 @@
+export declare function hasLifecycleArtifacts(fileNames: Iterable<string>): boolean;
+export declare function projectNeedsStateFile(fileNames: Iterable<string>): boolean;
+export declare function projectPlanMarksComplete(planContent: string): boolean;
+export declare function stateLifecycleIsComplete(stateContent: string): boolean;
+export declare function projectNeedsLifecycleComplete(planContent: string, stateContent: string): boolean;
+export declare function renderProjectStateTemplate(templateContent: string, projectName: string, today: string): string;
+export declare function upsertLifecycleCompleteFrontmatter(content: string): string;
+//# sourceMappingURL=project.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project.utils.d.ts","sourceRoot":"","sources":["../../../../src/commands/cleanup/project/project.utils.ts"],"names":[],"mappings":"AAQA,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAG1E;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAG1E;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAEtE;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB,OAAO,CAKT;AAED,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACZ,MAAM,CAMR;AAED,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkB1E"}

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

@@ -0,0 +1,48 @@
+const LIFECYCLE_ARTIFACTS = [
+    'discovery.md',
+    'spec.md',
+    'design.md',
+    'plan.md',
+    'implementation.md',
+];
+export function hasLifecycleArtifacts(fileNames) {
+    const files = new Set(fileNames);
+    return LIFECYCLE_ARTIFACTS.some((entry) => files.has(entry));
+}
+export function projectNeedsStateFile(fileNames) {
+    const files = new Set(fileNames);
+    return !files.has('state.md') && hasLifecycleArtifacts(files);
+}
+export function projectPlanMarksComplete(planContent) {
+    return /\|\s*final\s*\|\s*code\s*\|\s*passed\s*\|/i.test(planContent);
+}
+export function stateLifecycleIsComplete(stateContent) {
+    return /^oat_lifecycle:\s*complete$/m.test(stateContent);
+}
+export function projectNeedsLifecycleComplete(planContent, stateContent) {
+    return (projectPlanMarksComplete(planContent) &&
+        !stateLifecycleIsComplete(stateContent));
+}
+export function renderProjectStateTemplate(templateContent, projectName, today) {
+    return templateContent
+        .replaceAll('{Project Name}', projectName)
+        .replaceAll('YYYY-MM-DD', today)
+        .replaceAll(/\n?oat_template:\s*true\s*\n/gi, '\n')
+        .replaceAll(/\n?oat_template_name:\s*[^\n]*\n/gi, '\n');
+}
+export function upsertLifecycleCompleteFrontmatter(content) {
+    const hasFrontmatter = content.startsWith('---\n');
+    if (!hasFrontmatter) {
+        return ['---', 'oat_lifecycle: complete', '---', '', content].join('\n');
+    }
+    const blockEnd = content.indexOf('\n---', 4);
+    if (blockEnd === -1) {
+        return ['---', 'oat_lifecycle: complete', '---', '', content].join('\n');
+    }
+    const frontmatter = content.slice(4, blockEnd);
+    const rest = content.slice(blockEnd + 4);
+    const updatedFrontmatter = /^oat_lifecycle:\s*.+$/m.test(frontmatter)
+        ? frontmatter.replace(/^oat_lifecycle:\s*.+$/m, 'oat_lifecycle: complete')
+        : `${frontmatter}\noat_lifecycle: complete`;
+    return `---\n${updatedFrontmatter}\n---${rest}`;
+}

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

@@ -0,0 +1,16 @@
+import { buildCommandContext, type CommandContext } from '../../app/command-context.js';
+import { type OatConfig, type OatLocalConfig } from '../../config/oat-config.js';
+import { Command } from 'commander';
+interface ConfigCommandDependencies {
+    buildCommandContext: (options: Parameters<typeof buildCommandContext>[0]) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    readOatConfig: (repoRoot: string) => Promise<OatConfig>;
+    writeOatConfig: (repoRoot: string, config: OatConfig) => Promise<void>;
+    readOatLocalConfig: (repoRoot: string) => Promise<OatLocalConfig>;
+    writeOatLocalConfig: (repoRoot: string, config: OatLocalConfig) => Promise<void>;
+    resolveProjectsRoot: (repoRoot: string, env: NodeJS.ProcessEnv) => Promise<string>;
+    processEnv: NodeJS.ProcessEnv;
+}
+export declare function createConfigCommand(overrides?: Partial<ConfigCommandDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGhF,OAAO,EACL,KAAK,SAAS,EACd,KAAK,cAAc,EAKpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoCpC,UAAU,yBAAyB;IACjC,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,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAClE,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,cAAc,KACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B;AAkwBD,wBAAgB,mBAAmB,CACjC,SAAS,GAAE,OAAO,CAAC,yBAAyB,CAAM,GACjD,OAAO,CAiET"}