@open-agent-toolkit/cli 0.0.10

package/dist/commands/instructions/sync/sync.js

@@ -0,0 +1,142 @@
+import { writeFile } from 'node:fs/promises';
+import { buildCommandContext } from '../../../app/command-context.js';
+import { buildInstructionsPayload, EXPECTED_CLAUDE_CONTENT, formatInstructionsReport, scanInstructionFiles, } from '../../instructions/instructions.utils.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+function defaultDependencies() {
+    return {
+        buildCommandContext,
+        resolveProjectRoot,
+        scanInstructionFiles,
+        writeFile,
+    };
+}
+function planSyncActions({ entries, force, }) {
+    const actions = [];
+    for (const entry of entries) {
+        if (entry.status === 'missing') {
+            actions.push({
+                type: 'create',
+                target: entry.claudePath,
+                reason: 'missing CLAUDE.md pointer file',
+                result: 'planned',
+            });
+            continue;
+        }
+        if (entry.status !== 'content_mismatch') {
+            continue;
+        }
+        if (!force) {
+            actions.push({
+                type: 'skip',
+                target: entry.claudePath,
+                reason: 'content mismatch requires --force',
+                result: 'skipped',
+            });
+            continue;
+        }
+        actions.push({
+            type: 'update',
+            target: entry.claudePath,
+            reason: 'overwrite CLAUDE.md with canonical pointer',
+            result: 'planned',
+        });
+    }
+    return actions;
+}
+async function applySyncActions(actions, dependencies) {
+    const appliedActions = [];
+    for (const action of actions) {
+        if (action.result !== 'planned') {
+            appliedActions.push(action);
+            continue;
+        }
+        await dependencies.writeFile(action.target, EXPECTED_CLAUDE_CONTENT, 'utf8');
+        appliedActions.push({
+            ...action,
+            result: 'applied',
+        });
+    }
+    return appliedActions;
+}
+function getPostSyncEntries(entries, actions) {
+    const actionByTarget = new Map(actions.map((action) => [action.target, action]));
+    return entries.map((entry) => {
+        const action = actionByTarget.get(entry.claudePath);
+        if (!action) {
+            return entry;
+        }
+        if (action.result === 'applied' && action.type !== 'skip') {
+            return {
+                ...entry,
+                status: 'ok',
+                detail: 'pointer synced',
+            };
+        }
+        return entry;
+    });
+}
+function hasSkippedActions(actions) {
+    return actions.some((action) => action.result === 'skipped');
+}
+export function createInstructionsSyncCommand(overrides = {}) {
+    const dependencies = {
+        ...defaultDependencies(),
+        ...overrides,
+    };
+    return new Command('sync')
+        .description('Repair AGENTS.md to CLAUDE.md pointer drift')
+        .option('--dry-run', 'Preview sync changes without applying')
+        .option('--force', 'Overwrite mismatched CLAUDE.md files')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const entries = await dependencies.scanInstructionFiles(repoRoot);
+            const plannedActions = planSyncActions({
+                entries,
+                force: options.force ?? false,
+            });
+            const dryRun = options.dryRun ?? false;
+            const actions = dryRun
+                ? plannedActions
+                : await applySyncActions(plannedActions, dependencies);
+            const payload = buildInstructionsPayload({
+                mode: dryRun ? 'dry-run' : 'apply',
+                entries: dryRun ? entries : getPostSyncEntries(entries, actions),
+                actions,
+            });
+            if (context.json) {
+                context.logger.json(payload);
+            }
+            else {
+                context.logger.info(formatInstructionsReport(payload, repoRoot));
+                if (dryRun) {
+                    context.logger.warn('\nDry-run only: no filesystem changes were made.');
+                    if (plannedActions.length > 0) {
+                        context.logger.info('Run without --dry-run to apply changes.');
+                    }
+                    else {
+                        context.logger.info('No changes to apply.');
+                    }
+                }
+                else if (payload.status === 'ok') {
+                    context.logger.success('\nInstruction sync applied successfully.');
+                }
+            }
+            process.exitCode = hasSkippedActions(actions) ? 1 : 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 : 2;
+        }
+    });
+}

package/dist/commands/instructions/validate/validate.d.ts

@@ -0,0 +1,4 @@
+import type { InstructionsValidateCommandDependencies } from '../../instructions/instructions.types.js';
+import { Command } from 'commander';
+export declare function createInstructionsValidateCommand(overrides?: Partial<InstructionsValidateCommandDependencies>): Command;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/instructions/validate/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/commands/instructions/validate/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AASzG,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC,wBAAgB,iCAAiC,CAC/C,SAAS,GAAE,OAAO,CAAC,uCAAuC,CAAM,GAC/D,OAAO,CA0CT"}

package/dist/commands/instructions/validate/validate.js

