@open-agent-toolkit/cli 0.0.10

package/dist/providers/codex/codec/config-merge.js

@@ -0,0 +1,61 @@
+import { CliError } from '../../../errors/index.js';
+import TOML from '@iarna/toml';
+import { stringifyToml } from './shared.js';
+function parseConfig(content) {
+    if (!content || content.trim() === '') {
+        return {};
+    }
+    try {
+        const parsed = TOML.parse(content);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new CliError('Codex config TOML must parse to an object.');
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        throw new CliError(`Failed to parse .codex/config.toml: ${error instanceof Error ? error.message : 'unknown parse error'}`);
+    }
+}
+function getObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return { ...value };
+}
+export function mergeCodexConfig({ existingContent, desiredRoles, staleManagedRoles = [], }) {
+    const parsed = parseConfig(existingContent);
+    const features = getObject(parsed.features);
+    const agents = getObject(parsed.agents);
+    const nextConfig = {
+        ...parsed,
+        features: {
+            ...features,
+            multi_agent: true,
+        },
+        agents,
+    };
+    for (const role of desiredRoles) {
+        agents[role.roleName] = {
+            ...getObject(agents[role.roleName]),
+            description: role.description,
+            config_file: role.configFile,
+        };
+    }
+    const removedRoles = [];
+    for (const staleRole of staleManagedRoles) {
+        if (staleRole in agents) {
+            delete agents[staleRole];
+            removedRoles.push(staleRole);
+        }
+    }
+    const mergedContent = stringifyToml(nextConfig);
+    const changed = (existingContent ?? '').trimEnd() !== mergedContent.trimEnd();
+    return {
+        mergedContent,
+        changed,
+        removedRoles,
+    };
+}

package/dist/providers/codex/codec/export-to-codex.d.ts

@@ -0,0 +1,9 @@
+import type { CanonicalAgentDocument } from '../../../agents/canonical/index.js';
+export interface CodexRoleExport {
+    roleName: string;
+    description: string;
+    configFile: string;
+    content: string;
+}
+export declare function exportCanonicalAgentToCodexRole(agent: CanonicalAgentDocument): CodexRoleExport;
+//# sourceMappingURL=export-to-codex.d.ts.map

package/dist/providers/codex/codec/export-to-codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-to-codex.d.ts","sourceRoot":"","sources":["../../../../src/providers/codex/codec/export-to-codex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAShE,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAgCD,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,sBAAsB,GAC5B,eAAe,CA2BjB"}

package/dist/providers/codex/codec/export-to-codex.js

@@ -0,0 +1,45 @@
+import { CliError } from '../../../errors/index.js';
+import { sanitizeCodexRoleName, stringifyToml, withOatManagedCodexHeader, } from './shared.js';
+function resolveSandboxMode(agent) {
+    const codexExtension = agent.extensions.x_codex;
+    if (codexExtension &&
+        typeof codexExtension === 'object' &&
+        codexExtension !== null &&
+        'sandbox_mode' in codexExtension &&
+        typeof codexExtension.sandbox_mode === 'string') {
+        return codexExtension.sandbox_mode;
+    }
+    if (agent.readonly === true) {
+        return 'read-only';
+    }
+    return 'workspace-write';
+}
+function codexExtensionMap(agent) {
+    const extension = agent.extensions.x_codex;
+    if (!extension || typeof extension !== 'object' || Array.isArray(extension)) {
+        return {};
+    }
+    return { ...extension };
+}
+export function exportCanonicalAgentToCodexRole(agent) {
+    const roleName = sanitizeCodexRoleName(agent.name);
+    if (!roleName) {
+        throw new CliError('Cannot export Codex role: missing canonical agent name.');
+    }
+    const extension = codexExtensionMap(agent);
+    const roleObject = {
+        ...extension,
+        developer_instructions: agent.body,
+        sandbox_mode: resolveSandboxMode(agent),
+    };
+    if (agent.model && typeof roleObject.model !== 'string') {
+        roleObject.model = agent.model;
+    }
+    const tomlBody = stringifyToml(roleObject);
+    return {
+        roleName,
+        description: agent.description,
+        configFile: `agents/${roleName}.toml`,
+        content: withOatManagedCodexHeader(roleName, tomlBody),
+    };
+}

