@sloop-dev/skill-forge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 skill-forge contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,341 @@
+# skill-forge
+
+**A CLI middleware that bridges AI agents to MCP servers and CLI tools via lightweight skill files.**
+
+## The Problem
+
+Modern AI agents rely on tool definitions to interact with the outside world. As the number of tools grows, so does the context window overhead: full MCP schemas, argument descriptions, and usage examples eat into the tokens available for actual reasoning. A project with ten registered tools can easily burn thousands of tokens before the agent even starts working.
+
+## The Solution
+
+skill-forge sits between your AI agent and its tools. Instead of feeding raw schemas into the context window, it **generates compact Markdown skill files** that summarize each tool's capabilities, triggers, and invocation syntax. At runtime, the agent reads a single `SKILL.md` to discover what is available and calls tools through skill-forge's thin proxy layer.
+
+```
+                  SKILL.md
+                     |
+    AI Agent ----> skill-forge ----> MCP Server
+                     |
+                     +-------------> CLI Tool
+```
+
+The result: smaller context windows, faster agent loops, and a single registry for every tool your agent can reach.
+
+## Architecture
+
+```
++------------+       +--------------+       +----------------+
+|            | add   |              | stdio |                |
+|  AI Agent  +------>| skill-forge  +------>|   MCP Server   |
+|            | call  |              |       |                |
+|            |       |  - registry  |       +----------------+
+|            |       |  - gen       |
+|            |       |  - proxy     |       +----------------+
+|            |       |              | spawn |                |
+|            |       |              +------>|    CLI Tool     |
++------------+       +--------------+       +----------------+
+                           |
+                           v
+                    skill-forge/
+                      SKILL.md
+                      references/
+                        tool-a.md
+                        tool-b.md
+```
+
+skill-forge manages a **tool registry** (JSON config), connects to MCP servers via the SDK stdio transport, and spawns CLI tools as child processes. The `gen` command introspects every registered tool and writes a `SKILL.md` plus per-tool reference files that any agent can consume.
+
+## Installation
+
+```bash
+npm install -g skill-forge
+```
+
+**Requirements:** Node.js 18 or later.
+
+Verify the installation:
+
+```bash
+skill-forge --version
+```
+
+## Quick Start
+
+### 1. Register a tool
+
+```bash
+# Add an MCP server
+skill-forge add my-server mcp --command npx --args @example/mcp-server
+
+# Add a CLI tool
+skill-forge add git-tool cli --command git
+```
+
+### 2. List registered tools
+
+```bash
+skill-forge list
+```
+
+```
+  my-server (mcp) — npx
+  git-tool (cli) — git
+```
+
+### 3. Generate skill files
+
+```bash
+skill-forge gen
+```
+
+This creates a `skill-forge/` directory containing `SKILL.md` and a `references/` folder with one file per tool.
+
+### 4. Call a tool
+
+```bash
+# Call an MCP method
+skill-forge call my-server list_files '{"path": "/src"}'
+
+# Call a CLI tool
+skill-forge call git-tool "status --short"
+```
+
+## Commands
+
+| Command   | Description                                      |
+| --------- | ------------------------------------------------ |
+| `add`     | Register a new MCP or CLI tool                   |
+| `update`  | Update settings for a registered tool            |
+| `remove`  | Unregister a tool                                |
+| `list`    | Show all registered tools                        |
+| `gen`     | Generate skill files from registered tools       |
+| `call`    | Invoke a registered MCP method or CLI command    |
+
+---
+
+### `add`
+
+Register a new MCP or CLI tool in the config.
+
+```bash
+skill-forge add <name> <type> --command <cmd> [--args <items...>] [--env <pairs...>]
+```
+
+**Arguments:**
+
+- `name` -- Unique identifier for the tool
+- `type` -- `mcp` or `cli`
+
+**Options:**
+
+- `--command <cmd>` -- Command to execute (required)
+- `--args <items...>` -- Arguments passed to the command (MCP only)
+- `--env <pairs...>` -- Environment variables as `KEY=VALUE` pairs (MCP only)
+
+**Examples:**
+
+```bash
+skill-forge add my-server mcp --command npx --args @example/mcp-server
+skill-forge add my-server mcp --command node --args server.js --env API_KEY=abc123
+skill-forge add docker cli --command docker
+```
+
+---
+
+### `update`
+
+Modify settings for a tool that is already registered.
+
+```bash
+skill-forge update <name> [--command <cmd>] [--args <items...>] [--env <pairs...>] [--timeout <ms>]
+```
+
+**Options:**
+
+- `--command <cmd>` -- Replace the command
+- `--args <items...>` -- Replace arguments (MCP only)
+- `--env <pairs...>` -- Merge environment variables (MCP only)
+- `--timeout <ms>` -- Set a custom timeout in milliseconds
+
+**Example:**
+
+```bash
+skill-forge update my-server --timeout 60000
+skill-forge update my-server --env API_KEY=new-value
+```
+
+---
+
+### `remove`
+
+Unregister a tool from the config.
+
+```bash
+skill-forge remove <name>
+```
+
+**Example:**
+
+```bash
+skill-forge remove my-server
+```
+
+---
+
+### `list`
+
+Display all registered tools with their type and command.
+
+```bash
+skill-forge list
+```
+
+---
+
+### `gen`
+
+Generate skill files by introspecting every registered tool. For MCP tools, skill-forge connects via stdio and calls `tools/list`. For CLI tools, it runs `--help` and parses the output.
+
+```bash
+skill-forge gen [-o, --output <dir>]
+```
+
+**Options:**
+
+- `-o, --output <dir>` -- Output directory (defaults to `.`)
+
+The command produces:
+
+```
+<output>/skill-forge/
+  SKILL.md                  # Summary with trigger keywords
+  .skill-forge-manifest.json  # Tracks config hashes for incremental updates
+  references/
+    my-server.md            # Detailed MCP tool schemas
+    docker.md               # Parsed CLI help
+```
+
+A **manifest file** tracks the config hash of each tool. On subsequent runs, skill-forge detects added, removed, and changed tools so it can clean up stale reference files automatically.
+
+---
+
+### `call`
+
+Invoke a tool through skill-forge's proxy layer.
+
+```bash
+# MCP tool — pass the method name and a JSON argument object
+skill-forge call <name> <method> '<json>'
+
+# CLI tool — pass the full command string
+skill-forge call <name> "<command>"
+```
+
+**Examples:**
+
+```bash
+skill-forge call my-server list_files '{"path": "/src"}'
+skill-forge call docker "ps -a --format json"
+```
+
+For MCP tools, skill-forge opens a stdio connection, sends the `tools/call` request, prints the JSON result, and disconnects. For CLI tools, it spawns the configured command with the provided arguments and streams stdout/stderr.
+
+## Configuration
+
+skill-forge stores its configuration at:
+
+```
+~/.skill-forge/config.json
+```
+
+**Format:**
+
+```json
+{
+  "version": 1,
+  "tools": {
+    "my-server": {
+      "type": "mcp",
+      "command": "npx",
+      "args": ["@example/mcp-server"],
+      "env": {
+        "API_KEY": "abc123"
+      }
+    },
+    "docker": {
+      "type": "cli",
+      "command": "docker",
+      "timeout": 15000
+    }
+  },
+  "defaults": {
+    "timeout": 30000
+  }
+}
+```
+
+**Fields:**
+
+| Field              | Type     | Description                                         |
+| ------------------ | -------- | --------------------------------------------------- |
+| `version`          | `number` | Config format version (currently `1`)               |
+| `tools`            | `object` | Map of tool name to tool configuration              |
+| `defaults.timeout` | `number` | Default timeout in milliseconds (default: `30000`)  |
+
+**Per-tool fields:**
+
+| Field     | Type       | Applies to | Description                          |
+| --------- | ---------- | ---------- | ------------------------------------ |
+| `type`    | `string`   | all        | `"mcp"` or `"cli"`                   |
+| `command` | `string`   | all        | Executable to run                    |
+| `args`    | `string[]` | mcp        | Arguments passed to the command      |
+| `env`     | `object`   | mcp        | Environment variables for the process|
+| `timeout` | `number`   | all        | Per-tool timeout override (ms)       |
+
+The config file is created automatically on first use. You can also edit it directly.
+
+## How It Works
+
+### Thin Proxy Architecture
+
+skill-forge does not wrap or reimplement tool protocols. It acts as a **thin proxy**:
+
+- **MCP tools** are connected via the official `@modelcontextprotocol/sdk` stdio transport. skill-forge spawns the server process, performs the JSON-RPC handshake, and forwards requests verbatim.
+- **CLI tools** are spawned as child processes with arguments split by whitespace. No shell is invoked, so command strings are executed safely.
+
+### Skill Generation
+
+The `gen` command introspects each tool and produces Markdown output:
+
+1. **MCP tools** -- skill-forge connects, calls `tools/list`, and renders each tool's name, description, parameter schema, and an example invocation.
+2. **CLI tools** -- skill-forge runs `<command> --help`, parses the output into subcommands, and renders each with a description and example.
+
+The top-level `SKILL.md` includes YAML front matter with trigger keywords that help agents decide when to use skill-forge.
+
+### Manifest Sync
+
+A `.skill-forge-manifest.json` file tracks the SHA-256 config hash of each tool. On subsequent `gen` runs, skill-forge compares hashes to detect changes and removes reference files for tools that are no longer registered.
+
+## Security
+
+skill-forge is designed to be safe by default:
+
+- **No shell injection.** CLI tools are spawned with `shell: false`. The command string is split by whitespace into an argument array, preventing shell metacharacter injection.
+- **Config file permissions.** On Unix-like systems, the config file is written with mode `600` (owner read/write only).
+- **No secrets in generated files.** Skill files contain only tool names, descriptions, and usage examples. Environment variables and connection details stay in the config.
+- **Timeouts.** Every tool invocation has a configurable timeout (default 30 seconds). On timeout, the process receives `SIGTERM` followed by `SIGKILL` after a 3-second grace period.
+
+## Cross-Platform
+
+skill-forge works on **Windows**, **macOS**, and **Linux**. The child process layer uses Node.js `spawn` directly, and the config directory resolves via `os.homedir()` on all platforms.
+
+Config location by platform:
+
+| Platform | Path                              |
+| -------- | --------------------------------- |
+| Linux    | `~/.skill-forge/config.json`      |
+| macOS    | `~/.skill-forge/config.json`      |
+| Windows  | `%USERPROFILE%\.skill-forge\config.json` |
+
+## License
+
+[MIT](./LICENSE)

