dryai 2.1.0 → 3.0.0

package/dest/lib/agent-definitions.d.ts

@@ -0,0 +1,333 @@
+import { z } from 'zod';
+import type { AgentCmdSyncSpec, AgentRuleSyncSpec, AgentSkillSyncSpec } from './agent-types.js';
+type ConfiguredTargetRoots = Record<string, Record<string, string>>;
+/**
+ * The central sync agent registry, mapping each agent name to its command, rule, and skill definitions.
+ */
+export declare const AGENT_DEFINITIONS: {
+    readonly copilot: {
+        readonly displayLabel: "Copilot";
+        readonly targetRoots: {
+            readonly prompts: readonly [".copilot", "prompts"];
+            readonly instructions: readonly [".copilot", "instructions"];
+            readonly skills: readonly [".copilot", "skills"];
+        };
+        readonly command: {
+            frontmatterSection: {
+                schema: z.ZodType<Record<string, never> | undefined, unknown, z.core.$ZodTypeInternals<Record<string, never> | undefined, unknown>>;
+                createSyncInputExtension: (value: unknown, context: {
+                    currentInput: AgentCmdSyncSpec;
+                    sectionValues: ReadonlyMap<string, unknown>;
+                }) => {
+                    success: false;
+                    issues: readonly z.ZodIssue[];
+                } | {
+                    success: true;
+                    data: Partial<AgentCmdSyncSpec>;
+                };
+            };
+            ownershipKey: {
+                prefix: "copilot:prompt-path:";
+                descriptionLabel: string;
+                createKey: (value: string) => `copilot:prompt-path:${string}`;
+                createKeyForInput: (value: import("./agent-types.js").OwnershipKeyInput) => `copilot:prompt-path:${string}`;
+            };
+            outputPathCreators: {
+                createTargetPath: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    itemName: string;
+                    sourceFileStem: string;
+                }) => string;
+                createWritePath: (targetPath: string) => string;
+            };
+            metadata: {
+                schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                }, z.core.$strict>;
+                create: (value: {
+                    name: string;
+                    description: string;
+                }) => {
+                    name: string;
+                    description: string;
+                };
+            };
+            target: {
+                buildTarget: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    input: AgentCmdSyncSpec;
+                }) => {
+                    agent: string;
+                    body: string;
+                    metadata: {
+                        name: string;
+                        description: string;
+                    };
+                    outputPath: string;
+                    targetType: "markdown";
+                    writePath: string;
+                };
+            };
+        };
+        readonly rule: {
+            frontmatterSection: {
+                schema: z.ZodType<{
+                    applyTo: string;
+                }, unknown, z.core.$ZodTypeInternals<{
+                    applyTo: string;
+                }, unknown>>;
+                createSyncInputExtension: (value: unknown, context: {
+                    currentInput: AgentRuleSyncSpec;
+                    sectionValues: ReadonlyMap<string, unknown>;
+                }) => {
+                    success: false;
+                    issues: readonly z.ZodIssue[];
+                } | {
+                    success: true;
+                    data: Partial<AgentRuleSyncSpec>;
+                };
+            };
+            ownershipKey: {
+                prefix: "copilot:instruction-path:";
+                descriptionLabel: string;
+                createKey: (value: string) => `copilot:instruction-path:${string}`;
+                createKeyForInput: (value: import("./agent-types.js").OwnershipKeyInput) => `copilot:instruction-path:${string}`;
+            };
+            outputPathCreators: {
+                createTargetPath: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    itemName: string;
+                    sourceFileStem: string;
+                }) => string;
+                createWritePath: (targetPath: string) => string;
+            };
+            metadata: {
+                schema: z.ZodObject<{
+                    description: z.ZodString;
+                    applyTo: z.ZodString;
+                }, z.core.$strict>;
+                create: (value: {
+                    description: string;
+                    applyTo: string;
+                }) => {
+                    description: string;
+                    applyTo: string;
+                };
+            };
+            target: {
+                buildTarget: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    input: AgentRuleSyncSpec;
+                }) => {
+                    agent: string;
+                    body: string;
+                    metadata: {
+                        description: string;
+                        applyTo: string;
+                    };
+                    outputPath: string;
+                    targetType: "markdown";
+                    writePath: string;
+                };
+            };
+        };
+        readonly skill: {
+            ownershipKey: {
+                prefix: "copilot:skill-name:";
+                descriptionLabel: string;
+                createKey: (value: string) => `copilot:skill-name:${string}`;
+                createKeyForInput: (value: import("./agent-types.js").OwnershipKeyInput) => `copilot:skill-name:${string}`;
+            };
+            outputPathCreators: {
+                createTargetPath: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    itemName: string;
+                    sourceFileStem: string;
+                }) => string;
+                createWritePath: (targetPath: string) => string;
+            };
+            target: {
+                buildTarget: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    input: AgentSkillSyncSpec;
+                }) => {
+                    agent: string;
+                    outputPath: string;
+                    sourceDir: string;
+                    targetType: "directory";
+                };
+            };
+        };
+    };
+    readonly cursor: {
+        readonly displayLabel: "Cursor";
+        readonly targetRoots: {
+            readonly rules: readonly [".cursor", "rules"];
+            readonly skills: readonly [".cursor", "skills"];
+        };
+        readonly command: {
+            frontmatterSection: {
+                schema: z.ZodType<{
+                    'disable-model-invocation'?: boolean | undefined;
+                } | undefined, unknown, z.core.$ZodTypeInternals<{
+                    'disable-model-invocation'?: boolean | undefined;
+                } | undefined, unknown>>;
+                createSyncInputExtension: (value: unknown, context: {
+                    currentInput: AgentCmdSyncSpec;
+                    sectionValues: ReadonlyMap<string, unknown>;
+                }) => {
+                    success: false;
+                    issues: readonly z.ZodIssue[];
+                } | {
+                    success: true;
+                    data: Partial<AgentCmdSyncSpec>;
+                };
+            };
+            ownershipKey: {
+                prefix: "cursor:skill-name:";
+                descriptionLabel: string;
+                createKey: (value: string) => `cursor:skill-name:${string}`;
+                createKeyForInput: (value: import("./agent-types.js").OwnershipKeyInput) => `cursor:skill-name:${string}`;
+            };
+            outputPathCreators: {
+                createTargetPath: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    itemName: string;
+                    sourceFileStem: string;
+                }) => string;
+                createWritePath: (targetPath: string) => string;
+            };
+            metadata: {
+                schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    'disable-model-invocation': z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                create: (value: {
+                    name: string;
+                    description: string;
+                    disableModelInvocation: boolean | undefined;
+                }) => {
+                    name: string;
+                    description: string;
+                    'disable-model-invocation'?: boolean | undefined;
+                };
+            };
+            target: {
+                buildTarget: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    input: AgentCmdSyncSpec;
+                }) => {
+                    agent: string;
+                    body: string;
+                    metadata: {
+                        name: string;
+                        description: string;
+                        'disable-model-invocation'?: boolean | undefined;
+                    };
+                    outputPath: string;
+                    targetType: "markdown";
+                    writePath: string;
+                };
+            };
+        };
+        readonly rule: {
+            frontmatterSection: {
+                schema: z.ZodType<{
+                    alwaysApply?: boolean | undefined;
+                    globs?: string | undefined;
+                } | undefined, unknown, z.core.$ZodTypeInternals<{
+                    alwaysApply?: boolean | undefined;
+                    globs?: string | undefined;
+                } | undefined, unknown>>;
+                createSyncInputExtension: (value: unknown, context: {
+                    currentInput: AgentRuleSyncSpec;
+                    sectionValues: ReadonlyMap<string, unknown>;
+                }) => {
+                    success: false;
+                    issues: readonly z.ZodIssue[];
+                } | {
+                    success: true;
+                    data: Partial<AgentRuleSyncSpec>;
+                };
+            };
+            ownershipKey: {
+                prefix: "cursor:rule-path:";
+                descriptionLabel: string;
+                createKey: (value: string) => `cursor:rule-path:${string}`;
+                createKeyForInput: (value: import("./agent-types.js").OwnershipKeyInput) => `cursor:rule-path:${string}`;
+            };
+            outputPathCreators: {
+                createTargetPath: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    itemName: string;
+                    sourceFileStem: string;
+                }) => string;
+                createWritePath: (targetPath: string) => string;
+            };
+            metadata: {
+                schema: z.ZodObject<{
+                    description: z.ZodString;
+                    globs: z.ZodOptional<z.ZodString>;
+                    alwaysApply: z.ZodBoolean;
+                }, z.core.$strict>;
+                create: (value: {
+                    description: string;
+                    globs: string | undefined;
+                    alwaysApply: boolean;
+                }) => {
+                    description: string;
+                    alwaysApply: boolean;
+                    globs?: string | undefined;
+                };
+            };
+            target: {
+                buildTarget: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    input: AgentRuleSyncSpec;
+                }) => {
+                    agent: string;
+                    body: string;
+                    metadata: {
+                        description: string;
+                        alwaysApply: boolean;
+                        globs?: string | undefined;
+                    };
+                    outputPath: string;
+                    targetType: "markdown";
+                    writePath: string;
+                };
+            };
+        };
+        readonly skill: {
+            ownershipKey: {
+                prefix: "cursor:skill-name:";
+                descriptionLabel: string;
+                createKey: (value: string) => `cursor:skill-name:${string}`;
+                createKeyForInput: (value: import("./agent-types.js").OwnershipKeyInput) => `cursor:skill-name:${string}`;
+            };
+            outputPathCreators: {
+                createTargetPath: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    itemName: string;
+                    sourceFileStem: string;
+                }) => string;
+                createWritePath: (targetPath: string) => string;
+            };
+            target: {
+                buildTarget: (value: {
+                    targetRoots: ConfiguredTargetRoots;
+                    input: AgentSkillSyncSpec;
+                }) => {
+                    agent: string;
+                    outputPath: string;
+                    sourceDir: string;
+                    targetType: "directory";
+                };
+            };
+        };
+    };
+};
+export {};
+//# sourceMappingURL=agent-definitions.d.ts.map

