dryai 2.1.0 → 3.0.0

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

@@ -1,11 +1,11 @@
 import { Command } from 'commander';
-import { type AgentsContext } from '../../lib/context.js';
+import type { CommandEnv } from '../../cli.js';
 /**
  * Registers the managed skills command tree on the parent CLI program.
  */
 export declare function addSkillsCommand(input: {
-    parent: Command;
+    program: Command;
     commandName: string;
-    resolveContext: () => AgentsContext;
+    resolveEnv: () => CommandEnv;
 }): Command;
 //# sourceMappingURL=index.d.ts.map

package/dest/commands/skills/index.js

@@ -1,8 +1,6 @@
 import { Command } from 'commander';
 import dedent from 'dedent';
 import { z } from 'zod';
-import { nonEmptyOptionStringSchema, parseOptionsObject, parseOptionValue, } from '../../lib/command-options.js';
-import {} from '../../lib/context.js';
 import { runSkillsAddCommand } from './add.js';
 import { runSkillsListCommand } from './list.js';
 import { runSkillsRehashAllCommand } from './rehash-all.js';
@@ -10,10 +8,12 @@ import { runSkillsRehashCommand } from './rehash.js';
 import { runSkillsRemoveCommand } from './remove.js';
 import { runSkillsUpdateAllCommand } from './update-all.js';
 import { runSkillsUpdateCommand } from './update.js';