package/dist/providers/codex/codec/import-from-codex.d.ts

@@ -0,0 +1,9 @@
+import { type CanonicalAgentDocument } from '../../../agents/canonical/index.js';
+export interface CodexRoleImportArgs {
+    roleName: string;
+    roleContent: string;
+    description?: string;
+    tools?: string;
+}
+export declare function importCanonicalAgentFromCodexRole({ roleName, roleContent, description, tools, }: CodexRoleImportArgs): CanonicalAgentDocument;
+//# sourceMappingURL=import-from-codex.d.ts.map

package/dist/providers/codex/codec/import-from-codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-from-codex.d.ts","sourceRoot":"","sources":["../../../../src/providers/codex/codec/import-from-codex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,mBAAmB,CAAC;AAyC3B,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,iCAAiC,CAAC,EAChD,QAAQ,EACR,WAAW,EACX,WAAW,EACX,KAAK,GACN,EAAE,mBAAmB,GAAG,sBAAsB,CA4B9C"}

package/dist/providers/codex/codec/import-from-codex.js

@@ -0,0 +1,52 @@
+import { parseCanonicalAgentMarkdown, } from '../../../agents/canonical/index.js';
+import { CliError } from '../../../errors/index.js';
+import TOML from '@iarna/toml';
+import YAML from 'yaml';
+import { sanitizeCodexRoleName } from './shared.js';
+const DEFAULT_CANONICAL_TOOLS = 'Read, Grep, Glob, Bash';
+function parseCodexRoleToml(roleContent) {
+    try {
+        const parsed = TOML.parse(roleContent);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new CliError('Codex role TOML must parse to an object.');
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        throw new CliError(`Failed to parse Codex role TOML: ${error instanceof Error ? error.message : 'unknown parse error'}`);
+    }
+}
+function pickCodexExtension(role) {
+    const extension = { ...role };
+    delete extension.developer_instructions;
+    return extension;
+}
+function renderMarkdown(frontmatter, body) {
+    return `---\n${YAML.stringify(frontmatter).trimEnd()}\n---\n\n${body}`;
+}
+export function importCanonicalAgentFromCodexRole({ roleName, roleContent, description, tools, }) {
+    const normalizedRoleName = sanitizeCodexRoleName(roleName);
+    const parsed = parseCodexRoleToml(roleContent);
+    const instructions = typeof parsed.developer_instructions === 'string'
+        ? parsed.developer_instructions
+        : '';
+    const extension = pickCodexExtension(parsed);
+    const frontmatter = {
+        name: normalizedRoleName,
+        description: description && description.trim().length > 0
+            ? description
+            : `Imported from Codex role ${normalizedRoleName}`,
+        tools: tools ?? DEFAULT_CANONICAL_TOOLS,
+    };
+    if (parsed.sandbox_mode === 'read-only') {
+        frontmatter.readonly = true;
+    }
+    if (Object.keys(extension).length > 0) {
+        frontmatter.x_codex = extension;
+    }
+    const markdown = renderMarkdown(frontmatter, instructions);
+    return parseCanonicalAgentMarkdown(markdown, `codex:${normalizedRoleName}`);
+}

package/dist/providers/codex/codec/shared.d.ts

@@ -0,0 +1,7 @@
+export declare const OAT_MANAGED_ROLE_HEADER = "# oat-managed: true";
+export declare const OAT_MANAGED_ROLE_NAME_PREFIX = "# oat-role: ";
+export declare function sanitizeCodexRoleName(input: string): string;
+export declare function isOatManagedCodexRoleFile(content: string, roleName?: string): boolean;
+export declare function withOatManagedCodexHeader(roleName: string, tomlBody: string): string;
+export declare function stringifyToml(object: Record<string, unknown>): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/providers/codex/codec/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/providers/codex/codec/shared.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAC7D,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAE3D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAUT;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAErE"}

package/dist/providers/codex/codec/shared.js