package/dest/lib/agent-definitions.js

@@ -0,0 +1,301 @@
+import path from 'node:path';
+import { z } from 'zod';
+import { defineAgentFrontmatterSection, defineMetadata, defineOutputPathCreators, defineOwnershipKey, defineTarget, } from './agent-definition-helpers.js';
+import { compactObject } from './object-helpers.js';
+const nonEmptyStringSchema = z.string().trim().min(1);
+/**
+ * The central sync agent registry, mapping each agent name to its command, rule, and skill definitions.
+ */
+export const AGENT_DEFINITIONS = {
+    copilot: {
+        displayLabel: 'Copilot',
+        targetRoots: {
+            prompts: ['.copilot', 'prompts'],
+            instructions: ['.copilot', 'instructions'],
+            skills: ['.copilot', 'skills'],
+        },
+        command: (() => {
+            const outputPathCreators = defineOutputPathCreators({
+                createTargetPath: ({ targetRoots, sourceFileStem }) => path.join(targetRoots.copilot.prompts, `${sourceFileStem}.prompt.md`),
+            });
+            const frontmatterSectionSchema = z.strictObject({}).optional();
+            const metadata = defineMetadata({
+                shape: {
+                    name: z.string().min(1),
+                    description: z.string().min(1),
+                },
+                buildMetadata: (value) => compactObject({
+                    name: value.name,
+                    description: value.description,
+                }),
+            });
+            return {
+                frontmatterSection: defineAgentFrontmatterSection({
+                    schema: frontmatterSectionSchema,
+                    extendSyncInput: () => ({}),
+                }),
+                ownershipKey: defineOwnershipKey({
+                    prefix: 'copilot:prompt-path:',
+                    descriptionLabel: 'Copilot prompt output',
+                    selectSuffix: (value) => value.outputPath,
+                }),
+                outputPathCreators,
+                metadata,
+                target: defineTarget({
+                    buildTarget: ({ targetRoots, input, }) => {
+                        const outputPath = outputPathCreators.createTargetPath({
+                            targetRoots,
+                            itemName: input.name,
+                            sourceFileStem: input.sourceFileStem,
+                        });
+                        return {
+                            agent: 'copilot',
+                            body: input.body,
+                            metadata: metadata.create({
+                                name: input.name,
+                                description: input.description,
+                            }),
+                            outputPath,
+                            targetType: 'markdown',
+                            writePath: outputPath,
+                        };
+                    },
+                }),
+            };
+        })(),
+        rule: (() => {
+            const outputPathCreators = defineOutputPathCreators({
+                createTargetPath: ({ targetRoots, sourceFileStem }) => path.join(targetRoots.copilot.instructions, `${sourceFileStem}.instructions.md`),
+            });
+            const frontmatterSectionSchema = z.strictObject({
+                applyTo: nonEmptyStringSchema,
+            });
+            const metadata = defineMetadata({
+                shape: {
+                    description: z.string().min(1),
+                    applyTo: z.string().min(1),
+                },
+                buildMetadata: (value) => compactObject({
+                    description: value.description,
+                    applyTo: value.applyTo,
+                }),
+            });
+            return {
+                frontmatterSection: defineAgentFrontmatterSection({
+                    schema: frontmatterSectionSchema,
+                    extendSyncInput: (value) => ({
+                        applyTo: value.applyTo,
+                    }),
+                }),
+                ownershipKey: defineOwnershipKey({
+                    prefix: 'copilot:instruction-path:',
+                    descriptionLabel: 'Copilot instruction output',
+                    selectSuffix: (value) => value.outputPath,
+                }),
+                outputPathCreators,
+                metadata,
+                target: defineTarget({
+                    buildTarget: ({ targetRoots, input, }) => {
+                        const outputPath = outputPathCreators.createTargetPath({
+                            targetRoots,
+                            itemName: input.name,
+                            sourceFileStem: input.sourceFileStem,
+                        });
+                        return {
+                            agent: 'copilot',
+                            body: input.body,
+                            metadata: metadata.create({
+                                description: input.description,
+                                applyTo: input.applyTo,
+                            }),
+                            outputPath,
+                            targetType: 'markdown',
+                            writePath: outputPath,
+                        };
+                    },
+                }),
+            };
+        })(),
+        skill: (() => {
+            const outputPathCreators = defineOutputPathCreators({
+                createTargetPath: ({ targetRoots, itemName }) => path.join(targetRoots.copilot.skills, itemName),
+            });
+            return {
+                ownershipKey: defineOwnershipKey({
+                    prefix: 'copilot:skill-name:',
+                    descriptionLabel: 'Copilot skill name',
+                    selectSuffix: (value) => value.name,
+                }),
+                outputPathCreators,
+                target: defineTarget({
+                    buildTarget: ({ targetRoots, input, }) => ({
+                        agent: 'copilot',
+                        outputPath: outputPathCreators.createTargetPath({
+                            targetRoots,
+                            itemName: input.name,
+                            sourceFileStem: input.name,
+                        }),
+                        sourceDir: input.sourceDir,
+                        targetType: 'directory',
+                    }),
+                }),
+            };
+        })(),
+    },
+    cursor: {
+        displayLabel: 'Cursor',
+        targetRoots: {
+            rules: ['.cursor', 'rules'],
+            skills: ['.cursor', 'skills'],
+        },
+        command: (() => {
+            const outputPathCreators = defineOutputPathCreators({
+                createTargetPath: ({ targetRoots, itemName }) => path.join(targetRoots.cursor.skills, itemName),
+                createWritePath: (targetPath) => path.join(targetPath, 'SKILL.md'),
+            });
+            const frontmatterSectionSchema = z
+                .strictObject({
+                'disable-model-invocation': z.boolean().optional(),
+            })
+                .optional();
+            const metadata = defineMetadata({
+                shape: {
+                    name: z.string().min(1),
+                    description: z.string().min(1),
+                    'disable-model-invocation': z.boolean().optional(),
+                },
+                buildMetadata: (value) => compactObject({
+                    name: value.name,
+                    description: value.description,
+                    'disable-model-invocation': value.disableModelInvocation,
+                }),
+            });
+            return {
+                frontmatterSection: defineAgentFrontmatterSection({
+                    schema: frontmatterSectionSchema,
+                    extendSyncInput: (value) => ({
+                        disableModelInvocation: value?.['disable-model-invocation'],
+                    }),
+                }),
+                ownershipKey: defineOwnershipKey({
+                    prefix: 'cursor:skill-name:',
+                    descriptionLabel: 'Cursor skill name',
+                    selectSuffix: (value) => value.name,
+                }),
+                outputPathCreators,
+                metadata,
+                target: defineTarget({
+                    buildTarget: ({ targetRoots, input, }) => {
+                        const outputPath = outputPathCreators.createTargetPath({
+                            targetRoots,
+                            itemName: input.name,
+                            sourceFileStem: input.sourceFileStem,
+                        });
+                        return {
+                            agent: 'cursor',
+                            body: input.body,
+                            metadata: metadata.create({
+                                name: input.name,
+                                description: input.description,
+                                disableModelInvocation: input.disableModelInvocation,
+                            }),
+                            outputPath,
+                            targetType: 'markdown',
+                            writePath: outputPathCreators.createWritePath(outputPath),
+                        };
+                    },
+                }),
+            };
+        })(),
+        rule: (() => {
+            const outputPathCreators = defineOutputPathCreators({
+                createTargetPath: ({ targetRoots, sourceFileStem }) => path.join(targetRoots.cursor.rules, `${sourceFileStem}.mdc`),
+            });
+            const frontmatterSectionSchema = z
+                .strictObject({
+                alwaysApply: z.boolean().optional(),
+                globs: nonEmptyStringSchema.optional(),
+            })
+                .optional();
+            const metadata = defineMetadata({
+                shape: {
+                    description: z.string().min(1),
+                    globs: z.string().min(1).optional(),
+                    alwaysApply: z.boolean(),
+                },
+                buildMetadata: (value) => compactObject({
+                    description: value.description,
+                    globs: value.globs,
+                    alwaysApply: value.alwaysApply,
+                }),
+            });
+            return {
+                frontmatterSection: defineAgentFrontmatterSection({
+                    schema: frontmatterSectionSchema,
+                    extendSyncInput: (value, { currentInput }) => {
+                        const scopedGlobs = value?.globs ?? currentInput.applyTo;
+                        const alwaysApply = value?.alwaysApply ??
+                            (scopedGlobs === undefined || scopedGlobs === '**');
+                        return {
+                            alwaysApply,
+                            globs: alwaysApply ? undefined : scopedGlobs,
+                        };
+                    },
+                }),
+                ownershipKey: defineOwnershipKey({
+                    prefix: 'cursor:rule-path:',
+                    descriptionLabel: 'Cursor rule output',
+                    selectSuffix: (value) => value.outputPath,
+                }),
+                outputPathCreators,
+                metadata,
+                target: defineTarget({
+                    buildTarget: ({ targetRoots, input, }) => {
+                        const outputPath = outputPathCreators.createTargetPath({
+                            targetRoots,
+                            itemName: input.name,
+                            sourceFileStem: input.sourceFileStem,
+                        });
+                        return {
+                            agent: 'cursor',
+                            body: input.body,
+                            metadata: metadata.create({
+                                description: input.description,
+                                globs: input.globs,
+                                alwaysApply: input.alwaysApply,
+                            }),
+                            outputPath,
+                            targetType: 'markdown',
+                            writePath: outputPath,
+                        };
+                    },
+                }),
+            };
+        })(),
+        skill: (() => {
+            const outputPathCreators = defineOutputPathCreators({
+                createTargetPath: ({ targetRoots, itemName }) => path.join(targetRoots.cursor.skills, itemName),
+            });
+            return {
+                ownershipKey: defineOwnershipKey({
+                    prefix: 'cursor:skill-name:',
+                    descriptionLabel: 'Cursor skill name',
+                    selectSuffix: (value) => value.name,
+                }),
+                outputPathCreators,
+                target: defineTarget({
+                    buildTarget: ({ targetRoots, input, }) => ({
+                        agent: 'cursor',
+                        outputPath: outputPathCreators.createTargetPath({
+                            targetRoots,
+                            itemName: input.name,
+                            sourceFileStem: input.name,
+                        }),
+                        sourceDir: input.sourceDir,
+                        targetType: 'directory',
+                    }),
+                }),
+            };
+        })(),
+    },
+};

