@memoraone/mcp 0.1.29 → 0.1.30

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.29",
+      version: "0.1.30",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -67,9 +67,9 @@ var require_package = __commonJS({
 });
 
 // src/cli.ts
-var path6 = __toESM(require("path"), 1);
+var path7 = __toESM(require("path"), 1);
 var net = __toESM(require("net"), 1);
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 
 // src/socketPaths.ts
 var os = __toESM(require("os"), 1);
@@ -292,8 +292,9 @@ function encodeResolvedBinding(binding) {
 }
 
 // src/setupIdeFiles.ts
-var fs5 = __toESM(require("fs/promises"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs/promises"), 1);
+var os4 = __toESM(require("os"), 1);
+var path6 = __toESM(require("path"), 1);
 
 // src/cleanup.ts
 var fs3 = __toESM(require("fs/promises"), 1);
@@ -891,6 +892,435 @@ function logCursorGlobalMcpCliSummary(info, dryRun) {
   );
 }
 
+// src/jetbrainsMcpConfig.ts
+var fs5 = __toESM(require("fs/promises"), 1);
+var os3 = __toESM(require("os"), 1);
+var path5 = __toESM(require("path"), 1);
+var import_node_child_process3 = require("child_process");
+
+// src/configUtils.ts
+var DEV_API_URL = "http://localhost:3001";
+
+// src/jetbrainsMcpConfig.ts
+var PROD_API_URL = "https://api.memoraone.com";
+var JETBRAINS_DEBUG_ENV_VARS = [
+  "MEMORAONE_DEBUG_INIT",
+  "MEMORAONE_DEBUG_MINIMAL_TOOLS",
+  "MEMORAONE_DEBUG_MINIMAL_INITIALIZE",
+  "MEMORAONE_DEBUG_DIRECT_STDIO"
+];
+function stripLeadingLineComments2(text) {
+  return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
+}
+async function pathExists2(filePath) {
+  try {
+    await fs5.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatJetBrainsBackupTimestamp(d = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+function getJetBrainsGlobalMcpConfigPath(homeDir) {
+  return path5.join(homeDir, ".ai", "mcp", "mcp.json");
+}
+function getJetBrainsProjectMcpConfigPaths(repoRoot) {
+  return [
+    { kind: "project-ai", path: path5.join(repoRoot, ".ai", "mcp", "mcp.json") },
+    { kind: "project-ij", path: path5.join(repoRoot, ".ij", "mcp", "mcp.json") }
+  ];
+}
+function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
+  return [
+    { kind: "global", path: getJetBrainsGlobalMcpConfigPath(homeDir) },
+    ...getJetBrainsProjectMcpConfigPaths(repoRoot)
+  ];
+}
+async function isZeroByteConfigFile(filePath) {
+  if (!await pathExists2(filePath)) return false;
+  const stat2 = await fs5.stat(filePath);
+  return stat2.size === 0;
+}
+function buildMemoraoneJetBrainsMcpServer(options) {
+  const env = {
+    MEMORAONE_API_URL: options.devMode ? DEV_API_URL : PROD_API_URL,
+    MEMORAONE_IDE_TYPE: "jetbrains",
+    MEMORAONE_M1_PATH: options.m1Path
+  };
+  if (options.devMode) {
+    env.MEMORAONE_DEV_MODE = "1";
+  }
+  return {
+    command: options.command,
+    args: options.args,
+    env
+  };
+}
+function mergeJetBrainsMcpConfigObject(existing, memoraone) {
+  const base = existing && typeof existing === "object" ? { ...existing } : { mcpServers: {} };
+  const mcpServers = typeof base.mcpServers === "object" && base.mcpServers !== null && !Array.isArray(base.mcpServers) ? { ...base.mcpServers } : {};
+  mcpServers.memoraone = memoraone;
+  return { ...base, mcpServers };
+}
+function memoraoneServerMatches2(server, expected) {
+  if (!server || typeof server !== "object") return false;
+  const s = server;
+  if (s.command !== expected.command) return false;
+  if (!Array.isArray(s.args) || s.args.length !== expected.args.length) return false;
+  for (let i = 0; i < expected.args.length; i += 1) {
+    if (s.args[i] !== expected.args[i]) return false;
+  }
+  const env = s.env;
+  if (!env || typeof env !== "object") return false;
+  const e = env;
+  for (const [key, value] of Object.entries(expected.env)) {
+    if (e[key] !== value) return false;
+  }
+  for (const debugKey of JETBRAINS_DEBUG_ENV_VARS) {
+    if (debugKey in e) return false;
+  }
+  return true;
+}
+function validateJetBrainsMcpConfig(parsed, expected) {
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("[setup-ide-files] JetBrains MCP config must be a JSON object.");
+  }
+  const mcpServers = parsed.mcpServers;
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    throw new Error("[setup-ide-files] JetBrains MCP config missing mcpServers object.");
+  }
+  const memoraone = mcpServers.memoraone;
+  if (!memoraoneServerMatches2(memoraone, expected)) {
+    throw new Error(
+      "[setup-ide-files] JetBrains MCP config mcpServers.memoraone is missing or invalid."
+    );
+  }
+}
+async function readJsonConfig(filePath) {
+  const raw = await fs5.readFile(filePath, "utf8");
+  if (raw.trim() === "") return null;
+  return JSON.parse(stripLeadingLineComments2(raw));
+}
+async function backupConfigFile(filePath) {
+  const backupPath = `${filePath}.bak-${formatJetBrainsBackupTimestamp()}`;
+  await fs5.copyFile(filePath, backupPath);
+  return backupPath;
+}
+async function repairZeroByteConfigFile(filePath, dryRun) {
+  if (!await isZeroByteConfigFile(filePath)) {
+    return { repaired: false };
+  }
+  if (dryRun) {
+    return { repaired: true, backupPath: `${filePath}.bak-<timestamp>` };
+  }
+  const backupPath = await backupConfigFile(filePath);
+  await fs5.unlink(filePath);
+  return { repaired: true, backupPath };
+}
+function configHasMemoraone(parsed) {
+  if (!parsed) return false;
+  const mcpServers = parsed.mcpServers;
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) return false;
+  return Boolean(mcpServers.memoraone);
+}
+async function removeMemoraoneFromProjectConfig(options) {
+  const { configPath, dryRun } = options;
+  if (!await pathExists2(configPath)) {
+    return { changed: false };
+  }
+  let parsed = null;
+  try {
+    parsed = await readJsonConfig(configPath);
+  } catch {
+    return { changed: false };
+  }
+  if (!configHasMemoraone(parsed)) {
+    return { changed: false };
+  }
+  if (dryRun) {
+    return { changed: true, backupPath: `${configPath}.bak-<timestamp>` };
+  }
+  const backupPath = await backupConfigFile(configPath);
+  const mcpServers = parsed && typeof parsed.mcpServers === "object" && parsed.mcpServers !== null && !Array.isArray(parsed.mcpServers) ? { ...parsed.mcpServers } : {};
+  delete mcpServers.memoraone;
+  const hasOtherServers = Object.keys(mcpServers).length > 0;
+  if (!hasOtherServers) {
+    await fs5.unlink(configPath);
+    return { changed: true, backupPath };
+  }
+  const next = { ...parsed, mcpServers };
+  await fs5.mkdir(path5.dirname(configPath), { recursive: true });
+  await fs5.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  return { changed: true, backupPath };
+}
+async function resolveLocalCliPathAsync() {
+  const here = process.argv[1] ? path5.dirname(path5.resolve(process.argv[1])) : process.cwd();
+  const candidates = [
+    path5.join(here, "cli.cjs"),
+    path5.join(here, "..", "dist", "cli.cjs"),
+    path5.join(here, "..", "..", "dist", "cli.cjs")
+  ];
+  for (const candidate of candidates) {
+    if (await pathExists2(candidate)) {
+      return path5.resolve(candidate);
+    }
+  }
+  return null;
+}
+async function buildJetBrainsMemoraoneServer(options) {
+  if (options.devMode) {
+    let cliPath = options.cliPathOverride;
+    if (cliPath === void 0) {
+      cliPath = await resolveLocalCliPathAsync();
+    }
+    if (!cliPath) {
+      throw new Error(
+        "[setup-ide-files] Dev mode requires a built CLI at packages/mcp/dist/cli.cjs. Run pnpm build first."
+      );
+    }
+    return buildMemoraoneJetBrainsMcpServer({
+      command: process.execPath,
+      args: [cliPath],
+      m1Path: options.m1Path,
+      devMode: true
+    });
+  }
+  let npxPath = options.npxPathOverride;
+  if (npxPath === void 0) {
+    npxPath = await resolveNpxPath();
+  }
+  if (!npxPath) {
+    throw new Error(
+      "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring JetBrains MCP."
+    );
+  }
+  return buildMemoraoneJetBrainsMcpServer({
+    command: npxPath,
+    args: ["-y", "@memoraone/mcp@latest"],
+    m1Path: options.m1Path,
+    devMode: false
+  });
+}
+async function verifyJetBrainsMcpHandshake(options) {
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const { server } = options;
+  return new Promise((resolve7) => {
+    let settled = false;
+    const finish = (ok, detail) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.kill();
+      } catch {
+      }
+      resolve7({ ok, detail });
+    };
+    const child = (0, import_node_child_process3.spawn)(server.command, [...server.args], {
+      env: { ...process.env, ...server.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let buffer = "";
+    let initializeOk = false;
+    let toolsListOk = false;
+    let nextId = 1;
+    const send = (method, params) => {
+      const msg = JSON.stringify({ jsonrpc: "2.0", id: nextId, method, params }) + "\n";
+      nextId += 1;
+      child.stdin?.write(msg);
+    };
+    const timer = setTimeout(() => {
+      finish(false, `handshake timed out after ${timeoutMs}ms`);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (msg.id === 1 && msg.result) {
+          initializeOk = true;
+          send("notifications/initialized", {});
+          send("tools/list", {});
+        }
+        if (msg.id === 2 && msg.result) {
+          toolsListOk = true;
+          finish(true, "initialize OK; tools/list OK");
+        }
+        if (msg.error) {
+          finish(false, `JSON-RPC error: ${JSON.stringify(msg.error)}`);
+        }
+      }
+    });
+    child.on("error", (err) => {
+      finish(false, `spawn error: ${String(err)}`);
+    });
+    child.on("exit", (code) => {
+      if (!settled) {
+        if (initializeOk && toolsListOk) {
+          finish(true, "initialize OK; tools/list OK");
+        } else {
+          finish(
+            false,
+            `process exited code=${code ?? "null"} (initialize=${initializeOk}, tools/list=${toolsListOk})`
+          );
+        }
+      }
+    });
+    send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "memoraone-setup", version: "1.0.0" }
+    });
+  });
+}
+async function setupJetBrainsMcpConfig(options) {
+  const homeDir = options.homeDir ?? os3.homedir();
+  const globalPath = options.globalConfigPath ?? getJetBrainsGlobalMcpConfigPath(homeDir);
+  const m1Path = path5.join(path5.resolve(options.repoRoot), "memoraone.m1");
+  const repairActions = [];
+  const allLocations = getKnownJetBrainsMcpConfigLocations(homeDir, options.repoRoot);
+  for (const location of allLocations) {
+    if (await pathExists2(location.path)) {
+      repairActions.push({ type: "found-config", location });
+    }
+  }
+  for (const location of allLocations) {
+    const zeroByte = await repairZeroByteConfigFile(location.path, options.dryRun);
+    if (zeroByte.repaired) {
+      repairActions.push({
+        type: "repaired-zero-byte",
+        path: location.path,
+        backupPath: zeroByte.backupPath ?? `${location.path}.bak-<timestamp>`
+      });
+    }
+  }
+  const memoraone = await buildJetBrainsMemoraoneServer({
+    m1Path,
+    devMode: options.devMode,
+    npxPathOverride: options.npxPathOverride,
+    cliPathOverride: options.cliPathOverride
+  });
+  for (const location of getJetBrainsProjectMcpConfigPaths(options.repoRoot)) {
+    const removal = await removeMemoraoneFromProjectConfig({
+      configPath: location.path,
+      dryRun: options.dryRun
+    });
+    if (removal.changed) {
+      if (removal.backupPath) {
+        repairActions.push({
+          type: "backed-up-conflicting-project-config",
+          path: location.path,
+          backupPath: removal.backupPath
+        });
+      }
+      repairActions.push({ type: "removed-project-memoraone", path: location.path });
+    }
+  }
+  const existed = await pathExists2(globalPath);
+  let existing = null;
+  if (existed) {
+    try {
+      existing = await readJsonConfig(globalPath);
+    } catch {
+      if (options.dryRun) {
+        existing = null;
+      } else {
+        const backupPath2 = await backupConfigFile(globalPath);
+        repairActions.push({
+          type: "repaired-zero-byte",
+          path: globalPath,
+          backupPath: backupPath2
+        });
+        await fs5.unlink(globalPath);
+        existing = null;
+      }
+    }
+  }
+  const merged = mergeJetBrainsMcpConfigObject(existing, memoraone);
+  const body = JSON.stringify(merged, null, 2) + "\n";
+  if (existed && existing) {
+    const currentMemoraone = existing.mcpServers && typeof existing.mcpServers === "object" && !Array.isArray(existing.mcpServers) ? existing.mcpServers.memoraone : void 0;
+    if (memoraoneServerMatches2(currentMemoraone, memoraone)) {
+      repairActions.push({ type: "wrote-global-config", path: globalPath, outcome: "skipped" });
+      return { outcome: "skipped", repairActions, memoraone };
+    }
+  }
+  if (options.dryRun) {
+    const outcome2 = existed ? "updated" : "created";
+    repairActions.push({ type: "wrote-global-config", path: globalPath, outcome: outcome2 });
+    return { outcome: outcome2, repairActions, memoraone };
+  }
+  let backupPath;
+  if (existed) {
+    backupPath = await backupConfigFile(globalPath);
+  }
+  await fs5.mkdir(path5.dirname(globalPath), { recursive: true });
+  await fs5.writeFile(globalPath, body, "utf8");
+  const verifyRaw = await fs5.readFile(globalPath, "utf8");
+  const verifyParsed = JSON.parse(stripLeadingLineComments2(verifyRaw));
+  validateJetBrainsMcpConfig(verifyParsed, memoraone);
+  const outcome = existed ? "updated" : "created";
+  repairActions.push({ type: "wrote-global-config", path: globalPath, outcome });
+  let verifyOk;
+  let verifyDetail;
+  if (options.verify !== false) {
+    const verify = await verifyJetBrainsMcpHandshake({ server: memoraone });
+    verifyOk = verify.ok;
+    verifyDetail = verify.detail;
+    repairActions.push({ type: "verify-handshake", ok: verify.ok, detail: verify.detail });
+  }
+  return { outcome, backupPath, repairActions, verifyOk, verifyDetail, memoraone };
+}
+function logJetBrainsMcpCliSummary(info, dryRun) {
+  for (const action of info.repairActions) {
+    if (action.type === "found-config") {
+      console.log(`[setup-ide-files] Found JetBrains MCP config (${action.location.kind}): ${action.location.path}`);
+    } else if (action.type === "repaired-zero-byte") {
+      console.log(`[setup-ide-files] Repaired zero-byte MCP config: ${action.path}`);
+      console.log(`[setup-ide-files] Backup: ${action.backupPath}`);
+    } else if (action.type === "backed-up-conflicting-project-config") {
+      console.log(`[setup-ide-files] Backed up conflicting project MCP config: ${action.path}`);
+      console.log(`[setup-ide-files] Backup: ${action.backupPath}`);
+    } else if (action.type === "removed-project-memoraone") {
+      console.log(`[setup-ide-files] Removed project-scoped memoraone definition: ${action.path}`);
+    } else if (action.type === "verify-handshake") {
+      if (action.ok) {
+        console.log(`[setup-ide-files] MCP handshake verification: ${action.detail}`);
+      } else {
+        console.log(`[setup-ide-files] MCP handshake verification skipped/failed: ${action.detail}`);
+      }
+    }
+  }
+  const prefix = dryRun ? "would be " : "";
+  if (info.outcome === "created") {
+    console.log(`[setup-ide-files] JetBrains global MCP config ${prefix}created: ${info.activeConfigPath}`);
+  } else if (info.outcome === "updated") {
+    console.log(`[setup-ide-files] JetBrains global MCP config ${prefix}updated: ${info.activeConfigPath}`);
+  } else {
+    console.log(`[setup-ide-files] JetBrains global MCP config unchanged: ${info.activeConfigPath}`);
+  }
+  if (info.backupPath) {
+    console.log(`[setup-ide-files] JetBrains global MCP config backup: ${info.backupPath}`);
+  }
+  if (info.npxPath) {
+    console.log(`[setup-ide-files] Resolved npx: ${info.npxPath}`);
+  }
+  console.log(`[setup-ide-files] Final active JetBrains MCP config: ${info.activeConfigPath}`);
+  console.log(
+    "[setup-ide-files] Fully quit JetBrains IDE and reopen this repo for MCP changes to take effect."
+  );
+}
+
 // src/setupIdeFiles.ts
 var MANAGED_MARKER = "<!-- MemoraOne managed IDE helper -->";
 var GITIGNORE_MEMORAONE_COMMENT = "# MemoraOne local project binding / API key";