@@ -0,0 +1,53 @@
+import { buildCommandContext } from '../../../app/command-context.js';
+import { buildInstructionsPayload, formatInstructionsReport, scanInstructionFiles, } from '../../instructions/instructions.utils.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+function defaultDependencies() {
+    return {
+        buildCommandContext,
+        resolveProjectRoot,
+        scanInstructionFiles,
+    };
+}
+export function createInstructionsValidateCommand(overrides = {}) {
+    const dependencies = {
+        ...defaultDependencies(),
+        ...overrides,
+    };
+    return new Command('validate')
+        .description('Validate AGENTS.md to CLAUDE.md pointer integrity')
+        .action(async (_options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const entries = await dependencies.scanInstructionFiles(repoRoot);
+            const payload = buildInstructionsPayload({
+                mode: 'validate',
+                entries,
+                actions: [],
+            });
+            if (context.json) {
+                context.logger.json(payload);
+            }
+            else {
+                context.logger.info(formatInstructionsReport(payload, repoRoot));
+                if (payload.status === 'drift') {
+                    context.logger.info('Fix with: oat instructions sync');
+                }
+            }
+            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/internal/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/internal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,wBAAgB,qBAAqB,IAAI,OAAO,CAI/C"}

package/dist/commands/internal/index.js

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+import { createValidateOatSkillsCommand } from './validate-oat-skills.js';
+export function createInternalCommand() {
+    return new Command('internal')
+        .description('Internal OAT maintenance commands')
+        .addCommand(createValidateOatSkillsCommand());
+}

package/dist/commands/internal/validate-oat-skills.d.ts

@@ -0,0 +1,10 @@
+import { type CommandContext, type GlobalOptions } from '../../app/command-context.js';
+import { type ValidateOatSkillsResult } from '../../validation/index.js';
+import { Command } from 'commander';
+interface ValidateOatSkillsDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    validateOatSkills: (repoRoot: string) => Promise<ValidateOatSkillsResult>;
+}
+export declare function createValidateOatSkillsCommand(overrides?: Partial<ValidateOatSkillsDependencies>): Command;
+export {};
+//# sourceMappingURL=validate-oat-skills.d.ts.map

package/dist/commands/internal/validate-oat-skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-oat-skills.d.ts","sourceRoot":"","sources":["../../../src/commands/internal/validate-oat-skills.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,UAAU,6BAA6B;IACrC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;CAC3E;AAiED,wBAAgB,8BAA8B,CAC5C,SAAS,GAAE,OAAO,CAAC,6BAA6B,CAAM,GACrD,OAAO,CAcT"}

package/dist/commands/internal/validate-oat-skills.js

@@ -0,0 +1,66 @@
+import { buildCommandContext, } from '../../app/command-context.js';
+import { readGlobalOptions } from '../shared/shared.utils.js';
+import { validateOatSkills as defaultValidateOatSkills, } from '../../validation/index.js';
+import { Command } from 'commander';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    validateOatSkills: defaultValidateOatSkills,
+};
+function reportFindings(context, result) {
+    if (context.json) {
+        context.logger.json({
+            status: 'failed',
+            validatedSkillCount: result.validatedSkillCount,
+            findings: result.findings,
+        });
+        return;
+    }
+    context.logger.error('OAT skill validation failed:\n');
+    for (const finding of result.findings) {
+        context.logger.error(`- ${finding.file}: ${finding.message}`);
+    }
+    context.logger.error('\nFix the issues above, then re-run: pnpm oat:validate-skills');
+}
+async function runValidateOatSkills(context, dependencies) {
+    try {
+        const result = await dependencies.validateOatSkills(context.cwd);
+        if (result.findings.length > 0) {
+            reportFindings(context, result);
+            process.exitCode = 1;
+            return;
+        }
+        if (context.json) {
+            context.logger.json({
+                status: 'ok',
+                validatedSkillCount: result.validatedSkillCount,
+                findings: result.findings,
+            });
+        }
+        else {
+            context.logger.info(`OK: validated ${result.validatedSkillCount} oat-* skills`);
+        }
+        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 = 2;
+    }
+}
+export function createValidateOatSkillsCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    return new Command('validate-oat-skills')
+        .description('Validate required structure of oat-* workflow skills')
+        .action(async (_options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runValidateOatSkills(context, dependencies);
+    });
+}

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

@@ -0,0 +1,6 @@
+export interface ApplyResult {
+    action: 'created' | 'updated' | 'no-change';
+    paths: string[];
+}
+export declare function applyGitignore(repoRoot: string, localPaths: string[]): Promise<ApplyResult>;
+//# sourceMappingURL=apply.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/local/apply.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;IAC5C,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAYD,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,WAAW,CAAC,CAwDtB"}

package/dist/commands/local/apply.js