package/bin/skill-forge.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/index.js');

package/dist/commands/add.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from 'commander';
+import type { ToolConfig } from '../config/schema.js';
+export declare function addTool(name: string, tool: ToolConfig, configPath?: string): Promise<void>;
+export declare function registerAddCommand(program: Command): void;
+//# sourceMappingURL=add.d.ts.map

package/dist/commands/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../src/commands/add.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,wBAAsB,OAAO,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwCzD"}

package/dist/commands/add.js

@@ -0,0 +1,48 @@
+import { loadConfig, saveConfig } from '../config/manager.js';
+export async function addTool(name, tool, configPath) {
+    const config = await loadConfig(configPath);
+    if (config.tools[name]) {
+        throw new Error(`Tool '${name}' already exists. Use 'skill-forge update' to modify it.`);
+    }
+    config.tools[name] = tool;
+    await saveConfig(config, configPath);
+}
+export function registerAddCommand(program) {
+    program
+        .command('add')
+        .description('Register a new MCP or CLI tool')
+        .argument('<name>', 'Unique tool name')
+        .argument('<type>', 'Tool type: mcp or cli')
+        .requiredOption('--command <cmd>', 'Command to execute')
+        .option('--args <items...>', 'Arguments for the command')
+        .option('--env <pairs...>', 'Environment variables as KEY=VALUE pairs')
+        .action(async (name, type, opts) => {
+        const command = opts.command;
+        const args = opts.args;
+        const envPairs = opts.env;
+        let env;
+        if (envPairs) {
+            env = {};
+            for (const pair of envPairs) {
+                const eqIdx = pair.indexOf('=');
+                if (eqIdx === -1) {
+                    console.error(`Invalid env format: "${pair}". Expected KEY=VALUE.`);
+                    process.exit(1);
+                }
+                env[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+            }
+        }
+        const tool = type === 'mcp'
+            ? { type: 'mcp', command, ...(args && { args }), ...(env && { env }) }
+            : { type: 'cli', command };
+        try {
+            await addTool(name, tool);
+            console.log(`Added ${type} tool '${name}'.`);
+        }
+        catch (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=add.js.map

package/dist/commands/add.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.js","sourceRoot":"","sources":["../../src/commands/add.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG9D,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,IAAY,EACZ,IAAgB,EAChB,UAAmB;IAEnB,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,UAAU,CAAC,CAAC;IAC5C,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,SAAS,IAAI,0DAA0D,CAAC,CAAC;IAC3F,CAAC;IACD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1B,MAAM,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,OAAgB;IACjD,OAAO;SACJ,OAAO,CAAC,KAAK,CAAC;SACd,WAAW,CAAC,gCAAgC,CAAC;SAC7C,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;SACtC,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;SAC3C,cAAc,CAAC,iBAAiB,EAAE,oBAAoB,CAAC;SACvD,MAAM,CAAC,mBAAmB,EAAE,2BAA2B,CAAC;SACxD,MAAM,CAAC,kBAAkB,EAAE,0CAA0C,CAAC;SACtE,MAAM,CAAC,KAAK,EAAE,IAAY,EAAE,IAAY,EAAE,IAA6B,EAAE,EAAE;QAC1E,MAAM,OAAO,GAAG,IAAI,CAAC,OAAiB,CAAC;QACvC,MAAM,IAAI,GAAG,IAAI,CAAC,IAA4B,CAAC;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,GAA2B,CAAC;QAElD,IAAI,GAAuC,CAAC;QAC5C,IAAI,QAAQ,EAAE,CAAC;YACb,GAAG,GAAG,EAAE,CAAC;YACT,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;gBAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBAChC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;oBACjB,OAAO,CAAC,KAAK,CAAC,wBAAwB,IAAI,wBAAwB,CAAC,CAAC;oBACpE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAClB,CAAC;gBACD,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;YACpD,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GACR,IAAI,KAAK,KAAK;YACZ,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE;YACtE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAE/B,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAC1B,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,UAAU,IAAI,IAAI,CAAC,CAAC;QAC/C,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAE,GAAa,CAAC,OAAO,CAAC,CAAC;YACtC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;IACH,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/commands/call.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from 'commander';
+export interface CallToolOptions {
+    name: string;
+    args: string[];
+    configPath?: string;
+}
+export declare function callTool(opts: CallToolOptions): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+}>;
+export declare function registerCallCommand(program: Command): void;
+//# sourceMappingURL=call.d.ts.map

package/dist/commands/call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.d.ts","sourceRoot":"","sources":["../../src/commands/call.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKzC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAuD1H;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiB1D"}

package/dist/commands/call.js

@@ -0,0 +1,75 @@
+import { loadConfig } from '../config/manager.js';
+import { McpClient } from '../tools/mcp-client.js';
+import { runCliTool } from '../tools/cli-runner.js';
+export async function callTool(opts) {
+    const config = await loadConfig(opts.configPath);
+    const tool = config.tools[opts.name];
+    if (!tool) {
+        throw new Error(`'${opts.name}' is not registered. Run 'skill-forge list' to see available tools.`);
+    }
+    const timeout = tool.timeout ?? config.defaults.timeout;
+    if (tool.type === 'mcp') {
+        // MCP: expect 2 args — method + json
+        if (opts.args.length !== 2) {
+            throw new Error(`'${opts.name}' is an MCP tool. Usage: skill-forge call ${opts.name} <method> '<json>'`);
+        }
+        const [method, jsonStr] = opts.args;
+        const args = JSON.parse(jsonStr);
+        const client = new McpClient({
+            command: tool.command,
+            args: tool.args ?? [],
+            env: tool.env,
+            timeout,
+        });
+        try {
+            await client.connect();
+            const result = await client.callTool(method, args);
+            await client.disconnect();
+            return { stdout: JSON.stringify(result, null, 2), stderr: '', exitCode: 0 };
+        }
+        catch (err) {
+            await client.disconnect().catch(() => { });
+            // Wrap timeout errors to include the tool name
+            const msg = err.message;
+            if (msg.includes('timed out')) {
+                throw new Error(`'${opts.name}' timed out after ${timeout}ms`);
+            }
+            throw err;
+        }
+    }
+    else {
+        // CLI: expect 1 arg — command string
+        if (opts.args.length !== 1) {
+            throw new Error(`'${opts.name}' is a CLI tool. Usage: skill-forge call ${opts.name} "<command>"`);
+        }
+        const result = await runCliTool({
+            command: tool.command,
+            commandString: opts.args[0],
+            timeout,
+        });
+        // Pass through CLI output as-is, forward exit code
+        return { stdout: result.stdout, stderr: result.stderr, exitCode: result.exitCode };
+    }
+}
+export function registerCallCommand(program) {
+    program
+        .command('call')
+        .description('Invoke a registered MCP method or CLI command')
+        .argument('<name>', 'Tool name')
+        .argument('<args...>', 'For MCP: <method> <json>. For CLI: "<command>"')
+        .action(async (name, args) => {
+        try {
+            const result = await callTool({ name, args });
+            if (result.stdout)
+                process.stdout.write(result.stdout);
+            if (result.stderr)
+                process.stderr.write(result.stderr);
+            process.exit(result.exitCode ?? 0);
+        }
+        catch (err) {
+            process.stderr.write(`Error: ${err.message}\n`);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=call.js.map

package/dist/commands/call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.js","sourceRoot":"","sources":["../../src/commands/call.ts"],"names":[],"mappings":"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"}

package/dist/commands/gen.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+export interface GenerateOptions {
+    output: string;
+    configPath?: string;
+}
+export declare function generateSkills(opts: GenerateOptions): Promise<void>;
+export declare function registerGenCommand(program: Command): void;
+//# sourceMappingURL=gen.d.ts.map

package/dist/commands/gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen.d.ts","sourceRoot":"","sources":["../../src/commands/gen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAazC,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,wBAAsB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAqDzE;AA+DD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAczD"}

package/dist/commands/gen.js

@@ -0,0 +1,128 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { loadConfig } from '../config/manager.js';
+import { McpClient } from '../tools/mcp-client.js';
+import { runCliTool } from '../tools/cli-runner.js';
+import { parseHelpOutput } from '../tools/help-parser.js';
+import { generateSkillMd } from '../gen/skill-writer.js';
+import { generateMcpReference, generateCliReference } from '../gen/reference-writer.js';
+import { loadManifest, saveManifest, diffManifest } from '../gen/manifest.js';
+import { configHash } from '../utils/hash.js';
+// Generate skill files for all registered tools.
+export async function generateSkills(opts) {
+    const config = await loadConfig(opts.configPath);
+    const skillDir = join(opts.output, 'skill-forge');
+    const refsDir = join(skillDir, 'references');
+    await mkdir(refsDir, { recursive: true });
+    const toolInfos = [];
+    const currentHashes = {};
+    for (const [name, tool] of Object.entries(config.tools)) {
+        const hash = configHash(tool);
+        currentHashes[name] = hash;
+        let refMd;
+        let description;
+        let triggers;
+        if (tool.type === 'mcp') {
+            const result = await generateMcpToolReference(name, tool);
+            refMd = result.refMd;
+            description = result.description;
+            triggers = result.triggers;
+        }
+        else {
+            const result = await generateCliToolReference(name, tool);
+            refMd = result.refMd;
+            description = result.description;
+            triggers = result.triggers;
+        }
+        await writeFile(join(refsDir, `${name}.md`), refMd, 'utf-8');
+        toolInfos.push({ name, type: tool.type, description, triggers });
+    }
+    // Generate SKILL.md
+    const skillMd = generateSkillMd(toolInfos);
+    await writeFile(join(skillDir, 'SKILL.md'), skillMd, 'utf-8');
+    // Load previous manifest, diff, and clean up removed tool reference files
+    const previousManifest = await loadManifest(skillDir);
+    const diff = diffManifest(previousManifest, currentHashes);
+    for (const removedName of diff.removed) {
+        await rm(join(refsDir, `${removedName}.md`), { force: true });
+    }
+    // Save new manifest
+    const newManifest = {
+        generated_at: new Date().toISOString(),
+        tools: {},
+    };
+    for (const [name, hash] of Object.entries(currentHashes)) {
+        newManifest.tools[name] = { config_hash: hash };
+    }
+    await saveManifest(skillDir, newManifest);
+}
+// Generate reference for an MCP tool by connecting and listing tools.
+async function generateMcpToolReference(name, tool) {
+    try {
+        const client = new McpClient({
+            command: tool.command,
+            args: tool.args ?? [],
+            env: tool.env,
+            timeout: tool.timeout ?? 30000,
+        });
+        await client.connect();
+        const tools = await client.listTools();
+        await client.disconnect();
+        const schemas = tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        }));
+        const refMd = generateMcpReference(name, schemas);
+        const description = schemas.length > 0
+            ? schemas.map(s => s.description || s.name).join(', ')
+            : `MCP tool: ${name}`;
+        const triggers = [name, ...schemas.map(s => s.name)];
+        return { refMd, description, triggers };
+    }
+    catch {
+        // Fallback when MCP connection fails
+        const refMd = `# ${name}\n\nMCP server could not be reached during generation.\nRun \`skill-forge call ${name} <method> '<json>'\` to use.\n`;
+        return { refMd, description: `MCP tool: ${name}`, triggers: [name] };
+    }
+}
+// Generate reference for a CLI tool by running --help and parsing the output.
+async function generateCliToolReference(name, tool) {
+    try {
+        const result = await runCliTool({
+            command: tool.command,
+            commandString: '--help',
+            timeout: tool.timeout ?? 10000,
+        });
+        const helpOutput = result.stdout || result.stderr;
+        const parsed = parseHelpOutput(helpOutput);
+        const refMd = generateCliReference(name, parsed.commands, parsed.raw);
+        const description = parsed.commands.length > 0
+            ? parsed.commands.map(c => c.description).join(', ')
+            : `CLI tool: ${name}`;
+        const triggers = [name, ...parsed.commands.map(c => c.name)];
+        return { refMd, description, triggers };
+    }
+    catch {
+        // Fallback when help parse fails
+        const refMd = generateCliReference(name, [], '');
+        return { refMd, description: `CLI tool: ${name}`, triggers: [name] };
+    }
+}
+export function registerGenCommand(program) {
+    program
+        .command('gen')
+        .description('Generate skill files from registered tools')
+        .option('-o, --output <dir>', 'Output directory', '.')
+        .action(async (opts) => {
+        try {
+            await generateSkills({ output: opts.output });
+            console.log('Skill files generated successfully.');
+        }
+        catch (err) {
+            console.error(`Generation failed: ${err.message}`);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=gen.js.map