@open-agent-toolkit/cli 0.0.10

package/dist/commands/init/tools/workflows/index.js

@@ -0,0 +1,84 @@
+import { buildCommandContext, } from '../../../../app/command-context.js';
+import { confirmAction, } from '../../../shared/shared.prompts.js';
+import { readGlobalOptions } from '../../../shared/shared.utils.js';
+import { resolveAssetsRoot } from '../../../../fs/assets.js';
+import { resolveProjectRoot } from '../../../../fs/paths.js';
+import { Command } from 'commander';
+import { installWorkflows as defaultInstallWorkflows, } from './install-workflows.js';
+const PROJECT_SCOPE_ONLY_MESSAGE = 'oat init tools workflows currently supports only --scope project.';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveAssetsRoot,
+    installWorkflows: defaultInstallWorkflows,
+    confirmAction,
+};
+function reportSuccess(context, targetRoot, assetsRoot, result) {
+    if (context.json) {
+        context.logger.json({
+            status: 'ok',
+            scope: 'project',
+            targetRoot,
+            assetsRoot,
+            result,
+        });
+        return;
+    }
+    context.logger.info('Installed workflows tool pack.');
+    context.logger.info(`Target root: ${targetRoot}`);
+    context.logger.info(`Skills: copied=${result.copiedSkills.length}, updated=${result.updatedSkills.length}, skipped=${result.skippedSkills.length}`);
+    context.logger.info(`Agents: copied=${result.copiedAgents.length}, updated=${result.updatedAgents.length}, skipped=${result.skippedAgents.length}`);
+    context.logger.info(`Templates: copied=${result.copiedTemplates.length}, updated=${result.updatedTemplates.length}, skipped=${result.skippedTemplates.length}`);
+    context.logger.info(`Scripts: copied=${result.copiedScripts.length}, updated=${result.updatedScripts.length}, skipped=${result.skippedScripts.length}`);
+    context.logger.info(`Projects root initialized: ${result.projectsRootInitialized ? 'yes' : 'no'}`);
+    context.logger.info('Run: oat sync --scope project');
+}
+async function runInitToolsWorkflows(context, options, dependencies) {
+    try {
+        if (context.scope === 'user') {
+            throw new Error(PROJECT_SCOPE_ONLY_MESSAGE);
+        }
+        const targetRoot = await dependencies.resolveProjectRoot(context.cwd);
+        if (options.force && context.interactive) {
+            const confirmed = await dependencies.confirmAction('Force overwrite existing workflows assets in project scope?', { interactive: context.interactive });
+            if (!confirmed) {
+                if (!context.json) {
+                    context.logger.info('Cancelled: no files were overwritten.');
+                }
+                process.exitCode = 0;
+                return;
+            }
+        }
+        const assetsRoot = await dependencies.resolveAssetsRoot();
+        const result = await dependencies.installWorkflows({
+            assetsRoot,
+            targetRoot,
+            force: options.force,
+        });
+        reportSuccess(context, targetRoot, assetsRoot, result);
+        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;
+    }
+}
+export function createInitToolsWorkflowsCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    return new Command('workflows')
+        .description('Install OAT workflows skills, agents, templates, and scripts')
+        .option('--force', 'Overwrite existing files where applicable')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runInitToolsWorkflows(context, options, dependencies);
+    });
+}

package/dist/commands/init/tools/workflows/install-workflows.d.ts

