dryai 2.2.0 → 3.0.0

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'];

package/dest/lib/agents.d.ts

@@ -0,0 +1,81 @@
+import type { CLIRuntime } from '../cli.js';
+import { AGENT_DEFINITIONS } from './agent-definitions.js';
+import { type SyncTargetSpec, type AgentCmdSyncSpec, type OwnershipKeyInput, type AgentRuleSyncSpec, type SyncItemKind } from './agent-types.js';
+import type { CommandFrontmatter, RuleFrontmatter } from './frontmatter.js';
+export { AGENT_DEFINITIONS } from './agent-definitions.js';
+export { SYNC_ITEM_KINDS, type SyncTargetSpec as BuildSyncTargetsInput, type AgentCmdSyncSpec as CommandSyncSource, type OwnershipKeyInput, type AgentRuleSyncSpec as RuleSyncSource, type AgentSkillSyncSpec as SkillSyncSource, type SyncItemKind, type AgentSyncSpecByKind as SyncSourceByKind, } from './agent-types.js';
+export type SyncAgent = keyof typeof AGENT_DEFINITIONS;
+export type TargetRoots = Record<string, Record<string, string>>;
+/**
+ * Returns whether a string is a recognized sync agent name.
+ */
+export declare function isSyncAgent(value: string): value is SyncAgent;
+export declare const SYNC_AGENTS: ("copilot" | "cursor")[];
+export type OwnershipKey = string;
+export type SyncTarget = {
+    agent: string;
+    outputPath: string;
+    targetType: 'markdown';
+    body: string;
+    metadata: Record<string, unknown>;
+    writePath: string;
+} | {
+    agent: string;
+    outputPath: string;
+    targetType: 'directory';
+    sourceDir: string;
+};
+export type MarkdownSyncTarget = Extract<SyncTarget, {
+    targetType: 'markdown';
+}>;
+export type DirectorySyncTarget = Extract<SyncTarget, {
+    targetType: 'directory';
+}>;
+export type SyncMarkdownMetadata = MarkdownSyncTarget['metadata'];
+/**
+ * Builds the map of output root directory paths for every agent, each resolved relative to baseDir.
+ */
+export declare function createTargetRoots(baseDir: string): TargetRoots;
+/**
+ * Returns the display label used for one agent in user-facing sync reports.
+ */
+export declare function getAgentLabel(agent: SyncAgent): string;
+/**
+ * Returns the supported agent names joined as a natural English list.
+ */
+export declare function describeSupportedAgents(): string;
+/**
+ * Returns every output root directory path from the given TargetRoots map.
+ */
+export declare function listTargetRootPaths(targetRoots: TargetRoots): string[];
+/**
+ * Builds one sync target per supported agent for the given item kind and input.
+ */
+export declare function buildSyncTargets(value: SyncTargetSpec): SyncTarget[];
+/**
+ * Returns the ownership key for the given agent, item kind, and input.
+ */
+export declare function createOwnershipKey(agent: SyncAgent, kind: SyncItemKind, value: OwnershipKeyInput): OwnershipKey;
+/**
+ * Formats an ownership key as a human-readable phrase for use in warning messages.
+ */
+export declare function describeOwnershipKey(ownershipKey: OwnershipKey): string;
+/**
+ * Builds a CommandSyncSource from parsed command frontmatter. Returns null if any per-agent section fails validation.
+ */
+export declare function createAgentCmdSyncSpec(runtime: CLIRuntime, input: {
+    filePath: string;
+    sourceFileStem: string;
+    body: string;
+    frontmatter: CommandFrontmatter;
+}): AgentCmdSyncSpec | null;
+/**
+ * Builds a RuleSyncSource from parsed rule frontmatter. Returns null if any per-agent section fails validation.
+ */
+export declare function createAgentRuleSyncSpec(runtime: CLIRuntime, input: {
+    filePath: string;
+    sourceFileStem: string;
+    body: string;
+    frontmatter: RuleFrontmatter;
+}): AgentRuleSyncSpec | null;
+//# sourceMappingURL=agents.d.ts.map