@webpresso/agent-kit 0.21.0

package/dist/esm/codex/app-server/client.d.ts

@@ -0,0 +1,50 @@
+import { type CodexAppServerApi, type ConfigBatchWriteParams, type ConfigBatchWriteResponse, type HooksListResponse } from './types.js';
+interface ChildProcessLike {
+    readonly stdin: {
+        write(chunk: string, callback?: (error?: Error | null) => void): boolean;
+        end(chunk?: string, callback?: () => void): void;
+        on?(event: 'error', listener: (error: Error) => void): unknown;
+    };
+    readonly stdout: NodeJS.ReadableStream;
+    readonly stderr?: NodeJS.ReadableStream | null;
+    kill(signal?: NodeJS.Signals | number): boolean;
+    on(event: 'error', listener: (error: Error) => void): this;
+    on(event: 'close', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+}
+type SpawnLike = (command: string, args: readonly string[], options: {
+    cwd?: string;
+    stdio: ['pipe', 'pipe', 'pipe'];
+}) => ChildProcessLike;
+export interface CodexAppServerClientOptions {
+    readonly command?: string;
+    readonly cwd?: string;
+    readonly spawn?: SpawnLike;
+    readonly timeoutMs?: number;
+}
+export declare class CodexAppServerClient implements CodexAppServerApi {
+    private readonly child;
+    private readonly timeoutMs;
+    private readonly pending;
+    private readonly ready;
+    private nextId;
+    private stdoutBuffer;
+    private stderrBuffer;
+    private closed;
+    private fatalError;
+    private constructor();
+    static start(options?: CodexAppServerClientOptions): Promise<CodexAppServerClient>;
+    hooksList(cwds: string[]): Promise<HooksListResponse>;
+    configBatchWrite(params: ConfigBatchWriteParams): Promise<ConfigBatchWriteResponse>;
+    close(): Promise<void>;
+    private attachListeners;
+    private drainStdoutBuffer;
+    private handleStdoutLine;
+    private initialize;
+    private notify;
+    private request;
+    private decorateErrorMessage;
+    private failTransport;
+    private rejectAll;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/esm/codex/app-server/client.js

@@ -0,0 +1,202 @@
+import { spawn } from 'node:child_process';
+import { ConfigBatchWriteParamsSchema, ConfigBatchWriteResponseSchema, HooksListResponseSchema, JsonRpcErrorSchema, } from './types.js';
+const DEFAULT_PROTOCOL_VERSION = '2025-09-22';
+const DEFAULT_TIMEOUT_MS = 5_000;
+const STDERR_TAIL_LIMIT = 400;
+export class CodexAppServerClient {
+    child;
+    timeoutMs;
+    pending = new Map();
+    ready;
+    nextId = 1;
+    stdoutBuffer = '';
+    stderrBuffer = '';
+    closed = false;
+    fatalError = null;
+    constructor(child, timeoutMs) {
+        this.child = child;
+        this.timeoutMs = timeoutMs;
+        this.attachListeners();
+        this.ready = this.initialize();
+    }
+    static async start(options = {}) {
+        const spawnProcess = options.spawn ?? defaultSpawn;
+        const child = spawnProcess(options.command ?? 'codex', ['app-server', '--listen', 'stdio://'], {
+            cwd: options.cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const client = new CodexAppServerClient(child, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        await client.ready;
+        return client;
+    }
+    async hooksList(cwds) {
+        await this.ready;
+        return this.request('hooks/list', { cwds }, HooksListResponseSchema.parse);
+    }
+    async configBatchWrite(params) {
+        await this.ready;
+        const validatedParams = ConfigBatchWriteParamsSchema.parse(params);
+        return this.request('config/batchWrite', validatedParams, ConfigBatchWriteResponseSchema.parse);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const waitForClose = new Promise((resolve) => {
+            this.child.on('close', () => resolve());
+        });
+        this.child.stdin.end();
+        this.child.kill('SIGTERM');
+        this.rejectAll(new Error('Codex app-server client closed before response'));
+        await waitForClose.catch(() => undefined);
+    }
+    attachListeners() {
+        this.child.stdout.on('data', (chunk) => {
+            this.stdoutBuffer += String(chunk);
+            this.drainStdoutBuffer();
+        });
+        this.child.stdout.on('end', () => {
+            this.failTransport(new Error('Codex app-server stdout closed before response'));
+        });
+        this.child.stderr?.on('data', (chunk) => {
+            this.stderrBuffer = `${this.stderrBuffer}${String(chunk)}`.slice(-STDERR_TAIL_LIMIT);
+        });
+        // stdin EPIPE — surface as a transport failure rather than letting Node's
+        // default error handler bubble it up as an uncaught exception when the
+        // child exits before we finish writing the request line.
+        this.child.stdin.on?.('error', (error) => {
+            this.failTransport(new Error(`Codex app-server stdin error: ${error.message}`));
+        });
+        this.child.on('error', (error) => {
+            this.failTransport(new Error(`Codex app-server transport error: ${error.message}`));
+        });
+        this.child.on('close', (code, signal) => {
+            if (this.closed && this.pending.size === 0)
+                return;
+            const suffix = signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`;
+            this.failTransport(new Error(`Codex app-server exited before response (${suffix})`));
+        });
+    }
+    drainStdoutBuffer() {
+        let newlineIndex = this.stdoutBuffer.indexOf('\n');
+        while (newlineIndex !== -1) {
+            const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            if (line.length > 0)
+                this.handleStdoutLine(line);
+            newlineIndex = this.stdoutBuffer.indexOf('\n');
+        }
+    }
+    handleStdoutLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.failTransport(new Error(`Codex app-server emitted invalid JSON: ${line.slice(0, 120)}`));
+            return;
+        }
+        if (!('id' in parsed) || typeof parsed.id !== 'number')
+            return;
+        const pending = this.pending.get(parsed.id);
+        if (!pending)
+            return;
+        this.pending.delete(parsed.id);
+        clearTimeout(pending.timer);
+        if ('error' in parsed && parsed.error !== undefined) {
+            const error = JsonRpcErrorSchema.safeParse(parsed.error);
+            if (error.success) {
+                pending.reject(new Error(this.decorateErrorMessage(pending.method, `JSON-RPC error ${error.data.code}: ${error.data.message}`)));
+                return;
+            }
+            pending.reject(new Error(this.decorateErrorMessage(pending.method, 'JSON-RPC error response was invalid')));
+            return;
+        }
+        if (!('result' in parsed)) {
+            pending.reject(new Error(this.decorateErrorMessage(pending.method, 'Missing JSON-RPC result')));
+            return;
+        }
+        try {
+            pending.resolve(pending.parse(parsed.result));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            pending.reject(new Error(this.decorateErrorMessage(pending.method, `Invalid response payload: ${message}`)));
+        }
+    }
+    async initialize() {
+        await this.request('initialize', {
+            protocolVersion: DEFAULT_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: {
+                name: 'webpresso_agent_kit',
+                version: '0.0.0',
+            },
+        }, (_value) => undefined);
+        this.notify('initialized', {});
+    }
+    notify(method, params) {
+        if (this.fatalError)
+            throw this.fatalError;
+        this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`, (error) => {
+            if (error)
+                this.failTransport(new Error(this.decorateErrorMessage(method, error.message)));
+        });
+    }
+    request(method, params, parse) {
+        if (this.fatalError)
+            return Promise.reject(this.fatalError);
+        const id = this.nextId;
+        this.nextId += 1;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(this.decorateErrorMessage(method, `Timed out after ${this.timeoutMs}ms`)));
+            }, this.timeoutMs);
+            this.pending.set(id, {
+                method,
+                parse: (value) => parse(value),
+                resolve: (value) => resolve(value),
+                reject,
+                timer,
+            });
+            this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`, (error) => {
+                if (!error)
+                    return;
+                const pending = this.pending.get(id);
+                if (!pending)
+                    return;
+                this.pending.delete(id);
+                clearTimeout(timer);
+                reject(new Error(this.decorateErrorMessage(method, error.message)));
+            });
+        });
+    }
+    decorateErrorMessage(method, detail) {
+        const stderrTail = this.stderrBuffer.trim();
+        return stderrTail.length > 0
+            ? `${method} failed: ${detail}. stderr tail: ${stderrTail}`
+            : `${method} failed: ${detail}`;
+    }
+    failTransport(error) {
+        if (this.fatalError)
+            return;
+        this.fatalError = new Error(this.decorateErrorMessage('transport', error.message));
+        this.rejectAll(this.fatalError);
+    }
+    rejectAll(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(this.decorateErrorMessage(pending.method, error.message)));
+        }
+        this.pending.clear();
+    }
+}
+function defaultSpawn(command, args, options) {
+    const child = spawn(command, [...args], options);
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        throw new Error('Codex app-server requires piped stdin/stdout/stderr');
+    }
+    return child;
+}
+//# sourceMappingURL=client.js.map

package/dist/esm/codex/app-server/types.d.ts

@@ -0,0 +1,240 @@
+import { z } from 'zod';
+export declare const HookEventNameSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const HookHandlerTypeSchema: z.ZodEnum<{
+    command: "command";
+    agent: "agent";
+    prompt: "prompt";
+}>;
+export declare const HookSourceSchema: z.ZodEnum<{
+    unknown: "unknown";
+    system: "system";
+    user: "user";
+    plugin: "plugin";
+    project: "project";
+    mdm: "mdm";
+    sessionFlags: "sessionFlags";
+    cloudRequirements: "cloudRequirements";
+    legacyManagedConfigFile: "legacyManagedConfigFile";
+    legacyManagedConfigMdm: "legacyManagedConfigMdm";
+}>;
+export declare const HookTrustStatusSchema: z.ZodEnum<{
+    managed: "managed";
+    untrusted: "untrusted";
+    trusted: "trusted";
+    modified: "modified";
+}>;
+export declare const HookMetadataSchema: z.ZodObject<{
+    key: z.ZodString;
+    eventName: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    handlerType: z.ZodEnum<{
+        command: "command";
+        agent: "agent";
+        prompt: "prompt";
+    }>;
+    matcher: z.ZodNullable<z.ZodString>;
+    command: z.ZodNullable<z.ZodString>;
+    timeoutSec: z.ZodNumber;
+    statusMessage: z.ZodNullable<z.ZodString>;
+    sourcePath: z.ZodString;
+    source: z.ZodEnum<{
+        unknown: "unknown";
+        system: "system";
+        user: "user";
+        plugin: "plugin";
+        project: "project";
+        mdm: "mdm";
+        sessionFlags: "sessionFlags";
+        cloudRequirements: "cloudRequirements";
+        legacyManagedConfigFile: "legacyManagedConfigFile";
+        legacyManagedConfigMdm: "legacyManagedConfigMdm";
+    }>;
+    pluginId: z.ZodNullable<z.ZodString>;
+    displayOrder: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    isManaged: z.ZodBoolean;
+    currentHash: z.ZodString;
+    trustStatus: z.ZodEnum<{
+        managed: "managed";
+        untrusted: "untrusted";
+        trusted: "trusted";
+        modified: "modified";
+    }>;
+}, z.core.$strip>;
+export declare const CommandHookMetadataSchema: z.ZodObject<{
+    key: z.ZodString;
+    eventName: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    matcher: z.ZodNullable<z.ZodString>;
+    timeoutSec: z.ZodNumber;
+    statusMessage: z.ZodNullable<z.ZodString>;
+    sourcePath: z.ZodString;
+    source: z.ZodEnum<{
+        unknown: "unknown";
+        system: "system";
+        user: "user";
+        plugin: "plugin";
+        project: "project";
+        mdm: "mdm";
+        sessionFlags: "sessionFlags";
+        cloudRequirements: "cloudRequirements";
+        legacyManagedConfigFile: "legacyManagedConfigFile";
+        legacyManagedConfigMdm: "legacyManagedConfigMdm";
+    }>;
+    pluginId: z.ZodNullable<z.ZodString>;
+    displayOrder: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    isManaged: z.ZodBoolean;
+    currentHash: z.ZodString;
+    trustStatus: z.ZodEnum<{
+        managed: "managed";
+        untrusted: "untrusted";
+        trusted: "trusted";
+        modified: "modified";
+    }>;
+    handlerType: z.ZodLiteral<"command">;
+    command: z.ZodString;
+}, z.core.$strip>;
+export declare const HooksListEntrySchema: z.ZodObject<{
+    cwd: z.ZodString;
+    hooks: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        eventName: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        handlerType: z.ZodEnum<{
+            command: "command";
+            agent: "agent";
+            prompt: "prompt";
+        }>;
+        matcher: z.ZodNullable<z.ZodString>;
+        command: z.ZodNullable<z.ZodString>;
+        timeoutSec: z.ZodNumber;
+        statusMessage: z.ZodNullable<z.ZodString>;
+        sourcePath: z.ZodString;
+        source: z.ZodEnum<{
+            unknown: "unknown";
+            system: "system";
+            user: "user";
+            plugin: "plugin";
+            project: "project";
+            mdm: "mdm";
+            sessionFlags: "sessionFlags";
+            cloudRequirements: "cloudRequirements";
+            legacyManagedConfigFile: "legacyManagedConfigFile";
+            legacyManagedConfigMdm: "legacyManagedConfigMdm";
+        }>;
+        pluginId: z.ZodNullable<z.ZodString>;
+        displayOrder: z.ZodNumber;
+        enabled: z.ZodBoolean;
+        isManaged: z.ZodBoolean;
+        currentHash: z.ZodString;
+        trustStatus: z.ZodEnum<{
+            managed: "managed";
+            untrusted: "untrusted";
+            trusted: "trusted";
+            modified: "modified";
+        }>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodString>;
+    errors: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodString]>>;
+}, z.core.$strip>;
+export declare const HooksListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        cwd: z.ZodString;
+        hooks: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            eventName: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            handlerType: z.ZodEnum<{
+                command: "command";
+                agent: "agent";
+                prompt: "prompt";
+            }>;
+            matcher: z.ZodNullable<z.ZodString>;
+            command: z.ZodNullable<z.ZodString>;
+            timeoutSec: z.ZodNumber;
+            statusMessage: z.ZodNullable<z.ZodString>;
+            sourcePath: z.ZodString;
+            source: z.ZodEnum<{
+                unknown: "unknown";
+                system: "system";
+                user: "user";
+                plugin: "plugin";
+                project: "project";
+                mdm: "mdm";
+                sessionFlags: "sessionFlags";
+                cloudRequirements: "cloudRequirements";
+                legacyManagedConfigFile: "legacyManagedConfigFile";
+                legacyManagedConfigMdm: "legacyManagedConfigMdm";
+            }>;
+            pluginId: z.ZodNullable<z.ZodString>;
+            displayOrder: z.ZodNumber;
+            enabled: z.ZodBoolean;
+            isManaged: z.ZodBoolean;
+            currentHash: z.ZodString;
+            trustStatus: z.ZodEnum<{
+                managed: "managed";
+                untrusted: "untrusted";
+                trusted: "trusted";
+                modified: "modified";
+            }>;
+        }, z.core.$strip>>;
+        warnings: z.ZodArray<z.ZodString>;
+        errors: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            path: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>, z.ZodString]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const MergeStrategySchema: z.ZodEnum<{
+    replace: "replace";
+    merge: "merge";
+    upsert: "upsert";
+}>;
+export declare const ConfigEditSchema: z.ZodObject<{
+    keyPath: z.ZodString;
+    value: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    mergeStrategy: z.ZodEnum<{
+        replace: "replace";
+        merge: "merge";
+        upsert: "upsert";
+    }>;
+}, z.core.$strip>;
+export declare const ConfigBatchWriteParamsSchema: z.ZodObject<{
+    edits: z.ZodArray<z.ZodObject<{
+        keyPath: z.ZodString;
+        value: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        mergeStrategy: z.ZodEnum<{
+            replace: "replace";
+            merge: "merge";
+            upsert: "upsert";
+        }>;
+    }, z.core.$strip>>;
+    filePath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expectedVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    reloadUserConfig: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ConfigBatchWriteResponseSchema: z.ZodObject<{}, z.core.$loose>;
+export declare const JsonRpcErrorSchema: z.ZodObject<{
+    code: z.ZodNumber;
+    message: z.ZodString;
+    data: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;
+export type HookEventName = z.infer<typeof HookEventNameSchema>;
+export type HookHandlerType = z.infer<typeof HookHandlerTypeSchema>;
+export type HookSource = z.infer<typeof HookSourceSchema>;
+export type HookTrustStatus = z.infer<typeof HookTrustStatusSchema>;
+export type HookMetadata = z.infer<typeof HookMetadataSchema>;
+export type CommandHookMetadata = z.infer<typeof CommandHookMetadataSchema>;
+export type HooksListEntry = z.infer<typeof HooksListEntrySchema>;
+export type HooksListResponse = z.infer<typeof HooksListResponseSchema>;
+export type ConfigEdit = z.infer<typeof ConfigEditSchema>;
+export type ConfigBatchWriteParams = z.infer<typeof ConfigBatchWriteParamsSchema>;
+export type ConfigBatchWriteResponse = z.infer<typeof ConfigBatchWriteResponseSchema>;
+export type JsonRpcError = z.infer<typeof JsonRpcErrorSchema>;
+export interface CodexAppServerApi {
+    hooksList(cwds: string[]): Promise<HooksListResponse>;
+    configBatchWrite(params: ConfigBatchWriteParams): Promise<ConfigBatchWriteResponse>;
+    close(): Promise<void> | void;
+}
+export declare function parseCommandHookMetadata(value: unknown): CommandHookMetadata;
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/codex/app-server/types.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+// Official app-server protocol reference:
+// https://developers.openai.com/codex/app-server/
+// https://github.com/openai/codex/blob/main/codex-rs/app-server/README.md
+// Generated upstream Rust/TS source of truth:
+// https://github.com/openai/codex/blob/main/codex-rs/app-server-protocol/src/protocol/v2.rs
+const JsonValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema),
+]));
+export const HookEventNameSchema = z
+    .string()
+    .min(1)
+    .transform((value) => {
+    switch (value) {
+        case 'preToolUse':
+            return 'pre_tool_use';
+        case 'permissionRequest':
+            return 'permission_request';
+        case 'postToolUse':
+            return 'post_tool_use';
+        case 'sessionStart':
+            return 'session_start';
+        case 'userPromptSubmit':
+            return 'user_prompt_submit';
+        default:
+            return value;
+    }
+});
+export const HookHandlerTypeSchema = z.enum(['command', 'prompt', 'agent']);
+export const HookSourceSchema = z.enum([
+    'system',
+    'user',
+    'project',
+    'mdm',
+    'sessionFlags',
+    'plugin',
+    'cloudRequirements',
+    'legacyManagedConfigFile',
+    'legacyManagedConfigMdm',
+    'unknown',
+]);
+export const HookTrustStatusSchema = z.enum(['managed', 'untrusted', 'trusted', 'modified']);
+export const HookMetadataSchema = z.object({
+    key: z.string().min(1),
+    eventName: HookEventNameSchema,
+    handlerType: HookHandlerTypeSchema,
+    matcher: z.string().nullable(),
+    command: z.string().nullable(),
+    timeoutSec: z.number(),
+    statusMessage: z.string().nullable(),
+    sourcePath: z.string().min(1),
+    source: HookSourceSchema,
+    pluginId: z.string().nullable(),
+    displayOrder: z.number(),
+    enabled: z.boolean(),
+    isManaged: z.boolean(),
+    currentHash: z.string().min(1),
+    trustStatus: HookTrustStatusSchema,
+});
+export const CommandHookMetadataSchema = HookMetadataSchema.extend({
+    handlerType: z.literal('command'),
+    command: z.string().min(1),
+});
+export const HooksListEntrySchema = z.object({
+    cwd: z.string().min(1),
+    hooks: z.array(HookMetadataSchema),
+    warnings: z.array(z.string()),
+    errors: z.array(z.object({ path: z.string(), message: z.string() }).or(z.string())),
+});
+export const HooksListResponseSchema = z.object({
+    data: z.array(HooksListEntrySchema),
+});
+export const MergeStrategySchema = z.enum(['replace', 'merge', 'upsert']);
+export const ConfigEditSchema = z.object({
+    keyPath: z.string().min(1),
+    value: JsonValueSchema,
+    mergeStrategy: MergeStrategySchema,
+});
+export const ConfigBatchWriteParamsSchema = z.object({
+    edits: z.array(ConfigEditSchema),
+    filePath: z.string().nullable().optional(),
+    expectedVersion: z.number().nullable().optional(),
+    reloadUserConfig: z.boolean().default(false),
+});
+export const ConfigBatchWriteResponseSchema = z.object({}).passthrough();
+export const JsonRpcErrorSchema = z.object({
+    code: z.number(),
+    message: z.string(),
+    data: JsonValueSchema.optional(),
+});
+export function parseCommandHookMetadata(value) {
+    const parsed = CommandHookMetadataSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new Error('Expected command hook metadata');
+    }
+    return parsed.data;
+}
+//# sourceMappingURL=types.js.map

package/dist/esm/compiler/flatten.d.ts

@@ -0,0 +1,10 @@
+export interface FlattenedAssets {
+    readonly skills: Readonly<Record<string, string>>;
+    readonly commands: Readonly<Record<string, string>>;
+    readonly agents: Readonly<Record<string, string>>;
+}
+/** Reads `.agent/{skills,commands,agents}/` and returns an in-memory flattened structure. */
+export declare function flattenAgentDir(agentDir: string): FlattenedAssets;
+/** Writes flattened assets to a directory structure mirroring rulesync's expected layout. */
+export declare function writeFlattenedAssets(assets: FlattenedAssets, outDir: string): Promise<void>;
+//# sourceMappingURL=flatten.d.ts.map

package/dist/esm/compiler/flatten.js

@@ -0,0 +1,71 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { glob } from 'glob';
+import matter from 'gray-matter';
+import { agentFrontmatterSchema, commandFrontmatterSchema, skillFrontmatterSchema, } from './schema.js';
+/** Warn on validation failure without throwing — keeps flatten non-fatal. */
+function validateFrontmatter(schema, data, filePath) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        process.stderr.write(`wp-compiler: frontmatter validation warning for ${filePath}: ${result.error?.message ?? 'unknown error'}\n`);
+    }
+}
+/** Reads a file as utf-8 string and parses its gray-matter frontmatter. */
+function readAndParse(filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const parsed = matter(raw);
+    return { data: parsed.data, raw };
+}
+/** Reads `.agent/{skills,commands,agents}/` and returns an in-memory flattened structure. */
+export function flattenAgentDir(agentDir) {
+    const skills = {};
+    const commands = {};
+    const agents = {};
+    // Skills: .agent/skills/<name>/SKILL.md — key is the directory name
+    const skillFiles = glob.sync('skills/*/SKILL.md', { cwd: agentDir, absolute: true });
+    for (const filePath of skillFiles) {
+        const { data, raw } = readAndParse(filePath);
+        validateFrontmatter(skillFrontmatterSchema, data, filePath);
+        // Extract skill name from path: .agent/skills/<name>/SKILL.md
+        const parts = filePath.split('/');
+        const skillIdx = parts.lastIndexOf('skills');
+        const name = (skillIdx !== -1 ? parts[skillIdx + 1] : undefined) ?? 'unknown';
+        skills[name] = raw;
+    }
+    // Commands: .agent/commands/<name>.md — key is the file stem
+    const commandFiles = glob.sync('commands/*.md', { cwd: agentDir, absolute: true });
+    for (const filePath of commandFiles) {
+        const { data, raw } = readAndParse(filePath);
+        validateFrontmatter(commandFrontmatterSchema, data, filePath);
+        const fileName = filePath.split('/').pop() ?? '';
+        const name = fileName.replace(/\.md$/, '');
+        commands[name] = raw;
+    }
+    // Agents: .agent/agents/<name>.md — key is the file stem
+    const agentFiles = glob.sync('agents/*.md', { cwd: agentDir, absolute: true });
+    for (const filePath of agentFiles) {
+        const { data, raw } = readAndParse(filePath);
+        validateFrontmatter(agentFrontmatterSchema, data, filePath);
+        const fileName = filePath.split('/').pop() ?? '';
+        const name = fileName.replace(/\.md$/, '');
+        agents[name] = raw;
+    }
+    return { skills, commands, agents };
+}
+/** Writes flattened assets to a directory structure mirroring rulesync's expected layout. */
+export async function writeFlattenedAssets(assets, outDir) {
+    const subdirs = ['skills', 'commands', 'agents'];
+    for (const sub of subdirs) {
+        mkdirSync(join(outDir, sub), { recursive: true });
+    }
+    for (const [name, content] of Object.entries(assets.skills)) {
+        writeFileSync(join(outDir, 'skills', `${name}.md`), content);
+    }
+    for (const [name, content] of Object.entries(assets.commands)) {
+        writeFileSync(join(outDir, 'commands', `${name}.md`), content);
+    }
+    for (const [name, content] of Object.entries(assets.agents)) {
+        writeFileSync(join(outDir, 'agents', `${name}.md`), content);
+    }
+}
+//# sourceMappingURL=flatten.js.map

package/dist/esm/compiler/manifests/_versions.d.ts

@@ -0,0 +1,7 @@
+export declare const MANIFEST_VERSIONS: {
+    readonly claude: "1.0.0";
+    readonly codex: "1.0.0";
+    readonly cursor: "1.0.0";
+    readonly gemini: "0.4.0";
+};
+//# sourceMappingURL=_versions.d.ts.map