@@ -0,0 +1,32 @@
+import { WORKFLOW_AGENTS, WORKFLOW_SCRIPTS, WORKFLOW_SKILLS, WORKFLOW_TEMPLATES } from '../../../init/tools/shared/skill-manifest.js';
+export { WORKFLOW_AGENTS, WORKFLOW_SCRIPTS, WORKFLOW_SKILLS, WORKFLOW_TEMPLATES, };
+export interface InstallWorkflowsOptions {
+    assetsRoot: string;
+    targetRoot: string;
+    force?: boolean;
+}
+export interface InstallWorkflowsResult {
+    copiedSkills: string[];
+    updatedSkills: string[];
+    skippedSkills: string[];
+    outdatedSkills: Array<{
+        name: string;
+        installed: string | null;
+        bundled: string | null;
+    }>;
+    copiedAgents: string[];
+    updatedAgents: string[];
+    skippedAgents: string[];
+    copiedTemplates: string[];
+    updatedTemplates: string[];
+    skippedTemplates: string[];
+    copiedScripts: string[];
+    updatedScripts: string[];
+    skippedScripts: string[];
+    projectsRootInitialized: boolean;
+    projectsRootConfigInitialized: boolean;
+    projectsDirsScaffolded: boolean;
+    resolvedProjectsRoot: string;
+}
+export declare function installWorkflows(options: InstallWorkflowsOptions): Promise<InstallWorkflowsResult>;
+//# sourceMappingURL=install-workflows.d.ts.map

package/dist/commands/init/tools/workflows/install-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-workflows.d.ts","sourceRoot":"","sources":["../../../../../src/commands/init/tools/workflows/install-workflows.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EACnB,MAAM,4CAA4C,CAAC;AAIpD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,kBAAkB,GACnB,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,EAAE,KAAK,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;KACxB,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,uBAAuB,EAAE,OAAO,CAAC;IACjC,6BAA6B,EAAE,OAAO,CAAC;IACvC,sBAAsB,EAAE,OAAO,CAAC;IAChC,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CA0IjC"}

package/dist/commands/init/tools/workflows/install-workflows.js

