@open-agent-toolkit/cli 0.0.10

package/dist/commands/local/index.js

@@ -0,0 +1,248 @@
+import { buildCommandContext } from '../../app/command-context.js';
+import { readGlobalOptions } from '../shared/shared.utils.js';
+import { readOatConfig, resolveLocalPaths } from '../../config/oat-config.js';
+import { resolveProjectRoot } from '../../fs/paths.js';
+import { Command } from 'commander';
+import { applyGitignore } from './apply.js';
+import { addLocalPaths, removeLocalPaths } from './manage.js';
+import { checkLocalPathsStatus } from './status.js';
+import { syncLocalPaths } from './sync.js';
+export function createLocalCommand() {
+    return new Command('local')
+        .description('Manage local-only paths (gitignored, worktree-synced)')
+        .addCommand(new Command('status')
+        .description('List localPaths with existence and gitignore membership status')
+        .action(async (_options, command) => {
+        const context = buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await resolveProjectRoot(context.cwd);
+            const config = await readOatConfig(repoRoot);
+            const localPaths = resolveLocalPaths(config);
+            if (localPaths.length === 0) {
+                if (context.json) {
+                    context.logger.json({ status: 'ok', paths: [] });
+                }
+                else {
+                    context.logger.info('No localPaths configured. Use `oat local add` to add paths.');
+                }
+                process.exitCode = 0;
+                return;
+            }
+            const results = await checkLocalPathsStatus(repoRoot, localPaths);
+            const hasDrift = results.some((r) => r.exists && !r.gitignored);
+            if (context.json) {
+                context.logger.json({ status: 'ok', paths: results, hasDrift });
+            }
+            else {
+                const lines = ['Path                        Exists  Gitignored'];
+                lines.push('---                         ------  ----------');
+                for (const r of results) {
+                    const existsStr = r.exists ? 'yes' : 'no';
+                    const gitStr = r.gitignored ? 'yes' : 'no';
+                    const warn = r.exists && !r.gitignored ? ' ⚠ not gitignored' : '';
+                    lines.push(`${r.path.padEnd(28)} ${existsStr.padEnd(8)} ${gitStr}${warn}`);
+                }
+                context.logger.info(lines.join('\n'));
+                if (hasDrift) {
+                    context.logger.warn('\nDrift detected: some localPaths exist but are not gitignored.');
+                    context.logger.warn('Run `oat local apply` to fix.');
+                }
+            }
+            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 = 1;
+        }
+    }))
+        .addCommand(new Command('apply')
+        .description('Sync .gitignore with configured localPaths')
+        .option('--dry-run', 'Show what would change without writing')
+        .action(async (options, command) => {
+        const context = buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await resolveProjectRoot(context.cwd);
+            const config = await readOatConfig(repoRoot);
+            const localPaths = resolveLocalPaths(config);
+            if (options.dryRun) {
+                if (localPaths.length === 0) {
+                    context.logger.info('No localPaths configured. Managed section would be removed (if present).');
+                }
+                else {
+                    context.logger.info(`Would write ${localPaths.length} path(s) to .gitignore managed section:`);
+                    for (const p of localPaths) {
+                        context.logger.info(`  ${p.endsWith('/') ? p : `${p}/`}`);
+                    }
+                }
+                process.exitCode = 0;
+                return;
+            }
+            const result = await applyGitignore(repoRoot, localPaths);
+            if (context.json) {
+                context.logger.json({
+                    status: 'ok',
+                    action: result.action,
+                    paths: result.paths,
+                });
+            }
+            else {
+                switch (result.action) {
+                    case 'created':
+                        context.logger.info(`Created .gitignore with ${result.paths.length} managed path(s).`);
+                        break;
+                    case 'updated':
+                        context.logger.info(`Updated .gitignore managed section (${result.paths.length} path(s)).`);
+                        break;
+                    case 'no-change':
+                        context.logger.info('.gitignore managed section is already up to date.');
+                        break;
+                }
+            }
+            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 = 1;
+        }
+    }))
+        .addCommand(new Command('sync')
+        .description('Copy localPaths between main repo and a worktree')
+        .argument('<worktree-path>', 'Path to the worktree directory')
+        .option('--from', 'Copy from worktree back to main repo')
+        .option('--force', 'Overwrite existing paths')
+        .action(async (worktreePath, options, command) => {
+        const context = buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await resolveProjectRoot(context.cwd);
+            const config = await readOatConfig(repoRoot);
+            const localPaths = resolveLocalPaths(config);
+            if (localPaths.length === 0) {
+                if (context.json) {
+                    context.logger.json({
+                        status: 'ok',
+                        message: 'No localPaths configured.',
+                        entries: [],
+                    });
+                }
+                else {
+                    context.logger.info('No localPaths configured. Nothing to sync.');
+                }
+                process.exitCode = 0;
+                return;
+            }
+            const direction = options.from ? 'from' : 'to';
+            const result = await syncLocalPaths({
+                sourceRoot: repoRoot,
+                targetRoot: worktreePath,
+                localPaths,
+                direction,
+                force: options.force ?? false,
+            });
+            if (context.json) {
+                context.logger.json({ status: 'ok', ...result });
+            }
+            else {
+                for (const entry of result.entries) {
+                    context.logger.info(`  ${entry.status.padEnd(8)} ${entry.path}`);
+                }
+                context.logger.info(`\nSync complete: ${result.copied} copied, ${result.skipped} skipped, ${result.missing} missing`);
+            }
+            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 = 1;
+        }
+    }))
+        .addCommand(new Command('add')
+        .description('Add paths to localPaths config')
+        .argument('<paths...>', 'Paths to add (e.g. .oat/ideas)')
+        .action(async (paths, _options, command) => {
+        const context = buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await resolveProjectRoot(context.cwd);
+            const result = await addLocalPaths(repoRoot, paths);
+            if (context.json) {
+                context.logger.json({ status: 'ok', ...result });
+            }
+            else {
+                if (result.rejected.length > 0) {
+                    for (const r of result.rejected) {
+                        context.logger.warn(`Rejected: ${r.path} (${r.reason})`);
+                    }
+                }
+                if (result.added.length > 0) {
+                    context.logger.info(`Added: ${result.added.join(', ')}`);
+                }
+                if (result.alreadyPresent.length > 0) {
+                    context.logger.info(`Already present: ${result.alreadyPresent.join(', ')}`);
+                }
+                if (result.added.length > 0) {
+                    context.logger.info('\nRun `oat local apply` to update .gitignore.');
+                }
+            }
+            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 = 1;
+        }
+    }))
+        .addCommand(new Command('remove')
+        .description('Remove paths from localPaths config')
+        .argument('<paths...>', 'Paths to remove')
+        .action(async (paths, _options, command) => {
+        const context = buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await resolveProjectRoot(context.cwd);
+            const result = await removeLocalPaths(repoRoot, paths);
+            if (context.json) {
+                context.logger.json({ status: 'ok', ...result });
+            }
+            else {
+                if (result.removed.length > 0) {
+                    context.logger.info(`Removed: ${result.removed.join(', ')}`);
+                }
+                if (result.notFound.length > 0) {
+                    context.logger.info(`Not found: ${result.notFound.join(', ')}`);
+                }
+                context.logger.info('\nRun `oat local apply` to update .gitignore.');
+            }
+            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 = 1;
+        }
+    }));
+}

