@ulpi/cli 0.1.4 → 0.1.6

package/dist/mcp-installer-PQU3XOGO.js

@@ -0,0 +1,259 @@
+import {
+  getBinaryPath
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/mcp-installer.ts
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+function mcpJsonPath(projectDir) {
+  return path.join(projectDir, ".mcp.json");
+}
+function readMcpJson(projectDir) {
+  const filePath = mcpJsonPath(projectDir);
+  if (fs.existsSync(filePath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      return { mcpServers: data.mcpServers ?? {} };
+    } catch {
+    }
+  }
+  return { mcpServers: {} };
+}
+function writeMcpJson(projectDir, mcpServers) {
+  const filePath = mcpJsonPath(projectDir);
+  fs.writeFileSync(filePath, JSON.stringify({ mcpServers }, null, 2) + "\n", "utf-8");
+}
+function buildMcpEntry(subcommandArgs, description) {
+  return { command: getBinaryPath(), args: subcommandArgs, description };
+}
+function installMcpServer(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  if (mcpServers["codemap"]) {
+    return { installed: false, message: "CodeMap MCP server already registered" };
+  }
+  mcpServers["codemap"] = buildMcpEntry(["codemap", "serve"], "Semantic code search (hybrid vector + BM25), symbol lookup, file summaries, dependency graph analysis (PageRank, cycles, coupling). Use search_code for concept-based queries, search_symbols to find functions/types by name.");
+  writeMcpJson(projectDir, mcpServers);
+  return { installed: true, message: "CodeMap MCP server registered in .mcp.json" };
+}
+function uninstallMcpServer(projectDir) {
+  const filePath = mcpJsonPath(projectDir);
+  if (!fs.existsSync(filePath)) return;
+  try {
+    const { mcpServers } = readMcpJson(projectDir);
+    if (mcpServers["codemap"]) {
+      delete mcpServers["codemap"];
+      writeMcpJson(projectDir, mcpServers);
+    }
+  } catch {
+  }
+}
+function isMcpServerInstalled(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  return !!mcpServers["codemap"];
+}
+function installMemoryMcpServer(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  if (mcpServers["memory"]) {
+    return { installed: false, message: "Memory MCP server already registered" };
+  }
+  mcpServers["memory"] = buildMcpEntry(["memory", "serve"], "Persistent agent memory across sessions. Search past decisions, patterns, and learnings. Save new memories, browse timeline, get session context, and manage retention.");
+  writeMcpJson(projectDir, mcpServers);
+  return { installed: true, message: "Memory MCP server registered in .mcp.json" };
+}
+function uninstallMemoryMcpServer(projectDir) {
+  const filePath = mcpJsonPath(projectDir);
+  if (!fs.existsSync(filePath)) return;
+  try {
+    const { mcpServers } = readMcpJson(projectDir);
+    if (mcpServers["memory"]) {
+      delete mcpServers["memory"];
+      writeMcpJson(projectDir, mcpServers);
+    }
+  } catch {
+  }
+}
+function isMemoryMcpServerInstalled(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  return !!mcpServers["memory"];
+}
+function installGatewayMcpServer(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  if (mcpServers["tools"]) {
+    return { installed: false, message: "MCP Gateway server already registered" };
+  }
+  mcpServers["tools"] = buildMcpEntry(["mcp", "gateway"], "MCP gateway proxy \u2014 aggregates tools from third-party MCP servers (databases, APIs, services) enabled for this project. Tool names are prefixed with the server name (e.g. postgres__query, stripe__list_customers).");
+  writeMcpJson(projectDir, mcpServers);
+  return { installed: true, message: "MCP Gateway server registered in .mcp.json" };
+}
+function isCommandAvailable(command) {
+  try {
+    execFileSync("which", [command], { encoding: "utf-8", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getProjectMcpEntries() {
+  const binary = getBinaryPath();
+  return {
+    codemap: { command: binary, args: ["codemap", "serve"] },
+    memory: { command: binary, args: ["memory", "serve"] },
+    gateway: { command: binary, args: ["mcp", "gateway"] }
+  };
+}
+function readJsonConfig(filePath) {
+  if (fs.existsSync(filePath)) {
+    try {
+      return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    } catch {
+    }
+  }
+  return {};
+}
+function writeJsonConfig(filePath, config) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function writeCodexProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, ".codex", "config.toml");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  let content = "";
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, "utf-8");
+  }
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    const sectionHeader = `[mcp_servers.${name}]`;
+    if (content.includes(sectionHeader)) continue;
+    const argsToml = entry.args.map((a) => `"${a}"`).join(", ");
+    content += `
+${sectionHeader}
+command = "${entry.command}"
+args = [${argsToml}]
+`;
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+  return { cli: "Codex", file: ".codex/config.toml", servers: added };
+}
+function writeKiroProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, ".kiro", "settings", "mcp.json");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  const config = readJsonConfig(filePath);
+  const mcpServers = config.mcpServers ?? {};
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    if (mcpServers[name]) continue;
+    mcpServers[name] = { command: entry.command, args: entry.args, transportType: "stdio" };
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  config.mcpServers = mcpServers;
+  writeJsonConfig(filePath, config);
+  return { cli: "Kiro", file: ".kiro/settings/mcp.json", servers: added };
+}
+function writeGeminiProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, ".gemini", "settings.json");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  const config = readJsonConfig(filePath);
+  const mcpServers = config.mcpServers ?? {};
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    if (mcpServers[name]) continue;
+    mcpServers[name] = { command: entry.command, args: entry.args };
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  config.mcpServers = mcpServers;
+  writeJsonConfig(filePath, config);
+  return { cli: "Gemini", file: ".gemini/settings.json", servers: added };
+}
+function writeOpenCodeProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, "opencode.json");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  const config = readJsonConfig(filePath);
+  const mcp = config.mcp ?? {};
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    if (mcp[name]) continue;
+    mcp[name] = { command: [entry.command, ...entry.args], type: "local" };
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  config.mcp = mcp;
+  writeJsonConfig(filePath, config);
+  return { cli: "OpenCode", file: "opencode.json", servers: added };
+}
+function writeDroidProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, ".factory", "mcp.json");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  const config = readJsonConfig(filePath);
+  const mcpServers = config.mcpServers ?? {};
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    if (mcpServers[name]) continue;
+    mcpServers[name] = { command: entry.command, args: entry.args, type: "stdio" };
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  config.mcpServers = mcpServers;
+  writeJsonConfig(filePath, config);
+  return { cli: "Droid", file: ".factory/mcp.json", servers: added };
+}
+function installMcpForAllClis(projectDir) {
+  const results = [];
+  const clis = [
+    { binary: "codex", writer: writeCodexProjectMcp },
+    { binary: "kiro", writer: writeKiroProjectMcp },
+    { binary: "gemini", writer: writeGeminiProjectMcp },
+    { binary: "opencode", writer: writeOpenCodeProjectMcp },
+    { binary: "droid", writer: writeDroidProjectMcp }
+  ];
+  for (const { binary, writer } of clis) {
+    if (!isCommandAvailable(binary)) continue;
+    const result = writer(projectDir);
+    if (result) results.push(result);
+  }
+  return results;
+}
+export {
+  installGatewayMcpServer,
+  installMcpForAllClis,
+  installMcpServer,
+  installMemoryMcpServer,
+  isMcpServerInstalled,
+  isMemoryMcpServerInstalled,
+  uninstallMcpServer,
+  uninstallMemoryMcpServer
+};