@@ -0,0 +1,135 @@
+import { chmod, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { copyDirWithVersionCheck, copyFileWithStatus, } from '../../../init/tools/shared/copy-helpers.js';
+import { WORKFLOW_AGENTS, WORKFLOW_SCRIPTS, WORKFLOW_SKILLS, WORKFLOW_TEMPLATES, } from '../../../init/tools/shared/skill-manifest.js';
+import { readOatConfig, writeOatConfig } from '../../../../config/oat-config.js';
+import { dirExists, ensureDir, fileExists } from '../../../../fs/io.js';
+export { WORKFLOW_AGENTS, WORKFLOW_SCRIPTS, WORKFLOW_SKILLS, WORKFLOW_TEMPLATES, };
+export async function installWorkflows(options) {
+    const force = options.force ?? false;
+    const result = {
+        copiedSkills: [],
+        updatedSkills: [],
+        skippedSkills: [],
+        outdatedSkills: [],
+        copiedAgents: [],
+        updatedAgents: [],
+        skippedAgents: [],
+        copiedTemplates: [],
+        updatedTemplates: [],
+        skippedTemplates: [],
+        copiedScripts: [],
+        updatedScripts: [],
+        skippedScripts: [],
+        projectsRootInitialized: false,
+        projectsRootConfigInitialized: false,
+        projectsDirsScaffolded: false,
+        resolvedProjectsRoot: '',
+    };
+    for (const skill of WORKFLOW_SKILLS) {
+        const source = join(options.assetsRoot, 'skills', skill);
+        const destination = join(options.targetRoot, '.agents', 'skills', skill);
+        const copyResult = await copyDirWithVersionCheck(source, destination, force);
+        if (copyResult.status === 'copied') {
+            result.copiedSkills.push(skill);
+        }
+        else if (copyResult.status === 'updated') {
+            result.updatedSkills.push(skill);
+        }
+        else if (copyResult.status === 'outdated') {
+            result.outdatedSkills.push({
+                name: skill,
+                installed: copyResult.installedVersion ?? null,
+                bundled: copyResult.bundledVersion ?? null,
+            });
+        }
+        else {
+            result.skippedSkills.push(skill);
+        }
+    }
+    for (const agent of WORKFLOW_AGENTS) {
+        const source = join(options.assetsRoot, 'agents', agent);
+        const destination = join(options.targetRoot, '.agents', 'agents', agent);
+        const copyStatus = await copyFileWithStatus(source, destination, force);
+        if (copyStatus === 'copied') {
+            result.copiedAgents.push(agent);
+        }
+        else if (copyStatus === 'updated') {
+            result.updatedAgents.push(agent);
+        }
+        else {
+            result.skippedAgents.push(agent);
+        }
+    }
+    for (const template of WORKFLOW_TEMPLATES) {
+        const source = join(options.assetsRoot, 'templates', template);
+        const destination = join(options.targetRoot, '.oat', 'templates', template);
+        const copyStatus = await copyFileWithStatus(source, destination, force);
+        if (copyStatus === 'copied') {
+            result.copiedTemplates.push(template);
+        }
+        else if (copyStatus === 'updated') {
+            result.updatedTemplates.push(template);
+        }
+        else {
+            result.skippedTemplates.push(template);
+        }
+    }
+    for (const script of WORKFLOW_SCRIPTS) {
+        const source = join(options.assetsRoot, 'scripts', script);
+        const destination = join(options.targetRoot, '.oat', 'scripts', script);
+        const sourceExists = await fileExists(source);
+        if (!sourceExists) {
+            result.skippedScripts.push(script);
+            continue;
+        }
+        const copyStatus = await copyFileWithStatus(source, destination, force);
+        if (copyStatus !== 'skipped') {
+            await chmod(destination, 0o755);
+        }
+        if (copyStatus === 'copied') {
+            result.copiedScripts.push(script);
+        }
+        else if (copyStatus === 'updated') {
+            result.updatedScripts.push(script);
+        }
+        else {
+            result.skippedScripts.push(script);
+        }
+    }
+    const projectsRootPath = join(options.targetRoot, '.oat', 'projects-root');
+    const hasProjectsRoot = await fileExists(projectsRootPath);
+    if (!hasProjectsRoot) {
+        await ensureDir(dirname(projectsRootPath));
+        await writeFile(projectsRootPath, '.oat/projects/shared\n', 'utf8');
+        result.projectsRootInitialized = true;
+    }
+    const config = await readOatConfig(options.targetRoot);
+    if (!config.projects?.root?.trim()) {
+        await writeOatConfig(options.targetRoot, {
+            ...config,
+            projects: { root: '.oat/projects/shared' },
+        });
+        result.projectsRootConfigInitialized = true;
+    }
+    const effectiveRoot = config.projects?.root?.trim() || '.oat/projects/shared';
+    result.resolvedProjectsRoot = effectiveRoot;
+    const sharedDir = join(options.targetRoot, effectiveRoot);
+    const projectsBase = dirname(sharedDir);
+    const localGitkeep = join(projectsBase, 'local', '.gitkeep');
+    const archivedGitkeep = join(projectsBase, 'archived', '.gitkeep');
+    const sharedExists = await dirExists(sharedDir);
+    if (!sharedExists) {
+        await ensureDir(sharedDir);
+        await ensureDir(dirname(localGitkeep));
+        await ensureDir(dirname(archivedGitkeep));
+        if (!(await fileExists(localGitkeep))) {
+            await writeFile(localGitkeep, '', 'utf8');
+        }
+        if (!(await fileExists(archivedGitkeep))) {
+            await writeFile(archivedGitkeep, '', 'utf8');
+        }
+        result.projectsDirsScaffolded = true;
+    }
+    return result;
+}

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

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

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

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

package/dist/commands/instructions/index.js

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import { createInstructionsSyncCommand } from './sync/sync.js';
+import { createInstructionsValidateCommand } from './validate/validate.js';
+export function createInstructionsCommand() {
+    return new Command('instructions')
+        .description('Manage AGENTS.md and CLAUDE.md instruction file integrity')
+        .addCommand(createInstructionsValidateCommand())
+        .addCommand(createInstructionsSyncCommand());
+}

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

@@ -0,0 +1,52 @@
+import type { Dirent, Stats } from 'node:fs';
+import type { CommandContext, GlobalOptions } from '../../app/command-context.js';
+export type InstructionStatus = 'ok' | 'missing' | 'content_mismatch';
+export type InstructionsStatus = 'ok' | 'drift';
+export interface InstructionEntry {
+    agentsPath: string;
+    claudePath: string;
+    status: InstructionStatus;
+    detail: string;
+}
+export type InstructionActionType = 'create' | 'update' | 'skip';
+export type InstructionActionResult = 'planned' | 'applied' | 'skipped';
+export interface InstructionActionRecord {
+    type: InstructionActionType;
+    target: string;
+    reason: string;
+    result: InstructionActionResult;
+}
+export type InstructionsMode = 'validate' | 'dry-run' | 'apply';
+export interface InstructionsSummary {
+    scanned: number;
+    ok: number;
+    missing: number;
+    contentMismatch: number;
+    created: number;
+    updated: number;
+    skipped: number;
+}
+export interface InstructionsJsonPayload {
+    mode: InstructionsMode;
+    status: InstructionsStatus;
+    summary: InstructionsSummary;
+    entries: InstructionEntry[];
+    actions: InstructionActionRecord[];
+}
+export interface InstructionsScanDependencies {
+    readdir: (path: string, options: {
+        withFileTypes: true;
+    }) => Promise<Dirent[]>;
+    readFile: (path: string, encoding: 'utf8') => Promise<string>;
+    stat: (path: string) => Promise<Stats>;
+    debug?: (message: string) => void;
+}
+export interface InstructionsValidateCommandDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    scanInstructionFiles: (repoRoot: string, overrides?: Partial<InstructionsScanDependencies>) => Promise<InstructionEntry[]>;
+}
+export interface InstructionsSyncCommandDependencies extends InstructionsValidateCommandDependencies {
+    writeFile: (path: string, content: string, encoding: 'utf8') => Promise<void>;
+}
+//# sourceMappingURL=instructions.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.types.d.ts","sourceRoot":"","sources":["../../../src/commands/instructions/instructions.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1E,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,SAAS,GAAG,kBAAkB,CAAC;AAEtE,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,OAAO,CAAC;AAEhD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEjE,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAExE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC;AAEhE,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE,mBAAmB,CAAC;IAC7B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,OAAO,EAAE,uBAAuB,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,CACP,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,KAC7B,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACvB,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9D,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IACvC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,uCAAuC;IACtD,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,oBAAoB,EAAE,CACpB,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,OAAO,CAAC,4BAA4B,CAAC,KAC9C,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,mCAAoC,SAAQ,uCAAuC;IAClG,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E"}

