@open-agent-toolkit/cli 0.0.10

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export declare function normalizeArgv(argv: string[]): string[];
+export declare function main(argv?: string[]): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAUA,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAatD;AAED,wBAAsB,IAAI,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIvE"}

package/dist/index.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createProgram } from './app/create-program.js';
+import { registerCommands } from './commands/index.js';
+import { CliError } from './errors/index.js';
+import { createLogger } from './ui/index.js';
+export function normalizeArgv(argv) {
+    // `pnpm run <script> -- ...` passes a literal `--` into argv.
+    // Strip that sentinel so Commander can parse subcommand options normally.
+    if (argv.length >= 3 && argv[2] === '--') {
+        const executable = argv[0];
+        const script = argv[1];
+        if (!executable || !script) {
+            return argv;
+        }
+        return [executable, script, ...argv.slice(3)];
+    }
+    return argv;
+}
+export async function main(argv = process.argv) {
+    const program = createProgram();
+    registerCommands(program);
+    await program.parseAsync(normalizeArgv(argv));
+}
+function isEntrypoint() {
+    if (!process.argv[1]) {
+        return false;
+    }
+    return import.meta.url === pathToFileURL(resolve(process.argv[1])).href;
+}
+if (isEntrypoint()) {
+    void main().catch((error) => {
+        const logger = createLogger({ json: false, verbose: false });
+        if (error instanceof CliError) {
+            logger.error(error.message);
+            process.exitCode = error.exitCode;
+        }
+        else if (error instanceof Error) {
+            logger.error(error.message);
+            process.exitCode = 2;
+        }
+        else {
+            logger.error('Unexpected error');
+            process.exitCode = 2;
+        }
+    });
+}

package/dist/manifest/hash.d.ts

@@ -0,0 +1,5 @@
+export declare function computeStringHash(content: string): string;
+export declare function computeFileHash(filePath: string): Promise<string>;
+export declare function computeContentHash(contentPath: string, isFile: boolean): Promise<string>;
+export declare function computeDirectoryHash(dirPath: string): Promise<string>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/manifest/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/manifest/hash.ts"],"names":[],"mappings":"AAMA,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAIzD;AAqBD,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBvE;AAED,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAyC3E"}

package/dist/manifest/hash.js

@@ -0,0 +1,75 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
+import { CliError } from '../errors/index.js';
+export function computeStringHash(content) {
+    const hash = createHash('sha256');
+    hash.update(content);
+    return hash.digest('hex');
+}
+async function collectFiles(root, current, acc) {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = resolve(current, entry.name);
+        if (entry.isDirectory()) {
+            await collectFiles(root, fullPath, acc);
+            continue;
+        }
+        if (entry.isFile()) {
+            acc.push(fullPath);
+        }
+    }
+}
+export async function computeFileHash(filePath) {
+    try {
+        const content = await readFile(filePath);
+        const hash = createHash('sha256');
+        hash.update(content);
+        return hash.digest('hex');
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            throw new CliError(`File does not exist: ${filePath}`);
+        }
+        throw new CliError(`Failed to compute hash for ${filePath}: ${error instanceof Error ? error.message : 'unknown error'}`, 2);
+    }
+}
+export async function computeContentHash(contentPath, isFile) {
+    return isFile
+        ? computeFileHash(contentPath)
+        : computeDirectoryHash(contentPath);
+}
+export async function computeDirectoryHash(dirPath) {
+    const root = resolve(dirPath);
+    const files = [];
+    try {
+        await collectFiles(root, root, files);
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            throw new CliError(`Directory does not exist: ${dirPath}`);
+        }
+        throw new CliError(`Failed to compute hash for ${dirPath}: ${error instanceof Error ? error.message : 'unknown error'}`, 2);
+    }
+    files.sort((left, right) => {
+        const leftRelative = relative(root, left);
+        const rightRelative = relative(root, right);
+        return leftRelative.localeCompare(rightRelative);
+    });
+    const hash = createHash('sha256');
+    for (const file of files) {
+        const relativePath = relative(root, file);
+        const content = await readFile(file);
+        hash.update(relativePath);
+        hash.update('\0');
+        hash.update(content);
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}

