@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-BE6IPRDM.js

@@ -0,0 +1,224 @@
+import {
+  logger
+} from "./chunk-X4HAERTQ.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/tool-system/mcp-manager.ts
+init_esm_shims();
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var MCPManager = class _MCPManager {
+  constructor(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+    _MCPManager.instance = this;
+  }
+  static instance = null;
+  connections = /* @__PURE__ */ new Map();
+  static getInstance() {
+    if (!_MCPManager.instance) {
+      throw new Error("MCPManager not initialized. Connect to servers first.");
+    }
+    return _MCPManager.instance;
+  }
+  /**
+   * Connect to all configured MCP servers and register their tools.
+   */
+  async connectAll(servers) {
+    const entries = Object.entries(servers);
+    if (entries.length === 0) return;
+    const results = await Promise.allSettled(
+      entries.map(([name, config]) => this.connect(name, config))
+    );
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === "rejected") {
+        logger.warn("mcp.connect_failed", {
+          server: entries[i][0],
+          error: result.reason.message
+        });
+      }
+    }
+  }
+  /**
+   * Connect to a single MCP server.
+   */
+  async connect(name, config) {
+    if (this.connections.has(name)) {
+      logger.info("mcp.already_connected", { server: name });
+      return;
+    }
+    logger.info("mcp.connecting", { server: name, transport: config.transport ?? "stdio" });
+    const client = new Client(
+      { name: "code-shell", version: "0.1.0" },
+      { capabilities: {} }
+    );
+    let transport;
+    const transportType = config.transport ?? "stdio";
+    if (transportType === "stdio") {
+      if (!config.command) {
+        throw new Error(`MCP server "${name}": command is required for stdio transport`);
+      }
+      transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: config.env ? { ...process.env, ...config.env } : void 0
+      });
+    } else if (transportType === "streamable-http" || transportType === "sse") {
+      if (!config.url) {
+        throw new Error(`MCP server "${name}": url is required for ${transportType} transport`);
+      }
+      transport = new StreamableHTTPClientTransport(new URL(config.url), {
+        requestInit: config.headers ? { headers: config.headers } : void 0
+      });
+    } else {
+      throw new Error(`MCP server "${name}": unsupported transport "${transportType}"`);
+    }
+    const CONNECT_TIMEOUT_MS = 15e3;
+    let timeoutHandle;
+    try {
+      await new Promise((resolve, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new Error(`MCP server "${name}" connect timed out after ${CONNECT_TIMEOUT_MS}ms`));
+        }, CONNECT_TIMEOUT_MS);
+        client.connect(transport).then(
+          () => resolve(),
+          (err) => reject(err)
+        );
+      });
+    } catch (err) {
+      try {
+        await transport.close?.();
+      } catch {
+      }
+      throw err;
+    } finally {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+    }
+    this.connections.set(name, { client, serverName: name, transport });
+    await this.discoverTools(name, client);
+    logger.info("mcp.connected", { server: name });
+  }
+  /**
+   * Discover tools from an MCP server and register them.
+   */
+  async discoverTools(serverName, client) {
+    const result = await client.listTools();
+    for (const tool of result.tools) {
+      const registered = {
+        name: `mcp_${serverName}_${tool.name}`,
+        description: `[${serverName}] ${tool.description ?? tool.name}`,
+        inputSchema: tool.inputSchema ?? { type: "object", properties: {} },
+        source: "mcp",
+        serverName,
+        permissionDefault: "ask",
+        isConcurrencySafe: true,
+        isReadOnly: false
+      };
+      this.toolRegistry.registerTool(registered, async (args) => {
+        const callResult = await client.callTool({ name: tool.name, arguments: args });
+        const parts = [];
+        if (Array.isArray(callResult.content)) {
+          for (const item of callResult.content) {
+            if (typeof item === "object" && item !== null && "text" in item) {
+              parts.push(String(item.text));
+            } else if (typeof item === "string") {
+              parts.push(item);
+            }
+          }
+        }
+        return parts.join("\n") || "(no output)";
+      });
+      logger.info("mcp.tool_registered", { server: serverName, tool: registered.name });
+    }
+  }
+  /**
+   * Disconnect all MCP servers.
+   */
+  async disconnectAll() {
+    for (const [name, conn] of this.connections) {
+      try {
+        await conn.client.close();
+        logger.info("mcp.disconnected", { server: name });
+      } catch (err) {
+        logger.warn("mcp.disconnect_error", { server: name, error: err.message });
+      }
+    }
+    this.connections.clear();
+  }
+  /**
+   * List connected servers.
+   */
+  listServers() {
+    return [...this.connections.keys()];
+  }
+  /**
+   * Call a tool on a specific MCP server.
+   */
+  async callTool(serverName, toolName, args) {
+    const conn = this.connections.get(serverName);
+    if (!conn) {
+      throw new Error(`MCP server "${serverName}" is not connected.`);
+    }
+    const result = await conn.client.callTool({ name: toolName, arguments: args });
+    const parts = [];
+    if (Array.isArray(result.content)) {
+      for (const item of result.content) {
+        if (typeof item === "object" && item !== null && "text" in item) {
+          parts.push(String(item.text));
+        } else if (typeof item === "string") {
+          parts.push(item);
+        }
+      }
+    }
+    return parts.join("\n") || "(no output)";
+  }
+  /**
+   * List resources from MCP servers.
+   */
+  async listResources(serverName) {
+    const results = [];
+    const servers = serverName ? [serverName] : [...this.connections.keys()];
+    for (const name of servers) {
+      const conn = this.connections.get(name);
+      if (!conn) continue;
+      try {
+        const res = await conn.client.listResources();
+        for (const r of res.resources) {
+          results.push({
+            uri: r.uri,
+            name: r.name ?? r.uri,
+            description: r.description
+          });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  /**
+   * Read a resource from an MCP server.
+   */
+  async readResource(serverName, uri) {
+    const conn = this.connections.get(serverName);
+    if (!conn) {
+      throw new Error(`MCP server "${serverName}" is not connected.`);
+    }
+    const result = await conn.client.readResource({ uri });
+    const parts = [];
+    if (Array.isArray(result.contents)) {
+      for (const item of result.contents) {
+        if (typeof item === "object" && item !== null && "text" in item) {
+          parts.push(String(item.text));
+        }
+      }
+    }
+    return parts.join("\n") || "(no content)";
+  }
+};
+
+export {
+  MCPManager
+};

package/dist/chunk-BHGIJ2DJ.js

@@ -0,0 +1,41 @@
+import {
+  FileRunStore,
+  RunManager
+} from "./chunk-7RMAR2Y3.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/run/index.ts
+init_esm_shims();
+
+// src/run/factory.ts
+init_esm_shims();
+import { join } from "path";
+import { homedir } from "os";
+function createRunManager(options) {
+  const runsDir = options.runsDir ?? join(homedir(), ".code-shell", "runs");
+  const store = new FileRunStore(runsDir);
+  return new RunManager({
+    store,
+    executor: {
+      llm: options.llm,
+      maxTurns: options.maxTurns ?? 30,
+      maxContextTokens: options.maxContextTokens ?? 2e5,
+      permissionMode: options.permissionMode ?? "acceptEdits",
+      sessionStorageDir: options.sessionStorageDir,
+      mcpServers: options.mcpServers,
+      enabledBuiltinTools: options.enabledBuiltinTools,
+      disabledBuiltinTools: options.disabledBuiltinTools,
+      customSystemPrompt: options.customSystemPrompt,
+      appendSystemPrompt: options.appendSystemPrompt
+    },
+    concurrency: options.concurrency ?? 1,
+    runsDir,
+    evaluator: options.evaluator
+  });
+}
+
+export {
+  createRunManager
+};

package/dist/chunk-BMH65OVB.cjs

@@ -0,0 +1,224 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkIMMTBZ33cjs = require('./chunk-IMMTBZ33.cjs');
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/tool-system/mcp-manager.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _indexjs = require('@modelcontextprotocol/sdk/client/index.js');
+var _stdiojs = require('@modelcontextprotocol/sdk/client/stdio.js');
+var _streamableHttpjs = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
+var MCPManager = (_class = class _MCPManager {
+  constructor(toolRegistry) {;_class.prototype.__init.call(this);
+    this.toolRegistry = toolRegistry;
+    _MCPManager.instance = this;
+  }
+  static __initStatic() {this.instance = null}
+  __init() {this.connections = /* @__PURE__ */ new Map()}
+  static getInstance() {
+    if (!_MCPManager.instance) {
+      throw new Error("MCPManager not initialized. Connect to servers first.");
+    }
+    return _MCPManager.instance;
+  }
+  /**
+   * Connect to all configured MCP servers and register their tools.
+   */
+  async connectAll(servers) {
+    const entries = Object.entries(servers);
+    if (entries.length === 0) return;
+    const results = await Promise.allSettled(
+      entries.map(([name, config]) => this.connect(name, config))
+    );
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === "rejected") {
+        _chunkIMMTBZ33cjs.logger.warn("mcp.connect_failed", {
+          server: entries[i][0],
+          error: result.reason.message
+        });
+      }
+    }
+  }
+  /**
+   * Connect to a single MCP server.
+   */
+  async connect(name, config) {
+    if (this.connections.has(name)) {
+      _chunkIMMTBZ33cjs.logger.info("mcp.already_connected", { server: name });
+      return;
+    }
+    _chunkIMMTBZ33cjs.logger.info("mcp.connecting", { server: name, transport: _nullishCoalesce(config.transport, () => ( "stdio")) });
+    const client = new (0, _indexjs.Client)(
+      { name: "code-shell", version: "0.1.0" },
+      { capabilities: {} }
+    );
+    let transport;
+    const transportType = _nullishCoalesce(config.transport, () => ( "stdio"));
+    if (transportType === "stdio") {
+      if (!config.command) {
+        throw new Error(`MCP server "${name}": command is required for stdio transport`);
+      }
+      transport = new (0, _stdiojs.StdioClientTransport)({
+        command: config.command,
+        args: config.args,
+        env: config.env ? { ...process.env, ...config.env } : void 0
+      });
+    } else if (transportType === "streamable-http" || transportType === "sse") {
+      if (!config.url) {
+        throw new Error(`MCP server "${name}": url is required for ${transportType} transport`);
+      }
+      transport = new (0, _streamableHttpjs.StreamableHTTPClientTransport)(new URL(config.url), {
+        requestInit: config.headers ? { headers: config.headers } : void 0
+      });
+    } else {
+      throw new Error(`MCP server "${name}": unsupported transport "${transportType}"`);
+    }
+    const CONNECT_TIMEOUT_MS = 15e3;
+    let timeoutHandle;
+    try {
+      await new Promise((resolve, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new Error(`MCP server "${name}" connect timed out after ${CONNECT_TIMEOUT_MS}ms`));
+        }, CONNECT_TIMEOUT_MS);
+        client.connect(transport).then(
+          () => resolve(),
+          (err) => reject(err)
+        );
+      });
+    } catch (err) {
+      try {
+        await _optionalChain([transport, 'access', _ => _.close, 'optionalCall', _2 => _2()]);
+      } catch (e) {
+      }
+      throw err;
+    } finally {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+    }
+    this.connections.set(name, { client, serverName: name, transport });
+    await this.discoverTools(name, client);
+    _chunkIMMTBZ33cjs.logger.info("mcp.connected", { server: name });
+  }
+  /**
+   * Discover tools from an MCP server and register them.
+   */
+  async discoverTools(serverName, client) {
+    const result = await client.listTools();
+    for (const tool of result.tools) {
+      const registered = {
+        name: `mcp_${serverName}_${tool.name}`,
+        description: `[${serverName}] ${_nullishCoalesce(tool.description, () => ( tool.name))}`,
+        inputSchema: _nullishCoalesce(tool.inputSchema, () => ( { type: "object", properties: {} })),
+        source: "mcp",
+        serverName,
+        permissionDefault: "ask",
+        isConcurrencySafe: true,
+        isReadOnly: false
+      };
+      this.toolRegistry.registerTool(registered, async (args) => {
+        const callResult = await client.callTool({ name: tool.name, arguments: args });
+        const parts = [];
+        if (Array.isArray(callResult.content)) {
+          for (const item of callResult.content) {
+            if (typeof item === "object" && item !== null && "text" in item) {
+              parts.push(String(item.text));
+            } else if (typeof item === "string") {
+              parts.push(item);
+            }
+          }
+        }
+        return parts.join("\n") || "(no output)";
+      });
+      _chunkIMMTBZ33cjs.logger.info("mcp.tool_registered", { server: serverName, tool: registered.name });
+    }
+  }
+  /**
+   * Disconnect all MCP servers.
+   */
+  async disconnectAll() {
+    for (const [name, conn] of this.connections) {
+      try {
+        await conn.client.close();
+        _chunkIMMTBZ33cjs.logger.info("mcp.disconnected", { server: name });
+      } catch (err) {
+        _chunkIMMTBZ33cjs.logger.warn("mcp.disconnect_error", { server: name, error: err.message });
+      }
+    }
+    this.connections.clear();
+  }
+  /**
+   * List connected servers.
+   */
+  listServers() {
+    return [...this.connections.keys()];
+  }
+  /**
+   * Call a tool on a specific MCP server.
+   */
+  async callTool(serverName, toolName, args) {
+    const conn = this.connections.get(serverName);
+    if (!conn) {
+      throw new Error(`MCP server "${serverName}" is not connected.`);
+    }
+    const result = await conn.client.callTool({ name: toolName, arguments: args });
+    const parts = [];
+    if (Array.isArray(result.content)) {
+      for (const item of result.content) {
+        if (typeof item === "object" && item !== null && "text" in item) {
+          parts.push(String(item.text));
+        } else if (typeof item === "string") {
+          parts.push(item);
+        }
+      }
+    }
+    return parts.join("\n") || "(no output)";
+  }
+  /**
+   * List resources from MCP servers.
+   */
+  async listResources(serverName) {
+    const results = [];
+    const servers = serverName ? [serverName] : [...this.connections.keys()];
+    for (const name of servers) {
+      const conn = this.connections.get(name);
+      if (!conn) continue;
+      try {
+        const res = await conn.client.listResources();
+        for (const r of res.resources) {
+          results.push({
+            uri: r.uri,
+            name: _nullishCoalesce(r.name, () => ( r.uri)),
+            description: r.description
+          });
+        }
+      } catch (e2) {
+      }
+    }
+    return results;
+  }
+  /**
+   * Read a resource from an MCP server.
+   */
+  async readResource(serverName, uri) {
+    const conn = this.connections.get(serverName);
+    if (!conn) {
+      throw new Error(`MCP server "${serverName}" is not connected.`);
+    }
+    const result = await conn.client.readResource({ uri });
+    const parts = [];
+    if (Array.isArray(result.contents)) {
+      for (const item of result.contents) {
+        if (typeof item === "object" && item !== null && "text" in item) {
+          parts.push(String(item.text));
+        }
+      }
+    }
+    return parts.join("\n") || "(no content)";
+  }
+}, _class.__initStatic(), _class);
+
+
+
+exports.MCPManager = MCPManager;