@@ -0,0 +1,21 @@
+import TOML from '@iarna/toml';
+export const OAT_MANAGED_ROLE_HEADER = '# oat-managed: true';
+export const OAT_MANAGED_ROLE_NAME_PREFIX = '# oat-role: ';
+export function sanitizeCodexRoleName(input) {
+    return input.trim().replace(/\.md$/i, '');
+}
+export function isOatManagedCodexRoleFile(content, roleName) {
+    if (!content.includes(OAT_MANAGED_ROLE_HEADER)) {
+        return false;
+    }
+    if (!roleName) {
+        return true;
+    }
+    return content.includes(`${OAT_MANAGED_ROLE_NAME_PREFIX}${roleName}`);
+}
+export function withOatManagedCodexHeader(roleName, tomlBody) {
+    return `${OAT_MANAGED_ROLE_HEADER}\n${OAT_MANAGED_ROLE_NAME_PREFIX}${roleName}\n${tomlBody}`;
+}
+export function stringifyToml(object) {
+    return TOML.stringify(object);
+}

package/dist/providers/codex/codec/sync-extension.d.ts

@@ -0,0 +1,32 @@
+import type { CanonicalEntry } from '../../../engine/index.js';
+export type CodexExtensionAction = 'create' | 'update' | 'remove' | 'skip';
+export type CodexExtensionTarget = 'role' | 'config';
+export interface CodexExtensionOperation {
+    action: CodexExtensionAction;
+    target: CodexExtensionTarget;
+    path: string;
+    reason: string;
+    roleName?: string;
+}
+export interface CodexExtensionWriteOperation extends CodexExtensionOperation {
+    content?: string;
+}
+export interface CodexExtensionPlan {
+    operations: CodexExtensionWriteOperation[];
+    managedRoles: string[];
+    aggregateConfigHash: string;
+}
+export interface CodexExtensionApplyResult {
+    applied: number;
+    failed: number;
+    skipped: number;
+}
+export declare function computeCodexProjectExtensionPlan(scopeRoot: string, canonicalEntries: CanonicalEntry[]): Promise<CodexExtensionPlan>;
+export declare function applyCodexProjectExtensionPlan(scopeRoot: string, plan: CodexExtensionPlan): Promise<CodexExtensionApplyResult>;
+export declare function hasCodexExtensionChanges(plan: CodexExtensionPlan): boolean;
+export declare function summarizeCodexExtension(plan: CodexExtensionPlan): {
+    plannedOperations: number;
+    skipped: number;
+};
+export declare function toCodexExtensionOperations(plan: CodexExtensionPlan): CodexExtensionOperation[];
+//# sourceMappingURL=sync-extension.d.ts.map

package/dist/providers/codex/codec/sync-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-extension.d.ts","sourceRoot":"","sources":["../../../../src/providers/codex/codec/sync-extension.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAQpD,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAC3E,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAErD,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,MAAM,EAAE,oBAAoB,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,4BAA6B,SAAQ,uBAAuB;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,4BAA4B,EAAE,CAAC;IAC3C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAuID,wBAAsB,gCAAgC,CACpD,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,cAAc,EAAE,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAuG7B;AAED,wBAAsB,8BAA8B,CAClD,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,yBAAyB,CAAC,CA6BpC;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAE1E;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,kBAAkB,GAAG;IACjE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB,CAaA;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,kBAAkB,GACvB,uBAAuB,EAAE,CAQ3B"}

package/dist/providers/codex/codec/sync-extension.js

