@nano-step/skill-manager 4.0.0 → 5.0.1

package/README.md

@@ -1,211 +1,116 @@
 # @nano-step/skill-manager
 
-CLI tool that installs and manages **AI agent skills** into [OpenCode](https://github.com/sst/opencode) projects. Reduces token usage by **80-95%** by isolating MCP tool definitions in a dedicated subagent context.
+Multi-skill registry CLI for [OpenCode](https://github.com/sst/opencode). Install, manage, and update AI agent skills from a built-in catalog.
 
-## Why?
-
-When using many MCP (Model Context Protocol) tools, the tool definitions consume thousands of tokens in your main agent's context window. This tool creates a lightweight routing layer that:
-
-1. **Installs a skill** (`mcp-management`) with routing logic and documentation
-2. **Configures a subagent** (`mcp-manager`) using a fast, cheap model
-3. **Caches tool metadata** in `.opencode/mcp-tools.json` for instant routing
-4. **Returns summarized results** — main agent stays lean
-
-## Installation
+## Quick Start
 
 ```bash
-npx @nano-step/skill-manager
-```
+# List available skills
+npx @nano-step/skill-manager list
 
-This will:
-- Detect your OpenCode config directory (`.opencode/` or `~/.config/opencode/`)
-- Install the `mcp-management` skill with routing logic
-- Install the `/mcp-refresh` command
-- Add the `mcp-manager` subagent to `oh-my-opencode.json`
+# Install a skill
+npx @nano-step/skill-manager install skill-management
 
-## Usage
-
-### Install (first time)
-
-```bash
-npx @nano-step/skill-manager
+# Install all skills
+npx @nano-step/skill-manager install --all
 ```
 
-### Update (to latest version)
+## Commands
 
-```bash
-npx @nano-step/skill-manager --update
-```
-
-Creates timestamped backups of customized files before updating.
+| Command | Description |
+|---------|-------------|
+| `list` | Show available skills from the catalog |
+| `install <name>` | Install a specific skill |
+| `install --all` | Install all available skills |
+| `remove <name>` | Remove an installed skill |
+| `update [name]` | Update one or all installed skills |
+| `installed` | Show currently installed skills |
 
-### Remove
+## Available Skills
 
-```bash
-npx @nano-step/skill-manager --remove
-```
-
-Cleanly removes all installed artifacts.
+| Skill | Description |
+|-------|-------------|
+| `skill-management` | AI skill routing — isolates tool definitions in subagent context to save 80-95% tokens |
+| `graphql-inspector` | GraphQL schema inspection with progressive discovery workflow |
 
 ## What Gets Installed
 
-| Artifact | Location | Purpose |
-|----------|----------|---------|
-| Skill | `{config}/skills/mcp-management/` | Routing logic & documentation |
-| Command | `{config}/command/agent-skill-refresh.md` | Re-index MCP tools |
-| Agent | `{config}/oh-my-opencode.json` | `mcp-manager` subagent config |
-| Version | `{config}/.agent-skill-version.json` | Track installed version |
-
-## After Installation
-
-Run the refresh command in OpenCode to create the initial tool cache:
+When you install a skill, the manager:
 
-```
-/agent-skill-refresh
-```
-
-This analyzes all available MCP tools and creates a semantic index at `.opencode/mcp-tools.json`.
-
-## Config Detection
+1. Copies skill files (SKILL.md, references, assets) to `{config}/skills/{name}/`
+2. Copies command files to `{config}/command/` (if the skill has commands)
+3. Merges agent config into `{config}/oh-my-opencode.json` (if the skill defines an agent)
+4. Tracks installation state in `{config}/.skill-manager.json`
 
-The tool looks for OpenCode configuration in this order:
+Config directory is detected automatically: `.opencode/` (project-level, preferred) or `~/.config/opencode/` (global).
 
-1. **Project-level**: `.opencode/` in current directory (preferred)
-2. **Global**: `~/.config/opencode/`
-
-## How It Works
-
-```
-User request → Main agent (Opus/Sonnet)
-  ↓ delegates MCP task
-  mcp-manager subagent (Haiku — fast & cheap)
-  ↓ reads .opencode/mcp-tools.json cache
-  ↓ routes to correct MCP tool category
-  ↓ executes tool, summarizes result
-  ↓ returns to main agent
-Main agent continues with minimal token cost
-```
+## Migrating from v4
 
-### Tool Categories
-
-| Category | Tools | Example |
-|----------|-------|---------|
-| browser | chrome-devtools__* | Screenshots, clicks, navigation |
-| github | github-*__* | PRs, issues, repos |
-| graphql | graphql-tools__* | Schema inspection, queries |
-| docs | context7__* | Documentation lookup |
-| reasoning | Sequential-Thinking__* | Complex analysis |
-
-## Advanced Features (v4.0.0)
-
-### Direct Passthrough
-
-Skip routing when you know the exact tool name:
-
-```
-MetaMCP_chrome-devtools__take_screenshot
-```
+v5.0.0 replaces the flag-based CLI with subcommands:
 
-Any tool name containing `__` executes directly without category lookup.
+| v4 (old) | v5 (new) |
+|----------|----------|
+| `npx @nano-step/skill-manager` | `npx @nano-step/skill-manager install skill-management` |
+| `npx @nano-step/skill-manager --update` | `npx @nano-step/skill-manager update` |
+| `npx @nano-step/skill-manager --remove` | `npx @nano-step/skill-manager remove skill-management` |
 
-### Batch Operations
-
-Execute multiple tools in one request:
-
-```
-BATCH: [
-  {"tool": "screenshot", "params": {}},
-  {"tool": "get_title", "params": {}}
-]
-```
-
-- Maximum 10 tools per batch
-- Returns array of results in execution order
-
-### Tool Chaining
-
-Chain tools with output passing:
-
-```
-CHAIN: [
-  {"tool": "get_element", "params": {"selector": "#btn"}, "output_as": "el"},
-  {"tool": "click", "params": {"element": "$el"}}
-]
-```
-
-- Use `$varname` to reference previous outputs
-- Maximum 5 tools per chain
-
-### Automatic Retry
-
-All tool executions automatically retry on failure:
-
-- Up to 3 attempts with delays: 0s → 1s → 2s
-- Returns detailed failure report if all attempts fail
-
-### Workflows
-
-Define prerequisite steps that automatically execute before certain tools:
-
-```bash
-# Add a workflow from template
-/agent-skill-workflow add --template database
-
-# List active workflows
-/agent-skill-workflow list
-
-# Disable temporarily
-/agent-skill-workflow disable database-safe-query
-```
-
-**Built-in templates:**
-
-| Template | Description | Prerequisites |
-|----------|-------------|---------------|
-| `database` | Safe database queries | list_databases → list_tables → inspect_table |
-| `browser` | Safe browser interaction | take_snapshot |
-| `github-pr` | PR review workflow | get_pr → get_files → get_status |
-
-**Workflow modes:**
-- `enforce`: Auto-run prerequisites (default)
-- `warn`: Show warning, allow skip
-- `suggest`: Mention only, don't block
+Existing v4 installations are automatically migrated on first run.
 
 ## Development
 
-### Build
-
 ```bash
 npm install
 npm run build
-```
 
-### Test Locally
-
-```bash
-# After building
-node bin/cli.js          # Install
-node bin/cli.js --update # Update
-node bin/cli.js --remove # Remove
+# Test locally
+node bin/cli.js list
+node bin/cli.js install skill-management
+node bin/cli.js installed
+node bin/cli.js remove skill-management
 ```
 
 ### Project Structure
 
 ```
 skill-manager/
-├── src/                    # TypeScript source
-│   ├── index.ts           # CLI entry point
-│   ├── install.ts         # Installation logic
-│   ├── update.ts          # Update with backup
-│   ├── remove.ts          # Clean removal
-│   └── utils.ts           # Shared utilities
-├── templates/              # Files to install
-│   ├── agent.json         # mcp-manager agent config
-│   ├── command-refresh.md # /agent-skill-refresh command
-│   └── skill/             # mcp-management skill
-├── bin/cli.js             # Executable entry
-└── dist/                  # Compiled output
-```
+├── src/
+│   ├── index.ts          # CLI entry (commander subcommands)
+│   ├── registry.ts       # Scan skills/ dirs, load manifests
+│   ├── installer.ts      # Install/remove/update logic
+│   ├── state.ts          # Read/write .skill-manager.json
+│   ├── config.ts         # Merge agents/commands into oh-my-opencode.json
+│   └── utils.ts          # Path detection, file ops, shared types
+├── skills/
+│   ├── skill-management/
+│   │   ├── skill.json    # Skill manifest
+│   │   ├── SKILL.md      # Skill instructions
+│   │   ├── skill-refresh.md
+│   │   ├── references/   # Detailed documentation
+│   │   └── assets/       # Templates and schemas
+│   └── graphql-inspector/
+│       ├── skill.json
+│       └── SKILL.md
+├── bin/cli.js
+└── package.json
+```
+
+### Adding a New Skill
+
+1. Create `skills/<name>/` directory
+2. Add `skill.json` manifest:
+   ```json
+   {
+     "name": "<name>",
+     "version": "1.0.0",
+     "description": "...",
+     "compatibility": "OpenCode with ...",
+     "agent": null,
+     "commands": [],
+     "tags": ["..."]
+   }
+   ```
+3. Add `SKILL.md` with skill instructions
+4. Build and test: `npm run build && node bin/cli.js list`
 
 ## Related Projects
 

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import { SkillManifest } from "./utils";
+export declare function mergeAgentConfig(agentConfigPath: string, manifest: SkillManifest): Promise<void>;
+export declare function removeAgentConfig(agentConfigPath: string, manifest: SkillManifest): Promise<void>;
+export declare function copyCommands(manifest: SkillManifest, packageSkillDir: string, commandDir: string): Promise<void>;
+export declare function removeCommands(manifest: SkillManifest, commandDir: string): Promise<void>;

package/dist/config.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeAgentConfig = mergeAgentConfig;
+exports.removeAgentConfig = removeAgentConfig;
+exports.copyCommands = copyCommands;
+exports.removeCommands = removeCommands;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./utils");
+async function mergeAgentConfig(agentConfigPath, manifest) {
+    if (!manifest.agent)
+        return;
+    const config = await (0, utils_1.readJsonFile)(agentConfigPath, {});
+    const agents = (config.agents || {});
+    agents[manifest.agent.id] = manifest.agent.config;
+    config.agents = agents;
+    await (0, utils_1.writeJsonFile)(agentConfigPath, config);
+}
+async function removeAgentConfig(agentConfigPath, manifest) {
+    if (!manifest.agent)
+        return;
+    const exists = await fs_extra_1.default.pathExists(agentConfigPath);
+    if (!exists)
+        return;
+    const config = await (0, utils_1.readJsonFile)(agentConfigPath, {});
+    const agents = (config.agents || {});
+    if (Object.prototype.hasOwnProperty.call(agents, manifest.agent.id)) {
+        delete agents[manifest.agent.id];
+        config.agents = agents;
+        await (0, utils_1.writeJsonFile)(agentConfigPath, config);
+    }
+}
+async function copyCommands(manifest, packageSkillDir, commandDir) {
+    if (!manifest.commands || manifest.commands.length === 0)
+        return;
+    await (0, utils_1.ensureDirExists)(commandDir);
+    for (const cmd of manifest.commands) {
+        const src = path_1.default.join(packageSkillDir, cmd);
+        const dest = path_1.default.join(commandDir, cmd);
+        const srcExists = await fs_extra_1.default.pathExists(src);
+        if (srcExists) {
+            await fs_extra_1.default.copy(src, dest, { overwrite: true });
+        }
+    }
+}
+async function removeCommands(manifest, commandDir) {
+    if (!manifest.commands || manifest.commands.length === 0)
+        return;
+    for (const cmd of manifest.commands) {
+        const cmdPath = path_1.default.join(commandDir, cmd);
+        const exists = await fs_extra_1.default.pathExists(cmdPath);
+        if (exists) {
+            await fs_extra_1.default.remove(cmdPath);
+        }
+    }
+}

package/dist/index.js

@@ -6,29 +6,155 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = run;
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
-const install_1 = require("./install");
-const update_1 = require("./update");
-const remove_1 = require("./remove");
+const utils_1 = require("./utils");
+const registry_1 = require("./registry");
+const state_1 = require("./state");
+const installer_1 = require("./installer");
 async function run() {
+    const args = process.argv.slice(2);
+    if (args.includes("--update") || args.includes("--remove")) {
+        console.log(chalk_1.default.yellow("\n⚠️  The --update and --remove flags were removed in v5.0.0."));
+        console.log(chalk_1.default.yellow("Use subcommands instead:"));
+        console.log(chalk_1.default.cyan("  skill-manager install <name>   # Install a skill"));
+        console.log(chalk_1.default.cyan("  skill-manager remove <name>    # Remove a skill"));
+        console.log(chalk_1.default.cyan("  skill-manager update [name]    # Update skill(s)"));
+        console.log(chalk_1.default.cyan("  skill-manager list             # Show available skills"));
+        console.log(chalk_1.default.cyan("  skill-manager installed        # Show installed skills\n"));
+        process.exit(1);
+    }
     const program = new commander_1.Command();
     program
         .name("skill-manager")
-        .description("Install and manage AI agent skills and configurations")
-        .option("--update", "Update existing agent skill installation")
-        .option("--remove", "Remove agent skill installation")
-        .parse(process.argv);
-    const options = program.opts();
-    if (options.update && options.remove) {
-        console.error(chalk_1.default.red("Cannot use --update and --remove together."));
-        process.exit(1);
-    }
-    if (options.remove) {
-        await (0, remove_1.remove)();
-        return;
-    }
-    if (options.update) {
-        await (0, update_1.update)();
-        return;
-    }
-    await (0, install_1.install)();
+        .description("Install and manage AI agent skills for OpenCode")
+        .version(utils_1.MANAGER_VERSION);
+    program
+        .command("list")
+        .description("Show available skills from the catalog")
+        .action(async () => {
+        const paths = await (0, utils_1.detectOpenCodePaths)();
+        await (0, state_1.migrateV4State)(paths.configDir, paths.stateFilePath, paths.skillsDir);
+        const catalog = await (0, registry_1.loadCatalog)(paths.packageSkillsDir);
+        const state = await (0, state_1.loadState)(paths.stateFilePath);
+        if (catalog.length === 0) {
+            console.log(chalk_1.default.yellow("No skills found in catalog."));
+            return;
+        }
+        console.log(chalk_1.default.bold("\nAvailable Skills:\n"));
+        const nameWidth = 22;
+        const versionWidth = 10;
+        const statusWidth = 14;
+        console.log(chalk_1.default.gray("  " +
+            "Name".padEnd(nameWidth) +
+            "Version".padEnd(versionWidth) +
+            "Status".padEnd(statusWidth) +
+            "Description"));
+        console.log(chalk_1.default.gray("  " + "─".repeat(nameWidth + versionWidth + statusWidth + 30)));
+        for (const skill of catalog) {
+            const installed = state.skills[skill.name];
+            const status = installed ? chalk_1.default.green("installed") : chalk_1.default.gray("not installed");
+            console.log("  " +
+                chalk_1.default.cyan(skill.name.padEnd(nameWidth)) +
+                skill.version.padEnd(versionWidth) +
+                status.padEnd(statusWidth + 10) +
+                skill.description);
+        }
+        console.log("");
+    });
+    program
+        .command("install [name]")
+        .description("Install a skill from the catalog")
+        .option("--all", "Install all available skills")
+        .action(async (name, options) => {
+        const paths = await (0, utils_1.detectOpenCodePaths)();
+        await (0, state_1.migrateV4State)(paths.configDir, paths.stateFilePath, paths.skillsDir);
+        if (options.all) {
+            const catalog = await (0, registry_1.loadCatalog)(paths.packageSkillsDir);
+            if (catalog.length === 0) {
+                console.log(chalk_1.default.yellow("No skills found in catalog."));
+                return;
+            }
+            for (const skill of catalog) {
+                await (0, installer_1.installSkill)(skill.name, paths);
+            }
+        }
+        else if (name) {
+            await (0, installer_1.installSkill)(name, paths);
+        }
+        else {
+            console.error(chalk_1.default.red("Please specify a skill name or use --all."));
+            console.error(chalk_1.default.yellow("Run 'skill-manager list' to see available skills."));
+            process.exit(1);
+        }
+    });
+    program
+        .command("remove <name>")
+        .description("Remove an installed skill")
+        .action(async (name) => {
+        const paths = await (0, utils_1.detectOpenCodePaths)();
+        await (0, state_1.migrateV4State)(paths.configDir, paths.stateFilePath, paths.skillsDir);
+        await (0, installer_1.removeSkill)(name, paths);
+    });
+    program
+        .command("update [name]")
+        .description("Update installed skill(s) to latest catalog version")
+        .action(async (name) => {
+        const paths = await (0, utils_1.detectOpenCodePaths)();
+        await (0, state_1.migrateV4State)(paths.configDir, paths.stateFilePath, paths.skillsDir);
+        if (name) {
+            await (0, installer_1.updateSkill)(name, paths);
+        }
+        else {
+            const state = await (0, state_1.loadState)(paths.stateFilePath);
+            const installed = Object.keys(state.skills);
+            if (installed.length === 0) {
+                console.log(chalk_1.default.yellow("No skills installed. Use 'skill-manager install <name>' first."));
+                return;
+            }
+            for (const skillName of installed) {
+                await (0, installer_1.updateSkill)(skillName, paths);
+            }
+        }
+    });
+    program
+        .command("installed")
+        .description("Show currently installed skills")
+        .action(async () => {
+        const paths = await (0, utils_1.detectOpenCodePaths)();
+        await (0, state_1.migrateV4State)(paths.configDir, paths.stateFilePath, paths.skillsDir);
+        const state = await (0, state_1.loadState)(paths.stateFilePath);
+        const catalog = await (0, registry_1.loadCatalog)(paths.packageSkillsDir);
+        const installedNames = Object.keys(state.skills);
+        if (installedNames.length === 0) {
+            console.log(chalk_1.default.yellow("No skills installed."));
+            console.log(chalk_1.default.gray("Run 'skill-manager list' to see available skills."));
+            return;
+        }
+        console.log(chalk_1.default.bold("\nInstalled Skills:\n"));
+        const nameWidth = 22;
+        const versionWidth = 12;
+        const catalogWidth = 12;
+        console.log(chalk_1.default.gray("  " +
+            "Name".padEnd(nameWidth) +
+            "Installed".padEnd(versionWidth) +
+            "Catalog".padEnd(catalogWidth) +
+            "Installed At"));
+        console.log(chalk_1.default.gray("  " + "─".repeat(nameWidth + versionWidth + catalogWidth + 24)));
+        for (const name of installedNames.sort()) {
+            const info = state.skills[name];
+            const catalogSkill = catalog.find((s) => s.name === name);
+            const catalogVersion = catalogSkill ? catalogSkill.version : "?";
+            const needsUpdate = catalogSkill && catalogSkill.version !== info.version;
+            const catalogDisplay = needsUpdate
+                ? chalk_1.default.yellow(catalogVersion)
+                : chalk_1.default.green(catalogVersion);
+            const date = new Date(info.installedAt).toLocaleDateString();
+            console.log("  " +
+                chalk_1.default.cyan(name.padEnd(nameWidth)) +
+                info.version.padEnd(versionWidth) +
+                catalogDisplay.padEnd(catalogWidth + 10) +
+                date);
+        }
+        console.log("");
+    });
+    await program.parseAsync(process.argv);
 }

package/dist/installer.d.ts

@@ -0,0 +1,4 @@
+import { OpenCodePaths } from "./utils";
+export declare function installSkill(name: string, paths: OpenCodePaths): Promise<void>;
+export declare function removeSkill(name: string, paths: OpenCodePaths): Promise<void>;
+export declare function updateSkill(name: string, paths: OpenCodePaths): Promise<void>;

package/dist/installer.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSkill = installSkill;
+exports.removeSkill = removeSkill;
+exports.updateSkill = updateSkill;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("./utils");
+const registry_1 = require("./registry");
+const state_1 = require("./state");
+const config_1 = require("./config");
+async function installSkill(name, paths) {
+    const manifest = await (0, registry_1.getSkillManifest)(paths.packageSkillsDir, name);
+    if (!manifest) {
+        const catalog = await (0, registry_1.loadCatalog)(paths.packageSkillsDir);
+        const available = catalog.map((s) => s.name).join(", ");
+        console.error(chalk_1.default.red(`Skill "${name}" not found in catalog.`));
+        console.error(chalk_1.default.yellow(`Available skills: ${available || "none"}`));
+        process.exit(1);
+    }
+    const state = await (0, state_1.loadState)(paths.stateFilePath);
+    const existing = state.skills[name];
+    if (existing && existing.version === manifest.version) {
+        console.log(chalk_1.default.yellow(`Skill "${name}" is already installed at v${manifest.version}.`));
+        return;
+    }
+    await (0, utils_1.ensureDirExists)(paths.skillsDir);
+    const packageSkillDir = path_1.default.join(paths.packageSkillsDir, name);
+    const targetSkillDir = path_1.default.join(paths.skillsDir, name);
+    await fs_extra_1.default.copy(packageSkillDir, targetSkillDir, { overwrite: true });
+    await (0, config_1.copyCommands)(manifest, packageSkillDir, paths.commandDir);
+    await (0, config_1.mergeAgentConfig)(paths.agentConfigPath, manifest);
+    state.skills[name] = {
+        version: manifest.version,
+        installedAt: new Date().toISOString(),
+        location: paths.configDir.includes(".config/opencode") ? "global" : "project",
+    };
+    await (0, state_1.saveState)(paths.stateFilePath, state);
+    console.log(chalk_1.default.green(`✓ Installed ${name} v${manifest.version}`));
+}
+async function removeSkill(name, paths) {
+    const state = await (0, state_1.loadState)(paths.stateFilePath);
+    if (!state.skills[name]) {
+        console.log(chalk_1.default.yellow(`Skill "${name}" is not installed.`));
+        return;
+    }
+    const manifest = await (0, registry_1.getSkillManifest)(paths.packageSkillsDir, name);
+    const targetSkillDir = path_1.default.join(paths.skillsDir, name);
+    if (await fs_extra_1.default.pathExists(targetSkillDir)) {
+        await fs_extra_1.default.remove(targetSkillDir);
+    }
+    if (manifest) {
+        await (0, config_1.removeCommands)(manifest, paths.commandDir);
+        await (0, config_1.removeAgentConfig)(paths.agentConfigPath, manifest);
+    }
+    delete state.skills[name];
+    await (0, state_1.saveState)(paths.stateFilePath, state);
+    console.log(chalk_1.default.green(`✓ Removed ${name}`));
+}
+async function updateSkill(name, paths) {
+    const state = await (0, state_1.loadState)(paths.stateFilePath);
+    if (!state.skills[name]) {
+        console.error(chalk_1.default.red(`Skill "${name}" is not installed. Use 'skill-manager install ${name}' first.`));
+        process.exit(1);
+    }
+    const manifest = await (0, registry_1.getSkillManifest)(paths.packageSkillsDir, name);
+    if (!manifest) {
+        console.error(chalk_1.default.red(`Skill "${name}" not found in catalog. It may have been removed.`));
+        process.exit(1);
+    }
+    const installed = state.skills[name];
+    if (installed.version === manifest.version) {
+        console.log(chalk_1.default.yellow(`Skill "${name}" is already at v${manifest.version} (up to date).`));
+        return;
+    }
+    const packageSkillDir = path_1.default.join(paths.packageSkillsDir, name);
+    const targetSkillDir = path_1.default.join(paths.skillsDir, name);
+    await fs_extra_1.default.copy(packageSkillDir, targetSkillDir, { overwrite: true });
+    await (0, config_1.copyCommands)(manifest, packageSkillDir, paths.commandDir);
+    await (0, config_1.mergeAgentConfig)(paths.agentConfigPath, manifest);
+    state.skills[name] = {
+        version: manifest.version,
+        installedAt: new Date().toISOString(),
+        location: installed.location,
+    };
+    await (0, state_1.saveState)(paths.stateFilePath, state);
+    console.log(chalk_1.default.green(`✓ Updated ${name} from v${installed.version} to v${manifest.version}`));
+}

package/dist/registry.d.ts

@@ -0,0 +1,3 @@
+import { SkillManifest } from "./utils";
+export declare function loadCatalog(packageSkillsDir: string): Promise<SkillManifest[]>;
+export declare function getSkillManifest(packageSkillsDir: string, name: string): Promise<SkillManifest | null>;