dryai 2.2.0 → 3.0.0

package/dest/lib/agents.js

@@ -0,0 +1,301 @@
+import path from 'node:path';
+import { AGENT_DEFINITIONS } from './agent-definitions.js';
+import {} from './agent-types.js';
+export { AGENT_DEFINITIONS } from './agent-definitions.js';
+export { SYNC_ITEM_KINDS, } from './agent-types.js';
+/**
+ * Returns whether a string is a recognized sync agent name.
+ */
+export function isSyncAgent(value) {
+    return Object.hasOwn(AGENT_DEFINITIONS, value);
+}
+/**
+ * Returns all sync agent names from the registry, in definition order.
+ */
+function collectSyncAgents() {
+    const agents = [];
+    for (const value in AGENT_DEFINITIONS) {
+        if (isSyncAgent(value)) {
+            agents.push(value);
+        }
+    }
+    return agents;
+}
+export const SYNC_AGENTS = collectSyncAgents();
+/**
+ * Returns the definition for the given sync agent from the central registry.
+ */
+function getAgentDefinition(agent) {
+    return AGENT_DEFINITIONS[agent];
+}
+/**
+ * Returns the command source definition for the given agent.
+ */
+function getCommandSourceDefinition(agent) {
+    return getAgentDefinition(agent).command.frontmatterSection;
+}
+/**
+ * Returns the rule source definition for the given agent.
+ */
+function getRuleSourceDefinition(agent) {
+    return getAgentDefinition(agent).rule.frontmatterSection;
+}
+/**
+ * Returns all ownership definitions registered across every agent and item kind.
+ */
+function listOwnershipDefinitions() {
+    return SYNC_AGENTS.flatMap((agent) => {
+        const definition = getAgentDefinition(agent);
+        return [
+            definition.command.ownershipKey,
+            definition.rule.ownershipKey,
+            definition.skill.ownershipKey,
+        ];
+    });
+}
+/**
+ * Builds the map of output root directory paths for every agent, each resolved relative to baseDir.
+ */
+export function createTargetRoots(baseDir) {
+    return Object.fromEntries(SYNC_AGENTS.map((agent) => [
+        agent,
+        Object.fromEntries(Object.entries(getAgentDefinition(agent).targetRoots).map(([rootName, pathSegments]) => [
+            rootName,
+            path.join(baseDir, ...pathSegments),
+        ])),
+    ]));
+}
+/**
+ * Returns the display label used for one agent in user-facing sync reports.
+ */
+export function getAgentLabel(agent) {
+    return getAgentDefinition(agent).displayLabel;
+}
+/**
+ * Returns the supported agent names joined as a natural English list.
+ */
+export function describeSupportedAgents() {
+    return formatLabelList(SYNC_AGENTS.map(getAgentLabel));
+}
+/**
+ * Returns every output root directory path from the given TargetRoots map.
+ */
+export function listTargetRootPaths(targetRoots) {
+    return SYNC_AGENTS.flatMap((agent) => Object.values(targetRoots[agent]));
+}
+/**
+ * Builds one sync target per supported agent for the given item kind and input.
+ */
+export function buildSyncTargets(value) {
+    switch (value.kind) {
+        case 'command': {
+            return SYNC_AGENTS.map((agent) => getAgentDefinition(agent).command.target.buildTarget({
+                input: value.input,
+                targetRoots: value.targetRoots,
+            }));
+        }
+        case 'rule': {
+            return SYNC_AGENTS.map((agent) => getAgentDefinition(agent).rule.target.buildTarget({
+                input: value.input,
+                targetRoots: value.targetRoots,
+            }));
+        }
+        case 'skill': {
+            return SYNC_AGENTS.map((agent) => getAgentDefinition(agent).skill.target.buildTarget({
+                input: value.input,
+                targetRoots: value.targetRoots,
+            }));
+        }
+    }
+}
+/**
+ * Returns the ownership key for the given agent, item kind, and input.
+ */
+export function createOwnershipKey(agent, kind, value) {
+    switch (kind) {
+        case 'command': {
+            return getAgentDefinition(agent).command.ownershipKey.createKeyForInput(value);
+        }
+        case 'rule': {
+            return getAgentDefinition(agent).rule.ownershipKey.createKeyForInput(value);
+        }
+        case 'skill': {
+            return getAgentDefinition(agent).skill.ownershipKey.createKeyForInput(value);
+        }
+    }
+}
+/**
+ * Returns whether an ownership key starts with the given prefix.
+ */
+function hasOwnershipKeyPrefix(ownershipKey, prefix) {
+    return ownershipKey.startsWith(prefix);
+}
+/**
+ * Strips the given prefix from an ownership key and returns the remainder.
+ */
+function stripOwnershipKeyPrefix(ownershipKey, prefix) {
+    return ownershipKey.slice(prefix.length);
+}
+/**
+ * Formats an ownership key as a human-readable phrase for use in warning messages.
+ */
+export function describeOwnershipKey(ownershipKey) {
+    for (const definition of listOwnershipDefinitions()) {
+        if (hasOwnershipKeyPrefix(ownershipKey, definition.prefix)) {
+            return `${definition.descriptionLabel} "${stripOwnershipKeyPrefix(ownershipKey, definition.prefix)}"`;
+        }
+    }
+    return `output namespace "${ownershipKey}"`;
+}
+/**
+ * Formats a list of strings as a natural English enumeration (e.g. "a, b, and c").
+ */
+function formatLabelList(values) {
+    if (values.length === 0) {
+        return '';
+    }
+    if (values.length === 1) {
+        return values[0];
+    }
+    if (values.length === 2) {
+        return `${values[0]} and ${values[1]}`;
+    }
+    return `${values.slice(0, -1).join(', ')}, and ${values.at(-1)}`;
+}
+/**
+ * Serializes validation errors as dot-qualified field paths paired with messages, joined by semicolons.
+ */
+function formatValidationIssues(input) {
+    return input.issues
+        .map((issue) => {
+        const fieldPath = issue.path.length > 0
+            ? `${input.pathPrefix}.${issue.path.join('.')}`
+            : input.pathPrefix;
+        return `${fieldPath}: ${issue.message}`;
+    })
+        .join('; ');
+}
+/**
+ * Reads the per-agent blocks from parsed frontmatter and returns a map of agent → raw section value.
+ */
+function collectAgentSectionValues(runtime, input) {
+    const sectionValues = new Map();
+    if (!input.sections) {
+        return sectionValues;
+    }
+    const unknownAgents = [];
+    for (const [agent, value] of Object.entries(input.sections)) {
+        if (isSyncAgent(agent)) {
+            sectionValues.set(agent, value);
+            continue;
+        }
+        unknownAgents.push(agent);
+    }
+    if (unknownAgents.length > 0) {
+        runtime.logInfo(`Skipping invalid ${input.kind} frontmatter in ${input.filePath}: ${unknownAgents
+            .map((agent) => `agents.${agent}: Unsupported agent`)
+            .join('; ')}`);
+        return null;
+    }
+    return sectionValues;
+}
+/**
+ * Validates each per-agent frontmatter block and merges the results into the base command sync input. Returns null if any block is invalid.
+ */
+function extendCommandSyncInputFromAgentSections(runtime, input) {
+    const sectionValues = collectAgentSectionValues(runtime, {
+        filePath: input.filePath,
+        kind: 'command',
+        sections: input.sections,
+    });
+    if (!sectionValues) {
+        return null;
+    }
+    let currentInput = input.currentInput;
+    for (const agent of SYNC_AGENTS) {
+        const sourceDefinition = getCommandSourceDefinition(agent);
+        const result = sourceDefinition.createSyncInputExtension(sectionValues.get(agent), {
+            currentInput,
+            sectionValues,
+        });
+        if (!result.success) {
+            runtime.logInfo(`Skipping invalid command frontmatter in ${input.filePath}: ${formatValidationIssues({
+                issues: result.issues,
+                pathPrefix: `agents.${agent}`,
+            })}`);
+            return null;
+        }
+        currentInput = {
+            ...currentInput,
+            ...result.data,
+        };
+    }
+    return currentInput;
+}
+/**
+ * Validates each per-agent frontmatter block and merges the results into the base rule sync input. Returns null if any block is invalid.
+ */
+function extendRuleSyncInputFromAgentSections(runtime, input) {
+    const sectionValues = collectAgentSectionValues(runtime, {
+        filePath: input.filePath,
+        kind: 'rule',
+        sections: input.sections,
+    });
+    if (!sectionValues) {
+        return null;
+    }
+    let currentInput = input.currentInput;
+    for (const agent of SYNC_AGENTS) {
+        const sourceDefinition = getRuleSourceDefinition(agent);
+        const result = sourceDefinition.createSyncInputExtension(sectionValues.get(agent), {
+            currentInput,
+            sectionValues,
+        });
+        if (!result.success) {
+            runtime.logInfo(`Skipping invalid rule frontmatter in ${input.filePath}: ${formatValidationIssues({
+                issues: result.issues,
+                pathPrefix: `agents.${agent}`,
+            })}`);
+            return null;
+        }
+        currentInput = {
+            ...currentInput,
+            ...result.data,
+        };
+    }
+    return currentInput;
+}
+/**
+ * Builds a CommandSyncSource from parsed command frontmatter. Returns null if any per-agent section fails validation.
+ */
+export function createAgentCmdSyncSpec(runtime, input) {
+    return extendCommandSyncInputFromAgentSections(runtime, {
+        filePath: input.filePath,
+        currentInput: {
+            name: input.frontmatter.name,
+            description: input.frontmatter.description,
+            sourceFileStem: input.sourceFileStem,
+            body: input.body,
+            disableModelInvocation: undefined,
+        },
+        sections: input.frontmatter.agents,
+    });
+}
+/**
+ * Builds a RuleSyncSource from parsed rule frontmatter. Returns null if any per-agent section fails validation.
+ */
+export function createAgentRuleSyncSpec(runtime, input) {
+    return extendRuleSyncInputFromAgentSections(runtime, {
+        filePath: input.filePath,
+        currentInput: {
+            name: input.sourceFileStem,
+            description: input.frontmatter.description,
+            sourceFileStem: input.sourceFileStem,
+            body: input.body,
+            applyTo: '',
+            globs: undefined,
+            alwaysApply: false,
+        },
+        sections: input.frontmatter.agents,
+    });
+}

