dryai 2.1.0 → 3.0.0

package/dest/lib/frontmatter.d.ts

@@ -1,72 +1,37 @@
 import { z } from 'zod';
+import type { CLIRuntime } from '../cli.js';
+export { compactObject } from './object-helpers.js';
 export declare const nonEmptyStringSchema: z.ZodString;
+export declare const agentFrontmatterSectionSchema: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+export declare const agentFrontmatterSectionsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>;
+/**
+ * Builds the Zod schema for the `agents:` frontmatter section by combining each agent's per-kind source schema from the registry.
+ */
+export declare function createAgentFrontmatterSectionsSchema(kind: 'command' | 'rule'): z.ZodOptional<z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$catchall<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>>;
+export declare const commandAgentFrontmatterSectionsSchema: z.ZodOptional<z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$catchall<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>>;
+export declare const ruleAgentFrontmatterSectionsSchema: z.ZodOptional<z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$catchall<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>>;
 export declare const commandFrontmatterSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
-    cursor: z.ZodOptional<z.ZodObject<{
-        'disable-model-invocation': z.ZodOptional<z.ZodBoolean>;
-    }, "strict", z.ZodTypeAny, {
-        'disable-model-invocation'?: boolean | undefined;
-    }, {
-        'disable-model-invocation'?: boolean | undefined;
-    }>>;
-}, "strict", z.ZodTypeAny, {
-    name: string;
-    description: string;
-    cursor?: {
-        'disable-model-invocation'?: boolean | undefined;
-    } | undefined;
-}, {
-    name: string;
-    description: string;
-    cursor?: {
-        'disable-model-invocation'?: boolean | undefined;
-    } | undefined;
-}>;
+    agents: z.ZodOptional<z.ZodObject<{
+        [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$catchall<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>>;
+}, z.core.$strict>;
 export declare const ruleFrontmatterSchema: z.ZodObject<{
     description: z.ZodString;
-    copilot: z.ZodObject<{
-        applyTo: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        applyTo: string;
-    }, {
-        applyTo: string;
-    }>;
-    cursor: z.ZodOptional<z.ZodObject<{
-        alwaysApply: z.ZodOptional<z.ZodBoolean>;
-        globs: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        alwaysApply?: boolean | undefined;
-        globs?: string | undefined;
-    }, {
-        alwaysApply?: boolean | undefined;
-        globs?: string | undefined;
-    }>>;
-}, "strict", z.ZodTypeAny, {
-    description: string;
-    copilot: {
-        applyTo: string;
-    };
-    cursor?: {
-        alwaysApply?: boolean | undefined;
-        globs?: string | undefined;
-    } | undefined;
-}, {
-    description: string;
-    copilot: {
-        applyTo: string;
-    };
-    cursor?: {
-        alwaysApply?: boolean | undefined;
-        globs?: string | undefined;
-    } | undefined;
-}>;
+    agents: z.ZodOptional<z.ZodObject<{
+        [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$catchall<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>>;
+}, z.core.$strict>;
+export type AgentFrontmatterSections = z.infer<typeof agentFrontmatterSectionsSchema>;
 export type CommandFrontmatter = z.infer<typeof commandFrontmatterSchema>;
 export type RuleFrontmatter = z.infer<typeof ruleFrontmatterSchema>;
-/**
- * Returns a copy of an object with all undefined-valued entries removed.
- */
-export declare function compactObject(value: Record<string, unknown>): Record<string, unknown>;
 /**
  * Returns whether a value is a non-null plain object and not an array.
  */
@@ -81,21 +46,13 @@ export declare function parseFrontmatter(fileContent: string): {
 /**
  * Validates parsed frontmatter against a schema and logs a skip message when validation fails.
  */
-export declare function validateFrontmatter<T>({ filePath, metadata, schema, }: {
+export declare function validateFrontmatter<T>(runtime: CLIRuntime, { filePath, metadata, schema, }: {
     filePath: string;
     metadata: Record<string, unknown>;
     schema: z.ZodType<T>;
 }): T | null;
 /**
- * Normalizes rule frontmatter into the apply settings used by downstream generators.
- */
-export declare function normalizeRuleMetadata(metadata: RuleFrontmatter): {
-    alwaysApply: boolean;
-    globs: string | undefined;
-    applyTo: string;
-};
-/**
- * Renders metadata and markdown body content back into a frontmatter document string.
+ * Serializes metadata as YAML frontmatter and combines it with the markdown body into a single document string.
  */
 export declare function renderMarkdown({ metadata, body, }: {
     metadata: Record<string, unknown>;

package/dest/lib/frontmatter.js

@@ -1,41 +1,37 @@
 import matter from 'gray-matter';
 import { z } from 'zod';
+import { AGENT_DEFINITIONS } from './agent-definitions.js';
+export { compactObject } from './object-helpers.js';
 export const nonEmptyStringSchema = z.string().trim().min(1);
+export const agentFrontmatterSectionSchema = z.object({}).catchall(z.unknown());
+export const agentFrontmatterSectionsSchema = z
+    .record(z.string(), agentFrontmatterSectionSchema)
+    .optional();
+/**
+ * Builds the Zod schema for the `agents:` frontmatter section by combining each agent's per-kind source schema from the registry.
+ */
+export function createAgentFrontmatterSectionsSchema(kind) {
+    const shape = {};
+    for (const [agent, definition] of Object.entries(AGENT_DEFINITIONS)) {
+        shape[agent] = definition[kind].frontmatterSection.schema;
+    }
+    return z.object(shape).catchall(agentFrontmatterSectionSchema).optional();
+}
+export const commandAgentFrontmatterSectionsSchema = createAgentFrontmatterSectionsSchema('command');
+export const ruleAgentFrontmatterSectionsSchema = createAgentFrontmatterSectionsSchema('rule');
 export const commandFrontmatterSchema = z
     .object({
     name: nonEmptyStringSchema,
     description: nonEmptyStringSchema,
-    cursor: z
-        .object({
-        'disable-model-invocation': z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
+    agents: commandAgentFrontmatterSectionsSchema,
 })
     .strict();
 export const ruleFrontmatterSchema = z
     .object({
     description: nonEmptyStringSchema,
-    copilot: z
-        .object({
-        applyTo: nonEmptyStringSchema,
-    })
-        .strict(),
-    cursor: z
-        .object({
-        alwaysApply: z.boolean().optional(),
-        globs: nonEmptyStringSchema.optional(),
-    })
-        .strict()
-        .optional(),
+    agents: ruleAgentFrontmatterSectionsSchema,
 })
     .strict();
-/**
- * Returns a copy of an object with all undefined-valued entries removed.
- */
-export function compactObject(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
-}
 /**
  * Returns whether a value is a non-null plain object and not an array.
  */
@@ -55,7 +51,7 @@ export function parseFrontmatter(fileContent) {
 /**
  * Validates parsed frontmatter against a schema and logs a skip message when validation fails.
  */
-export function validateFrontmatter({ filePath, metadata, schema, }) {
+export function validateFrontmatter(runtime, { filePath, metadata, schema, }) {
     const result = schema.safeParse(metadata);
     if (result.success) {
         return result.data;
@@ -66,26 +62,11 @@ export function validateFrontmatter({ filePath, metadata, schema, }) {
         return `${fieldPath}: ${issue.message}`;
     })
         .join('; ');
-    console.log(`Skipping invalid frontmatter in ${filePath}: ${issues}`);
+    runtime.logInfo(`Skipping invalid frontmatter in ${filePath}: ${issues}`);
     return null;
 }
 /**
- * Normalizes rule frontmatter into the apply settings used by downstream generators.
- */
-export function normalizeRuleMetadata(metadata) {
-    const copilotApplyTo = metadata.copilot.applyTo;
-    const explicitAlwaysApply = metadata.cursor?.alwaysApply;
-    const scopedGlobs = metadata.cursor?.globs ?? copilotApplyTo;
-    const alwaysApply = explicitAlwaysApply ?? (scopedGlobs === undefined || scopedGlobs === '**');
-    const globs = alwaysApply ? undefined : scopedGlobs;
-    return {
-        alwaysApply,
-        globs,
-        applyTo: copilotApplyTo,
-    };
-}
-/**
- * Renders metadata and markdown body content back into a frontmatter document string.
+ * Serializes metadata as YAML frontmatter and combines it with the markdown body into a single document string.
  */
 export function renderMarkdown({ metadata, body, }) {
     const normalizedBody = body.trim();

package/dest/lib/object-helpers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a copy of an object with all undefined-valued entries removed.
+ */
+export declare function compactObject(value: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=object-helpers.d.ts.map

package/dest/lib/object-helpers.js

@@ -0,0 +1,6 @@
+/**
+ * Returns a copy of an object with all undefined-valued entries removed.
+ */
+export function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}

package/dest/lib/skills.d.ts

@@ -10,26 +10,8 @@ declare const skillLockEntrySchema: z.ZodObject<{
     files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     importedAt: z.ZodString;
     updatedAt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    path: string;
-    repo: string;
-    commit: string;
-    importedAt: string;
-    updatedAt: string;
-    ref?: string | undefined;
-    files?: Record<string, string> | undefined;
-}, {
-    name: string;
-    path: string;
-    repo: string;
-    commit: string;
-    importedAt: string;
-    updatedAt: string;
-    ref?: string | undefined;
-    files?: Record<string, string> | undefined;
-}>;
-declare const skillsLockfileSchema: z.ZodEffects<z.ZodObject<{
+}, z.core.$strip>;
+declare const skillsLockfileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     skills: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -40,74 +22,8 @@ declare const skillsLockfileSchema: z.ZodEffects<z.ZodObject<{
         files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         importedAt: z.ZodString;
         updatedAt: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        path: string;
-        repo: string;
-        commit: string;
-        importedAt: string;
-        updatedAt: string;
-        ref?: string | undefined;
-        files?: Record<string, string> | undefined;
-    }, {
-        name: string;
-        path: string;
-        repo: string;
-        commit: string;
-        importedAt: string;
-        updatedAt: string;
-        ref?: string | undefined;
-        files?: Record<string, string> | undefined;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    skills: {
-        name: string;
-        path: string;
-        repo: string;
-        commit: string;
-        importedAt: string;
-        updatedAt: string;
-        ref?: string | undefined;
-        files?: Record<string, string> | undefined;
-    }[];
-    version: 1;
-}, {
-    skills: {
-        name: string;
-        path: string;
-        repo: string;
-        commit: string;
-        importedAt: string;
-        updatedAt: string;
-        ref?: string | undefined;
-        files?: Record<string, string> | undefined;
-    }[];
-    version: 1;
-}>, {
-    skills: {
-        name: string;
-        path: string;
-        repo: string;
-        commit: string;
-        importedAt: string;
-        updatedAt: string;
-        ref?: string | undefined;
-        files?: Record<string, string> | undefined;
-    }[];
-    version: 1;
-}, {
-    skills: {
-        name: string;
-        path: string;
-        repo: string;
-        commit: string;
-        importedAt: string;
-        updatedAt: string;
-        ref?: string | undefined;
-        files?: Record<string, string> | undefined;
-    }[];
-    version: 1;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type ManagedSkill = z.infer<typeof skillLockEntrySchema>;
 export type SkillsLockfile = z.infer<typeof skillsLockfileSchema>;
 export type ManagedSkillFiles = z.infer<typeof managedSkillFilesSchema>;
@@ -148,12 +64,22 @@ export declare function deriveSkillName({ repo, skillPath, explicitName, }: {
 }): string;
 export declare function normalizeRemoteRepo(repo: string): string;
 /**
- * Builds the canonical remote path for a managed skill under the repository `skills/` directory.
+ * Returns the canonical remote path for a managed skill under the repository `skills/` directory.
  */
 export declare function resolveManagedSkillImportPath({ skillName, }: {
     skillName: string;
 }): string;
-export declare function normalizeImportedSkillPath(skillPath: string | undefined): string;
+/**
+ * Normalizes an explicitly provided repository-relative skill path.
+ */
+export declare function normalizeImportedSkillPath(skillPath: string | undefined): string | undefined;
+/**
+ * Joins an optional base repository path with a requested managed skill name.
+ */
+export declare function resolveManagedSkillImportPathFromBase(input: {
+    basePath: string | undefined;
+    skillName: string;
+}): string;
 /**
  * Creates the lockfile record for a newly imported managed skill.
  */
@@ -167,7 +93,7 @@ export declare function createImportedSkillRecord(input: {
     repo: string;
 }): ManagedSkill;
 /**
- * Creates the next lockfile record for a managed skill after its local contents have been refreshed.
+ * Returns an updated lockfile record for an existing managed skill after a successful remote refresh.
  */
 export declare function createUpdatedSkillRecord(input: {
     commit: string;
@@ -176,7 +102,7 @@ export declare function createUpdatedSkillRecord(input: {
     updatedAt: string;
 }): ManagedSkill;
 /**
- * Computes stable SHA-256 hashes for every file within a managed skill directory.
+ * Returns a map of relative file path → SHA-256 hash for every file in directoryPath.
  */
 export declare function computeDirectoryHashes(directoryPath: string): Promise<ManagedSkillFiles>;
 /**
@@ -197,13 +123,25 @@ export declare function cloneRemoteRepo(input: {
     repo: string;
 }): Promise<RemoteRepoCheckout>;
 /**
- * Resolves and validates a managed skill directory from a temporary repository checkout.
+ * Removes one temporary repository checkout returned by `cloneRemoteRepo`.
+ */
+export declare function cleanupRemoteRepoCheckout(checkout: RemoteRepoCheckout): Promise<void>;
+/**
+ * Returns the source directory path for a skill at its default location (`skills/<skillName>`), confirming the directory and SKILL.md exist.
  */
 export declare function resolveSkillSourceDir(input: {
     checkoutDir: string;
     repo: string;
     skillName: string;
 }): Promise<string>;
+/**
+ * Returns the source directory path for a skill at an explicit repository-relative path, confirming the directory and SKILL.md exist.
+ */
+export declare function resolveSkillSourceDirByPath(input: {
+    checkoutDir: string;
+    repo: string;
+    skillPath: string;
+}): Promise<string>;
 /**
  * Fetches a validated remote skill directory snapshot for a specific repository path.
  */
@@ -212,6 +150,10 @@ export declare function fetchRemoteSkillSnapshot(input: {
     repo: string;
     skillPath: string;
 }): Promise<RemoteSkillSnapshot>;
+/**
+ * Removes one temporary remote skill snapshot returned by `fetchRemoteSkillSnapshot`.
+ */
+export declare function cleanupRemoteSkillSnapshot(snapshot: RemoteSkillSnapshot): Promise<void>;
 export declare function replaceManagedSkillDirectory({ targetDir, sourceDir, }: {
     targetDir: string;
     sourceDir: string;

package/dest/lib/skills.js

@@ -126,7 +126,7 @@ export function normalizeRemoteRepo(repo) {
     return trimmedRepo;
 }
 /**
- * Builds the canonical remote path for a managed skill under the repository `skills/` directory.
+ * Returns the canonical remote path for a managed skill under the repository `skills/` directory.
  */
 export function resolveManagedSkillImportPath({ skillName, }) {
     const trimmedSkillName = skillName.trim();
@@ -139,9 +139,30 @@ export function resolveManagedSkillImportPath({ skillName, }) {
     }
     return `skills/${trimmedSkillName}`;
 }
+/**
+ * Normalizes an explicitly provided repository-relative skill path.
+ */
 export function normalizeImportedSkillPath(skillPath) {
-    const normalizedPath = skillPath && skillPath.length > 0 ? skillPath : '.';
-    return path.normalize(normalizedPath);
+    if (skillPath === undefined) {
+        return undefined;
+    }
+    return path.normalize(skillPath);
+}
+/**
+ * Joins an optional base repository path with a requested managed skill name.
+ */
+export function resolveManagedSkillImportPathFromBase(input) {
+    const normalizedBasePath = normalizeImportedSkillPath(input.basePath);
+    const defaultSkillPath = resolveManagedSkillImportPath({
+        skillName: input.skillName,
+    });
+    if (normalizedBasePath === '.') {
+        return path.normalize(input.skillName);
+    }
+    if (normalizedBasePath === undefined) {
+        return defaultSkillPath;
+    }
+    return path.normalize(path.join(normalizedBasePath, input.skillName));
 }
 /**
  * Creates the lockfile record for a newly imported managed skill.
@@ -159,7 +180,7 @@ export function createImportedSkillRecord(input) {
     };
 }
 /**
- * Creates the next lockfile record for a managed skill after its local contents have been refreshed.
+ * Returns an updated lockfile record for an existing managed skill after a successful remote refresh.
  */
 export function createUpdatedSkillRecord(input) {
     return {
@@ -170,7 +191,7 @@ export function createUpdatedSkillRecord(input) {
     };
 }
 /**
- * Computes stable SHA-256 hashes for every file within a managed skill directory.
+ * Returns a map of relative file path → SHA-256 hash for every file in directoryPath.
  */
 export async function computeDirectoryHashes(directoryPath) {
     const relativeFilePaths = await listRelativeFilePaths(directoryPath);
@@ -200,8 +221,14 @@ export async function detectLocalSkillEdits(input) {
         };
     }
     const currentFiles = await computeDirectoryHashes(input.skillDir);
-    const changedFiles = [...new Set([...Object.keys(input.storedFiles), ...Object.keys(currentFiles)])]
-        .filter((relativeFilePath) => input.storedFiles?.[relativeFilePath] !== currentFiles[relativeFilePath])
+    const changedFiles = [
+        ...new Set([
+            ...Object.keys(input.storedFiles),
+            ...Object.keys(currentFiles),
+        ]),
+    ]
+        .filter((relativeFilePath) => input.storedFiles?.[relativeFilePath] !==
+        currentFiles[relativeFilePath])
         .sort((left, right) => left.localeCompare(right));
     return {
         changedFiles,
@@ -242,7 +269,13 @@ export async function cloneRemoteRepo(input) {
     }
 }
 /**
- * Resolves and validates a managed skill directory from a temporary repository checkout.
+ * Removes one temporary repository checkout returned by `cloneRemoteRepo`.
+ */
+export async function cleanupRemoteRepoCheckout(checkout) {
+    await checkout.cleanup();
+}
+/**
+ * Returns the source directory path for a skill at its default location (`skills/<skillName>`), confirming the directory and SKILL.md exist.
  */
 export async function resolveSkillSourceDir(input) {
     const skillPath = resolveManagedSkillImportPath({
@@ -259,6 +292,25 @@ export async function resolveSkillSourceDir(input) {
     });
     return sourceDir;
 }
+/**
+ * Returns the source directory path for a skill at an explicit repository-relative path, confirming the directory and SKILL.md exist.
+ */
+export async function resolveSkillSourceDirByPath(input) {
+    const normalizedSkillPath = normalizeImportedSkillPath(input.skillPath);
+    if (normalizedSkillPath === undefined) {
+        throw new Error('Skill path may not be empty');
+    }
+    const sourceDir = resolveRemoteSkillDirectory({
+        checkoutDir: input.checkoutDir,
+        skillPath: normalizedSkillPath,
+    });
+    await validateRemoteSkillDirectory({
+        sourceDir,
+        skillPath: normalizedSkillPath,
+        repo: normalizeRemoteRepo(input.repo),
+    });
+    return sourceDir;
+}
 /**
  * Fetches a validated remote skill directory snapshot for a specific repository path.
  */
@@ -292,6 +344,12 @@ export async function fetchRemoteSkillSnapshot(input) {
         });
     }
 }
+/**
+ * Removes one temporary remote skill snapshot returned by `fetchRemoteSkillSnapshot`.
+ */
+export async function cleanupRemoteSkillSnapshot(snapshot) {
+    await snapshot.cleanup();
+}
 export async function replaceManagedSkillDirectory({ targetDir, sourceDir, }) {
     await fs.ensureDir(path.dirname(targetDir));
     const stagingRoot = await fs.mkdtemp(path.join(path.dirname(targetDir), `${path.basename(targetDir)}.`));

package/dest/lib/sync.d.ts

@@ -0,0 +1,7 @@
+import type { CLIRuntime } from '../cli.js';
+import type { AgentsContext } from './context.js';
+/**
+ * Writes all command, rule, and skill outputs to their target directories, then prunes any stale dryai-managed files from prior runs.
+ */
+export declare function syncToTargets(context: AgentsContext, runtime: CLIRuntime): Promise<void>;
+//# sourceMappingURL=sync.d.ts.map