@ulpi/cli 0.1.5 → 0.1.6

package/dist/dist-EK45QNEM.js

@@ -0,0 +1,45 @@
+import {
+  addToLibrary,
+  collectProjectSignals,
+  disableMcp,
+  enableMcp,
+  getActivation,
+  getCatalogEntry,
+  getLibraryEntry,
+  listActivations,
+  listLibrary,
+  loadActivations,
+  loadCatalog,
+  loadLibrary,
+  removeFromLibrary,
+  saveActivations,
+  saveLibrary,
+  searchCatalog,
+  suggestMcps,
+  updateActivationConfig
+} from "./chunk-JLHNLM3C.js";
+import "./chunk-4ZPOZULQ.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-YOKL7RB5.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  addToLibrary,
+  collectProjectSignals,
+  disableMcp,
+  enableMcp,
+  getActivation,
+  getCatalogEntry,
+  getLibraryEntry,
+  listActivations,
+  listLibrary,
+  loadActivations,
+  loadCatalog,
+  loadLibrary,
+  removeFromLibrary,
+  saveActivations,
+  saveLibrary,
+  searchCatalog,
+  suggestMcps,
+  updateActivationConfig
+};

package/dist/{dist-U7ZIJMZD.js → dist-FKFEJRPX.js}

@@ -1,9 +1,3 @@
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  Server,
-  StdioServerTransport
-} from "./chunk-JWUUVXIV.js";
 import {
   generateMemoryId,
   getMemoryStats,
@@ -15,19 +9,26 @@ import {
   removeEntry,
   searchMemory,
   updateEntry
-} from "./chunk-UCMT5OKP.js";
-import "./chunk-6OURRFP7.js";
-import "./chunk-K4OVPFY2.js";
-import "./chunk-KLEASXUR.js";
-import "./chunk-L3PWNHSA.js";
-import "./chunk-26LLDX2T.js";
-import "./chunk-74WVVWJ4.js";
+} from "./chunk-BFEKZZHM.js";
+import "./chunk-IV6MWETF.js";
+import "./chunk-4UCJIAOU.js";
+import "./chunk-6ZL6NXMV.js";
+import "./chunk-TSLDGT5O.js";
+import "./chunk-AWOSRA5F.js";
+import "./chunk-3WB5CXH4.js";
+import "./chunk-SEU7WWNQ.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-YOKL7RB5.js";
 import "./chunk-KIKPIH6N.js";
-import "./chunk-DOIKS6C5.js";
-import "./chunk-DDRLI6JU.js";
 import "./chunk-4VNS5WPM.js";
 
 // ../../packages/memory-mcp/dist/index.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
 var searchMemoryTool = {
   name: "search_memory",
   description: "Search project memories by semantic similarity. Returns memories ranked by relevance, importance, and access frequency. Memories include decisions, patterns, bug root causes, preferences, constraints, context, lessons, and relationships.",

package/dist/dist-GTEJUBBT.js

@@ -0,0 +1,66 @@
+import {
+  EventResponseConfigSchema,
+  HookEventSchema,
+  NotifyChannelSchema,
+  PermissionDecisionSchema,
+  PermissionRuleInputSchema,
+  PipelineOnFailureSchema,
+  PipelineRuleInputSchema,
+  PipelineStepSchema,
+  PostconditionRuleInputSchema,
+  PreconditionRuleInputSchema,
+  ResponseConfigSchema,
+  ReviewSettingsConfigSchema,
+  RuleSourceSchema,
+  RulesConfigSchema,
+  SessionStateFlagSchema,
+  StackConfigSchema,
+  buildPermissionOutput,
+  checkPipelinePrereqs,
+  checkPrecondition,
+  collectPostconditions,
+  evaluatePermission,
+  evaluateRules,
+  isDangerousCommand,
+  loadRulesSync,
+  matchesCommand,
+  matchesFilePattern,
+  matchesTool,
+  normalizePath,
+  parseRules,
+  resolveVariables
+} from "./chunk-5MI5GIXM.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  EventResponseConfigSchema,
+  HookEventSchema,
+  NotifyChannelSchema,
+  PermissionDecisionSchema,
+  PermissionRuleInputSchema,
+  PipelineOnFailureSchema,
+  PipelineRuleInputSchema,
+  PipelineStepSchema,
+  PostconditionRuleInputSchema,
+  PreconditionRuleInputSchema,
+  ResponseConfigSchema,
+  ReviewSettingsConfigSchema,
+  RuleSourceSchema,
+  RulesConfigSchema,
+  SessionStateFlagSchema,
+  StackConfigSchema,
+  buildPermissionOutput,
+  checkPipelinePrereqs,
+  checkPrecondition,
+  collectPostconditions,
+  evaluatePermission,
+  evaluateRules,
+  isDangerousCommand,
+  loadRulesSync,
+  matchesCommand,
+  matchesFilePattern,
+  matchesTool,
+  normalizePath,
+  parseRules,
+  resolveVariables
+};