package/dest/lib/command-options.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const nonEmptyOptionStringSchema: z.ZodString;
 /**
- * Parses one Commander option value with a Zod schema.
+ * Returns a Commander option parser function that validates the raw string value with the given Zod schema.
  */
 export declare function parseOptionValue<TSchema extends z.ZodTypeAny>({ schema, optionLabel, }: {
     schema: TSchema;

package/dest/lib/command-options.js

@@ -18,7 +18,7 @@ function parseWithSchema({ schema, value, label, }) {
     throw new InvalidArgumentError(`${label}: ${issues}`);
 }
 /**
- * Parses one Commander option value with a Zod schema.
+ * Returns a Commander option parser function that validates the raw string value with the given Zod schema.
  */
 export function parseOptionValue({ schema, optionLabel, }) {
     return (value) => parseWithSchema({ schema, value, label: optionLabel });

package/dest/lib/context.d.ts

@@ -1,10 +1,4 @@
-export type TargetRoots = {
-    copilotPrompts: string;
-    copilotInstructions: string;
-    copilotSkills: string;
-    cursorRules: string;
-    cursorSkills: string;
-};
+import { type TargetRoots } from './agents.js';
 export type SourceRoots = {
     commands: string;
     rules: string;
@@ -14,27 +8,18 @@ export type AgentsContext = {
     inputRoot: string;
     outputRoot: string;
     skillsLockfilePath: string;
+    syncManifestPath: string;
     sourceRoots: SourceRoots;
     targetRoots: TargetRoots;
 };
 export declare const DEFAULT_INPUT_ROOT_SEGMENTS: readonly [".config", "dryai"];
 export declare const DEFAULT_TEST_OUTPUT_DIR_NAME = "output-test";
+export declare const DEFAULT_SYNC_MANIFEST_FILE_NAME = "sync-manifest.json";
 export declare const DEFAULT_SOURCE_ROOT_NAMES: {
     readonly commands: "commands";
     readonly rules: "rules";
     readonly skills: "skills";
 };
-export declare const DEFAULT_TARGET_ROOT_SEGMENTS: {
-    readonly copilotPrompts: readonly [".copilot", "prompts"];
-    readonly copilotInstructions: readonly [".copilot", "instructions"];
-    readonly copilotSkills: readonly [".copilot", "skills"];
-    readonly cursorRules: readonly [".cursor", "rules"];
-    readonly cursorSkills: readonly [".cursor", "skills"];
-};
-/**
- * Creates the Copilot and Cursor output root paths under one base directory.
- */
-export declare function createTargetRoots(baseDir: string): TargetRoots;
 /**
  * Creates the commands, rules, and skills input roots under one base directory.
  */
@@ -44,33 +29,31 @@ export declare function createSourceRoots(baseDir: string): SourceRoots;
  */
 export declare function expandHomePath(inputPath: string, homeDir: string): string;
 /**
- * Returns the requested output-root override derived from CLI-style options.
+ * Returns the explicit output root if --output-root or --test was passed, or undefined if neither was set.
  */
 export declare function resolveRequestedOutputRoot(input: {
     test: boolean;
     outputRoot?: string;
 }): string | undefined;
 /**
- * Returns the requested config root derived from CLI-style options.
+ * Returns the --config-root value if provided, or undefined.
  */
 export declare function resolveRequestedConfigRoot(input: {
     configRoot?: string;
 }): string | undefined;
 /**
- * Returns the filesystem path to use for generated output.
+ * Resolves the absolute output root path, expanding ~ and defaulting to homeDir when no override is given.
  */
 export declare function resolveOutputRoot(input: {
     homeDir: string;
     outputRoot?: string;
 }): string;
 /**
- * Returns a copy of the context with generated output redirected under one
- * explicit output root.
+ * Returns a shallow copy of context with outputRoot and targetRoots updated to the given path.
  */
 export declare function resolveOutputContext(context: AgentsContext, outputRoot: string): AgentsContext;
 /**
- * Creates the base CLI context with repository, input, and output paths
- * resolved.
+ * Builds the AgentsContext by resolving input and output roots, applying ~ expansion and test-mode defaults.
  */
 export declare function createAgentsContext(options?: {
     inputRoot?: string;

package/dest/lib/context.js

@@ -1,31 +1,14 @@
 import os from 'node:os';
 import path from 'node:path';
+import { createTargetRoots } from './agents.js';
 export const DEFAULT_INPUT_ROOT_SEGMENTS = ['.config', 'dryai'];
 export const DEFAULT_TEST_OUTPUT_DIR_NAME = 'output-test';
+export const DEFAULT_SYNC_MANIFEST_FILE_NAME = 'sync-manifest.json';
 export const DEFAULT_SOURCE_ROOT_NAMES = {
     commands: 'commands',
     rules: 'rules',
     skills: 'skills',
 };
-export const DEFAULT_TARGET_ROOT_SEGMENTS = {
-    copilotPrompts: ['.copilot', 'prompts'],
-    copilotInstructions: ['.copilot', 'instructions'],
-    copilotSkills: ['.copilot', 'skills'],
-    cursorRules: ['.cursor', 'rules'],
-    cursorSkills: ['.cursor', 'skills'],
-};
-/**
- * Creates the Copilot and Cursor output root paths under one base directory.
- */
-export function createTargetRoots(baseDir) {
-    return {
-        copilotPrompts: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.copilotPrompts),
-        copilotInstructions: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.copilotInstructions),
-        copilotSkills: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.copilotSkills),
-        cursorRules: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.cursorRules),
-        cursorSkills: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.cursorSkills),
-    };
-}
 /**
  * Creates the commands, rules, and skills input roots under one base directory.
  */
@@ -49,7 +32,7 @@ export function expandHomePath(inputPath, homeDir) {
     return inputPath;
 }
 /**
- * Returns the requested output-root override derived from CLI-style options.
+ * Returns the explicit output root if --output-root or --test was passed, or undefined if neither was set.
  */
 export function resolveRequestedOutputRoot(input) {
     if (input.outputRoot) {
@@ -58,13 +41,13 @@ export function resolveRequestedOutputRoot(input) {
     return input.test ? `./${DEFAULT_TEST_OUTPUT_DIR_NAME}` : undefined;
 }
 /**
- * Returns the requested config root derived from CLI-style options.
+ * Returns the --config-root value if provided, or undefined.
  */
 export function resolveRequestedConfigRoot(input) {
     return input.configRoot;
 }
 /**
- * Returns the filesystem path to use for generated output.
+ * Resolves the absolute output root path, expanding ~ and defaulting to homeDir when no override is given.
  */
 export function resolveOutputRoot(input) {
     if (input.outputRoot) {
@@ -73,8 +56,7 @@ export function resolveOutputRoot(input) {
     return input.homeDir;
 }
 /**
- * Returns a copy of the context with generated output redirected under one
- * explicit output root.
+ * Returns a shallow copy of context with outputRoot and targetRoots updated to the given path.
  */
 export function resolveOutputContext(context, outputRoot) {
     return {
@@ -84,8 +66,7 @@ export function resolveOutputContext(context, outputRoot) {
     };
 }
 /**
- * Creates the base CLI context with repository, input, and output paths
- * resolved.
+ * Builds the AgentsContext by resolving input and output roots, applying ~ expansion and test-mode defaults.
  */
 export function createAgentsContext(options) {
     const homeDir = os.homedir();
@@ -104,6 +85,7 @@ export function createAgentsContext(options) {
         inputRoot,
         outputRoot,
         skillsLockfilePath: path.join(inputRoot, 'skills.lock.json'),
+        syncManifestPath: path.join(inputRoot, DEFAULT_SYNC_MANIFEST_FILE_NAME),
         sourceRoots: createSourceRoots(inputRoot),
         targetRoots: createTargetRoots(outputRoot),
     };

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