dryai 2.2.0 → 3.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Share AI config CLI
 
-Installs command, rule, and skill sources from `~/.config/dryai` by default into Copilot and Cursor targets.
+Syncs command, rule, and skill sources from `~/.config/dryai` by default into supported agent targets.
 
 Global CLI options:
 
@@ -18,7 +18,7 @@ Input config files live under the selected config root:
 - `rules`
 - `skills`
 
-Live output is written to:
+The current built-in agent config writes live output to these default roots:
 
 - `~/.copilot/prompts`
 - `~/.copilot/instructions`
@@ -43,11 +43,13 @@ See VS Code editor setup note below.
 
 ## Commands
 
-### `install`
+### `sync`
 
-- Purpose: Install commands, rules, and skills from the selected config root into the Copilot and Cursor target directories.
+- Purpose: Sync commands, rules, and skills from the selected config root into the configured agent target directories.
 - Input roots: Reads from `commands`, `rules`, and `skills` under the selected config root.
-- Output roots: Writes to `~/.copilot/prompts`, `~/.copilot/instructions`, `~/.copilot/skills`, `~/.cursor/rules`, and `~/.cursor/skills` by default.
+- Output roots: Writes to the live output paths listed in Config Layout by default.
+- Pruning: Removes stale dryai-managed outputs that were written by earlier sync runs but are no longer present in the selected config root.
+- Safety: Only prunes outputs tracked in `sync-manifest.json`; unrelated user files in target roots are left alone.
 
 ### `skills add`
 
@@ -144,20 +146,21 @@ dryai skills update-all --force
 Rules are markdown files under `rules/`. `dryai` recognizes these rule frontmatter fields:
 
 - `description`
-- `copilot.applyTo`
-- `cursor.alwaysApply`
-- `cursor.globs`
+- `agents.copilot.applyTo`
+- `agents.cursor.alwaysApply`
+- `agents.cursor.globs`
 
-`cursor.globs` should be provided as one comma-separated glob string.
+`agents.cursor.globs` should be provided as one comma-separated glob string.
 
 ```md
 ---
 description: Reply with "Yes, Captain!" before answering when the user says "Make it so" or "Engage".
-copilot:
-  applyTo: '**/*.tsx, **/*.ts, src/**/*.ts, src/**/*.tsx, src/**/*.js, src/**/*.jsx'
-cursor:
-  alwaysApply: false
-  globs: '**/*.tsx, **/*.ts, src/**/*.ts, src/**/*.tsx, src/**/*.js, src/**/*.jsx'
+agents:
+  copilot:
+    applyTo: '**/*.tsx, **/*.ts, src/**/*.ts, src/**/*.tsx, src/**/*.js, src/**/*.jsx'
+  cursor:
+    alwaysApply: false
+    globs: '**/*.tsx, **/*.ts, src/**/*.ts, src/**/*.tsx, src/**/*.js, src/**/*.jsx'
 ---
 
 # Say Yes Captain
@@ -171,14 +174,15 @@ Commands are markdown files under `commands/`. `dryai` recognizes these command
 
 - `name`
 - `description`
-- `cursor.disable-model-invocation`
+- `agents.cursor.disable-model-invocation`
 
 ```md
 ---
 name: gen-commit-msg
 description: Generate a conventional commit message from the current staged git diff.
-cursor:
-  disable-model-invocation: true
+agents:
+  cursor:
+    disable-model-invocation: true
 ---
 
 # Generate Commit Message
@@ -188,9 +192,9 @@ Read the staged diff and produce a conventional commit message with a concise su
 
 ### Example Skill
 
-Skills live in directories under `skills/`. The directory is copied as-is into the Copilot and Cursor skills targets.
+Skills live in directories under `skills/`. The directory is copied as-is into the configured agent skill targets.
 