package/dist/dist-HA74OKJZ.js

@@ -0,0 +1,40 @@
+import {
+  ADAPTABLE_SKILLS,
+  CLAUDE_ONLY_SKILLS,
+  adaptContentForCodex,
+  adaptContentForKiro,
+  appendTomlSection,
+  convertClaudeAgentsToCodex,
+  convertClaudeAgentsToKiro,
+  convertClaudeSkillsToCodex,
+  convertClaudeSkillsToKiro,
+  copyDirRecursive,
+  extractCodexMcpServers,
+  extractKiroMcpServers,
+  inferSandboxMode,
+  mapClaudeModelToCodex,
+  mapClaudeToolsToKiro,
+  parseClaudeAgentFrontmatter,
+  serializeTomlTable
+} from "./chunk-SNQ7NAIS.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  ADAPTABLE_SKILLS,
+  CLAUDE_ONLY_SKILLS,
+  adaptContentForCodex,
+  adaptContentForKiro,
+  appendTomlSection,
+  convertClaudeAgentsToCodex,
+  convertClaudeAgentsToKiro,
+  convertClaudeSkillsToCodex,
+  convertClaudeSkillsToKiro,
+  copyDirRecursive,
+  extractCodexMcpServers,
+  extractKiroMcpServers,
+  inferSandboxMode,
+  mapClaudeModelToCodex,
+  mapClaudeToolsToKiro,
+  parseClaudeAgentFrontmatter,
+  serializeTomlTable
+};

package/dist/{dist-XG2GG5SD.js → dist-HU5RZAON.js}

@@ -1,36 +1,48 @@
 import {
   BUNDLED_SKILLS,
+  clearPromptCache,
   composeTemplates,
   deleteUserTemplate,
   exportUserTemplate,
+  getBuiltinPromptTemplate,
   getBundledSkillInfo,
   getBundledTemplate,
   importUserTemplate,
   injectSkill,
+  listBuiltinPromptTemplates,
   listUserTemplates,
   loadBundledTemplates,
+  loadMcpCatalog,
   loadSkillSync,
   loadTemplates,
   loadUserTemplate,
+  renderPrompt,
   resolveTemplate,
   saveUserTemplate
-} from "./chunk-IFATANHR.js";
-import "./chunk-DDRLI6JU.js";
+} from "./chunk-4ZPOZULQ.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-YOKL7RB5.js";
+import "./chunk-KIKPIH6N.js";
 import "./chunk-4VNS5WPM.js";
 export {
   BUNDLED_SKILLS,
+  clearPromptCache,
   composeTemplates,
   deleteUserTemplate,
   exportUserTemplate,
+  getBuiltinPromptTemplate,
   getBundledSkillInfo,
   getBundledTemplate,
   importUserTemplate,
   injectSkill,
+  listBuiltinPromptTemplates,
   listUserTemplates,
   loadBundledTemplates,
+  loadMcpCatalog,
   loadSkillSync,
   loadTemplates,
   loadUserTemplate,
+  renderPrompt as renderPromptTemplate,
   resolveTemplate,
   saveUserTemplate
 };

package/dist/dist-IYE3OBRB.js