package/dist/manifest/index.d.ts

@@ -0,0 +1,5 @@
+export { computeDirectoryHash } from './hash.js';
+export { addEntry, createEmptyManifest, findEntry, loadManifest, removeEntry, saveManifest, } from './manager.js';
+export type { Manifest, ManifestEntry } from './manifest.types.js';
+export { ManifestEntrySchema, ManifestSchema } from './manifest.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/manifest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/manifest/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EACL,QAAQ,EACR,mBAAmB,EACnB,SAAS,EACT,YAAY,EACZ,WAAW,EACX,YAAY,GACb,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/manifest/index.js

@@ -0,0 +1,3 @@
+export { computeDirectoryHash } from './hash.js';
+export { addEntry, createEmptyManifest, findEntry, loadManifest, removeEntry, saveManifest, } from './manager.js';
+export { ManifestEntrySchema, ManifestSchema } from './manifest.types.js';

package/dist/manifest/manager.d.ts

@@ -0,0 +1,8 @@
+import { type Manifest, type ManifestEntry } from './manifest.types.js';
+export declare function createEmptyManifest(): Manifest;
+export declare function loadManifest(manifestPath: string): Promise<Manifest>;
+export declare function saveManifest(manifestPath: string, manifest: Manifest): Promise<void>;
+export declare function findEntry(manifest: Manifest, canonicalPath: string, provider: string): ManifestEntry | undefined;
+export declare function addEntry(manifest: Manifest, entry: ManifestEntry): Manifest;
+export declare function removeEntry(manifest: Manifest, canonicalPath: string, provider: string): Manifest;
+//# sourceMappingURL=manager.d.ts.map

package/dist/manifest/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/manifest/manager.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAC;AAe1B,wBAAgB,mBAAmB,IAAI,QAAQ,CAO9C;AAED,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CA6C1E;AAED,wBAAsB,YAAY,CAChC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,GACf,aAAa,GAAG,SAAS,CAK3B;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,GAAG,QAAQ,CAc3E;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,GACf,QAAQ,CAeV"}

package/dist/manifest/manager.js

@@ -0,0 +1,86 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { CliError } from '../errors/index.js';
+import { ManifestSchema, } from './manifest.types.js';
+const OAT_VERSION = '0.0.7';
+function formatIssuePath(path) {
+    if (path.length === 0) {
+        return '(root)';
+    }
+    return path.map(String).join('.');
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+export function createEmptyManifest() {
+    return {
+        version: 1,
+        oatVersion: OAT_VERSION,
+        entries: [],
+        lastUpdated: nowIso(),
+    };
+}
+export async function loadManifest(manifestPath) {
+    try {
+        const raw = await readFile(manifestPath, 'utf8');
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new CliError(`Manifest at ${manifestPath} is not valid JSON. Delete or repair the file and re-run oat sync.`);
+        }
+        const result = ManifestSchema.safeParse(parsed);
+        if (!result.success) {
+            const issueDetails = result.error.issues
+                .map((issue) => `${formatIssuePath(issue.path)}: ${issue.message}`)
+                .join('; ');
+            throw new CliError(`Manifest at ${manifestPath} failed validation: ${issueDetails}. Delete or repair the file and re-run oat sync.`);
+        }
+        return result.data;
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return createEmptyManifest();
+        }
+        if (error instanceof CliError) {
+            throw error;
+        }
+        throw new CliError(`Failed to read manifest at ${manifestPath}: ${error instanceof Error ? error.message : 'unknown error'}`, 2);
+    }
+}
+export async function saveManifest(manifestPath, manifest) {
+    const validated = ManifestSchema.parse(manifest);
+    const dir = dirname(manifestPath);
+    const tempPath = `${manifestPath}.${randomUUID()}.tmp`;
+    await mkdir(dir, { recursive: true });
+    await writeFile(tempPath, `${JSON.stringify(validated, null, 2)}\n`, 'utf8');
+    await rename(tempPath, manifestPath);
+}
+export function findEntry(manifest, canonicalPath, provider) {
+    return manifest.entries.find((entry) => entry.canonicalPath === canonicalPath && entry.provider === provider);
+}
+export function addEntry(manifest, entry) {
+    const nextEntries = manifest.entries.filter((candidate) => !(candidate.canonicalPath === entry.canonicalPath &&
+        candidate.provider === entry.provider));
+    return {
+        ...manifest,
+        entries: [...nextEntries, entry],
+        lastUpdated: nowIso(),
+    };
+}
+export function removeEntry(manifest, canonicalPath, provider) {
+    const nextEntries = manifest.entries.filter((entry) => !(entry.canonicalPath === canonicalPath && entry.provider === provider));
+    if (nextEntries.length === manifest.entries.length) {
+        return manifest;
+    }
+    return {
+        ...manifest,
+        entries: nextEntries,
+        lastUpdated: nowIso(),
+    };
+}