package/dist/mcp-setup-OA7IB3H3.js

@@ -0,0 +1,263 @@
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/mcp-setup.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execFileSync } from "child_process";
+import chalk from "chalk";
+function isCommandAvailable(command) {
+  try {
+    execFileSync("which", [command], { encoding: "utf-8", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectAgents() {
+  const agents = [];
+  const home = os.homedir();
+  if (isCommandAvailable("claude")) {
+    agents.push({
+      name: "Claude Code",
+      binary: "claude",
+      configPath: path.join(home, ".claude", "settings.json"),
+      format: "json"
+    });
+  }
+  if (isCommandAvailable("opencode")) {
+    const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    const opencodePath = path.join(xdgConfig, "opencode", "config.json");
+    agents.push({
+      name: "OpenCode",
+      binary: "opencode",
+      configPath: opencodePath,
+      format: "json"
+    });
+  }
+  if (isCommandAvailable("gemini")) {
+    const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    agents.push({
+      name: "Gemini CLI",
+      binary: "gemini",
+      configPath: path.join(xdgConfig, "gemini", "settings.json"),
+      format: "json"
+    });
+  }
+  if (isCommandAvailable("codex")) {
+    agents.push({
+      name: "Codex",
+      binary: "codex",
+      configPath: path.join(home, ".codex", "config.json"),
+      format: "json"
+    });
+  }
+  if (isCommandAvailable("kiro")) {
+    agents.push({
+      name: "Kiro",
+      binary: "kiro",
+      configPath: path.join(home, ".kiro", "settings", "mcp.json"),
+      format: "json-nested"
+    });
+  }
+  if (isCommandAvailable("droid")) {
+    const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    agents.push({
+      name: "Droid",
+      binary: "droid",
+      configPath: path.join(xdgConfig, "droid", "mcp.json"),
+      format: "json"
+    });
+  }
+  return agents;
+}
+function buildMcpEntries() {
+  return {
+    codemap: {
+      command: "ulpi",
+      args: ["codemap", "serve"]
+    },
+    memory: {
+      command: "ulpi",
+      args: ["memory", "serve"]
+    },
+    gateway: {
+      command: "ulpi",
+      args: ["mcp", "gateway"]
+    }
+  };
+}
+function writeJsonMcpConfig(configPath, agentName) {
+  const entries = [];
+  const mcpEntries = buildMcpEntries();
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mcpServers = config.mcpServers ?? {};
+  let changed = false;
+  if (!mcpServers["ulpi-codemap"]) {
+    mcpServers["ulpi-codemap"] = mcpEntries.codemap;
+    entries.push("ulpi-codemap");
+    changed = true;
+  }
+  if (!mcpServers["ulpi-memory"]) {
+    mcpServers["ulpi-memory"] = mcpEntries.memory;
+    entries.push("ulpi-memory");
+    changed = true;
+  }
+  if (!mcpServers["tools"]) {
+    mcpServers["tools"] = mcpEntries.gateway;
+    entries.push("tools");
+    changed = true;
+  }
+  if (changed) {
+    config.mcpServers = mcpServers;
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  }
+  return { written: changed, entries };
+}
+function writeKiroMcpConfig(configPath) {
+  const entries = [];
+  const mcpEntries = buildMcpEntries();
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mcpServers = config.mcpServers ?? {};
+  let changed = false;
+  if (!mcpServers["ulpi-codemap"]) {
+    mcpServers["ulpi-codemap"] = {
+      command: mcpEntries.codemap.command,
+      args: mcpEntries.codemap.args,
+      transportType: "stdio"
+    };
+    entries.push("ulpi-codemap");
+    changed = true;
+  }
+  if (!mcpServers["ulpi-memory"]) {
+    mcpServers["ulpi-memory"] = {
+      command: mcpEntries.memory.command,
+      args: mcpEntries.memory.args,
+      transportType: "stdio"
+    };
+    entries.push("ulpi-memory");
+    changed = true;
+  }
+  if (!mcpServers["tools"]) {
+    mcpServers["tools"] = {
+      command: mcpEntries.gateway.command,
+      args: mcpEntries.gateway.args,
+      transportType: "stdio"
+    };
+    entries.push("tools");
+    changed = true;
+  }
+  if (changed) {
+    config.mcpServers = mcpServers;
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  }
+  return { written: changed, entries };
+}
+function suggestAdditionalMcpServers(projectDir) {
+  const suggestions = [];
+  suggestions.push(
+    `${chalk.cyan("context7")} - Library documentation lookup (npx -y @upstash/context7-mcp@latest)`
+  );
+  const claudeSettingsPath = path.join(projectDir, ".claude", "settings.local.json");
+  if (fs.existsSync(claudeSettingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(claudeSettingsPath, "utf-8"));
+      const mcpServers = settings.mcpServers;
+      if (mcpServers) {
+        const projectServers = Object.keys(mcpServers).filter(
+          (k) => !k.startsWith("ulpi-") && k !== "codemap" && k !== "memory"
+        );
+        if (projectServers.length > 0) {
+          suggestions.push(
+            `${chalk.dim("Project MCP servers detected:")} ${projectServers.join(", ")}`
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  if (suggestions.length > 0) {
+    console.log(chalk.bold("\nSuggested additional MCP servers:"));
+    for (const suggestion of suggestions) {
+      console.log(`  ${suggestion}`);
+    }
+  }
+}
+async function runMcpSetup(projectDir) {
+  console.log(chalk.bold("\nULPI MCP Setup\n"));
+  const agents = detectAgents();
+  if (agents.length === 0) {
+    console.log(chalk.yellow("No supported agent CLIs detected on PATH."));
+    console.log(chalk.dim("\nSupported agents: claude, opencode, gemini, codex, kiro, droid"));
+    console.log(chalk.dim("Install one and run this command again."));
+    return;
+  }
+  console.log(`Detected ${chalk.cyan(String(agents.length))} agent CLI(s):
+`);
+  let totalWritten = 0;
+  let totalSkipped = 0;
+  for (const agent of agents) {
+    console.log(`  ${chalk.bold(agent.name)} (${chalk.dim(agent.binary)})`);
+    console.log(`    Config: ${chalk.dim(agent.configPath)}`);
+    let result;
+    if (agent.format === "json-nested") {
+      result = writeKiroMcpConfig(agent.configPath);
+    } else {
+      result = writeJsonMcpConfig(agent.configPath, agent.name);
+    }
+    if (result.written) {
+      console.log(
+        `    ${chalk.green("Added:")} ${result.entries.join(", ")}`
+      );
+      totalWritten += result.entries.length;
+    } else {
+      console.log(`    ${chalk.dim("Already configured")}`);
+      totalSkipped++;
+    }
+    console.log("");
+  }
+  if (totalWritten > 0) {
+    console.log(
+      chalk.green(`Registered ${totalWritten} MCP server(s) across ${agents.length} agent(s).`)
+    );
+  } else if (totalSkipped > 0) {
+    console.log(chalk.dim("All agents already have ULPI MCP servers configured."));
+  }
+  try {
+    const { installMcpForAllClis } = await import("./mcp-installer-PQU3XOGO.js");
+    const cliResults = installMcpForAllClis(projectDir);
+    if (cliResults.length > 0) {
+      console.log(chalk.bold("Project-level MCP configs:\n"));
+      for (const result of cliResults) {
+        console.log(`  ${chalk.green("\u2713")} ${result.cli} \u2014 ${result.file} (${result.servers.join(", ")})`);
+      }
+      console.log("");
+    }
+  } catch {
+  }
+  suggestAdditionalMcpServers(projectDir);
+  console.log("");
+}
+export {
+  runMcpSetup
+};

package/dist/{memory-Y6OZTXJ2.js → memory-ZNAEAK3B.js}

@@ -50,8 +50,8 @@ Subcommands:
 }
 async function initSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Initialize\n"));
-  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-GJYT2OQV.js");
-  const { projectMemoryDir } = await import("./dist-RKOGLK7R.js");
+  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-JLU26AB6.js");
+  const { projectMemoryDir } = await import("./dist-NUXMDXZ3.js");
   const fs = await import("fs");
   if (isMemoryInitialized(projectDir)) {
     console.log(chalk.yellow("Memory is already initialized for this project."));
@@ -67,7 +67,7 @@ async function initSubcommand(projectDir) {
   console.log(chalk.dim(`  Capture mode: ${config.captureMode}`));
   console.log(chalk.dim(`  Classifier:   ${config.classifier.enabled ? "enabled" : "disabled"}`));
   console.log(chalk.dim(`  Surface:      ${config.surfaceOnStart ? `on start (limit ${config.surfaceLimit})` : "disabled"}`));
-  const { installMemoryMcpServer } = await import("./mcp-installer-NQCGKQ23.js");
+  const { installMemoryMcpServer } = await import("./mcp-installer-PQU3XOGO.js");
   const mcp = installMemoryMcpServer(projectDir);
   if (mcp.installed) {
     console.log(chalk.green("\u2713 MCP server registered"));
@@ -104,7 +104,7 @@ async function searchSubcommand(args, projectDir) {
   const ora = (await import("ora")).default;
   const spinner = ora("Searching memories...").start();
   try {
-    const { searchMemory, isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
+    const { searchMemory, isMemoryInitialized } = await import("./dist-JLU26AB6.js");
     if (!isMemoryInitialized(projectDir)) {
       spinner.fail("Memory not initialized");
       console.log(chalk.dim("Run 'ulpi memory init' first."));
@@ -170,7 +170,7 @@ async function rememberSubcommand(args, projectDir) {
     console.log(chalk.dim('\nExample: ulpi memory remember "Always run tests before committing" --type PREFERENCE --importance high'));
     return;
   }
-  const { isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
+  const { isMemoryInitialized } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -190,7 +190,7 @@ async function rememberSubcommand(args, projectDir) {
   const ora = (await import("ora")).default;
   const spinner = ora("Storing memory...").start();
   try {
-    const { generateMemoryId, rememberMemory } = await import("./dist-GJYT2OQV.js");
+    const { generateMemoryId, rememberMemory } = await import("./dist-JLU26AB6.js");
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const entry = {
       id: generateMemoryId(memType, text),
@@ -216,7 +216,7 @@ async function rememberSubcommand(args, projectDir) {
   }
 }
 async function statusSubcommand(projectDir) {
-  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-GJYT2OQV.js");
+  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-JLU26AB6.js");
   console.log(chalk.bold("\nAgent Memory Status\n"));
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.yellow("  Not initialized"));
@@ -257,7 +257,7 @@ async function statusSubcommand(projectDir) {
 }
 async function exportSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Export\n"));
-  const { isMemoryInitialized, exportMemories } = await import("./dist-GJYT2OQV.js");
+  const { isMemoryInitialized, exportMemories } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -277,7 +277,7 @@ async function exportSubcommand(projectDir) {
 }
 async function importSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Import\n"));
-  const { importMemories } = await import("./dist-GJYT2OQV.js");
+  const { importMemories } = await import("./dist-JLU26AB6.js");
   try {
     const result = await importMemories(projectDir);
     if (!result.success) {
@@ -295,18 +295,18 @@ async function importSubcommand(projectDir) {
   }
 }
 async function serveSubcommand(projectDir) {
-  const { isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
+  const { isMemoryInitialized } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.error(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     process.exit(1);
   }
   console.error(chalk.dim("[memory-mcp] Starting MCP server..."));
   console.error(chalk.dim(`[memory-mcp] Project: ${projectDir}`));
-  const { startMemoryMcpServer } = await import("./dist-CS2VKNYS.js");
+  const { startMemoryMcpServer } = await import("./dist-FKFEJRPX.js");
   await startMemoryMcpServer({ projectDir });
 }
 async function classifySubcommand(args, projectDir) {
-  const { isMemoryInitialized, listCapturedSessions, classifySession, loadWatermark, writeClassifyBatchProgress, clearClassifyBatchProgress } = await import("./dist-GJYT2OQV.js");
+  const { isMemoryInitialized, listCapturedSessions, classifySession, loadWatermark, writeClassifyBatchProgress, clearClassifyBatchProgress } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -341,7 +341,7 @@ async function classifySubcommand(args, projectDir) {
       }
       if (doExport) {
         try {
-          const { exportMemories } = await import("./dist-GJYT2OQV.js");
+          const { exportMemories } = await import("./dist-JLU26AB6.js");
           await exportMemories(projectDir);
         } catch {
         }
@@ -351,7 +351,7 @@ async function classifySubcommand(args, projectDir) {
     await classifySingleSession(projectDir, sessionId, classifySession);
     if (doExport) {
       try {
-        const { exportMemories } = await import("./dist-GJYT2OQV.js");
+        const { exportMemories } = await import("./dist-JLU26AB6.js");
         const result = await exportMemories(projectDir);
         console.log(chalk.green(`\u2713 Exported ${result.memoriesExported} memories to ${result.branchName}`));
       } catch (err) {
@@ -526,7 +526,7 @@ Agent Memory -- Classify Session
   }
 }
 async function enableSubcommand(projectDir) {
-  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -537,7 +537,7 @@ async function enableSubcommand(projectDir) {
   console.log(chalk.green("\u2713 Memory capture enabled"));
 }
 async function disableSubcommand(projectDir) {
-  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -548,7 +548,7 @@ async function disableSubcommand(projectDir) {
   console.log(chalk.yellow("\u2713 Memory capture disabled"));
 }
 async function reindexSubcommand(projectDir) {
-  const { isMemoryInitialized, reindexMemories } = await import("./dist-GJYT2OQV.js");
+  const { isMemoryInitialized, reindexMemories } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;

package/dist/{ollama-3XCUZMZT-FYKHW4TZ.js → ollama-3XCUZMZT-4JMH6B7P.js}

@@ -1,6 +1,6 @@
 import {
   OllamaEmbedder
-} from "./chunk-KLEASXUR.js";
+} from "./chunk-6ZL6NXMV.js";
 import "./chunk-4VNS5WPM.js";
 export {
   OllamaEmbedder

package/dist/{openai-E7G2YAHU-UYY4ZWON.js → openai-E7G2YAHU-T3HMBPH7.js}

@@ -1,7 +1,7 @@
 import {
   OpenAIEmbedder
-} from "./chunk-2HEE5OKX.js";
-import "./chunk-7LXY5UVC.js";
+} from "./chunk-4UCJIAOU.js";
+import "./chunk-C7CLUQI6.js";
 import "./chunk-4VNS5WPM.js";
 export {
   OpenAIEmbedder