@@ -0,0 +1,227 @@
+import { createHash } from 'node:crypto';
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { parseCanonicalAgentFile } from '../../../agents/canonical/index.js';
+import { ensureDir, fileExists } from '../../../fs/io.js';
+import TOML from '@iarna/toml';
+import { mergeCodexConfig } from './config-merge.js';
+import { exportCanonicalAgentToCodexRole } from './export-to-codex.js';
+import { isOatManagedCodexRoleFile } from './shared.js';
+function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+function configPath(scopeRoot) {
+    return join(scopeRoot, '.codex', 'config.toml');
+}
+function toRelativePath(scopeRoot, absolutePath) {
+    return relative(scopeRoot, absolutePath).replaceAll('\\', '/');
+}
+async function readOptionalFile(path) {
+    if (!(await fileExists(path))) {
+        return null;
+    }
+    return readFile(path, 'utf8');
+}
+function normalizeManagedRolesConfig(desiredRoles) {
+    return desiredRoles.map((role) => ({
+        roleName: role.roleName,
+        description: role.description,
+        configFile: role.configFile,
+    }));
+}
+async function desiredRolesFromCanonical(canonicalEntries, scopeRoot) {
+    const roles = [];
+    for (const entry of canonicalEntries) {
+        if (entry.type !== 'agent' ||
+            !entry.isFile ||
+            !entry.name.endsWith('.md')) {
+            continue;
+        }
+        const parsed = await parseCanonicalAgentFile(entry.canonicalPath);
+        const exported = exportCanonicalAgentToCodexRole(parsed);
+        roles.push({
+            roleName: exported.roleName,
+            description: exported.description,
+            configFile: exported.configFile,
+            rolePath: join(scopeRoot, '.codex', exported.configFile),
+            content: exported.content,
+        });
+    }
+    return roles.sort((left, right) => left.roleName.localeCompare(right.roleName));
+}
+function parseConfigAgentTable(content) {
+    if (!content || content.trim() === '') {
+        return {};
+    }
+    try {
+        const parsed = TOML.parse(content);
+        const agents = parsed.agents;
+        if (!agents || typeof agents !== 'object' || Array.isArray(agents)) {
+            return {};
+        }
+        const normalized = {};
+        for (const [roleName, roleConfig] of Object.entries(agents)) {
+            if (!roleConfig ||
+                typeof roleConfig !== 'object' ||
+                Array.isArray(roleConfig)) {
+                continue;
+            }
+            normalized[roleName] = roleConfig;
+        }
+        return normalized;
+    }
+    catch {
+        return {};
+    }
+}
+async function collectStaleManagedRoles(scopeRoot, existingConfigContent, desiredRoleNames) {
+    const agents = parseConfigAgentTable(existingConfigContent);
+    const stale = [];
+    for (const [roleName, roleConfig] of Object.entries(agents)) {
+        if (desiredRoleNames.has(roleName)) {
+            continue;
+        }
+        const configFile = roleConfig.config_file;
+        if (typeof configFile !== 'string' || !configFile.startsWith('agents/')) {
+            continue;
+        }
+        const rolePath = join(scopeRoot, '.codex', configFile);
+        const roleContent = await readOptionalFile(rolePath);
+        if (!roleContent || !isOatManagedCodexRoleFile(roleContent, roleName)) {
+            continue;
+        }
+        stale.push(roleName);
+    }
+    return stale.sort((left, right) => left.localeCompare(right));
+}
+export async function computeCodexProjectExtensionPlan(scopeRoot, canonicalEntries) {
+    const desiredRoles = await desiredRolesFromCanonical(canonicalEntries, scopeRoot);
+    const desiredRoleNames = new Set(desiredRoles.map((role) => role.roleName));
+    const existingConfigPath = configPath(scopeRoot);
+    const existingConfigContent = await readOptionalFile(existingConfigPath);
+    const staleRoles = await collectStaleManagedRoles(scopeRoot, existingConfigContent, desiredRoleNames);
+    const operations = [];
+    for (const role of desiredRoles) {
+        const existingRoleContent = await readOptionalFile(role.rolePath);
+        if (existingRoleContent === null) {
+            operations.push({
+                action: 'create',
+                target: 'role',
+                path: toRelativePath(scopeRoot, role.rolePath),
+                reason: 'managed role file missing',
+                roleName: role.roleName,
+                content: role.content,
+            });
+            continue;
+        }
+        if (existingRoleContent.trimEnd() !== role.content.trimEnd()) {
+            operations.push({
+                action: 'update',
+                target: 'role',
+                path: toRelativePath(scopeRoot, role.rolePath),
+                reason: 'managed role file differs from canonical export',
+                roleName: role.roleName,
+                content: role.content,
+            });
+            continue;
+        }
+        operations.push({
+            action: 'skip',
+            target: 'role',
+            path: toRelativePath(scopeRoot, role.rolePath),
+            reason: 'managed role file already in sync',
+            roleName: role.roleName,
+        });
+    }
+    for (const staleRole of staleRoles) {
+        const staleRolePath = join(scopeRoot, '.codex', 'agents', `${staleRole}.toml`);
+        const staleRoleContent = await readOptionalFile(staleRolePath);
+        if (staleRoleContent &&
+            isOatManagedCodexRoleFile(staleRoleContent, staleRole)) {
+            operations.push({
+                action: 'remove',
+                target: 'role',
+                path: toRelativePath(scopeRoot, staleRolePath),
+                reason: 'stale managed role removed',
+                roleName: staleRole,
+            });
+        }
+    }
+    const configMerge = mergeCodexConfig({
+        existingContent: existingConfigContent,
+        desiredRoles: normalizeManagedRolesConfig(desiredRoles),
+        staleManagedRoles: staleRoles,
+    });
+    operations.push({
+        action: existingConfigContent === null
+            ? 'create'
+            : configMerge.changed
+                ? 'update'
+                : 'skip',
+        target: 'config',
+        path: '.codex/config.toml',
+        reason: existingConfigContent === null
+            ? 'codex config missing'
+            : configMerge.changed
+                ? 'codex config differs from desired managed state'
+                : 'codex config already in sync',
+        content: configMerge.mergedContent,
+    });
+    return {
+        operations,
+        managedRoles: desiredRoles.map((role) => role.roleName),
+        aggregateConfigHash: hashContent(configMerge.mergedContent),
+    };
+}
+export async function applyCodexProjectExtensionPlan(scopeRoot, plan) {
+    const result = {
+        applied: 0,
+        failed: 0,
+        skipped: 0,
+    };
+    for (const operation of plan.operations) {
+        if (operation.action === 'skip') {
+            result.skipped += 1;
+            continue;
+        }
+        const absolutePath = resolve(scopeRoot, operation.path);
+        try {
+            if (operation.action === 'remove') {
+                await rm(absolutePath, { recursive: true, force: true });
+            }
+            else {
+                await ensureDir(dirname(absolutePath));
+                await writeFile(absolutePath, operation.content ?? '', 'utf8');
+            }
+            result.applied += 1;
+        }
+        catch {
+            result.failed += 1;
+        }
+    }
+    return result;
+}
+export function hasCodexExtensionChanges(plan) {
+    return plan.operations.some((operation) => operation.action !== 'skip');
+}
+export function summarizeCodexExtension(plan) {
+    let plannedOperations = 0;
+    let skipped = 0;
+    for (const operation of plan.operations) {
+        if (operation.action === 'skip') {
+            skipped += 1;
+            continue;
+        }
+        plannedOperations += 1;
+    }
+    return { plannedOperations, skipped };
+}
+export function toCodexExtensionOperations(plan) {
+    return plan.operations.map((operation) => ({
+        action: operation.action,
+        target: operation.target,
+        path: operation.path,
+        reason: operation.reason,
+        roleName: operation.roleName,
+    }));
+}

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