@@ -906,15 +1336,15 @@ function buildMemoraoneMcpServer(ideType, command = "npx") {
   };
 }
 function assertUnderRepoRoot(repoRoot, absPath) {
-  const normRoot = path5.resolve(repoRoot) + path5.sep;
-  const normPath = path5.resolve(absPath);
-  if (normPath !== path5.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
+  const normRoot = path6.resolve(repoRoot) + path6.sep;
+  const normPath = path6.resolve(absPath);
+  if (normPath !== path6.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
     throw new Error(`[setup-ide-files] Refusing to write outside repo root: ${absPath}`);
   }
 }
-async function pathExists2(filePath) {
+async function pathExists3(filePath) {
   try {
-    await fs5.access(filePath);
+    await fs6.access(filePath);
     return true;
   } catch {
     return false;
@@ -935,12 +1365,12 @@ ${GITIGNORE_MEMORAONE_ENTRY}
 }
 async function ensureGitignoreMemoraone(repoRoot, opts) {
   if (opts.noGitignore) return "skipped";
-  const abs = path5.join(repoRoot, ".gitignore");
+  const abs = path6.join(repoRoot, ".gitignore");
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs5.readFile(abs, "utf8");
+    prior = await fs6.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
@@ -951,25 +1381,25 @@ async function ensureGitignoreMemoraone(repoRoot, opts) {
   const separator = existed && prior.length > 0 ? prior.endsWith("\n") ? "\n" : "\n\n" : "";
   const next = (existed ? prior : "") + separator + block;
   if (opts.dryRun) return existed ? "updated" : "created";
-  await fs5.writeFile(abs, next, "utf8");
+  await fs6.writeFile(abs, next, "utf8");
   return existed ? "updated" : "created";
 }
 async function findRepoRoot(startDir) {
-  let current = path5.resolve(startDir);
-  const root = path5.parse(current).root;
+  let current = path6.resolve(startDir);
+  const root = path6.parse(current).root;
   while (true) {
-    const gitPath = path5.join(current, ".git");
-    const m1Path = path5.join(current, "memoraone.m1");
-    if (await pathExists2(gitPath) || await pathExists2(m1Path)) {
+    const gitPath = path6.join(current, ".git");
+    const m1Path = path6.join(current, "memoraone.m1");
+    if (await pathExists3(gitPath) || await pathExists3(m1Path)) {
       return current;
     }
     if (current === root) {
       return null;
     }
-    current = path5.dirname(current);
+    current = path6.dirname(current);
   }
 }
-function stripLeadingLineComments2(text) {
+function stripLeadingLineComments3(text) {
   return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
 function cursorRuleBody() {
@@ -1020,42 +1450,42 @@ function buildVscodeMcpJsonBody(existing) {
   return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
 }
 async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
-  const abs = path5.join(repoRoot, relPath);
+  const abs = path6.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs5.readFile(abs, "utf8");
+    prior = await fs6.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
   if (!existed) {
     if (opts.dryRun) return "created";
-    await fs5.mkdir(path5.dirname(abs), { recursive: true });
-    await fs5.writeFile(abs, fullContent, "utf8");
+    await fs6.mkdir(path6.dirname(abs), { recursive: true });
+    await fs6.writeFile(abs, fullContent, "utf8");
     return "created";
   }
   if (prior.includes(MANAGED_MARKER)) {
     if (prior === fullContent) return "skipped";
     if (opts.dryRun) return "updated";
-    await fs5.mkdir(path5.dirname(abs), { recursive: true });
-    await fs5.writeFile(abs, fullContent, "utf8");
+    await fs6.mkdir(path6.dirname(abs), { recursive: true });
+    await fs6.writeFile(abs, fullContent, "utf8");
     return "updated";
   }
   if (!opts.force) return "skipped-untracked";
   if (opts.dryRun) return "updated";
-  await fs5.mkdir(path5.dirname(abs), { recursive: true });
-  await fs5.writeFile(abs, fullContent, "utf8");
+  await fs6.mkdir(path6.dirname(abs), { recursive: true });
+  await fs6.writeFile(abs, fullContent, "utf8");
   return "updated";
 }
 async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
-  const abs = path5.join(repoRoot, relPath);
+  const abs = path6.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let raw = "";
   let existed = false;
   try {
-    raw = await fs5.readFile(abs, "utf8");
+    raw = await fs6.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
@@ -1063,15 +1493,15 @@ async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
   if (!existed) {
     const body = buildBody(null);
     if (opts.dryRun) return "created";
-    await fs5.mkdir(path5.dirname(abs), { recursive: true });
-    await fs5.writeFile(abs, body, "utf8");
+    await fs6.mkdir(path6.dirname(abs), { recursive: true });
+    await fs6.writeFile(abs, body, "utf8");
     return "created";
   }
   const managed = raw.includes(MANAGED_MARKER);
   if (!managed && !opts.force) return "skipped-untracked";
   let parsed = null;
   try {
-    parsed = JSON.parse(stripLeadingLineComments2(raw));
+    parsed = JSON.parse(stripLeadingLineComments3(raw));
   } catch {
     parsed = null;
   }
@@ -1079,8 +1509,8 @@ async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
   const next = buildBody(parsed);
   if (managed && next === raw) return "skipped";
   if (opts.dryRun) return "updated";
-  await fs5.mkdir(path5.dirname(abs), { recursive: true });
-  await fs5.writeFile(abs, next, "utf8");
+  await fs6.mkdir(path6.dirname(abs), { recursive: true });
+  await fs6.writeFile(abs, next, "utf8");
   return "updated";
 }
 function parseSetupIdeFlags(argv) {
@@ -1092,6 +1522,8 @@ function parseSetupIdeFlags(argv) {
   let dryRun = false;
   let noGitignore = false;
   let cleanup = false;
+  let devMode = false;
+  let repair = false;
   const unknown = [];
   for (const a of argv) {
     if (a === "--cursor") cursor = true;
@@ -1102,6 +1534,8 @@ function parseSetupIdeFlags(argv) {
     else if (a === "--dry-run") dryRun = true;
     else if (a === "--no-gitignore") noGitignore = true;
     else if (a === "--cleanup") cleanup = true;
+    else if (a === "--dev") devMode = true;
+    else if (a === "--repair") repair = true;
     else if (a.startsWith("-")) unknown.push(a);
   }
   const specific = cursor || vscode || jetbrains;
@@ -1111,7 +1545,7 @@ function parseSetupIdeFlags(argv) {
   } else {
     targets = { cursor, vscode, jetbrains };
   }
-  return { targets, force, dryRun, noGitignore, cleanup, unknown };
+  return { targets, force, dryRun, noGitignore, cleanup, devMode, repair, unknown };
 }
 function summarizeOutcomes(outcomes) {
   const created = [];
@@ -1136,6 +1570,7 @@ function summarizeOutcomes(outcomes) {
 async function runSetupIdeFiles(o) {
   const outcomes = {};
   let cursorGlobalMcp;
+  let jetbrainsMcp;
   const repoRoot = await findRepoRoot(o.cwd);
   if (!repoRoot) {
     return {
@@ -1236,11 +1671,45 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       copilotAndJetBrainsBody("MemoraOne MCP \u2014 JetBrains AI Assistant"),
       { force: o.force, dryRun: o.dryRun }
     );
+    try {
+      const homeDir = o.jetbrainsHomeDir ?? os4.homedir();
+      const activePath = o.jetbrainsGlobalMcpConfigPath ?? getJetBrainsGlobalMcpConfigPath(homeDir);
+      const jetbrainsSetup = await setupJetBrainsMcpConfig({
+        homeDir,
+        repoRoot,
+        globalConfigPath: activePath,
+        dryRun: o.dryRun,
+        devMode: o.devMode,
+        repair: o.repair ?? false,
+        verify: o.verifyHandshake ?? !o.dryRun,
+        npxPathOverride: o.npxPathOverride,
+        cliPathOverride: o.cliPathOverride
+      });
+      jetbrainsMcp = {
+        activeConfigPath: activePath,
+        outcome: jetbrainsSetup.outcome,
+        npxPath: jetbrainsSetup.memoraone?.command,
+        backupPath: jetbrainsSetup.backupPath,
+        repairActions: jetbrainsSetup.repairActions,
+        verifyOk: jetbrainsSetup.verifyOk,
+        verifyDetail: jetbrainsSetup.verifyDetail
+      };
+      outcomes[`jetbrains-global:${activePath}`] = jetbrainsSetup.outcome;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        cursorGlobalMcp,
+        error: message
+      };
+    }
   }
-  return { exitCode: 0, repoRoot, outcomes, cursorGlobalMcp };
+  return { exitCode: 0, repoRoot, outcomes, cursorGlobalMcp, jetbrainsMcp };
 }
 async function cliSetupIdeFiles(argv) {
-  const { targets, force, dryRun, noGitignore, cleanup, unknown } = parseSetupIdeFlags(argv);
+  const { targets, force, dryRun, noGitignore, cleanup, devMode, repair, unknown } = parseSetupIdeFlags(argv);
   if (unknown.length) {
     console.error(`[setup-ide-files] Unknown option(s): ${unknown.join(", ")}`);
     return 1;
@@ -1250,7 +1719,9 @@ async function cliSetupIdeFiles(argv) {
     targets,
     force,
     dryRun,
-    noGitignore
+    noGitignore,
+    devMode,
+    repair
   });
   if (result.error) {
     console.error(result.error);
@@ -1266,6 +1737,9 @@ async function cliSetupIdeFiles(argv) {
   if (targets.cursor && result.cursorGlobalMcp) {
     logCursorGlobalMcpCliSummary(result.cursorGlobalMcp, dryRun);
   }
+  if (targets.jetbrains && result.jetbrainsMcp) {
+    logJetBrainsMcpCliSummary(result.jetbrainsMcp, dryRun);
+  }
   summarizeOutcomes(result.outcomes);
   if (dryRun) {
     console.log("[setup-ide-files] Dry run: no files written.");
@@ -1302,7 +1776,7 @@ if (args.includes("--version") || args.includes("-v")) {
 }
 if (args.includes("--help") || args.includes("-h")) {
   console.log(
-    "Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid> [--ide cursor|copilot-vscode|jetbrains]]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains] [--force] [--dry-run] [--no-gitignore] [--cleanup]\n       memoraone-mcp cleanup [--project-id <uuid>] [--ide cursor|copilot-vscode|jetbrains] [--dry-run] [--all-projects] [--yes]"
+    "Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid> [--ide cursor|copilot-vscode|jetbrains]]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains] [--force] [--dry-run] [--no-gitignore] [--cleanup] [--dev] [--repair]\n       memoraone-mcp cleanup [--project-id <uuid>] [--ide cursor|copilot-vscode|jetbrains] [--dry-run] [--all-projects] [--yes]"
   );
   process.exit(0);
 }
@@ -1329,8 +1803,8 @@ if (args[0] === "cleanup") {
     const raw = process.env.WORKSPACE_FOLDER_PATHS;
     const parts = [];
     if (raw !== void 0 && raw.trim() !== "") {
-      for (const p of raw.split(path6.delimiter).map((s) => s.trim()).filter(Boolean)) {
-        parts.push(path6.resolve(p));
+      for (const p of raw.split(path7.delimiter).map((s) => s.trim()).filter(Boolean)) {
+        parts.push(path7.resolve(p));
       }
     }
     parts.push(process.cwd());
@@ -1344,10 +1818,10 @@ if (args[0] === "cleanup") {
     }
     return deduped;
   }, connectWithRetry = function(socketPath) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const tryConnect = (attempt) => {
         const socket = net.connect(socketPath, () => {
-          resolve6(socket);
+          resolve7(socket);
         });
         socket.on("error", (err) => {
           if (attempt >= MAX_RETRIES) {
@@ -1383,7 +1857,7 @@ if (args[0] === "cleanup") {
       socket = await connectWithRetry(socketPath);
     } catch {
       log("daemon not running, spawning...");
-      const child = (0, import_node_child_process3.spawn)(
+      const child = (0, import_node_child_process4.spawn)(
         process.execPath,
         buildDaemonSpawnArgs(process.argv[1], binding.projectId),
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "type": "module",
   "main": "dist/index.cjs",
   "bin": {