@nano-step/skill-manager 4.0.0

package/README.md

@@ -0,0 +1,218 @@
+# @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.
+
+## 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
+
+```bash
+npx @nano-step/skill-manager
+```
+
+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`
+
+## Usage
+
+### Install (first time)
+
+```bash
+npx @nano-step/skill-manager
+```
+
+### Update (to latest version)
+
+```bash
+npx @nano-step/skill-manager --update
+```
+
+Creates timestamped backups of customized files before updating.
+
+### Remove
+
+```bash
+npx @nano-step/skill-manager --remove
+```
+
+Cleanly removes all installed artifacts.
+
+## 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:
+
+```
+/agent-skill-refresh
+```
+
+This analyzes all available MCP tools and creates a semantic index at `.opencode/mcp-tools.json`.
+
+## Config Detection
+
+The tool looks for OpenCode configuration in this order:
+
+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
+```
+
+### 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
+```
+
+Any tool name containing `__` executes directly without category lookup.
+
+### 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
+
+## 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
+```
+
+### 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
+```
+
+## Related Projects
+
+- [nano-brain](https://github.com/nano-step/nano-brain) — Persistent memory for AI agents
+- [graphql-inspector-mcp](https://github.com/nano-step/graphql-inspector-mcp) — GraphQL schema inspection MCP server
+- [mcp-database-inspector](https://github.com/nano-step/mcp-database-inspector) — Database inspection MCP server
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { run } = require("../dist/index.js");
+
+run().catch((error) => {
+  // eslint-disable-next-line no-console
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function run(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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");
+async function run() {
+    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)();
+}

package/dist/install.d.ts

@@ -0,0 +1 @@
+export declare function install(): Promise<void>;

package/dist/install.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = install;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./utils");
+async function install() {
+    const paths = await (0, utils_1.detectOpenCodePaths)();
+    await (0, utils_1.ensureDirExists)(paths.commandDir);
+    await (0, utils_1.ensureDirExists)(paths.skillsDir);
+    const skillTargetDir = path_1.default.join(paths.skillsDir, utils_1.SKILL_DIR_NAME);
+    const commandTargetPath = path_1.default.join(paths.commandDir, "agent-skill-refresh.md");
+    await fs_extra_1.default.copy(paths.templateSkillDir, skillTargetDir, { overwrite: true });
+    const commandTemplate = await (0, utils_1.readText)(paths.templateCommandPath);
+    await (0, utils_1.writeText)(commandTargetPath, commandTemplate);
+    const agentTemplate = await (0, utils_1.readJsonFile)(paths.templateAgentPath, {});
+    const agentConfig = await (0, utils_1.readJsonFile)(paths.agentConfigPath, {});
+    const agents = (agentConfig.agents || {});
+    const templateAgents = (agentTemplate.agents || agentTemplate);
+    agentConfig.agents = { ...agents, ...templateAgents };
+    await (0, utils_1.writeJsonFile)(paths.agentConfigPath, agentConfig);
+    await (0, utils_1.writeJsonFile)(paths.versionFilePath, { version: utils_1.PACKAGE_VERSION, installedAt: new Date().toISOString() });
+    const state = await (0, utils_1.getInstallationState)(paths);
+    if (!state.skillInstalled || !state.commandInstalled || !state.agentInstalled) {
+        throw new Error("Installation verification failed. Some files were not installed.");
+    }
+    if (Object.keys(agentConfig).length > 0 && Object.prototype.hasOwnProperty.call(agentConfig, utils_1.AGENT_ID)) {
+        console.log(chalk_1.default.yellow("agent-skill-manager agent already existed; configuration was updated."));
+    }
+    console.log(chalk_1.default.green("Agent skill manager installed successfully."));
+}

package/dist/remove.d.ts

@@ -0,0 +1 @@
+export declare function remove(): Promise<void>;

package/dist/remove.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = remove;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./utils");
+async function remove() {
+    const paths = await (0, utils_1.detectOpenCodePaths)();
+    const skillTargetDir = path_1.default.join(paths.skillsDir, utils_1.SKILL_DIR_NAME);
+    const commandTargetPath = path_1.default.join(paths.commandDir, "agent-skill-refresh.md");
+    if (await fs_extra_1.default.pathExists(skillTargetDir)) {
+        await fs_extra_1.default.remove(skillTargetDir);
+    }
+    if (await fs_extra_1.default.pathExists(commandTargetPath)) {
+        await fs_extra_1.default.remove(commandTargetPath);
+    }
+    const agentConfig = await (0, utils_1.readJsonFile)(paths.agentConfigPath, {});
+    const agents = (agentConfig.agents || {});
+    if (Object.prototype.hasOwnProperty.call(agents, utils_1.AGENT_ID)) {
+        delete agents[utils_1.AGENT_ID];
+        agentConfig.agents = agents;
+        await (0, utils_1.writeJsonFile)(paths.agentConfigPath, agentConfig);
+    }
+    if (await fs_extra_1.default.pathExists(paths.versionFilePath)) {
+        await fs_extra_1.default.remove(paths.versionFilePath);
+    }
+    console.log(chalk_1.default.green("Agent skill manager removed successfully."));
+}

package/dist/update.d.ts

@@ -0,0 +1 @@
+export declare function update(): Promise<void>;

package/dist/update.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = update;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./utils");
+async function update() {
+    const paths = await (0, utils_1.detectOpenCodePaths)();
+    await (0, utils_1.ensureDirExists)(paths.commandDir);
+    await (0, utils_1.ensureDirExists)(paths.skillsDir);
+    const skillTargetDir = path_1.default.join(paths.skillsDir, utils_1.SKILL_DIR_NAME);
+    const commandTargetPath = path_1.default.join(paths.commandDir, "agent-skill-refresh.md");
+    await (0, utils_1.ensureDirExists)(skillTargetDir);
+    const state = await (0, utils_1.getInstallationState)(paths);
+    if (state.installedVersion === utils_1.PACKAGE_VERSION) {
+        console.log(chalk_1.default.green("Agent skill manager is already up to date."));
+        return;
+    }
+    const [skillCustomized, commandCustomized] = await Promise.all([
+        (0, utils_1.directoryDiffersFromTemplate)(skillTargetDir, paths.templateSkillDir),
+        (0, utils_1.fileDiffersFromTemplate)(commandTargetPath, paths.templateCommandPath),
+    ]);
+    if (skillCustomized || commandCustomized) {
+        console.log(chalk_1.default.yellow("Detected customized files. Backups will be created before update."));
+    }
+    if (await fs_extra_1.default.pathExists(skillTargetDir)) {
+        console.log(chalk_1.default.yellow("Backing up existing skill directory before update."));
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const backupDir = `${skillTargetDir}.backup-${timestamp}.bak`;
+        await fs_extra_1.default.copy(skillTargetDir, backupDir, { overwrite: true });
+    }
+    if (await fs_extra_1.default.pathExists(commandTargetPath)) {
+        await (0, utils_1.backupFile)(commandTargetPath, "backup");
+    }
+    if (await fs_extra_1.default.pathExists(paths.agentConfigPath)) {
+        await (0, utils_1.backupFile)(paths.agentConfigPath, "backup");
+    }
+    await fs_extra_1.default.copy(paths.templateSkillDir, skillTargetDir, { overwrite: true });
+    const commandTemplate = await fs_extra_1.default.readFile(paths.templateCommandPath, "utf8");
+    await fs_extra_1.default.writeFile(commandTargetPath, commandTemplate, "utf8");
+    const agentTemplate = await (0, utils_1.readJsonFile)(paths.templateAgentPath, {});
+    const agentConfig = await (0, utils_1.readJsonFile)(paths.agentConfigPath, {});
+    const agents = (agentConfig.agents || {});
+    const templateAgents = (agentTemplate.agents || agentTemplate);
+    agentConfig.agents = { ...agents, ...templateAgents };
+    await (0, utils_1.writeJsonFile)(paths.agentConfigPath, agentConfig);
+    await (0, utils_1.writeJsonFile)(paths.versionFilePath, { version: utils_1.PACKAGE_VERSION, updatedAt: new Date().toISOString() });
+    console.log(chalk_1.default.green("Agent skill manager updated successfully."));
+}

package/dist/utils.d.ts

@@ -0,0 +1,30 @@
+export declare const PACKAGE_VERSION = "4.0.0";
+export declare const AGENT_ID = "mcp-manager";
+export declare const SKILL_DIR_NAME = "mcp-management";
+export interface OpenCodePaths {
+    configDir: string;
+    projectDir: string;
+    commandDir: string;
+    skillsDir: string;
+    agentConfigPath: string;
+    versionFilePath: string;
+    templateSkillDir: string;
+    templateCommandPath: string;
+    templateAgentPath: string;
+}
+export interface InstallationState {
+    installedVersion: string | null;
+    skillInstalled: boolean;
+    commandInstalled: boolean;
+    agentInstalled: boolean;
+}
+export declare function detectOpenCodePaths(): Promise<OpenCodePaths>;
+export declare function ensureDirExists(dirPath: string): Promise<void>;
+export declare function readJsonFile<T>(filePath: string, fallback: T): Promise<T>;
+export declare function writeJsonFile(filePath: string, data: unknown): Promise<void>;
+export declare function readText(filePath: string): Promise<string>;
+export declare function writeText(filePath: string, data: string): Promise<void>;
+export declare function backupFile(filePath: string, suffix: string): Promise<string>;
+export declare function fileDiffersFromTemplate(filePath: string, templatePath: string): Promise<boolean>;
+export declare function directoryDiffersFromTemplate(dirPath: string, templateDir: string): Promise<boolean>;
+export declare function getInstallationState(paths: OpenCodePaths): Promise<InstallationState>;

package/dist/utils.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKILL_DIR_NAME = exports.AGENT_ID = exports.PACKAGE_VERSION = void 0;
+exports.detectOpenCodePaths = detectOpenCodePaths;
+exports.ensureDirExists = ensureDirExists;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+exports.readText = readText;
+exports.writeText = writeText;
+exports.backupFile = backupFile;
+exports.fileDiffersFromTemplate = fileDiffersFromTemplate;
+exports.directoryDiffersFromTemplate = directoryDiffersFromTemplate;
+exports.getInstallationState = getInstallationState;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+exports.PACKAGE_VERSION = "4.0.0";
+exports.AGENT_ID = "mcp-manager";
+exports.SKILL_DIR_NAME = "mcp-management";
+async function detectOpenCodePaths() {
+    const homeConfig = path_1.default.join(os_1.default.homedir(), ".config", "opencode");
+    const cwd = process.cwd();
+    const projectConfig = path_1.default.join(cwd, ".opencode");
+    const hasHomeConfig = await fs_extra_1.default.pathExists(homeConfig);
+    const hasProjectConfig = await fs_extra_1.default.pathExists(projectConfig);
+    if (!hasHomeConfig && !hasProjectConfig) {
+        throw new Error("OpenCode config not found. Expected ~/.config/opencode or .opencode in project.");
+    }
+    const configDir = hasProjectConfig ? projectConfig : homeConfig;
+    const commandDir = path_1.default.join(configDir, "command");
+    const skillsDir = path_1.default.join(configDir, "skills");
+    const agentConfigPath = path_1.default.join(configDir, "oh-my-opencode.json");
+    const packageRoot = path_1.default.join(__dirname, "..");
+    const templateSkillDir = path_1.default.join(packageRoot, "templates", "skill");
+    const templateCommandPath = path_1.default.join(packageRoot, "templates", "command-refresh.md");
+    const templateAgentPath = path_1.default.join(packageRoot, "templates", "agent.json");
+    const versionFilePath = path_1.default.join(configDir, ".agent-skill-version.json");
+    return {
+        configDir,
+        projectDir: cwd,
+        commandDir,
+        skillsDir,
+        agentConfigPath,
+        versionFilePath,
+        templateSkillDir,
+        templateCommandPath,
+        templateAgentPath,
+    };
+}
+async function ensureDirExists(dirPath) {
+    await fs_extra_1.default.ensureDir(dirPath);
+}
+async function readJsonFile(filePath, fallback) {
+    const exists = await fs_extra_1.default.pathExists(filePath);
+    if (!exists) {
+        return fallback;
+    }
+    const data = await fs_extra_1.default.readFile(filePath, "utf8");
+    return JSON.parse(data);
+}
+async function writeJsonFile(filePath, data) {
+    await fs_extra_1.default.writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+async function readText(filePath) {
+    return fs_extra_1.default.readFile(filePath, "utf8");
+}
+async function writeText(filePath, data) {
+    await fs_extra_1.default.writeFile(filePath, data, "utf8");
+}
+async function backupFile(filePath, suffix) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = `${filePath}.${suffix}-${timestamp}.bak`;
+    await fs_extra_1.default.copy(filePath, backupPath);
+    return backupPath;
+}
+async function fileDiffersFromTemplate(filePath, templatePath) {
+    const exists = await fs_extra_1.default.pathExists(filePath);
+    if (!exists) {
+        return false;
+    }
+    const [current, template] = await Promise.all([readText(filePath), readText(templatePath)]);
+    return current.trim() !== template.trim();
+}
+async function listFilesRecursively(dirPath, baseDir) {
+    const entries = await fs_extra_1.default.readdir(dirPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFilesRecursively(fullPath, baseDir)));
+        }
+        else if (entry.isFile()) {
+            files.push(path_1.default.relative(baseDir, fullPath));
+        }
+    }
+    return files;
+}
+async function directoryDiffersFromTemplate(dirPath, templateDir) {
+    const [dirExists, templateExists] = await Promise.all([
+        fs_extra_1.default.pathExists(dirPath),
+        fs_extra_1.default.pathExists(templateDir),
+    ]);
+    if (!dirExists) {
+        return false;
+    }
+    if (!templateExists) {
+        return true;
+    }
+    const [currentFiles, templateFiles] = await Promise.all([
+        listFilesRecursively(dirPath, dirPath),
+        listFilesRecursively(templateDir, templateDir),
+    ]);
+    currentFiles.sort();
+    templateFiles.sort();
+    if (currentFiles.length !== templateFiles.length) {
+        return true;
+    }
+    for (let index = 0; index < currentFiles.length; index += 1) {
+        if (currentFiles[index] !== templateFiles[index]) {
+            return true;
+        }
+    }
+    for (const relativePath of currentFiles) {
+        const [currentBuffer, templateBuffer] = await Promise.all([
+            fs_extra_1.default.readFile(path_1.default.join(dirPath, relativePath)),
+            fs_extra_1.default.readFile(path_1.default.join(templateDir, relativePath)),
+        ]);
+        if (!currentBuffer.equals(templateBuffer)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function getInstallationState(paths) {
+    const skillPath = path_1.default.join(paths.skillsDir, exports.SKILL_DIR_NAME, "SKILL.md");
+    const commandPath = path_1.default.join(paths.commandDir, "agent-skill-refresh.md");
+    const [versionData, skillInstalled, commandInstalled] = await Promise.all([
+        readJsonFile(paths.versionFilePath, {}),
+        fs_extra_1.default.pathExists(skillPath),
+        fs_extra_1.default.pathExists(commandPath),
+    ]);
+    const agentConfig = await readJsonFile(paths.agentConfigPath, {});
+    const agents = agentConfig.agents;
+    const agentInstalled = agents ? Object.prototype.hasOwnProperty.call(agents, exports.AGENT_ID) : false;
+    return {
+        installedVersion: typeof versionData.version === "string" ? versionData.version : null,
+        skillInstalled,
+        commandInstalled,
+        agentInstalled,
+    };
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@nano-step/skill-manager",
+  "version": "4.0.0",
+  "description": "CLI tool that installs and manages AI agent skills, MCP tool routing, and workflow configurations.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "skill-manager": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "nano-step",
+    "opencode",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "llm",
+    "cli"
+  ],
+  "author": "nano-step",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nano-step/skill-manager"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.30",
+    "typescript": "^5.4.5"
+  }
+}

package/templates/agent.json

@@ -0,0 +1,11 @@
+{
+  "agents": {
+    "mcp-manager": {
+      "mode": "subagent",
+      "model": "gitlab/duo-chat-haiku-4-5",
+      "temperature": 0.1,
+      "description": "MCP tool router - isolates MCP tools in separate context window to save tokens",
+      "prompt_append": "You are mcp-manager, a specialized agent for executing MCP (Model Context Protocol) tools. Your purpose is to ISOLATE MCP tool definitions from the main agent's context window, reducing token usage by 80-95%.\n\nWORKFLOW:\n1. Read .opencode/mcp-tools.json cache for tool routing (if exists)\n2. Parse the task to identify which MCP category is needed (browser, github, graphql, docs, reasoning)\n3. Select the appropriate tool(s) from that category\n4. Execute the tool with correct parameters\n5. Filter/summarize results before returning to main agent\n\nTOOL CATEGORIES:\n- browser: chrome-devtools__* (screenshots, clicks, navigation, DOM)\n- github: github-*__* (PRs, issues, repos, commits, branches)\n- graphql: graphql-tools__* (schema, queries, mutations)\n- docs: context7__* (documentation lookup, library references)\n- reasoning: Sequential-Thinking__* (complex multi-step analysis)\n\nRESULT HANDLING:\n- For large results (>1000 chars): Summarize key information\n- For file operations: Return path/status, not full content\n- For data queries: Return relevant subset, not full dataset\n- Always include: Success/failure status, key identifiers, actionable next steps\n\nERROR HANDLING:\n- Tool not found: Suggest similar tools or ask for clarification\n- Tool execution failed: Return error details and potential fixes\n- Cache missing: Prompt user to run /mcp-refresh command\n- Never silently fail\n\nYou are FAST (Haiku model) and DETERMINISTIC (temp 0.1). Focus on accurate tool selection and execution."
+    }
+  }
+}