package/dist/commands/local/manage.d.ts

@@ -0,0 +1,18 @@
+export interface RejectedPath {
+    path: string;
+    reason: string;
+}
+export interface AddResult {
+    added: string[];
+    alreadyPresent: string[];
+    rejected: RejectedPath[];
+    all: string[];
+}
+export interface RemoveResult {
+    removed: string[];
+    notFound: string[];
+    all: string[];
+}
+export declare function addLocalPaths(repoRoot: string, paths: string[]): Promise<AddResult>;
+export declare function removeLocalPaths(repoRoot: string, paths: string[]): Promise<RemoveResult>;
+//# sourceMappingURL=manage.d.ts.map

package/dist/commands/local/manage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manage.d.ts","sourceRoot":"","sources":["../../../src/commands/local/manage.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,GAAG,EAAE,MAAM,EAAE,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,EAAE,MAAM,EAAE,CAAC;CACf;AAkBD,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,SAAS,CAAC,CA4BpB;AAED,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,YAAY,CAAC,CA4BvB"}

package/dist/commands/local/manage.js

@@ -0,0 +1,66 @@
+import { readOatConfig, resolveLocalPaths, writeOatConfig, } from '../../config/oat-config.js';
+function validatePath(p) {
+    const trimmed = p.trim();
+    if (trimmed === '') {
+        return { path: p, reason: 'empty path' };
+    }
+    if (trimmed.startsWith('/')) {
+        return { path: p, reason: 'absolute path' };
+    }
+    // Check for parent-relative segments (../ at start, /../ in middle, /.. at end)
+    const segments = trimmed.split('/');
+    if (segments.some((s) => s === '..')) {
+        return { path: p, reason: 'parent-relative path' };
+    }
+    return null;
+}
+export async function addLocalPaths(repoRoot, paths) {
+    const config = await readOatConfig(repoRoot);
+    const existing = new Set(resolveLocalPaths(config));
+    const added = [];
+    const alreadyPresent = [];
+    const rejected = [];
+    for (const p of paths) {
+        const rejection = validatePath(p);
+        if (rejection) {
+            rejected.push(rejection);
+            continue;
+        }
+        const normalized = p.trim().replace(/\/+$/, '');
+        if (existing.has(normalized)) {
+            alreadyPresent.push(normalized);
+        }
+        else {
+            existing.add(normalized);
+            added.push(normalized);
+        }
+    }
+    const sorted = [...existing].sort();
+    await writeOatConfig(repoRoot, { ...config, localPaths: sorted });
+    return { added, alreadyPresent, rejected, all: sorted };
+}
+export async function removeLocalPaths(repoRoot, paths) {
+    const config = await readOatConfig(repoRoot);
+    const existing = resolveLocalPaths(config);
+    const toRemove = new Set(paths.map((p) => p.replace(/\/+$/, '')));
+    const removed = [];
+    const notFound = [];
+    for (const p of toRemove) {
+        if (existing.includes(p)) {
+            removed.push(p);
+        }
+        else {
+            notFound.push(p);
+        }
+    }
+    const remaining = existing.filter((p) => !toRemove.has(p));
+    const updated = { ...config };
+    if (remaining.length > 0) {
+        updated.localPaths = remaining;
+    }
+    else {
+        delete updated.localPaths;
+    }
+    await writeOatConfig(repoRoot, updated);
+    return { removed, notFound, all: remaining };
+}

