dryai 0.2.1

package/README.md

@@ -0,0 +1,117 @@
+# Share AI config CLI
+
+Installs command, rule, and skill sources from `~/.config/agents` by default into Copilot and Cursor targets.
+
+Pass `--input <path>` to read configs from a different root such as `./config`.
+
+Pass `--output <path>` to write generated output somewhere other than your home directory.
+
+`--test` is a shortcut for `--output ./output-test`, and if both are provided, `--output` wins.
+
+## Input
+
+Input config files live under the selected input root:
+
+- `commands`
+- `rules`
+- `skills`
+
+Live output is written to:
+
+- `~/.copilot/prompts`
+- `~/.copilot/instructions`
+- `~/.copilot/skills`
+- `~/.cursor/rules`
+- `~/.cursor/skills`
+
+## Commands
+
+```sh
+dryai install
+dryai skills list                                 List local skills
+dryai skills add [options] <repo>                 Add managed skills from a remote repository
+dryai skills remove <name>                        Remove a managed skill
+dryai skills update <name>                        Update a managed skill from its tracked source
+dryai skills update-all                           Update all managed skills from their tracked sources
+```
+
+`<repo>` may be a full git remote URL or a GitHub `owner/repo` shorthand such as `anthropics/skills`.
+
+## Managed Skills
+
+Imported skills are copied into `config/skills/<name>/` and tracked in `skills.lock.json`.
+
+`skills add` requires at least one `--skill <name>` value. Each requested skill is always resolved from `<repo root>/skills/<name>`.
+
+Use `--as <name>` to choose a different local managed skill name when importing exactly one skill.
+
+Examples:
+
+```sh
+dryai skills add anthropics/skills --skill skill-creator
+dryai skills add vercel-labs/agent-skills --skill pr-review commit
+dryai skills add https://github.com/vercel-labs/agent-skills.git --skill pr-review commit
+```
+
+By default, imports track the requested ref. With no `--ref`, that means the remote default branch `HEAD` is tracked. Use `--pin` to store the currently resolved commit instead, so later `skills update` operations stay pinned to that commit.
+
+The lockfile records:
+
+- the local skill name
+- the source repository
+- the source path within that repository
+- the requested git ref, when one was provided
+- the resolved commit that was imported
+
+`skills update` and `skills update-all` re-fetch the tracked repository snapshot and replace the local copied skill directory.
+
+`skills remove` deletes the local copied skill directory and removes its lockfile entry.
+
+`skills list` reports local skill directories, annotating managed entries from the lockfile and flagging managed entries whose local directory is missing.
+
+## Development
+
+For development, use `pnpm dev` to rebuild into `dest/` on change and `pnpm dev:dryai --test install` to run the built CLI.
+
+Run `pnpm run setup:editor` after installing dependencies if you want the Effect language service workspace patch applied locally.
+
+```sh
+pnpm run setup:editor
+pnpm run build
+pnpm run dev
+pnpm run test
+pnpm run test:watch
+
+pnpm dev:dryai install
+pnpm dev:dryai --test install
+pnpm dev:dryai --output ./tmp/install-root install
+pnpm dev:dryai --input ./config install
+```
+
+## CI and Release
+
+- On pull request open or update
+  - Run CI validation with build, test, and `npm pack --dry-run`.
+- On changes landing on `main`
+  - Run the same CI validation with build, test, and `npm pack --dry-run`.
+- On `v*` tag pushed to `main`
+  - Verify the tag matches the checked-in `package.json` version.
+  - Verify the tagged commit is on `main`.
+  - Build and test the CLI.
+  - Create a tarball with `npm pack`.
+  - Publish the package to npm using the repository `NPM_TOKEN` secret.
+  - Create or update the matching GitHub Release.
+  - Upload the tarball as a release asset.
+
+Example release flow:
+
+```sh
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+Install from the release tarball with:
+
+```sh
+npm install -g https://github.com/willmruzek/share-ai-config/releases/download/v0.1.0/share-ai-config-0.1.0.tgz
+```

package/dest/commands/install.d.ts

@@ -0,0 +1,3 @@
+import type { AgentsContext } from '../lib/context.js';
+export declare function runInstallCommand(context: AgentsContext): Promise<void>;
+//# sourceMappingURL=install.d.ts.map

package/dest/commands/install.js

@@ -0,0 +1,4 @@
+import { installToTargets } from '../lib/install.js';
+export async function runInstallCommand(context) {
+    await installToTargets(context, { targetRoots: context.targetRoots });
+}

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

@@ -0,0 +1,12 @@
+import type { AgentsContext } from '../../lib/context.js';
+/**
+ * Imports one or more managed skills from a remote repository `skills/` directory into the local skills directory.
+ */
+export declare function runSkillsAddCommand(context: AgentsContext, input: {
+    repo: string;
+    skillNames: string[];
+    asName: string | undefined;
+    pin: boolean;
+    ref: string | undefined;
+}): Promise<void>;
+//# sourceMappingURL=add.d.ts.map

package/dest/commands/skills/add.js

@@ -0,0 +1,99 @@
+import fs from 'fs-extra';
+import { cloneRemoteRepo, createImportedSkillRecord, ensureSkillsLockfile, ensureSkillsRoot, findManagedSkill, formatManagedSkillSummary, getManagedSkillDirectory, loadSkillsLockfile, normalizeRemoteRepo, replaceManagedSkillDirectory, resolveManagedSkillImportPath, resolveSkillSourceDir, saveSkillsLockfile, timestampNow, upsertManagedSkill, } from '../../lib/skills.js';
+/**
+ * Normalizes and de-duplicates requested skill names while preserving their input order.
+ */
+function normalizeRequestedSkillNames(skillNames) {
+    const uniqueSkillNames = [];
+    const seenSkillNames = new Set();
+    for (const rawSkillName of skillNames) {
+        const normalizedSkillPath = resolveManagedSkillImportPath({
+            skillName: rawSkillName,
+        });
+        const skillName = normalizedSkillPath.slice('skills/'.length);
+        if (seenSkillNames.has(skillName)) {
+            continue;
+        }
+        seenSkillNames.add(skillName);
+        uniqueSkillNames.push(skillName);
+    }
+    return uniqueSkillNames;
+}
+/**
+ * Imports one or more managed skills from a remote repository `skills/` directory into the local skills directory.
+ */
+export async function runSkillsAddCommand(context, input) {
+    const repo = normalizeRemoteRepo(input.repo);
+    if (input.skillNames.length === 0) {
+        throw new Error('At least one skill name must be provided with --skill');
+    }
+    const requestedSkillNames = normalizeRequestedSkillNames(input.skillNames);
+    if (requestedSkillNames.length === 0) {
+        throw new Error('At least one skill name must be provided with --skill');
+    }
+    if (input.asName && requestedSkillNames.length !== 1) {
+        throw new Error('--as may only be used when importing exactly one skill');
+    }
+    await ensureSkillsRoot(context);
+    await ensureSkillsLockfile(context);
+    let lockfile = await loadSkillsLockfile(context);
+    const checkout = await cloneRemoteRepo({
+        ref: input.ref,
+        repo,
+    });
+    const skippedSkillNames = [];
+    const importedSkillSummaries = [];
+    try {
+        for (const requestedSkillName of requestedSkillNames) {
+            const skillName = input.asName ?? requestedSkillName;
+            const importedSkillPath = resolveManagedSkillImportPath({
+                skillName: requestedSkillName,
+            });
+            const existingManagedSkill = findManagedSkill(lockfile, {
+                name: skillName,
+            });
+            if (existingManagedSkill) {
+                skippedSkillNames.push(skillName);
+                continue;
+            }
+            const targetDir = getManagedSkillDirectory(context, { skillName });
+            if (await fs.pathExists(targetDir)) {
+                throw new Error(`A local skill directory already exists: ${targetDir}`);
+            }
+            const sourceDir = await resolveSkillSourceDir({
+                checkoutDir: checkout.checkoutDir,
+                repo,
+                skillName: requestedSkillName,
+            });
+            await replaceManagedSkillDirectory({
+                targetDir,
+                sourceDir,
+            });
+            const importedSkill = createImportedSkillRecord({
+                commit: checkout.commit,
+                importedAt: timestampNow(),
+                name: skillName,
+                path: importedSkillPath,
+                ref: input.pin ? checkout.commit : input.ref,
+                repo,
+            });
+            lockfile = upsertManagedSkill(lockfile, {
+                updatedSkill: importedSkill,
+            });
+            await saveSkillsLockfile(context, { lockfile });
+            importedSkillSummaries.push(formatManagedSkillSummary(importedSkill));
+        }
+    }
+    finally {
+        await checkout.cleanup();
+    }
+    for (const importedSkillSummary of importedSkillSummaries) {
+        console.log(`Imported ${importedSkillSummary}`);
+    }
+    if (skippedSkillNames.length > 0) {
+        console.warn(`Skipped already-imported skills: ${skippedSkillNames.join(', ')}`);
+    }
+    if (importedSkillSummaries.length === 0) {
+        console.log('No skills were imported.');
+    }
+}

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

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

package/dest/commands/skills/index.js

@@ -0,0 +1,90 @@
+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 { runSkillsRemoveCommand } from './remove.js';
+import { runSkillsUpdateAllCommand } from './update-all.js';
+import { runSkillsUpdateCommand } from './update.js';
+const skillsImportOptionsSchema = z.object({
+    skill: z.array(z.string()).optional(),
+    as: nonEmptyOptionStringSchema.optional(),
+    pin: z.boolean().optional().default(false),
+    ref: nonEmptyOptionStringSchema.optional(),
+});
+/**
+ * Registers the managed skills command tree on the parent CLI program.
+ */
+export function addSkillsCommand(input) {
+    const { parent, commandName, resolveContext } = input;
+    const skills = parent
+        .command('skills')
+        .description('Manage imported skills')
+        .usage('<subcommand> [args]')
+        .helpOption('-h, --help', 'Display this message')
+        .helpCommand(false)
+        .addHelpText('after', dedent `
+        Examples:
+          ${commandName} list
+          ${commandName} add anthropics/skills --skill skill-creator
+          ${commandName} add vercel-labs/agent-skills --skill pr-review commit
+          ${commandName} update skill-creator
+      `)
+        .action(() => {
+        skills.outputHelp();
+    });
+    skills
+        .command('list')
+        .description('List local skills')
+        .action(async () => {
+        await runSkillsListCommand(resolveContext());
+    });
+    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('--as <name>', 'Store the imported skill under a different local managed name', parseOptionValue({
+        schema: nonEmptyOptionStringSchema,
+        optionLabel: '--as',
+    }))
+        .option('--pin', 'Pin the import to the currently resolved commit instead of tracking a moving ref')
+        .option('--ref <gitRef>', 'Fetch a specific git ref instead of the remote default', parseOptionValue({
+        schema: nonEmptyOptionStringSchema,
+        optionLabel: '--ref',
+    }))
+        .action(async (repo, options) => {
+        const parsedOptions = parseOptionsObject({
+            schema: skillsImportOptionsSchema,
+            options,
+            optionsLabel: 'skills add options',
+        });
+        await runSkillsAddCommand(resolveContext(), {
+            repo,
+            skillNames: parsedOptions.skill ?? [],
+            asName: parsedOptions.as,
+            pin: parsedOptions.pin,
+            ref: parsedOptions.ref,
+        });
+    });
+    skills
+        .command('remove <name>')
+        .description('Remove a managed skill')
+        .action(async (skillName) => {
+        await runSkillsRemoveCommand(resolveContext(), { skillName });
+    });
+    skills
+        .command('update <name>')
+        .description('Update a managed skill from its tracked source')
+        .action(async (skillName) => {
+        await runSkillsUpdateCommand(resolveContext(), { skillName });
+    });
+    skills
+        .command('update-all')
+        .description('Update all managed skills from their tracked sources')
+        .action(async () => {
+        await runSkillsUpdateAllCommand(resolveContext());
+    });
+    return skills;
+}

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

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

package/dest/commands/skills/list.js

@@ -0,0 +1,26 @@
+import { ensureSkillsRoot, findManagedSkill, formatManagedSkillSummary, listLocalSkillDirectories, loadSkillsLockfile, } from '../../lib/skills.js';
+/**
+ * Lists local skills and annotates which ones are managed by the lockfile.
+ */
+export async function runSkillsListCommand(context) {
+    await ensureSkillsRoot(context);
+    const [localSkillDirectories, lockfile] = await Promise.all([
+        listLocalSkillDirectories(context),
+        loadSkillsLockfile(context),
+    ]);
+    const localSkillLines = localSkillDirectories.map((skillName) => {
+        const managedSkill = findManagedSkill(lockfile, { name: skillName });
+        return managedSkill
+            ? `- ${formatManagedSkillSummary(managedSkill)}`
+            : `- ${skillName} unmanaged`;
+    });
+    const missingManagedLines = lockfile.skills
+        .filter((managedSkill) => !localSkillDirectories.includes(managedSkill.name))
+        .map((managedSkill) => `- ${formatManagedSkillSummary(managedSkill)} missing-local-directory`);
+    const outputLines = [...localSkillLines, ...missingManagedLines];
+    if (outputLines.length === 0) {
+        console.log('No local skills found.');
+        return;
+    }
+    console.log(outputLines.join('\n'));
+}

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

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

package/dest/commands/skills/remove.js

@@ -0,0 +1,17 @@
+import { findManagedSkill, formatManagedSkillSummary, loadSkillsLockfile, removeManagedSkill, removeManagedSkillDirectory, saveSkillsLockfile, } from '../../lib/skills.js';
+/**
+ * Removes a managed skill from the local directory and updates the lockfile.
+ */
+export async function runSkillsRemoveCommand(context, input) {
+    const { skillName } = input;
+    const lockfile = await loadSkillsLockfile(context);
+    const managedSkill = findManagedSkill(lockfile, { name: skillName });
+    if (!managedSkill) {
+        throw new Error(`Managed skill not found: ${skillName}`);
+    }
+    await removeManagedSkillDirectory(context, { skillName });
+    await saveSkillsLockfile(context, {
+        lockfile: removeManagedSkill(lockfile, { name: skillName }),
+    });
+    console.log(`Removed ${formatManagedSkillSummary(managedSkill)}`);
+}

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

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

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

@@ -0,0 +1,39 @@
+import { createUpdatedSkillRecord, 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) {
+    let lockfile = await loadSkillsLockfile(context);
+    if (lockfile.skills.length === 0) {
+        console.log('No managed skills to update.');
+        return;
+    }
+    const updatedLines = [];
+    for (const managedSkill of lockfile.skills) {
+        const snapshot = await fetchRemoteSkillSnapshot({
+            ref: managedSkill.ref,
+            repo: managedSkill.repo,
+            skillPath: managedSkill.path,
+        });
+        try {
+            await replaceManagedSkillDirectory({
+                targetDir: getManagedSkillDirectory(context, {
+                    skillName: managedSkill.name,
+                }),
+                sourceDir: snapshot.sourceDir,
+            });
+        }
+        finally {
+            await snapshot.cleanup();
+        }
+        const updatedSkill = createUpdatedSkillRecord({
+            commit: snapshot.commit,
+            existingSkill: managedSkill,
+            updatedAt: timestampNow(),
+        });
+        lockfile = upsertManagedSkill(lockfile, { updatedSkill });
+        updatedLines.push(`- ${formatManagedSkillSummary(updatedSkill)}`);
+    }
+    await saveSkillsLockfile(context, { lockfile });
+    console.log(`Updated ${updatedLines.length} managed skills:\n${updatedLines.join('\n')}`);
+}

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

@@ -0,0 +1,8 @@
+import type { AgentsContext } from '../../lib/context.js';
+/**
+ * Updates one managed skill from its tracked remote source and refreshes the lockfile.
+ */
+export declare function runSkillsUpdateCommand(context: AgentsContext, input: {
+    skillName: string;
+}): Promise<void>;
+//# sourceMappingURL=update.d.ts.map

package/dest/commands/skills/update.js

@@ -0,0 +1,35 @@
+import { createUpdatedSkillRecord, 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) {
+    const { skillName } = input;
+    const lockfile = await loadSkillsLockfile(context);
+    const managedSkill = findManagedSkill(lockfile, { name: skillName });
+    if (!managedSkill) {
+        throw new Error(`Managed skill not found: ${skillName}`);
+    }
+    const snapshot = await fetchRemoteSkillSnapshot({
+        ref: managedSkill.ref,
+        repo: managedSkill.repo,
+        skillPath: managedSkill.path,
+    });
+    try {
+        await replaceManagedSkillDirectory({
+            targetDir: getManagedSkillDirectory(context, { skillName }),
+            sourceDir: snapshot.sourceDir,
+        });
+    }
+    finally {
+        await snapshot.cleanup();
+    }
+    const updatedSkill = createUpdatedSkillRecord({
+        commit: snapshot.commit,
+        existingSkill: managedSkill,
+        updatedAt: timestampNow(),
+    });
+    await saveSkillsLockfile(context, {
+        lockfile: upsertManagedSkill(lockfile, { updatedSkill }),
+    });
+    console.log(`Updated ${formatManagedSkillSummary(updatedSkill)}`);
+}

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const nonEmptyOptionStringSchema: z.ZodString;
+/**
+ * Parses one Commander option value with a Zod schema.
+ */
+export declare function parseOptionValue<TSchema extends z.ZodTypeAny>({ schema, optionLabel, }: {
+    schema: TSchema;
+    optionLabel: string;
+}): (value: z.input<TSchema>) => z.output<TSchema>;
+/**
+ * Parses a Commander options object with a Zod schema.
+ */
+export declare function parseOptionsObject<TSchema extends z.ZodTypeAny>({ schema, options, optionsLabel, }: {
+    schema: TSchema;
+    options: unknown;
+    optionsLabel: string;
+}): z.output<TSchema>;
+//# sourceMappingURL=command-options.d.ts.map

package/dest/lib/command-options.js

@@ -0,0 +1,31 @@
+import { InvalidArgumentError } from 'commander';
+import { z } from 'zod';
+export const nonEmptyOptionStringSchema = z.string().trim().min(1);
+/**
+ * Parses a value with a Zod schema, throwing a Commander InvalidArgumentError on failure.
+ */
+function parseWithSchema({ schema, value, label, }) {
+    const result = schema.safeParse(value);
+    if (result.success) {
+        return result.data;
+    }
+    const issues = result.error.issues
+        .map((issue) => {
+        const issuePath = issue.path.length > 0 ? `${issue.path.join('.')}: ` : '';
+        return `${issuePath}${issue.message}`;
+    })
+        .join('; ');
+    throw new InvalidArgumentError(`${label}: ${issues}`);
+}
+/**
+ * Parses one Commander option value with a Zod schema.
+ */
+export function parseOptionValue({ schema, optionLabel, }) {
+    return (value) => parseWithSchema({ schema, value, label: optionLabel });
+}
+/**
+ * Parses a Commander options object with a Zod schema.
+ */
+export function parseOptionsObject({ schema, options, optionsLabel, }) {
+    return parseWithSchema({ schema, value: options, label: optionsLabel });
+}

package/dest/lib/context.d.ts

@@ -0,0 +1,73 @@
+export type TargetRoots = {
+    copilotPrompts: string;
+    copilotInstructions: string;
+    copilotSkills: string;
+    cursorRules: string;
+    cursorSkills: string;
+};
+export type SourceRoots = {
+    commands: string;
+    rules: string;
+    skills: string;
+};
+export type AgentsContext = {
+    inputRoot: string;
+    outputRoot: string;
+    skillsLockfilePath: string;
+    sourceRoots: SourceRoots;
+    targetRoots: TargetRoots;
+};
+export declare const DEFAULT_INPUT_ROOT_SEGMENTS: readonly [".config", "agents"];
+export declare const DEFAULT_TEST_OUTPUT_DIR_NAME = "output-test";
+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.
+ */
+export declare function createSourceRoots(baseDir: string): SourceRoots;
+/**
+ * Expands a leading `~` in a path to the current user's home directory.
+ */
+export declare function expandHomePath(inputPath: string, homeDir: string): string;
+/**
+ * Returns the requested output-root override derived from CLI-style options.
+ */
+export declare function resolveRequestedOutputRoot(input: {
+    test: boolean;
+    outputRoot?: string;
+}): string | undefined;
+/**
+ * Returns the filesystem path to use for generated output.
+ */
+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.
+ */
+export declare function resolveOutputContext(context: AgentsContext, outputRoot: string): AgentsContext;
+/**
+ * Creates the base CLI context with repository, input, and output paths
+ * resolved.
+ */
+export declare function createAgentsContext(options?: {
+    inputRoot?: string;
+    outputRoot?: string;
+}): AgentsContext;
+//# sourceMappingURL=context.d.ts.map