dryai 2.2.0 → 3.0.0

package/dest/commands/skills/update-all.js

@@ -1,11 +1,12 @@
-import { computeDirectoryHashes, createUpdatedSkillRecord, detectLocalSkillEdits, fetchRemoteSkillSnapshot, formatManagedSkillSummary, getManagedSkillDirectory, loadSkillsLockfile, replaceManagedSkillDirectory, saveSkillsLockfile, timestampNow, upsertManagedSkill, } from '../../lib/skills.js';
+import { cleanupRemoteSkillSnapshot, computeDirectoryHashes, createUpdatedSkillRecord, detectLocalSkillEdits, fetchRemoteSkillSnapshot, formatManagedSkillSummary, getManagedSkillDirectory, loadSkillsLockfile, replaceManagedSkillDirectory, saveSkillsLockfile, timestampNow, upsertManagedSkill, } from '../../lib/skills.js';
 /**
  * Updates every managed skill from its tracked remote source and saves the refreshed lockfile.
  */
-export async function runSkillsUpdateAllCommand(context, input) {
+export async function runSkillsUpdateAllCommand(env, input) {
+    const { context, runtime } = env;
     let lockfile = await loadSkillsLockfile(context);
     if (lockfile.skills.length === 0) {
-        console.log('No managed skills to update.');
+        runtime.logInfo('No managed skills to update.');
         return;
     }
     const updatedLines = [];
@@ -43,17 +44,17 @@ export async function runSkillsUpdateAllCommand(context, input) {
             updatedLines.push(`- ${formatManagedSkillSummary(updatedSkill)}`);
         }
         finally {
-            await snapshot.cleanup();
+            await cleanupRemoteSkillSnapshot(snapshot);
         }
     }
     await saveSkillsLockfile(context, { lockfile });
     if (updatedLines.length > 0) {
-        console.log(`Updated ${updatedLines.length} managed skills:\n${updatedLines.join('\n')}`);
+        runtime.logInfo(`Updated ${updatedLines.length} managed skills:\n${updatedLines.join('\n')}`);
     }
     else {
-        console.log('No managed skills were updated.');
+        runtime.logInfo('No managed skills were updated.');
     }
     if (skippedLines.length > 0) {
-        console.warn(`Skipped ${skippedLines.length} managed skills due to local edits. Re-run with --force to overwrite local changes:\n${skippedLines.join('\n')}`);
+        runtime.logWarn(`Skipped ${skippedLines.length} managed skills due to local edits. Re-run with --force to overwrite local changes:\n${skippedLines.join('\n')}`);
     }
 }

package/dest/commands/skills/update.d.ts

@@ -1,8 +1,8 @@
-import type { AgentsContext } from '../../lib/context.js';
+import type { CommandEnv } from '../../cli.js';
 /**
  * Updates one managed skill from its tracked remote source and refreshes the lockfile.
  */