package/dist/chunk-C7JBCO5V.js

@@ -0,0 +1,80 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/agent/coordinator.ts
+init_esm_shims();
+var AgentCoordinator = class {
+  agents = /* @__PURE__ */ new Map();
+  inbox = /* @__PURE__ */ new Map();
+  /** Register a named agent. */
+  register(id, name, description) {
+    this.agents.set(name, {
+      id,
+      name,
+      status: "running",
+      description,
+      startedAt: Date.now()
+    });
+    if (!this.inbox.has(name)) {
+      this.inbox.set(name, []);
+    }
+  }
+  /** Mark an agent as completed. */
+  complete(name, result) {
+    const agent = this.agents.get(name);
+    if (agent) {
+      agent.status = "completed";
+      agent.completedAt = Date.now();
+      agent.result = result;
+    }
+  }
+  /** Mark an agent as failed. */
+  fail(name) {
+    const agent = this.agents.get(name);
+    if (agent) {
+      agent.status = "failed";
+      agent.completedAt = Date.now();
+    }
+  }
+  /** Get agent info by name. */
+  get(name) {
+    return this.agents.get(name);
+  }
+  /** List all agents. */
+  list() {
+    return [...this.agents.values()];
+  }
+  /** List active (running) agents. */
+  listActive() {
+    return [...this.agents.values()].filter((a) => a.status === "running");
+  }
+  /** Send a message to a named agent. */
+  send(from, to, content) {
+    if (!this.agents.has(to)) return false;
+    const messages = this.inbox.get(to) ?? [];
+    messages.push({ from, to, content, timestamp: Date.now() });
+    this.inbox.set(to, messages);
+    return true;
+  }
+  /** Read messages for a named agent (drains the inbox). */
+  receive(name) {
+    const messages = this.inbox.get(name) ?? [];
+    this.inbox.set(name, []);
+    return messages;
+  }
+  /** Peek at messages without draining. */
+  peek(name) {
+    return this.inbox.get(name) ?? [];
+  }
+  /** Reset all state. */
+  reset() {
+    this.agents.clear();
+    this.inbox.clear();
+  }
+};
+var agentCoordinator = new AgentCoordinator();
+
+export {
+  agentCoordinator
+};