@@ -0,0 +1,6 @@
+export { codexAdapter } from './adapter.js';
+export { mergeCodexConfig } from './codec/config-merge.js';
+export { exportCanonicalAgentToCodexRole } from './codec/export-to-codex.js';
+export { importCanonicalAgentFromCodexRole } from './codec/import-from-codex.js';
+export { CODEX_PROJECT_MAPPINGS, CODEX_USER_MAPPINGS } from './paths.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,iCAAiC,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC"}

package/dist/providers/codex/index.js

@@ -0,0 +1,5 @@
+export { codexAdapter } from './adapter.js';
+export { mergeCodexConfig } from './codec/config-merge.js';
+export { exportCanonicalAgentToCodexRole } from './codec/export-to-codex.js';
+export { importCanonicalAgentFromCodexRole } from './codec/import-from-codex.js';
+export { CODEX_PROJECT_MAPPINGS, CODEX_USER_MAPPINGS } from './paths.js';

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,eAAO,MAAM,sBAAsB,EAAE,WAAW,EAa/C,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,WAAW,EAa5C,CAAC"}

package/dist/providers/codex/paths.js

@@ -0,0 +1,28 @@
+export const CODEX_PROJECT_MAPPINGS = [
+    {
+        contentType: 'skill',
+        canonicalDir: '.agents/skills',
+        providerDir: '.agents/skills',
+        nativeRead: true,
+    },
+    {
+        contentType: 'agent',
+        canonicalDir: '.agents/agents',
+        providerDir: '.agents/agents',
+        nativeRead: true,
+    },
+];
+export const CODEX_USER_MAPPINGS = [
+    {
+        contentType: 'skill',
+        canonicalDir: '.agents/skills',
+        providerDir: '.agents/skills',
+        nativeRead: true,
+    },
+    {
+        contentType: 'agent',
+        canonicalDir: '.agents/agents',
+        providerDir: '.agents/agents',
+        nativeRead: true,
+    },
+];

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

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

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

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