package/dist/manifest/manifest.types.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+export declare const ManifestEntrySchema: z.ZodEffects<z.ZodObject<{
+    canonicalPath: z.ZodEffects<z.ZodString, string, string>;
+    providerPath: z.ZodEffects<z.ZodString, string, string>;
+    provider: z.ZodString;
+    contentType: z.ZodEnum<["skill", "agent", "rule"]>;
+    strategy: z.ZodEnum<["symlink", "copy"]>;
+    contentHash: z.ZodNullable<z.ZodString>;
+    isFile: z.ZodDefault<z.ZodBoolean>;
+    lastSynced: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    canonicalPath: string;
+    providerPath: string;
+    provider: string;
+    contentType: "skill" | "agent" | "rule";
+    strategy: "symlink" | "copy";
+    contentHash: string | null;
+    isFile: boolean;
+    lastSynced: string;
+}, {
+    canonicalPath: string;
+    providerPath: string;
+    provider: string;
+    contentType: "skill" | "agent" | "rule";
+    strategy: "symlink" | "copy";
+    contentHash: string | null;
+    lastSynced: string;
+    isFile?: boolean | undefined;
+}>, {
+    canonicalPath: string;
+    providerPath: string;
+    provider: string;
+    contentType: "skill" | "agent" | "rule";
+    strategy: "symlink" | "copy";
+    contentHash: string | null;
+    isFile: boolean;
+    lastSynced: string;
+}, {
+    canonicalPath: string;
+    providerPath: string;
+    provider: string;
+    contentType: "skill" | "agent" | "rule";
+    strategy: "symlink" | "copy";
+    contentHash: string | null;
+    lastSynced: string;
+    isFile?: boolean | undefined;
+}>;
+export declare const ManifestSchema: z.ZodEffects<z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    oatVersion: z.ZodString;
+    entries: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        canonicalPath: z.ZodEffects<z.ZodString, string, string>;
+        providerPath: z.ZodEffects<z.ZodString, string, string>;
+        provider: z.ZodString;
+        contentType: z.ZodEnum<["skill", "agent", "rule"]>;
+        strategy: z.ZodEnum<["symlink", "copy"]>;
+        contentHash: z.ZodNullable<z.ZodString>;
+        isFile: z.ZodDefault<z.ZodBoolean>;
+        lastSynced: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        canonicalPath: string;
+        providerPath: string;
+        provider: string;
+        contentType: "skill" | "agent" | "rule";
+        strategy: "symlink" | "copy";
+        contentHash: string | null;
+        isFile: boolean;
+        lastSynced: string;
+    }, {
+        canonicalPath: string;
+        providerPath: string;
+        provider: string;
+        contentType: "skill" | "agent" | "rule";
+        strategy: "symlink" | "copy";
+        contentHash: string | null;
+        lastSynced: string;
+        isFile?: boolean | undefined;
+    }>, {
+        canonicalPath: string;
+        providerPath: string;
+        provider: string;
+        contentType: "skill" | "agent" | "rule";
+        strategy: "symlink" | "copy";
+        contentHash: string | null;
+        isFile: boolean;
+        lastSynced: string;
+    }, {
+        canonicalPath: string;
+        providerPath: string;
+        provider: string;
+        contentType: "skill" | "agent" | "rule";
+        strategy: "symlink" | "copy";
+        contentHash: string | null;
+        lastSynced: string;
+        isFile?: boolean | undefined;
+    }>, "many">;
+    lastUpdated: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        canonicalPath: string;
+        providerPath: string;
+        provider: string;
+        contentType: "skill" | "agent" | "rule";
+        strategy: "symlink" | "copy";
+        contentHash: string | null;
+        isFile: boolean;
+        lastSynced: string;
+    }[];
+    version: 1;
+    oatVersion: string;
+    lastUpdated: string;
+}, {
+    entries: {
+        canonicalPath: string;
+        providerPath: string;
+        provider: string;
+        contentType: "skill" | "agent" | "rule";
+        strategy: "symlink" | "copy";
+        contentHash: string | null;
+        lastSynced: string;
+        isFile?: boolean | undefined;
+    }[];
+    version: 1;
+    oatVersion: string;
+    lastUpdated: string;
+}>, {
+    entries: {
+        canonicalPath: string;
+        providerPath: string;
+        provider: string;
+        contentType: "skill" | "agent" | "rule";
+        strategy: "symlink" | "copy";
+        contentHash: string | null;
+        isFile: boolean;
+        lastSynced: string;
+    }[];
+    version: 1;
+    oatVersion: string;
+    lastUpdated: string;
+}, {
+    entries: {
+        canonicalPath: string;
+        providerPath: string;
+        provider: string;
+        contentType: "skill" | "agent" | "rule";
+        strategy: "symlink" | "copy";
+        contentHash: string | null;
+        lastSynced: string;
+        isFile?: boolean | undefined;
+    }[];
+    version: 1;
+    oatVersion: string;
+    lastUpdated: string;
+}>;
+export type ManifestEntry = z.infer<typeof ManifestEntrySchema>;
+export type Manifest = z.infer<typeof ManifestSchema>;
+//# sourceMappingURL=manifest.types.d.ts.map