@@ -0,0 +1,374 @@
+import {
+  loadActivations,
+  loadLibrary
+} from "./chunk-JLHNLM3C.js";
+import "./chunk-4ZPOZULQ.js";
+import {
+  projectMcpsFile
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-YOKL7RB5.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-4VNS5WPM.js";
+
+// ../../packages/mcp-gateway/dist/index.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import * as fs from "fs";
+function resolveEnabledMcps(projectDir) {
+  const library = loadLibrary();
+  const activations = loadActivations(projectDir);
+  const resolved = [];
+  for (const [name, activation] of Object.entries(activations.mcps)) {
+    if (!activation.enabled) continue;
+    const definition = library.mcps[name];
+    if (!definition) {
+      process.stderr.write(`[mcp-gateway] Warning: MCP "${name}" enabled in repo but not found in library -- skipping
+`);
+      continue;
+    }
+    const resolvedEnv = {};
+    for (const [key, value] of Object.entries(activation.config)) {
+      if (typeof value === "string" && value.startsWith("env:")) {
+        const envName = value.slice(4);
+        const envValue = process.env[envName];
+        if (envValue !== void 0) {
+          resolvedEnv[envName] = envValue;
+        } else {
+          process.stderr.write(`[mcp-gateway] Warning: env var "${envName}" not set for MCP "${name}" config key "${key}"
+`);
+        }
+      }
+    }
+    resolved.push({ name, definition, activation, resolvedEnv });
+  }
+  return resolved;
+}
+var CONNECT_TIMEOUT_MS = 3e4;
+var MAX_BACKENDS = 20;
+var MAX_CRASH_RETRIES = 1;
+var BackendManager = class {
+  backends = /* @__PURE__ */ new Map();
+  get size() {
+    return this.backends.size;
+  }
+  getBackend(name) {
+    return this.backends.get(name);
+  }
+  getAllBackends() {
+    return Array.from(this.backends.values());
+  }
+  getAllTools() {
+    const tools = [];
+    for (const backend of this.backends.values()) {
+      if (backend.status === "running") {
+        tools.push(...backend.tools);
+      }
+    }
+    return tools;
+  }
+  /**
+   * Spawn and connect to a backend MCP server.
+   */
+  async startBackend(mcp) {
+    if (this.backends.size >= MAX_BACKENDS) {
+      throw new Error(`Maximum backend limit reached (${MAX_BACKENDS})`);
+    }
+    const entry = {
+      name: mcp.name,
+      definition: mcp.definition,
+      activation: mcp.activation,
+      client: null,
+      transport: null,
+      status: "starting",
+      tools: [],
+      crashCount: 0
+    };
+    this.backends.set(mcp.name, entry);
+    try {
+      await this.connectBackend(entry, mcp);
+    } catch (err) {
+      entry.status = "crashed";
+      entry.error = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[mcp-gateway] Failed to start backend "${mcp.name}": ${entry.error}
+`);
+    }
+    return entry;
+  }
+  async connectBackend(entry, mcp) {
+    const { definition } = mcp;
+    const isHttp = definition.transport === "http" || definition.transport === "sse";
+    if (isHttp) {
+      process.stderr.write(`[mcp-gateway] Connecting to HTTP backend "${mcp.name}" (${definition.command})
+`);
+    } else {
+      process.stderr.write(`[mcp-gateway] Starting backend "${mcp.name}" (${definition.command} ${definition.args.join(" ")})
+`);
+    }
+    let transport;
+    if (isHttp) {
+      const headers = {};
+      const authHeader = mcp.resolvedEnv.AUTHORIZATION ?? mcp.resolvedEnv.Authorization;
+      if (authHeader) {
+        headers["Authorization"] = authHeader;
+      }
+      transport = new StreamableHTTPClientTransport(
+        new URL(definition.command),
+        { requestInit: { headers } }
+      );
+    } else {
+      const childEnv = {};
+      for (const [k, v] of Object.entries(process.env)) {
+        if (v !== void 0) childEnv[k] = v;
+      }
+      Object.assign(childEnv, mcp.resolvedEnv);
+      transport = new StdioClientTransport({
+        command: definition.command,
+        args: definition.args,
+        env: childEnv
+      });
+    }
+    const client = new Client(
+      { name: `ulpi-gateway-${mcp.name}`, version: "0.1.0" },
+      { capabilities: {} }
+    );
+    entry.transport = transport;
+    entry.client = client;
+    transport.onclose = () => {
+      if (entry.status === "running") {
+        entry.status = "crashed";
+        process.stderr.write(`[mcp-gateway] Backend "${mcp.name}" ${isHttp ? "disconnected" : "crashed"}
+`);
+      }
+    };
+    const connectPromise = client.connect(transport);
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Connection timeout after ${CONNECT_TIMEOUT_MS}ms`)), CONNECT_TIMEOUT_MS)
+    );
+    await Promise.race([connectPromise, timeoutPromise]);
+    const toolsResult = await client.listTools();
+    const tools = (toolsResult.tools ?? []).map((tool) => ({
+      namespacedName: `${mcp.name}__${tool.name}`,
+      originalName: tool.name,
+      backendName: mcp.name,
+      definition: {
+        name: `${mcp.name}__${tool.name}`,
+        description: tool.description ? `[${mcp.definition.display_name ?? mcp.name}] ${tool.description}` : void 0,
+        inputSchema: tool.inputSchema ?? { type: "object" }
+      }
+    }));
+    entry.tools = tools;
+    entry.status = "running";
+    process.stderr.write(`[mcp-gateway] Backend "${mcp.name}" connected (${tools.length} tools)
+`);
+  }
+  /**
+   * Call a tool on a specific backend.
+   * Handles crash recovery (one retry).
+   */
+  async callTool(backendName, toolName, args) {
+    const entry = this.backends.get(backendName);
+    if (!entry) {
+      return { content: [{ type: "text", text: `Unknown MCP server: ${backendName}` }], isError: true };
+    }
+    if (entry.status === "crashed" && entry.crashCount < MAX_CRASH_RETRIES) {
+      entry.crashCount++;
+      process.stderr.write(`[mcp-gateway] Attempting to restart backend "${backendName}" (retry ${entry.crashCount}/${MAX_CRASH_RETRIES})
+`);
+      try {
+        await this.connectBackend(entry, {
+          name: entry.name,
+          definition: entry.definition,
+          activation: entry.activation,
+          resolvedEnv: {}
+        });
+      } catch {
+        return { content: [{ type: "text", text: `[${backendName}] MCP server crashed and could not be restarted` }], isError: true };
+      }
+    }
+    if (entry.status !== "running" || !entry.client) {
+      return { content: [{ type: "text", text: `[${backendName}] MCP server is not running` }], isError: true };
+    }
+    const startTime = Date.now();
+    try {
+      const resultPromise = entry.client.callTool({ name: toolName, arguments: args });
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), 6e4)
+      );
+      const result = await Promise.race([resultPromise, timeoutPromise]);
+      const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+      process.stderr.write(`[mcp-gateway] Tool call: ${backendName}__${toolName} (${elapsed}s)
+`);
+      return result;
+    } catch (err) {
+      if (err instanceof Error && err.message === "timeout") {
+        return { content: [{ type: "text", text: `[${backendName}] Tool call timed out after 60s` }], isError: true };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: "text", text: `[${backendName}] ${message}` }], isError: true };
+    }
+  }
+  /**
+   * Stop a specific backend.
+   */
+  async stopBackend(name) {
+    const entry = this.backends.get(name);
+    if (!entry) return;
+    entry.status = "stopped";
+    try {
+      if (entry.transport && typeof entry.transport.close === "function") {
+        await entry.transport.close();
+      }
+    } catch {
+    }
+    this.backends.delete(name);
+  }
+  /**
+   * Stop all backends.
+   */
+  async stopAll() {
+    const names = Array.from(this.backends.keys());
+    await Promise.allSettled(names.map((name) => this.stopBackend(name)));
+  }
+};
+function parseToolName(namespacedName) {
+  const idx = namespacedName.indexOf("__");
+  if (idx <= 0) return null;
+  return {
+    backend: namespacedName.slice(0, idx),
+    tool: namespacedName.slice(idx + 2)
+  };
+}
+function buildToolList(tools) {
+  return tools.map((t) => t.definition);
+}
+function watchMcpsConfig(projectDir, callback) {
+  const filePath = projectMcpsFile(projectDir);
+  let debounceTimer = null;
+  let watcher = null;
+  try {
+    const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+    if (!fs.existsSync(dir)) {
+      return { close: () => {
+      } };
+    }
+    watcher = fs.watch(dir, (_eventType, filename) => {
+      if (filename && filename.endsWith("mcps.yml")) {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+          process.stderr.write("[mcp-gateway] Config change detected: reloading mcps.yml\n");
+          callback();
+        }, 500);
+      }
+    });
+    watcher.on("error", () => {
+    });
+  } catch {
+    return { close: () => {
+    } };
+  }
+  return {
+    close: () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      if (watcher) watcher.close();
+    }
+  };
+}
+function createGateway(options) {
+  const manager = new BackendManager();
+  let initialized = false;
+  const server = new Server(
+    { name: "tools", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  async function initBackends() {
+    const mcps = resolveEnabledMcps(options.projectDir);
+    if (mcps.length === 0) {
+      process.stderr.write("[mcp-gateway] No MCPs enabled for this repo\n");
+      return;
+    }
+    process.stderr.write(`[mcp-gateway] Starting ${mcps.length} backend(s)
+`);
+    await Promise.allSettled(
+      mcps.map((mcp) => manager.startBackend(mcp))
+    );
+    initialized = true;
+  }
+  async function handleConfigChange() {
+    const mcps = resolveEnabledMcps(options.projectDir);
+    const enabledNames = new Set(mcps.map((m) => m.name));
+    const runningNames = new Set(manager.getAllBackends().map((b) => b.name));
+    for (const name of runningNames) {
+      if (!enabledNames.has(name)) {
+        process.stderr.write(`[mcp-gateway] Stopping disabled backend "${name}"
+`);
+        await manager.stopBackend(name);
+      }
+    }
+    for (const mcp of mcps) {
+      if (!runningNames.has(mcp.name)) {
+        process.stderr.write(`[mcp-gateway] Starting newly enabled backend "${mcp.name}"
+`);
+        await manager.startBackend(mcp);
+      }
+    }
+    try {
+      await server.sendToolListChanged();
+    } catch {
+    }
+  }
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    if (!initialized) {
+      await initBackends();
+    }
+    const tools = buildToolList(manager.getAllTools());
+    return { tools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const parsed = parseToolName(name);
+    if (!parsed) {
+      return {
+        content: [{ type: "text", text: `Invalid tool name format: ${name}. Expected: {mcpName}__{toolName}` }],
+        isError: true
+      };
+    }
+    const result = await manager.callTool(parsed.backend, parsed.tool, args ?? {});
+    return result;
+  });
+  const watcher = watchMcpsConfig(options.projectDir, () => {
+    void handleConfigChange();
+  });
+  const shutdownHandler = async () => {
+    process.stderr.write("[mcp-gateway] Shutting down...\n");
+    watcher.close();
+    await manager.stopAll();
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => void shutdownHandler());
+  process.on("SIGINT", () => void shutdownHandler());
+  const forceKill = () => {
+    setTimeout(() => {
+      process.stderr.write("[mcp-gateway] Force killing after timeout\n");
+      process.exit(1);
+    }, 5e3).unref();
+  };
+  process.on("SIGTERM", forceKill);
+  process.on("SIGINT", forceKill);
+  return server;
+}
+async function startGateway(options) {
+  const server = createGateway(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  createGateway,
+  startGateway
+};

package/dist/{dist-7WLLPWWB.js → dist-JLU26AB6.js}

@@ -7,6 +7,7 @@ import {
   buildClassificationPrompt,
   buildClassificationWindows,
   buildSingleClassificationPrompt,
+  captureJobForClassification,
   classifySession,
   classifySinglePrompt,
   classifyWindow,
@@ -49,16 +50,17 @@ import {
   updateEntry,
   writeClassifyBatchProgress,
   writeMemoryStats
-} from "./chunk-UCMT5OKP.js";
-import "./chunk-6OURRFP7.js";
-import "./chunk-K4OVPFY2.js";
-import "./chunk-KLEASXUR.js";
-import "./chunk-L3PWNHSA.js";
-import "./chunk-26LLDX2T.js";
-import "./chunk-74WVVWJ4.js";
+} from "./chunk-BFEKZZHM.js";
+import "./chunk-IV6MWETF.js";
+import "./chunk-4UCJIAOU.js";
+import "./chunk-6ZL6NXMV.js";
+import "./chunk-TSLDGT5O.js";
+import "./chunk-AWOSRA5F.js";
+import "./chunk-3WB5CXH4.js";
+import "./chunk-SEU7WWNQ.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-YOKL7RB5.js";
 import "./chunk-KIKPIH6N.js";
-import "./chunk-DOIKS6C5.js";
-import "./chunk-DDRLI6JU.js";
 import "./chunk-4VNS5WPM.js";
 export {
   DEFAULT_MEMORY_CONFIG,
@@ -69,6 +71,7 @@ export {
   buildClassificationPrompt,
   buildClassificationWindows,
   buildSingleClassificationPrompt,
+  captureJobForClassification,
   classifySession,
   classifySinglePrompt,
   classifyWindow,