package/dest/lib/agent-types.d.ts

@@ -0,0 +1,46 @@
+import type { TargetRoots } from './agents.js';
+export declare const SYNC_ITEM_KINDS: readonly ["command", "rule", "skill"];
+export type SyncItemKind = (typeof SYNC_ITEM_KINDS)[number];
+export type OwnershipKeyInput = {
+    name: string;
+    outputPath: string;
+};
+export type AgentCmdSyncSpec = {
+    name: string;
+    description: string;
+    sourceFileStem: string;
+    body: string;
+    disableModelInvocation: boolean | undefined;
+};
+export type AgentRuleSyncSpec = {
+    name: string;
+    description: string;
+    sourceFileStem: string;
+    body: string;
+    applyTo: string;
+    globs: string | undefined;
+    alwaysApply: boolean;
+};
+export type AgentSkillSyncSpec = {
+    name: string;
+    sourceDir: string;
+};
+export type AgentSyncSpecByKind = {
+    command: AgentCmdSyncSpec;
+    rule: AgentRuleSyncSpec;
+    skill: AgentSkillSyncSpec;
+};
+export type SyncTargetSpec = {
+    kind: 'command';
+    input: AgentCmdSyncSpec;
+    targetRoots: TargetRoots;
+} | {
+    kind: 'rule';
+    input: AgentRuleSyncSpec;
+    targetRoots: TargetRoots;
+} | {
+    kind: 'skill';
+    input: AgentSkillSyncSpec;
+    targetRoots: TargetRoots;
+};
+//# sourceMappingURL=agent-types.d.ts.map

package/dest/lib/agent-types.js

@@ -0,0 +1 @@
+export const SYNC_ITEM_KINDS = ['command', 'rule', 'skill'];