package/dist/manifest/manifest.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.types.d.ts","sourceRoot":"","sources":["../../src/manifest/manifest.types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B5B,CAAC;AAEL,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBvB,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/manifest/manifest.types.js

@@ -0,0 +1,56 @@
+import { ContentTypeSchema } from '../shared/types.js';
+import { z } from 'zod';
+const RelativePathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !value.startsWith('/') && !value.startsWith('~'), 'Path must be relative');
+export const ManifestEntrySchema = z
+    .object({
+    canonicalPath: RelativePathSchema,
+    providerPath: RelativePathSchema,
+    provider: z.string().min(1),
+    contentType: ContentTypeSchema,
+    strategy: z.enum(['symlink', 'copy']),
+    contentHash: z.string().nullable(),
+    isFile: z.boolean().default(false),
+    lastSynced: z.string().datetime(),
+})
+    .superRefine((entry, ctx) => {
+    if (entry.strategy === 'copy' && entry.contentHash === null) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'copy strategy requires non-null contentHash',
+            path: ['contentHash'],
+        });
+    }
+    if (entry.strategy === 'symlink' && entry.contentHash !== null) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'symlink strategy requires null contentHash',
+            path: ['contentHash'],
+        });
+    }
+});
+export const ManifestSchema = z
+    .object({
+    version: z.literal(1),
+    oatVersion: z.string().min(1),
+    entries: z.array(ManifestEntrySchema),
+    lastUpdated: z.string().datetime(),
+})
+    .superRefine((manifest, ctx) => {
+    const seen = new Set();
+    for (const [index, entry] of manifest.entries.entries()) {
+        const key = `${entry.canonicalPath}::${entry.provider}`;
+        if (seen.has(key)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'duplicate (canonicalPath, provider) pair',
+                path: ['entries', index],
+            });
+        }
+        else {
+            seen.add(key);
+        }
+    }
+});