-Unlike commands and rules, `dryai` does not define or validate a fixed skill frontmatter schema. Skill files are passed through unchanged, so the allowed frontmatter fields depend on the skill format expected by the target editor or agent.
+Unlike commands and rules, `dryai` does not define or validate a fixed skill frontmatter schema. Skill files are passed through unchanged, so the allowed frontmatter fields depend on the skill format expected by the target agent.
 
 ```text
 skills/
@@ -232,9 +236,9 @@ pnpm dev:dryai <...>
 
 ## VS Code Setup
 
-VS Code Copilot does not automatically discover prompt files from `~/.copilot/prompts`.
+One current editor-specific note: VS Code does not automatically discover prompt files from the Copilot prompt target at `~/.copilot/prompts`.
 
-Add this to your VS Code user settings so prompt files installed by `dryai` are picked up:
+Add this to your VS Code user settings if you want prompt files installed by `dryai` into that target to be picked up:
 
 ```json
 {

package/dest/cli.d.ts

@@ -0,0 +1,68 @@
+import { Command } from 'commander';
+import { z } from 'zod';
+import { type AgentsContext } from './lib/context.js';
+declare const rootOptionsSchema: z.ZodObject<{
+    test: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    configRoot: z.ZodOptional<z.ZodString>;
+    outputRoot: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RootOptions = z.output<typeof rootOptionsSchema>;
+/**
+ * Raw stdout/stderr write functions, without newline conventions. These are
+ * the CLI-layer primitive used by Commander for help and version output; they
+ * also back the higher-level {@link CLIRuntime}.
+ */
+export type StdioWriters = {
+    writeOut: (output: string) => void;
+    writeErr: (output: string) => void;
+};
+/**
+ * The line-oriented output interface available to every command action.
+ *
+ * Both methods append a trailing newline. The `log*` prefix is used to make
+ * call sites trivially greppable ("where do we emit CLI output?") without
+ * colliding with `console.log` / `console.warn` or arbitrary variables.
+ *
+ * Commands should not reach for the underlying {@link StdioWriters.writeOut}
+ * / {@link StdioWriters.writeErr} stream writes; that raw byte-level stream
+ * access is confined to the CLI layer (Commander help/version output).
+ */
+export type CLIRuntime = {
+    /** Writes an informational message to stdout, with an appended newline. */
+    logInfo: (message: string) => void;
+    /** Writes a warning message to stderr, with an appended newline. */
+    logWarn: (message: string) => void;
+};
+/**
+ * The shared environment passed into every command action: the
+ * resolved domain context plus the runtime used for CLI output.
+ */
+export type CommandEnv = {
+    context: AgentsContext;
+    runtime: CLIRuntime;
+};
+export type CLIOptions = {
+    executableName?: string;
+    version: string;
+    stdioWriters?: StdioWriters;
+};
+/**
+ * Builds an AgentsContext from the parsed root options, expanding ~ in paths and applying --test path defaults.
+ */
+export declare function resolveActiveContext(rootOptions: RootOptions): AgentsContext;
+/**
+ * Creates the production stdio writers backed by the real process streams.
+ */
+export declare function createProductionStdioWriters(): StdioWriters;
+/**
+ * Builds and returns the Commander program with all subcommands and global flags registered.
+ */
+export declare function createCLI(options: CLIOptions): Command;
+/**
+ * Parses argv and runs the matching command, returning the Commander program after completion.
+ */
+export declare function runCLI(input: {
+    argv: string[];
+} & CLIOptions): Promise<Command>;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dest/cli.js

@@ -0,0 +1,147 @@
+import { Command } from 'commander';
+import { z } from 'zod';
+import { addSkillsCommand } from './commands/skills/index.js';
+import { runSyncCommand } from './commands/sync.js';
+import { describeSupportedAgents } from './lib/agents.js';
+import { nonEmptyOptionStringSchema, parseOptionValue, parseOptionsObject, } from './lib/command-options.js';
+import { createAgentsContext, resolveRequestedConfigRoot, resolveRequestedOutputRoot, } from './lib/context.js';
+const rootOptionsSchema = z.object({
+    test: z.boolean().optional().default(false),
+    configRoot: nonEmptyOptionStringSchema.optional(),
+    outputRoot: nonEmptyOptionStringSchema.optional(),
+});
+/**
+ * Parses the top-level CLI options into a validated shape.
+ */
+function getRootOptions(program) {
+    return parseOptionsObject({
+        schema: rootOptionsSchema,
+        options: program.opts(),
+        optionsLabel: 'root options',
+    });
+}
+/**
+ * Returns true if --test or --output-root was passed.
+ */
+function requestedOutputRootWasUsed(rootOptions) {
+    return rootOptions.test || rootOptions.outputRoot !== undefined;
+}
+/**
+ * Builds an AgentsContext from the parsed root options, expanding ~ in paths and applying --test path defaults.
+ */
+export function resolveActiveContext(rootOptions) {
+    const requestedConfigRoot = resolveRequestedConfigRoot({
+        ...(rootOptions.configRoot ? { configRoot: rootOptions.configRoot } : {}),
+    });
+    const requestedOutputRoot = resolveRequestedOutputRoot({
+        test: rootOptions.test,
+        ...(rootOptions.outputRoot ? { outputRoot: rootOptions.outputRoot } : {}),
+    });
+    return createAgentsContext({
+        ...(requestedConfigRoot ? { inputRoot: requestedConfigRoot } : {}),
+        ...(requestedOutputRoot ? { outputRoot: requestedOutputRoot } : {}),
+    });
+}
+/**
+ * Derives a {@link CLIRuntime} from a pair of raw stdio writers by wrapping
+ * each writer with the line-oriented newline convention.
+ */
+function wrapStdioWriters(stdioWriters) {
+    return {
+        logInfo(message) {
+            stdioWriters.writeOut(`${message}\n`);
+        },
+        logWarn(message) {
+            stdioWriters.writeErr(`${message}\n`);
+        },
+    };
+}
+/**
+ * Creates the production stdio writers backed by the real process streams.
+ */
+export function createProductionStdioWriters() {
+    return {
+        writeOut(output) {
+            process.stdout.write(output);
+        },
+        writeErr(output) {
+            process.stderr.write(output);
+        },
+    };
+}
+/**
+ * Merges the provided CLIOptions with production defaults, returning a fully resolved options object.
+ */
+function resolveCLIOptions(options) {
+    return {
+        executableName: options.executableName ?? 'dryai',
+        version: options.version,
+        stdioWriters: options.stdioWriters ?? createProductionStdioWriters(),
+    };
+}
+/**
+ * Builds and returns the Commander program with all subcommands and global flags registered.
+ */
+export function createCLI(options) {
+    const resolvedOptions = resolveCLIOptions(options);
+    const program = new Command();
+    const executableName = resolvedOptions.executableName;
+    const stdioWriters = resolvedOptions.stdioWriters;
+    const runtime = wrapStdioWriters(stdioWriters);
+    const resolveEnv = () => ({
+        context: resolveActiveContext(getRootOptions(program)),
+        runtime,
+    });
+    program.configureOutput({
+        writeOut: (output) => {
+            stdioWriters.writeOut(output);
+        },
+        writeErr: (output) => {
+            stdioWriters.writeErr(output);
+        },
+    });
+    program
+        .name(executableName)
+        .usage('[options] <command> [args]')
+        .helpOption('-h, --help', 'Display this message')
+        .version(resolvedOptions.version, '-v, --version', 'Display the current version')
+        .option('--test', 'Shortcut for writing generated output into ./output-test unless --output-root is also provided')
+        .option('--config-root <path>', 'Read configs from a different root instead of ~/.config/dryai', parseOptionValue({
+        schema: nonEmptyOptionStringSchema,
+        optionLabel: '--config-root',
+    }))
+        .option('--output-root <path>', 'Write generated output under a different root instead of the default home directory', parseOptionValue({
+        schema: nonEmptyOptionStringSchema,
+        optionLabel: '--output-root',
+    }))
+        .helpCommand(false)
+        .action(() => {
+        program.outputHelp();
+    });
+    program
+        .command('sync')
+        .description(`Sync generated output into ${describeSupportedAgents()} targets`)
+        .action(async () => {
+        const rootOptions = getRootOptions(program);
+        const env = resolveEnv();
+        await runSyncCommand(env);
+        if (requestedOutputRootWasUsed(rootOptions)) {
+            runtime.logInfo(`Generated output written to ${env.context.outputRoot}`);
+        }
+    });
+    addSkillsCommand({
+        program,
+        commandName: `${executableName} skills`,
+        resolveEnv,
+    });
+    return program;
+}
+/**
+ * Parses argv and runs the matching command, returning the Commander program after completion.
+ */
+export async function runCLI(input) {
+    const { argv, ...options } = input;
+    const program = createCLI(options);
+    await program.parseAsync(argv, { from: 'user' });
+    return program;
+}

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

@@ -1,8 +1,8 @@
-import type { AgentsContext } from '../../lib/context.js';
+import type { CommandEnv } from '../../cli.js';
 /**
  * Imports one or more managed skills from a remote repository into the local skills directory.
  */
-export declare function runSkillsAddCommand(context: AgentsContext, input: {
+export declare function runSkillsAddCommand(env: CommandEnv, input: {
     repo: string;
     repoPath: string | undefined;
     skillNames: string[];

package/dest/commands/skills/add.js

@@ -1,5 +1,5 @@
 import fs from 'fs-extra';
-import { cloneRemoteRepo, computeDirectoryHashes, createImportedSkillRecord, deriveSkillName, ensureSkillsLockfile, ensureSkillsRoot, findManagedSkill, formatManagedSkillSummary, getManagedSkillDirectory, loadSkillsLockfile, normalizeImportedSkillPath, normalizeRemoteRepo, replaceManagedSkillDirectory, resolveManagedSkillImportPath, resolveManagedSkillImportPathFromBase, resolveSkillSourceDirByPath, saveSkillsLockfile, timestampNow, upsertManagedSkill, } from '../../lib/skills.js';
+import { cleanupRemoteRepoCheckout, cloneRemoteRepo, computeDirectoryHashes, createImportedSkillRecord, deriveSkillName, ensureSkillsLockfile, ensureSkillsRoot, findManagedSkill, formatManagedSkillSummary, getManagedSkillDirectory, loadSkillsLockfile, normalizeImportedSkillPath, normalizeRemoteRepo, replaceManagedSkillDirectory, resolveManagedSkillImportPath, resolveManagedSkillImportPathFromBase, resolveSkillSourceDirByPath, saveSkillsLockfile, timestampNow, upsertManagedSkill, } from '../../lib/skills.js';
 /**
  * Normalizes and de-duplicates requested skill names while preserving their input order.
  */
@@ -20,7 +20,22 @@ function normalizeRequestedSkillNames(skillNames) {
     return uniqueSkillNames;
 }
 /**
- * Resolves the remote repository path for one managed skill import request.
+ * Returns the resolved repository-relative import path for a single requested skill.
+ *
+ * @example
+ * // No base path — defaults to the repository `skills/` directory
+ * resolveRequestedImportPath({ basePath: undefined, requestedSkillName: 'my-skill' });
+ * // → 'skills/my-skill'
+ *
+ * @example
+ * // With a base path — skill is resolved relative to that directory
+ * resolveRequestedImportPath({ basePath: 'tools', requestedSkillName: 'my-skill' });
+ * // → 'tools/my-skill'
+ *
+ * @example
+ * // Base path of '.' — skill is resolved from the repository root
+ * resolveRequestedImportPath({ basePath: '.', requestedSkillName: 'my-skill' });
+ * // → 'my-skill'
  */
 function resolveRequestedImportPath(input) {
     const importPath = resolveManagedSkillImportPathFromBase({
@@ -32,7 +47,8 @@ function resolveRequestedImportPath(input) {
 /**
  * Imports one or more managed skills from a remote repository into the local skills directory.
  */
-export async function runSkillsAddCommand(context, input) {
+export async function runSkillsAddCommand(env, input) {
+    const { context, runtime } = env;
     const repo = normalizeRemoteRepo(input.repo);
     const normalizedBasePath = normalizeImportedSkillPath(input.repoPath);
     if (input.skillNames.length === 0) {
@@ -103,15 +119,15 @@ export async function runSkillsAddCommand(context, input) {
         }
     }
     finally {
-        await checkout.cleanup();
+        await cleanupRemoteRepoCheckout(checkout);
     }
     for (const importedSkillSummary of importedSkillSummaries) {
-        console.log(`Imported ${importedSkillSummary}`);
+        runtime.logInfo(`Imported ${importedSkillSummary}`);
     }
     if (skippedSkillNames.length > 0) {
-        console.warn(`Skipped already-imported skills: ${skippedSkillNames.join(', ')}`);
+        runtime.logWarn(`Skipped already-imported skills: ${skippedSkillNames.join(', ')}`);
     }
     if (importedSkillSummaries.length === 0) {
-        console.log('No skills were imported.');
+        runtime.logInfo('No skills were imported.');
     }
 }

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,6 +8,7 @@ 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(),
@@ -24,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]')
@@ -48,7 +47,7 @@ export function addSkillsCommand(input) {
         .command('list')
         .description('List local skills')
         .action(async () => {
-        await runSkillsListCommand(resolveContext());
+        await runSkillsListCommand(resolveEnv());
     });
     skills
         .command('add <repo>')
@@ -73,7 +72,7 @@ export function addSkillsCommand(input) {
             options,
             optionsLabel: 'skills add options',
         });
-        await runSkillsAddCommand(resolveContext(), {
+        await runSkillsAddCommand(resolveEnv(), {
             repo,
             repoPath: parsedOptions.path,
             skillNames: parsedOptions.skill ?? [],
@@ -86,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>')
@@ -110,7 +109,7 @@ export function addSkillsCommand(input) {
             options,
             optionsLabel: 'skills update options',
         });
-        await runSkillsUpdateCommand(resolveContext(), {
+        await runSkillsUpdateCommand(resolveEnv(), {
             force: parsedOptions.force,
             skillName,
         });
@@ -125,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