package/dist/commands/instructions/instructions.types.js

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

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

@@ -0,0 +1,13 @@
+import type { InstructionActionRecord, InstructionEntry, InstructionsJsonPayload, InstructionsMode, InstructionsScanDependencies, InstructionsSummary } from './instructions.types.js';
+export declare const EXPECTED_CLAUDE_CONTENT = "@AGENTS.md\n";
+interface BuildInstructionsPayloadArgs {
+    mode: InstructionsMode;
+    entries: InstructionEntry[];
+    actions: InstructionActionRecord[];
+}
+export declare function scanInstructionFiles(repoRoot: string, overrides?: Partial<InstructionsScanDependencies>): Promise<InstructionEntry[]>;
+export declare function buildInstructionsSummary(entries: InstructionEntry[], actions: InstructionActionRecord[]): InstructionsSummary;
+export declare function buildInstructionsPayload({ mode, entries, actions, }: BuildInstructionsPayloadArgs): InstructionsJsonPayload;
+export declare function formatInstructionsReport(payload: InstructionsJsonPayload, repoRoot?: string): string;
+export {};
+//# sourceMappingURL=instructions.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.utils.d.ts","sourceRoot":"","sources":["../../../src/commands/instructions/instructions.utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,uBAAuB,EACvB,gBAAgB,EAChB,uBAAuB,EACvB,gBAAgB,EAChB,4BAA4B,EAE5B,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AAKtD,UAAU,4BAA4B;IACpC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,OAAO,EAAE,uBAAuB,EAAE,CAAC;CACpC;AAoHD,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACpD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAoD7B;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,gBAAgB,EAAE,EAC3B,OAAO,EAAE,uBAAuB,EAAE,GACjC,mBAAmB,CAmBrB;AAgBD,wBAAgB,wBAAwB,CAAC,EACvC,IAAI,EACJ,OAAO,EACP,OAAO,GACR,EAAE,4BAA4B,GAAG,uBAAuB,CAWxD;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,uBAAuB,EAChC,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAkCR"}