package/dist/commands/local/status.d.ts

@@ -0,0 +1,7 @@
+export interface LocalPathStatus {
+    path: string;
+    exists: boolean;
+    gitignored: boolean;
+}
+export declare function checkLocalPathsStatus(repoRoot: string, localPaths: string[]): Promise<LocalPathStatus[]>;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/local/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/commands/local/status.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACrB;AAqCD,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,eAAe,EAAE,CAAC,CAuB5B"}

package/dist/commands/local/status.js

@@ -0,0 +1,46 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { dirExists, fileExists } from '../../fs/io.js';
+import { expandLocalPaths, matchesPathPattern } from './expand.js';
+function matchesGitignoreLine(localPath, line) {
+    // Normalize: strip leading `/` (root-relative marker) and trailing `/` (dir marker)
+    const normalizedLine = line.replace(/^\//, '').replace(/\/+$/, '');
+    const normalizedPath = localPath.replace(/\/+$/, '');
+    // Exact match
+    if (normalizedPath === normalizedLine)
+        return true;
+    // Glob match (for patterns containing *, ?, or [)
+    if (/[*?[]/.test(normalizedLine)) {
+        return matchesPathPattern(normalizedPath, normalizedLine);
+    }
+    return false;
+}
+async function isPathGitignored(repoRoot, localPath) {
+    const gitignorePath = join(repoRoot, '.gitignore');
+    try {
+        const content = await readFile(gitignorePath, 'utf8');
+        const lines = content
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l !== '' && !l.startsWith('#'));
+        return lines.some((line) => matchesGitignoreLine(localPath, line));
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkLocalPathsStatus(repoRoot, localPaths) {
+    const results = [];
+    const { resolved, missingGlobs } = await expandLocalPaths(repoRoot, localPaths);
+    for (const pattern of missingGlobs) {
+        const gitignored = await isPathGitignored(repoRoot, pattern);
+        results.push({ path: pattern, exists: false, gitignored });
+    }
+    for (const localPath of resolved) {
+        const absolutePath = join(repoRoot, localPath);
+        const exists = (await dirExists(absolutePath)) || (await fileExists(absolutePath));
+        const gitignored = await isPathGitignored(repoRoot, localPath);
+        results.push({ path: localPath, exists, gitignored });
+    }
+    return results;
+}

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

@@ -0,0 +1,20 @@
+export type SyncStatus = 'copied' | 'skipped' | 'missing';
+export interface SyncEntry {
+    path: string;
+    status: SyncStatus;
+}
+export interface SyncResult {
+    entries: SyncEntry[];
+    copied: number;
+    skipped: number;
+    missing: number;
+}
+export interface SyncOptions {
+    sourceRoot: string;
+    targetRoot: string;
+    localPaths: string[];
+    direction: 'to' | 'from';
+    force: boolean;
+}
+export declare function syncLocalPaths(options: SyncOptions): Promise<SyncResult>;
+//# sourceMappingURL=sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/commands/local/sync.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;AAE1D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC,CAoDrB"}

package/dist/commands/local/sync.js

@@ -0,0 +1,40 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { copyDirectory, dirExists, fileExists } from '../../fs/io.js';
+import { expandLocalPaths } from './expand.js';
+export async function syncLocalPaths(options) {
+    const { sourceRoot, targetRoot, localPaths, direction, force } = options;
+    // Determine actual from/to based on direction
+    const fromRoot = direction === 'to' ? sourceRoot : targetRoot;
+    const toRoot = direction === 'to' ? targetRoot : sourceRoot;
+    const entries = [];
+    const { resolved, missingGlobs } = await expandLocalPaths(fromRoot, localPaths);
+    for (const pattern of missingGlobs) {
+        entries.push({ path: pattern, status: 'missing' });
+    }
+    for (const localPath of resolved) {
+        const sourcePath = join(fromRoot, localPath);
+        const destPath = join(toRoot, localPath);
+        const sourceExists = (await dirExists(sourcePath)) || (await fileExists(sourcePath));
+        if (!sourceExists) {
+            entries.push({ path: localPath, status: 'missing' });
+            continue;
+        }
+        const destExists = (await dirExists(destPath)) || (await fileExists(destPath));
+        if (destExists && !force) {
+            entries.push({ path: localPath, status: 'skipped' });
+            continue;
+        }
+        if (destExists && force) {
+            await rm(destPath, { recursive: true, force: true });
+        }
+        await copyDirectory(sourcePath, destPath);
+        entries.push({ path: localPath, status: 'copied' });
+    }
+    return {
+        entries,
+        copied: entries.filter((e) => e.status === 'copied').length,
+        skipped: entries.filter((e) => e.status === 'skipped').length,
+        missing: entries.filter((e) => e.status === 'missing').length,
+    };
+}

package/dist/commands/project/archive/archive-utils.d.ts

@@ -0,0 +1,70 @@
+import { copyDirectory, copySingleFile, dirExists, ensureDir, fileExists } from '../../../fs/io.js';
+export type ExecFileResult = {
+    stdout: string;
+    stderr: string;
+};
+export type ExecFileLike = (file: string, args: string[], options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}) => Promise<ExecFileResult>;
+export interface EnsureS3ArchiveAccessOptions {
+    mode: 'completion' | 'sync';
+    s3Uri?: string | null;
+    syncOnComplete: boolean;
+}
+interface EnsureS3ArchiveAccessDependencies {
+    execFile?: ExecFileLike;
+    env?: NodeJS.ProcessEnv;
+}
+export interface EnsureS3ArchiveAccessResult {
+    ok: boolean;
+    warnings: string[];
+}
+export interface ArchiveProjectOnCompletionOptions {
+    repoRoot: string;
+    projectPath: string;
+    projectName: string;
+    projectsRoot: string;
+    s3Uri?: string | null;
+    s3SyncOnComplete: boolean;
+    summaryExportPath?: string | null;
+}
+interface ArchiveProjectOnCompletionDependencies extends EnsureS3ArchiveAccessDependencies {
+    ensureS3ArchiveAccess?: typeof ensureS3ArchiveAccess;
+    execFile?: ExecFileLike;
+    gitExecFile?: ExecFileLike;
+    ensureDir?: typeof ensureDir;
+    copyDirectory?: typeof copyDirectory;
+    removePath?: (target: string, options: {
+        recursive: true;
+        force: true;
+    }) => Promise<void>;
+    copySingleFile?: typeof copySingleFile;
+    dirExists?: typeof dirExists;
+    fileExists?: typeof fileExists;
+    timestamp?: () => string;
+}
+export interface ArchiveProjectOnCompletionResult {
+    archivePath: string;
+    s3Path: string | null;
+    summaryExportFile: string | null;
+    warnings: string[];
+}
+export declare const ARCHIVE_SNAPSHOT_METADATA_FILENAME = ".oat-archive-source.json";
+export interface ArchiveSnapshotMetadata {
+    projectName: string;
+    snapshotName: string;
+}
+export declare function buildRepoArchiveS3Uri(s3Uri: string, repoRoot: string): string;
+export declare function buildProjectArchiveS3Uri(s3Uri: string, repoRoot: string, projectKey: string): string;
+export declare function buildArchiveSnapshotName(projectName: string, timestamp: string): string;
+export declare function parseArchiveSnapshotName(snapshotName: string): {
+    projectName: string;
+    snapshotName: string;
+    dateStamp: string | null;
+};
+export declare function resolveLocalArchiveProjectPath(projectsRoot: string, projectName: string): string;
+export declare function archiveProjectOnCompletion(options: ArchiveProjectOnCompletionOptions, dependencies?: ArchiveProjectOnCompletionDependencies): Promise<ArchiveProjectOnCompletionResult>;
+export declare function ensureS3ArchiveAccess(options: EnsureS3ArchiveAccessOptions, dependencies?: EnsureS3ArchiveAccessDependencies): Promise<EnsureS3ArchiveAccessResult>;
+export {};
+//# sourceMappingURL=archive-utils.d.ts.map

package/dist/commands/project/archive/archive-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-utils.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/archive/archive-utils.ts"],"names":[],"mappings":"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"}