package/dist/providers/claude/adapter.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderAdapter } from '../shared/adapter.types.js';
+export declare const claudeAdapter: ProviderAdapter;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/providers/claude/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/adapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAavE,eAAO,MAAM,aAAa,EAAE,eAO3B,CAAC"}

package/dist/providers/claude/adapter.js

@@ -0,0 +1,20 @@
+import { access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CLAUDE_PROJECT_MAPPINGS, CLAUDE_USER_MAPPINGS } from './paths.js';
+async function detectClaude(scopeRoot) {
+    try {
+        await access(join(scopeRoot, '.claude'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const claudeAdapter = {
+    name: 'claude',
+    displayName: 'Claude Code',
+    defaultStrategy: 'symlink',
+    projectMappings: CLAUDE_PROJECT_MAPPINGS,
+    userMappings: CLAUDE_USER_MAPPINGS,
+    detect: detectClaude,
+};

package/dist/providers/claude/index.d.ts

@@ -0,0 +1,3 @@
+export { claudeAdapter } from './adapter.js';
+export { CLAUDE_PROJECT_MAPPINGS, CLAUDE_USER_MAPPINGS } from './paths.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/claude/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC"}

package/dist/providers/claude/index.js

@@ -0,0 +1,2 @@
+export { claudeAdapter } from './adapter.js';
+export { CLAUDE_PROJECT_MAPPINGS, CLAUDE_USER_MAPPINGS } from './paths.js';

package/dist/providers/claude/paths.d.ts

@@ -0,0 +1,4 @@
+import type { PathMapping } from '../shared/adapter.types.js';
+export declare const CLAUDE_PROJECT_MAPPINGS: PathMapping[];
+export declare const CLAUDE_USER_MAPPINGS: PathMapping[];
+//# sourceMappingURL=paths.d.ts.map

package/dist/providers/claude/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAOnE,eAAO,MAAM,uBAAuB,EAAE,WAAW,EAsBhD,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,WAAW,EAa7C,CAAC"}

package/dist/providers/claude/paths.js

@@ -0,0 +1,38 @@
+import { parseClaudeRuleToCanonical, transformCanonicalToClaudeRule, } from './rule-transform.js';
+export const CLAUDE_PROJECT_MAPPINGS = [
+    {
+        contentType: 'skill',
+        canonicalDir: '.agents/skills',
+        providerDir: '.claude/skills',
+        nativeRead: false,
+    },
+    {
+        contentType: 'agent',
+        canonicalDir: '.agents/agents',
+        providerDir: '.claude/agents',
+        nativeRead: false,
+    },
+    {
+        contentType: 'rule',
+        canonicalDir: '.agents/rules',
+        providerDir: '.claude/rules',
+        nativeRead: false,
+        providerExtension: '.md',
+        transformCanonical: transformCanonicalToClaudeRule,
+        parseToCanonical: parseClaudeRuleToCanonical,
+    },
+];
+export const CLAUDE_USER_MAPPINGS = [
+    {
+        contentType: 'skill',
+        canonicalDir: '.agents/skills',
+        providerDir: '.claude/skills',
+        nativeRead: false,
+    },
+    {
+        contentType: 'agent',
+        canonicalDir: '.agents/agents',
+        providerDir: '.claude/agents',
+        nativeRead: false,
+    },
+];

package/dist/providers/claude/rule-transform.d.ts

@@ -0,0 +1,3 @@
+export declare function transformCanonicalToClaudeRule(canonicalContent: string, canonicalPath?: string): string;
+export declare function parseClaudeRuleToCanonical(providerContent: string): string;
+//# sourceMappingURL=rule-transform.d.ts.map

package/dist/providers/claude/rule-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-transform.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/rule-transform.ts"],"names":[],"mappings":"AAoBA,wBAAgB,8BAA8B,CAC5C,gBAAgB,EAAE,MAAM,EACxB,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CASR;AAED,wBAAgB,0BAA0B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAW1E"}

package/dist/providers/claude/rule-transform.js

@@ -0,0 +1,22 @@
+import { appendGeneratedMarker, parseCanonicalRuleMarkdown, parseMarkdownFrontmatter, renderCanonicalRuleMarkdown, renderMarkdownWithFrontmatter, } from '../../rules/canonical/index.js';
+function parsePaths(value) {
+    if (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((path) => typeof path === 'string' && path.trim() !== '')) {
+        return value.map((path) => path.trim());
+    }
+    return undefined;
+}
+export function transformCanonicalToClaudeRule(canonicalContent, canonicalPath) {
+    const rule = parseCanonicalRuleMarkdown(canonicalContent);
+    const frontmatter = rule.activation === 'glob' && rule.globs ? { paths: rule.globs } : null;
+    return appendGeneratedMarker(renderMarkdownWithFrontmatter(frontmatter, rule.body), canonicalPath);
+}
+export function parseClaudeRuleToCanonical(providerContent) {
+    const { frontmatter, body } = parseMarkdownFrontmatter(providerContent);
+    const globs = parsePaths(frontmatter?.paths);
+    return renderCanonicalRuleMarkdown({
+        ...(globs ? { globs } : {}),
+        activation: globs ? 'glob' : 'always',
+    }, body);
+}

package/dist/providers/codex/adapter.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderAdapter } from '../shared/adapter.types.js';
+export declare const codexAdapter: ProviderAdapter;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/providers/codex/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/adapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAavE,eAAO,MAAM,YAAY,EAAE,eAO1B,CAAC"}

package/dist/providers/codex/adapter.js

@@ -0,0 +1,20 @@
+import { access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CODEX_PROJECT_MAPPINGS, CODEX_USER_MAPPINGS } from './paths.js';
+async function detectCodex(scopeRoot) {
+    try {
+        await access(join(scopeRoot, '.codex'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const codexAdapter = {
+    name: 'codex',
+    displayName: 'Codex CLI',
+    defaultStrategy: 'auto',
+    projectMappings: CODEX_PROJECT_MAPPINGS,
+    userMappings: CODEX_USER_MAPPINGS,
+    detect: detectCodex,
+};

package/dist/providers/codex/codec/config-merge.d.ts

@@ -0,0 +1,17 @@
+export interface CodexManagedRoleConfig {
+    roleName: string;
+    description: string;
+    configFile: string;
+}
+export interface CodexConfigMergeArgs {
+    existingContent: string | null;
+    desiredRoles: CodexManagedRoleConfig[];
+    staleManagedRoles?: string[];
+}
+export interface CodexConfigMergeResult {
+    mergedContent: string;
+    changed: boolean;
+    removedRoles: string[];
+}
+export declare function mergeCodexConfig({ existingContent, desiredRoles, staleManagedRoles, }: CodexConfigMergeArgs): CodexConfigMergeResult;
+//# sourceMappingURL=config-merge.d.ts.map

package/dist/providers/codex/codec/config-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-merge.d.ts","sourceRoot":"","sources":["../../../../src/providers/codex/codec/config-merge.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,YAAY,EAAE,sBAAsB,EAAE,CAAC;IACvC,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAiCD,wBAAgB,gBAAgB,CAAC,EAC/B,eAAe,EACf,YAAY,EACZ,iBAAsB,GACvB,EAAE,oBAAoB,GAAG,sBAAsB,CAsC/C"}