@@ -0,0 +1,56 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileExists } from '../../fs/io.js';
+const SECTION_START = '# OAT local paths';
+const SECTION_END = '# END OAT local paths';
+function normalizePath(p) {
+    return p.endsWith('/') ? p : `${p}/`;
+}
+function buildSection(localPaths) {
+    if (localPaths.length === 0)
+        return '';
+    const entries = localPaths.map(normalizePath).join('\n');
+    return `${SECTION_START}\n${entries}\n${SECTION_END}`;
+}
+export async function applyGitignore(repoRoot, localPaths) {
+    const gitignorePath = join(repoRoot, '.gitignore');
+    const exists = await fileExists(gitignorePath);
+    const normalizedPaths = localPaths.map(normalizePath);
+    if (!exists) {
+        const section = buildSection(localPaths);
+        if (section) {
+            await writeFile(gitignorePath, `${section}\n`, 'utf8');
+        }
+        return { action: 'created', paths: normalizedPaths };
+    }
+    const content = await readFile(gitignorePath, 'utf8');
+    const startIdx = content.indexOf(SECTION_START);
+    const endIdx = content.indexOf(SECTION_END);
+    const newSection = buildSection(localPaths);
+    if (startIdx !== -1 && endIdx !== -1) {
+        // Extract existing section to check for no-change
+        const existingSection = content.slice(startIdx, endIdx + SECTION_END.length);
+        if (existingSection === newSection) {
+            return { action: 'no-change', paths: normalizedPaths };
+        }
+        // Replace existing section
+        const before = content.slice(0, startIdx);
+        const after = content.slice(endIdx + SECTION_END.length);
+        let updated;
+        if (newSection) {
+            updated = `${before}${newSection}${after}`;
+        }
+        else {
+            // Remove section and clean up surrounding blank lines
+            updated = `${before.replace(/\n+$/, '\n')}${after.replace(/^\n+/, '')}`;
+        }
+        await writeFile(gitignorePath, updated, 'utf8');
+        return { action: 'updated', paths: normalizedPaths };
+    }
+    // No existing section — append
+    if (newSection) {
+        const separator = content.endsWith('\n') ? '\n' : '\n\n';
+        await writeFile(gitignorePath, `${content}${separator}${newSection}\n`, 'utf8');
+    }
+    return { action: 'updated', paths: normalizedPaths };
+}

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

@@ -0,0 +1,8 @@
+export declare function isGlobPattern(path: string): boolean;
+export declare function matchesPathPattern(path: string, pattern: string): boolean;
+export interface ExpandResult {
+    resolved: string[];
+    missingGlobs: string[];
+}
+export declare function expandLocalPaths(root: string, localPaths: string[]): Promise<ExpandResult>;
+//# sourceMappingURL=expand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expand.d.ts","sourceRoot":"","sources":["../../../src/commands/local/expand.ts"],"names":[],"mappings":"AAuEA,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,YAAY,CAAC,CA0BvB"}

package/dist/commands/local/expand.js

@@ -0,0 +1,83 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+const GLOB_CHARS = /[*?[]/;
+function normalizePattern(path) {
+    return path.replaceAll('\\', '/').replace(/^\.\//, '').replace(/\/+$/, '');
+}
+function globToRegExp(pattern) {
+    let regex = '^';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const char = pattern[i];
+        if (char === '*') {
+            if (pattern[i + 1] === '*') {
+                regex += '.*';
+                i += 1;
+            }
+            else {
+                regex += '[^/]*';
+            }
+            continue;
+        }
+        if (char === '?') {
+            regex += '[^/]';
+            continue;
+        }
+        if (char === '[') {
+            const end = pattern.indexOf(']', i + 1);
+            if (end !== -1) {
+                regex += pattern.slice(i, end + 1);
+                i = end;
+                continue;
+            }
+        }
+        if (/[$()*+./?[\\\]^{|}]/.test(char)) {
+            regex += `\\${char}`;
+        }
+        else {
+            regex += char;
+        }
+    }
+    regex += '$';
+    return new RegExp(regex);
+}
+async function collectRelativePaths(root, current = '') {
+    const dirPath = current === '' ? root : join(root, current);
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const paths = [];
+    for (const entry of entries) {
+        const relativePath = current === '' ? entry.name : `${current}/${entry.name}`;
+        paths.push(relativePath);
+        if (entry.isDirectory()) {
+            paths.push(...(await collectRelativePaths(root, relativePath)));
+        }
+    }
+    return paths;
+}
+export function isGlobPattern(path) {
+    return GLOB_CHARS.test(path);
+}
+export function matchesPathPattern(path, pattern) {
+    return globToRegExp(normalizePattern(pattern)).test(normalizePattern(path));
+}
+export async function expandLocalPaths(root, localPaths) {
+    const resolved = [];
+    const missingGlobs = [];
+    let candidatePaths = null;
+    for (const localPath of localPaths) {
+        if (!isGlobPattern(localPath)) {
+            resolved.push(localPath);
+            continue;
+        }
+        // `fs/promises.glob` is Node 22+. Keep local path expansion working on
+        // Node 20.19+ with a tiny in-repo matcher instead of pulling in a package.
+        candidatePaths ??= await collectRelativePaths(root);
+        const matches = candidatePaths.filter((path) => matchesPathPattern(path, localPath));
+        if (matches.length === 0) {
+            missingGlobs.push(localPath);
+        }
+        else {
+            resolved.push(...matches.sort());
+        }
+    }
+    return { resolved, missingGlobs };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/local/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,wBAAgB,kBAAkB,IAAI,OAAO,CAmS5C"}