+import { nonEmptyOptionStringSchema, parseOptionsObject, parseOptionValue, } from '../../lib/command-options.js';
 const skillsImportOptionsSchema = z.object({
     skill: z.array(z.string()).optional(),
     as: nonEmptyOptionStringSchema.optional(),
     pin: z.boolean().optional().default(false),
+    path: nonEmptyOptionStringSchema.optional(),
     ref: nonEmptyOptionStringSchema.optional(),
 });
 const skillsUpdateOptionsSchema = z.object({
@@ -23,8 +23,8 @@ const skillsUpdateOptionsSchema = z.object({
  * Registers the managed skills command tree on the parent CLI program.
  */
 export function addSkillsCommand(input) {
-    const { parent, commandName, resolveContext } = input;
-    const skills = parent
+    const { program, commandName, resolveEnv } = input;
+    const skills = program
         .command('skills')
         .description('Manage imported skills')
         .usage('<subcommand> [args]')
@@ -34,6 +34,8 @@ export function addSkillsCommand(input) {
         Examples:
           ${commandName} list
           ${commandName} add anthropics/skills --skill skill-creator
+          ${commandName} add anthropics/skills --path . --skill review-helper
+          ${commandName} add anthropics/skills --path tools --skill review-helper
           ${commandName} add vercel-labs/agent-skills --skill pr-review commit
           ${commandName} rehash skill-creator
           ${commandName} update skill-creator
@@ -45,12 +47,16 @@ export function addSkillsCommand(input) {
         .command('list')
         .description('List local skills')
         .action(async () => {
-        await runSkillsListCommand(resolveContext());
+        await runSkillsListCommand(resolveEnv());
     });
     skills
         .command('add <repo>')
         .description('Add managed skills from a remote repository')
-        .option('--skill <names...>', 'Import one or more skills from the repository root skills/ directory')
+        .option('--skill <names...>', 'Import one or more skills by directory name')
+        .option('--path <repoPath>', 'Resolve each --skill from a different repository subdirectory; use . for the repository root instead of the default skills/ directory', parseOptionValue({
+        schema: nonEmptyOptionStringSchema,
+        optionLabel: '--path',
+    }))
         .option('--as <name>', 'Store the imported skill under a different local managed name', parseOptionValue({
         schema: nonEmptyOptionStringSchema,
         optionLabel: '--as',
@@ -66,8 +72,9 @@ export function addSkillsCommand(input) {
             options,
             optionsLabel: 'skills add options',
         });
-        await runSkillsAddCommand(resolveContext(), {
+        await runSkillsAddCommand(resolveEnv(), {
             repo,
+            repoPath: parsedOptions.path,
             skillNames: parsedOptions.skill ?? [],
             asName: parsedOptions.as,
             pin: parsedOptions.pin,
@@ -78,19 +85,19 @@ export function addSkillsCommand(input) {
         .command('remove <name>')
         .description('Remove a managed skill')
         .action(async (skillName) => {
-        await runSkillsRemoveCommand(resolveContext(), { skillName });
+        await runSkillsRemoveCommand(resolveEnv(), { skillName });
     });
     skills
         .command('rehash <name>')
         .description('Refresh stored file hashes for one managed skill')
         .action(async (skillName) => {
-        await runSkillsRehashCommand(resolveContext(), { skillName });
+        await runSkillsRehashCommand(resolveEnv(), { skillName });
     });
     skills
         .command('rehash-all')
         .description('Refresh stored file hashes for all managed skills')
         .action(async () => {
-        await runSkillsRehashAllCommand(resolveContext());
+        await runSkillsRehashAllCommand(resolveEnv());
     });
     skills
         .command('update <name>')
@@ -102,7 +109,7 @@ export function addSkillsCommand(input) {
             options,
             optionsLabel: 'skills update options',
         });
-        await runSkillsUpdateCommand(resolveContext(), {
+        await runSkillsUpdateCommand(resolveEnv(), {
             force: parsedOptions.force,
             skillName,
         });
@@ -117,7 +124,7 @@ export function addSkillsCommand(input) {
             options,
             optionsLabel: 'skills update-all options',
         });
-        await runSkillsUpdateAllCommand(resolveContext(), {
+        await runSkillsUpdateAllCommand(resolveEnv(), {
             force: parsedOptions.force,
         });
     });

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

@@ -1,6 +1,6 @@
-import type { AgentsContext } from '../../lib/context.js';
+import type { CommandEnv } from '../../cli.js';
 /**
  * Lists local skills and annotates which ones are managed by the lockfile.
  */
-export declare function runSkillsListCommand(context: AgentsContext): Promise<void>;
+export declare function runSkillsListCommand(env: CommandEnv): Promise<void>;
 //# sourceMappingURL=list.d.ts.map

package/dest/commands/skills/list.js

@@ -2,7 +2,8 @@ import { ensureSkillsRoot, findManagedSkill, formatManagedSkillSummary, listLoca
 /**
  * Lists local skills and annotates which ones are managed by the lockfile.
  */
-export async function runSkillsListCommand(context) {
+export async function runSkillsListCommand(env) {
+    const { context, runtime } = env;
     await ensureSkillsRoot(context);
     const [localSkillDirectories, lockfile] = await Promise.all([
         listLocalSkillDirectories(context),
@@ -19,8 +20,8 @@ export async function runSkillsListCommand(context) {
         .map((managedSkill) => `- ${formatManagedSkillSummary(managedSkill)} missing-local-directory`);
     const outputLines = [...localSkillLines, ...missingManagedLines];
     if (outputLines.length === 0) {
-        console.log('No local skills found.');
+        runtime.logInfo('No local skills found.');
         return;
     }
-    console.log(outputLines.join('\n'));
+    runtime.logInfo(outputLines.join('\n'));
 }

package/dest/commands/skills/rehash-all.d.ts

@@ -1,6 +1,6 @@
-import type { AgentsContext } from '../../lib/context.js';
+import type { CommandEnv } from '../../cli.js';
 /**
  * Refreshes the stored file hashes for every managed skill using current local directory contents.
  */
-export declare function runSkillsRehashAllCommand(context: AgentsContext): Promise<void>;
+export declare function runSkillsRehashAllCommand(env: CommandEnv): Promise<void>;
 //# sourceMappingURL=rehash-all.d.ts.map

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

@@ -3,10 +3,11 @@ import { computeDirectoryHashes, createUpdatedSkillRecord, formatManagedSkillSum
 /**
  * Refreshes the stored file hashes for every managed skill using current local directory contents.
  */
-export async function runSkillsRehashAllCommand(context) {
+export async function runSkillsRehashAllCommand(env) {
+    const { context, runtime } = env;
     let lockfile = await loadSkillsLockfile(context);
     if (lockfile.skills.length === 0) {
-        console.log('No managed skills to rehash.');
+        runtime.logInfo('No managed skills to rehash.');
         return;
     }
     const rehashedLines = [];
@@ -31,12 +32,12 @@ export async function runSkillsRehashAllCommand(context) {
     }
     await saveSkillsLockfile(context, { lockfile });
     if (rehashedLines.length > 0) {
-        console.log(`Rehashed ${rehashedLines.length} managed skills:\n${rehashedLines.join('\n')}`);
+        runtime.logInfo(`Rehashed ${rehashedLines.length} managed skills:\n${rehashedLines.join('\n')}`);
     }
     else {
-        console.log('No managed skills were rehashed.');
+        runtime.logInfo('No managed skills were rehashed.');
     }
     if (skippedLines.length > 0) {
-        console.warn(`Skipped ${skippedLines.length} managed skills because the local directory is missing:\n${skippedLines.join('\n')}`);
+        runtime.logWarn(`Skipped ${skippedLines.length} managed skills because the local directory is missing:\n${skippedLines.join('\n')}`);
     }
 }

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

@@ -1,8 +1,8 @@
-import type { AgentsContext } from '../../lib/context.js';
+import type { CommandEnv } from '../../cli.js';
 /**
  * Refreshes the stored file hashes for one managed skill using the current local directory contents.
  */
-export declare function runSkillsRehashCommand(context: AgentsContext, input: {
+export declare function runSkillsRehashCommand(env: CommandEnv, input: {
     skillName: string;
 }): Promise<void>;
 //# sourceMappingURL=rehash.d.ts.map

package/dest/commands/skills/rehash.js

@@ -3,7 +3,8 @@ import { computeDirectoryHashes, createUpdatedSkillRecord, findManagedSkill, for
 /**
  * Refreshes the stored file hashes for one managed skill using the current local directory contents.
  */
-export async function runSkillsRehashCommand(context, input) {
+export async function runSkillsRehashCommand(env, input) {
+    const { context, runtime } = env;
     const { skillName } = input;
     const lockfile = await loadSkillsLockfile(context);
     const managedSkill = findManagedSkill(lockfile, { name: skillName });
@@ -24,5 +25,5 @@ export async function runSkillsRehashCommand(context, input) {
     await saveSkillsLockfile(context, {
         lockfile: upsertManagedSkill(lockfile, { updatedSkill }),
     });
-    console.log(`Rehashed ${formatManagedSkillSummary(updatedSkill)}`);
+    runtime.logInfo(`Rehashed ${formatManagedSkillSummary(updatedSkill)}`);
 }

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

@@ -1,8 +1,8 @@
-import type { AgentsContext } from '../../lib/context.js';
+import type { CommandEnv } from '../../cli.js';
 /**
  * Removes a managed skill from the local directory and updates the lockfile.
  */
-export declare function runSkillsRemoveCommand(context: AgentsContext, input: {
+export declare function runSkillsRemoveCommand(env: CommandEnv, input: {
     skillName: string;
 }): Promise<void>;
 //# sourceMappingURL=remove.d.ts.map

package/dest/commands/skills/remove.js

@@ -2,7 +2,8 @@ import { findManagedSkill, formatManagedSkillSummary, loadSkillsLockfile, remove
 /**
  * Removes a managed skill from the local directory and updates the lockfile.
  */
-export async function runSkillsRemoveCommand(context, input) {
+export async function runSkillsRemoveCommand(env, input) {
+    const { context, runtime } = env;
     const { skillName } = input;
     const lockfile = await loadSkillsLockfile(context);
     const managedSkill = findManagedSkill(lockfile, { name: skillName });
@@ -13,5 +14,5 @@ export async function runSkillsRemoveCommand(context, input) {
     await saveSkillsLockfile(context, {
         lockfile: removeManagedSkill(lockfile, { name: skillName }),
     });
-    console.log(`Removed ${formatManagedSkillSummary(managedSkill)}`);
+    runtime.logInfo(`Removed ${formatManagedSkillSummary(managedSkill)}`);
 }

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

@@ -1,8 +1,8 @@
-import type { AgentsContext } from '../../lib/context.js';
+import type { CommandEnv } from '../../cli.js';
 /**
  * Updates every managed skill from its tracked remote source and saves the refreshed lockfile.
  */
-export declare function runSkillsUpdateAllCommand(context: AgentsContext, input: {
+export declare function runSkillsUpdateAllCommand(env: CommandEnv, input: {
     force: boolean;
 }): Promise<void>;
 //# sourceMappingURL=update-all.d.ts.map

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),
+            };
+        },
+    };
+}