package/dist/chunk-CSO5EOEP.cjs

@@ -0,0 +1,132 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/skills/index.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+
+// src/skills/scanner.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _path = require('path');
+var _os = require('os');
+function scanSkills(cwd) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  const dirs = [
+    // Project-level
+    _path.join.call(void 0, cwd, ".code-shell", "skills"),
+    _path.join.call(void 0, cwd, ".claude", "skills"),
+    // User-level
+    _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "skills"),
+    _path.join.call(void 0, _os.homedir.call(void 0, ), ".claude", "skills")
+  ];
+  for (const dir of dirs) {
+    if (!_fs.existsSync.call(void 0, dir)) continue;
+    try {
+      const files = _fs.readdirSync.call(void 0, dir).filter(
+        (f) => f.endsWith(".md") && _fs.statSync.call(void 0, _path.join.call(void 0, dir, f)).isFile()
+      );
+      for (const file of files) {
+        const filePath = _path.resolve.call(void 0, _path.join.call(void 0, dir, file));
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        const skill = parseSkillFile(filePath);
+        if (skill) skills.push(skill);
+      }
+    } catch (e) {
+    }
+  }
+  return skills;
+}
+function parseSkillFile(filePath) {
+  try {
+    const raw = _fs.readFileSync.call(void 0, filePath, "utf-8");
+    const match = raw.match(/^---\n([\s\S]*?)\n---\n\n?([\s\S]*)$/);
+    if (!match) return null;
+    const frontmatter = match[1];
+    const content = match[2].trim();
+    const name = extractField(frontmatter, "name");
+    if (!name) return null;
+    const description = _nullishCoalesce(extractField(frontmatter, "description"), () => ( ""));
+    const whenToUse = _nullishCoalesce(extractField(frontmatter, "when_to_use"), () => ( ""));
+    const keywords = extractList(frontmatter, "keywords");
+    const tools = extractList(frontmatter, "tools");
+    const intents = extractList(frontmatter, "intents");
+    return {
+      name,
+      description,
+      triggers: { keywords, tools, intents },
+      whenToUse,
+      content,
+      filePath
+    };
+  } catch (e2) {
+    return null;
+  }
+}
+function extractField(frontmatter, field) {
+  const match = frontmatter.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+  return _optionalChain([match, 'optionalAccess', _ => _[1], 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]);
+}
+function extractList(frontmatter, field) {
+  const match = frontmatter.match(new RegExp(`${field}:\\s*\\[([^\\]]+)\\]`));
+  if (!match) return [];
+  return match[1].split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+}
+
+// src/skills/matcher.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+function matchSkillsByInput(skills, input) {
+  const inputLower = input.toLowerCase();
+  const results = [];
+  for (const skill of skills) {
+    let bestScore = 0;
+    let matchedBy = "";
+    if (skill.triggers.keywords) {
+      for (const kw of skill.triggers.keywords) {
+        if (inputLower.includes(kw.toLowerCase())) {
+          const score = kw.length / input.length * 10 + 5;
+          if (score > bestScore) {
+            bestScore = score;
+            matchedBy = "keyword";
+          }
+        }
+      }
+    }
+    if (skill.triggers.intents) {
+      for (const intent of skill.triggers.intents) {
+        if (inputLower.includes(intent.toLowerCase())) {
+          const score = 8;
+          if (score > bestScore) {
+            bestScore = score;
+            matchedBy = "intent";
+          }
+        }
+      }
+    }
+    if (bestScore > 0) {
+      results.push({ skill, score: bestScore, matchedBy });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+function matchSkillsByTool(skills, toolName) {
+  return skills.filter((s) => _optionalChain([s, 'access', _4 => _4.triggers, 'access', _5 => _5.tools, 'optionalAccess', _6 => _6.includes, 'call', _7 => _7(toolName)])).map((skill) => ({ skill, score: 10, matchedBy: "tool" }));
+}
+function buildSkillListing(skills) {
+  if (skills.length === 0) return "";
+  const lines = skills.map(
+    (s) => `- **${s.name}**: ${s.description}${s.whenToUse ? ` \u2014 Use when: ${s.whenToUse}` : ""}`
+  );
+  return `# Available Skills
+
+${lines.join("\n")}`;
+}
+
+
+
+
+
+
+exports.scanSkills = scanSkills; exports.matchSkillsByInput = matchSkillsByInput; exports.matchSkillsByTool = matchSkillsByTool; exports.buildSkillListing = buildSkillListing;