-export declare function runSkillsUpdateCommand(context: AgentsContext, input: {
+export declare function runSkillsUpdateCommand(env: CommandEnv, input: {
     force: boolean;
     skillName: string;
 }): Promise<void>;

package/dest/commands/skills/update.js

@@ -1,8 +1,9 @@
-import { computeDirectoryHashes, createUpdatedSkillRecord, detectLocalSkillEdits, fetchRemoteSkillSnapshot, findManagedSkill, formatManagedSkillSummary, getManagedSkillDirectory, loadSkillsLockfile, replaceManagedSkillDirectory, saveSkillsLockfile, timestampNow, upsertManagedSkill, } from '../../lib/skills.js';
+import { cleanupRemoteSkillSnapshot, computeDirectoryHashes, createUpdatedSkillRecord, detectLocalSkillEdits, fetchRemoteSkillSnapshot, findManagedSkill, formatManagedSkillSummary, getManagedSkillDirectory, loadSkillsLockfile, replaceManagedSkillDirectory, saveSkillsLockfile, timestampNow, upsertManagedSkill, } from '../../lib/skills.js';
 /**
  * Updates one managed skill from its tracked remote source and refreshes the lockfile.
  */
-export async function runSkillsUpdateCommand(context, input) {
+export async function runSkillsUpdateCommand(env, input) {
+    const { context, runtime } = env;
     const { force, skillName } = input;
     const lockfile = await loadSkillsLockfile(context);
     const managedSkill = findManagedSkill(lockfile, { name: skillName });
@@ -15,7 +16,7 @@ export async function runSkillsUpdateCommand(context, input) {
         storedFiles: managedSkill.files,
     });
     if (localEditState.modified && !force) {
-        console.warn(`Skipped ${skillName} because local edits were detected in: ${localEditState.changedFiles.join(', ')}. Re-run with --force to overwrite local changes.`);
+        runtime.logWarn(`Skipped ${skillName} because local edits were detected in: ${localEditState.changedFiles.join(', ')}. Re-run with --force to overwrite local changes.`);
         return;
     }
     const snapshot = await fetchRemoteSkillSnapshot({
@@ -38,9 +39,9 @@ export async function runSkillsUpdateCommand(context, input) {
         await saveSkillsLockfile(context, {
             lockfile: upsertManagedSkill(lockfile, { updatedSkill }),
         });
-        console.log(`Updated ${formatManagedSkillSummary(updatedSkill)}`);
+        runtime.logInfo(`Updated ${formatManagedSkillSummary(updatedSkill)}`);
     }
     finally {
-        await snapshot.cleanup();
+        await cleanupRemoteSkillSnapshot(snapshot);
     }
 }

package/dest/commands/sync.d.ts

@@ -0,0 +1,6 @@
+import type { CommandEnv } from '../cli.js';
+/**
+ * Runs the sync command, writing all command, rule, and skill outputs into their agent target directories.
+ */
+export declare function runSyncCommand(env: CommandEnv): Promise<void>;
+//# sourceMappingURL=sync.d.ts.map

package/dest/commands/sync.js

@@ -0,0 +1,8 @@
+import { syncToTargets } from '../lib/sync.js';
+/**
+ * Runs the sync command, writing all command, rule, and skill outputs into their agent target directories.
+ */
+export async function runSyncCommand(env) {
+    const { context, runtime } = env;
+    await syncToTargets(context, runtime);
+}

package/dest/lib/agent-definition-helpers.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import type { OwnershipKeyInput } from './agent-types.js';
+type CreateTargetPathInput<TargetRoots> = {
+    targetRoots: TargetRoots;
+    itemName: string;
+    sourceFileStem: string;
+};
+type BuildTargetInput<Input, TargetRoots> = {
+    targetRoots: TargetRoots;
+    input: Input;
+};
+type AgentFrontmatterSectionEnv<SyncItemSpec> = {
+    currentInput: SyncItemSpec;
+    sectionValues: ReadonlyMap<string, unknown>;
+};
+/**
+ * Defines the ownership key namespace for one agent output type, providing a typed prefix and key-derivation functions.
+ */
+export declare function defineOwnershipKey<Prefix extends string>(input: {
+    prefix: Prefix;
+    descriptionLabel: string;
+    selectSuffix: (value: OwnershipKeyInput) => string;
+}): {
+    prefix: Prefix;
+    descriptionLabel: string;
+    createKey: (value: string) => `${Prefix}${string}`;
+    createKeyForInput: (value: OwnershipKeyInput) => `${Prefix}${string}`;
+};
+/**
+ * Defines a strict Zod schema and a `create` method for building validated frontmatter metadata objects.
+ */
+export declare function defineMetadata<Input, Shape extends z.ZodRawShape>(input: {
+    shape: Shape;
+    buildMetadata: (value: Input) => Record<string, unknown>;
+}): {
+    schema: z.ZodObject<Shape, z.core.$strict>;
+    create: (value: Input) => z.output<z.ZodObject<Shape, z.core.$strict>>;
+};
+/**
+ * Defines how to compute the outputPath and writePath for a sync target from target roots and source file metadata.
+ */
+export declare function defineOutputPathCreators<TargetRoots>(input: {
+    createTargetPath: (value: CreateTargetPathInput<TargetRoots>) => string;
+    createWritePath?: (targetPath: string) => string;
+}): {
+    createTargetPath: (value: CreateTargetPathInput<TargetRoots>) => string;
+    createWritePath: (targetPath: string) => string;
+};
+/**
+ * Wraps a typed buildTarget function for use in an agent's sync target definition.
+ */
+export declare function defineTarget<Input, Target, TargetRoots = unknown>(input: {
+    buildTarget: (value: BuildTargetInput<Input, TargetRoots>) => Target;
+}): {
+    buildTarget: (value: BuildTargetInput<Input, TargetRoots>) => Target;
+};
+/**
+ * Defines a validated frontmatter section that parses its value with a Zod schema and merges extra fields into the sync input.
+ */
+export declare function defineAgentFrontmatterSection<Section, SyncItemSpec extends Record<string, unknown>>(input: {
+    schema: z.ZodType<Section>;
+    extendSyncInput: (value: Section, context: AgentFrontmatterSectionEnv<SyncItemSpec>) => Partial<SyncItemSpec>;
+}): {
+    schema: z.ZodType<Section>;
+    createSyncInputExtension: (value: unknown, context: AgentFrontmatterSectionEnv<SyncItemSpec>) => {
+        success: true;
+        data: Partial<SyncItemSpec>;
+    } | {
+        success: false;
+        issues: readonly z.ZodIssue[];
+    };
+};
+export {};
+//# sourceMappingURL=agent-definition-helpers.d.ts.map

package/dest/lib/agent-definition-helpers.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+/**
+ * Defines the ownership key namespace for one agent output type, providing a typed prefix and key-derivation functions.
+ */
+export function defineOwnershipKey(input) {
+    return {
+        prefix: input.prefix,
+        descriptionLabel: input.descriptionLabel,
+        createKey(value) {
+            return `${input.prefix}${value}`;
+        },
+        createKeyForInput(value) {
+            return `${input.prefix}${input.selectSuffix(value)}`;
+        },
+    };
+}
+/**
+ * Defines a strict Zod schema and a `create` method for building validated frontmatter metadata objects.
+ */
+export function defineMetadata(input) {
+    const schema = z.strictObject(input.shape);
+    return {
+        schema,
+        create(value) {
+            return schema.parse(input.buildMetadata(value));
+        },
+    };
+}
+/**
+ * Defines how to compute the outputPath and writePath for a sync target from target roots and source file metadata.
+ */
+export function defineOutputPathCreators(input) {
+    return {
+        createTargetPath: input.createTargetPath,
+        createWritePath(targetPath) {
+            return input.createWritePath?.(targetPath) ?? targetPath;
+        },
+    };
+}
+/**
+ * Wraps a typed buildTarget function for use in an agent's sync target definition.
+ */
+export function defineTarget(input) {
+    return {
+        buildTarget: input.buildTarget,
+    };
+}
+/**
+ * Defines a validated frontmatter section that parses its value with a Zod schema and merges extra fields into the sync input.
+ */
+export function defineAgentFrontmatterSection(input) {
+    return {
+        schema: input.schema,
+        createSyncInputExtension(value, context) {
+            const result = input.schema.safeParse(value);
+            if (!result.success) {
+                return {
+                    success: false,
+                    issues: result.error.issues,
+                };
+            }
+            return {
+                success: true,
+                data: input.extendSyncInput(result.data, context),
+            };
+        },
+    };
+}

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