package/dist/providers/copilot/adapter.js

@@ -0,0 +1,30 @@
+import { access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { COPILOT_PROJECT_MAPPINGS, COPILOT_USER_MAPPINGS } from './paths.js';
+async function detectCopilot(scopeRoot) {
+    const markers = [
+        join(scopeRoot, '.copilot'),
+        join(scopeRoot, '.github', 'copilot-instructions.md'),
+        join(scopeRoot, '.github', 'agents'),
+        join(scopeRoot, '.github', 'skills'),
+        join(scopeRoot, '.github', 'instructions'),
+    ];
+    for (const marker of markers) {
+        try {
+            await access(marker);
+            return true;
+        }
+        catch {
+            // continue to next marker
+        }
+    }
+    return false;
+}
+export const copilotAdapter = {
+    name: 'copilot',
+    displayName: 'GitHub Copilot',
+    defaultStrategy: 'symlink',
+    projectMappings: COPILOT_PROJECT_MAPPINGS,
+    userMappings: COPILOT_USER_MAPPINGS,
+    detect: detectCopilot,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/copilot/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC"}

package/dist/providers/copilot/index.js

@@ -0,0 +1,2 @@
+export { copilotAdapter } from './adapter.js';
+export { COPILOT_PROJECT_MAPPINGS, COPILOT_USER_MAPPINGS } from './paths.js';

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/providers/copilot/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAOnE,eAAO,MAAM,wBAAwB,EAAE,WAAW,EAsBjD,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,WAAW,EAa9C,CAAC"}

package/dist/providers/copilot/paths.js

@@ -0,0 +1,38 @@
+import { parseCopilotRuleToCanonical, transformCanonicalToCopilotRule, } from './rule-transform.js';
+export const COPILOT_PROJECT_MAPPINGS = [
+    {
+        contentType: 'skill',
+        canonicalDir: '.agents/skills',
+        providerDir: '.github/skills',
+        nativeRead: false,
+    },
+    {
+        contentType: 'agent',
+        canonicalDir: '.agents/agents',
+        providerDir: '.github/agents',
+        nativeRead: false,
+    },
+    {
+        contentType: 'rule',
+        canonicalDir: '.agents/rules',
+        providerDir: '.github/instructions',
+        nativeRead: false,
+        providerExtension: '.instructions.md',
+        transformCanonical: transformCanonicalToCopilotRule,
+        parseToCanonical: parseCopilotRuleToCanonical,
+    },
+];
+export const COPILOT_USER_MAPPINGS = [
+    {
+        contentType: 'skill',
+        canonicalDir: '.agents/skills',
+        providerDir: '.copilot/skills',
+        nativeRead: false,
+    },
+    {
+        contentType: 'agent',
+        canonicalDir: '.agents/agents',
+        providerDir: '.copilot/agents',
+        nativeRead: false,
+    },
+];

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-transform.d.ts","sourceRoot":"","sources":["../../../src/providers/copilot/rule-transform.ts"],"names":[],"mappings":"AAkDA,wBAAgB,+BAA+B,CAC7C,gBAAgB,EAAE,MAAM,EACxB,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CAqBR;AAED,wBAAgB,2BAA2B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAa3E"}