package/dist/commands/instructions/instructions.utils.js

@@ -0,0 +1,211 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+export const EXPECTED_CLAUDE_CONTENT = '@AGENTS.md\n';
+const ROOT_EXCLUDED_DIRECTORIES = new Set(['.git', '.oat', '.worktrees']);
+const GLOBAL_EXCLUDED_DIRECTORIES = new Set(['node_modules']);
+function getErrorCode(error) {
+    return error && typeof error === 'object' && 'code' in error
+        ? String(error.code)
+        : null;
+}
+function normalizeLineEndings(content) {
+    return content.replaceAll('\r\n', '\n');
+}
+function toPosixPath(pathValue) {
+    return pathValue.replaceAll('\\', '/');
+}
+function normalizeEntries(entries) {
+    return [...entries].sort((left, right) => {
+        return (left.agentsPath.localeCompare(right.agentsPath) ||
+            left.claudePath.localeCompare(right.claudePath) ||
+            left.status.localeCompare(right.status) ||
+            left.detail.localeCompare(right.detail));
+    });
+}
+function normalizeActions(actions) {
+    return [...actions].sort((left, right) => {
+        return (left.target.localeCompare(right.target) ||
+            left.type.localeCompare(right.type) ||
+            left.result.localeCompare(right.result) ||
+            left.reason.localeCompare(right.reason));
+    });
+}
+async function scanAgentsFiles(repoRoot, dependencies) {
+    const queue = [repoRoot];
+    const agentsFiles = [];
+    while (queue.length > 0) {
+        const currentDirectory = queue.shift();
+        if (!currentDirectory) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = await dependencies.readdir(currentDirectory, {
+                withFileTypes: true,
+            });
+        }
+        catch (error) {
+            const errorCode = getErrorCode(error);
+            dependencies.debug?.(`Skipping directory scan for ${toPosixPath(currentDirectory)} (${errorCode ?? 'unknown error'})`);
+            continue;
+        }
+        for (const entry of entries) {
+            const entryPath = join(currentDirectory, entry.name);
+            const isRootLevel = currentDirectory === repoRoot;
+            if (entry.isDirectory()) {
+                if (GLOBAL_EXCLUDED_DIRECTORIES.has(entry.name)) {
+                    continue;
+                }
+                if (isRootLevel && ROOT_EXCLUDED_DIRECTORIES.has(entry.name)) {
+                    continue;
+                }
+                queue.push(entryPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                if (entry.name === 'AGENTS.md') {
+                    agentsFiles.push(entryPath);
+                }
+                continue;
+            }
+            if (!entry.isSymbolicLink()) {
+                continue;
+            }
+            let entryStats;
+            try {
+                entryStats = await dependencies.stat(entryPath);
+            }
+            catch (error) {
+                const errorCode = getErrorCode(error);
+                dependencies.debug?.(`Skipping symlink target stat for ${toPosixPath(entryPath)} (${errorCode ?? 'unknown error'})`);
+                continue;
+            }
+            if (entryStats.isDirectory()) {
+                continue;
+            }
+            if (entryStats.isFile() && entry.name === 'AGENTS.md') {
+                agentsFiles.push(entryPath);
+            }
+        }
+    }
+    return agentsFiles.sort((left, right) => left.localeCompare(right));
+}
+export async function scanInstructionFiles(repoRoot, overrides = {}) {
+    const dependencies = {
+        readdir,
+        readFile,
+        stat,
+        ...overrides,
+    };
+    const agentsFiles = await scanAgentsFiles(repoRoot, dependencies);
+    const entries = [];
+    for (const agentsPath of agentsFiles) {
+        const claudePath = join(dirname(agentsPath), 'CLAUDE.md');
+        try {
+            const claudeContent = await dependencies.readFile(claudePath, 'utf8');
+            if (normalizeLineEndings(claudeContent) === EXPECTED_CLAUDE_CONTENT) {
+                entries.push({
+                    agentsPath,
+                    claudePath,
+                    status: 'ok',
+                    detail: 'pointer valid',
+                });
+            }
+            else {
+                entries.push({
+                    agentsPath,
+                    claudePath,
+                    status: 'content_mismatch',
+                    detail: `expected ${JSON.stringify(EXPECTED_CLAUDE_CONTENT)}`,
+                });
+            }
+        }
+        catch (error) {
+            const errorCode = getErrorCode(error);
+            if (errorCode === 'ENOENT') {
+                entries.push({
+                    agentsPath,
+                    claudePath,
+                    status: 'missing',
+                    detail: 'CLAUDE.md missing',
+                });
+            }
+            else {
+                entries.push({
+                    agentsPath,
+                    claudePath,
+                    status: 'content_mismatch',
+                    detail: `unable to read CLAUDE.md (${errorCode ?? 'unknown error'})`,
+                });
+            }
+        }
+    }
+    return normalizeEntries(entries);
+}
+export function buildInstructionsSummary(entries, actions) {
+    const normalizedEntries = normalizeEntries(entries);
+    const normalizedActions = normalizeActions(actions);
+    return {
+        scanned: normalizedEntries.length,
+        ok: normalizedEntries.filter((entry) => entry.status === 'ok').length,
+        missing: normalizedEntries.filter((entry) => entry.status === 'missing')
+            .length,
+        contentMismatch: normalizedEntries.filter((entry) => entry.status === 'content_mismatch').length,
+        created: normalizedActions.filter((action) => action.type === 'create')
+            .length,
+        updated: normalizedActions.filter((action) => action.type === 'update')
+            .length,
+        skipped: normalizedActions.filter((action) => action.result === 'skipped')
+            .length,
+    };
+}
+function deriveInstructionsStatus(entries, actions) {
+    if (entries.some((entry) => entry.status !== 'ok') ||
+        actions.some((action) => action.result === 'skipped')) {
+        return 'drift';
+    }
+    return 'ok';
+}
+export function buildInstructionsPayload({ mode, entries, actions, }) {
+    const normalizedEntries = normalizeEntries(entries);
+    const normalizedActions = normalizeActions(actions);
+    return {
+        mode,
+        status: deriveInstructionsStatus(normalizedEntries, normalizedActions),
+        summary: buildInstructionsSummary(normalizedEntries, normalizedActions),
+        entries: normalizedEntries,
+        actions: normalizedActions,
+    };
+}
+export function formatInstructionsReport(payload, repoRoot) {
+    const lines = [
+        `instructions ${payload.mode}`,
+        `status: ${payload.status}`,
+        `summary: scanned=${payload.summary.scanned}, ok=${payload.summary.ok}, missing=${payload.summary.missing}, content_mismatch=${payload.summary.contentMismatch}, created=${payload.summary.created}, updated=${payload.summary.updated}, skipped=${payload.summary.skipped}`,
+    ];
+    if (payload.entries.length === 0) {
+        lines.push('entries: none');
+    }
+    else {
+        lines.push('entries:');
+        for (const entry of payload.entries) {
+            const agentsPath = repoRoot
+                ? toPosixPath(relative(repoRoot, entry.agentsPath)) || '.'
+                : toPosixPath(entry.agentsPath);
+            lines.push(`- ${agentsPath} -> ${entry.status} (${entry.detail})`);
+        }
+    }
+    if (payload.actions.length === 0) {
+        lines.push('actions: none');
+    }
+    else {
+        lines.push('actions:');
+        for (const action of payload.actions) {
+            const target = repoRoot
+                ? toPosixPath(relative(repoRoot, action.target)) || '.'
+                : toPosixPath(action.target);
+            lines.push(`- ${action.type} ${target} (${action.reason}) [${action.result}]`);
+        }
+    }
+    return lines.join('\n');
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/commands/instructions/sync/sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,mCAAmC,EACpC,MAAM,2CAA2C,CAAC;AAUnD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmHpC,wBAAgB,6BAA6B,CAC3C,SAAS,GAAE,OAAO,CAAC,mCAAmC,CAAM,GAC3D,OAAO,CA+DT"}