@pyxmate/memory 0.22.4 → 0.22.5

package/dist/cli/pyx-mem.mjs

@@ -15479,7 +15479,7 @@ var ALL_TOOL_NAMES = ALL_TOOLS.map((t) => t.name);
 // src/mcp/server.ts
 async function runMcpServer(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
-  const version2 = opts.version ?? (true ? "0.22.4" : "0.0.0-dev");
+  const version2 = opts.version ?? (true ? "0.22.5" : "0.0.0-dev");
   const server = new McpServer(
     { name: "pyx-memory", version: version2 },
     { instructions: PYX_MEMORY_INSTRUCTIONS, capabilities: { tools: {} } }
@@ -15518,21 +15518,136 @@ async function mcpCommand() {
 }
 
 // src/cli/commands/mcp-install.ts
-import { spawnSync } from "child_process";
+import { spawnSync as nodeSpawnSync } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/cli/commands/mcp-install-merge.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname } from "path";
+function mergeWriteJsonMcpEntry(opts) {
+  const { filePath, serverName, entry } = opts;
+  let existingDoc = {};
+  if (existsSync(filePath)) {
+    const raw = readFileSync(filePath, "utf8").trim();
+    if (raw.length > 0) {
+      try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          return {
+            exitCode: EXIT.USAGE,
+            status: "parse-error",
+            message: `Refusing to write: ${filePath} is not a JSON object at its root.
+Fix the file manually, then re-run.
+`
+          };
+        }
+        existingDoc = parsed;
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        return {
+          exitCode: EXIT.USAGE,
+          status: "parse-error",
+          message: `Refusing to write: ${filePath} contains invalid JSON (${reason}).
+Fix the file manually, then re-run.
+`
+        };
+      }
+    }
+  }
+  const rawServers = existingDoc.mcpServers;
+  const servers = rawServers !== null && typeof rawServers === "object" && !Array.isArray(rawServers) ? { ...rawServers } : {};
+  const existingEntry = servers[serverName];
+  if (existingEntry !== void 0) {
+    if (entriesEqual(existingEntry, entry)) {
+      return {
+        exitCode: EXIT.OK,
+        status: "already-installed",
+        message: `pyx-memory is already installed in ${filePath} (no changes written).
+`
+      };
+    }
+    return {
+      exitCode: EXIT.USAGE,
+      status: "conflict",
+      message: `Refusing to overwrite existing \`${serverName}\` entry in ${filePath}.
+
+Found:
+${indent(JSON.stringify(existingEntry, null, 2))}
+
+Proposed:
+${indent(JSON.stringify(entry, null, 2))}
+
+Remove or rename the existing entry, then re-run.
+`
+    };
+  }
+  servers[serverName] = entry;
+  const nextDoc = { ...existingDoc, mcpServers: servers };
+  const payload = `${JSON.stringify(nextDoc, null, 2)}
+`;
+  const parent = dirname(filePath);
+  if (!existsSync(parent)) {
+    mkdirSync(parent, { recursive: true });
+  }
+  const tmpPath = `${filePath}.tmp`;
+  writeFileSync(tmpPath, payload, { mode: 384 });
+  renameSync(tmpPath, filePath);
+  return {
+    exitCode: EXIT.OK,
+    status: "installed",
+    message: `Installed \`${serverName}\` MCP server entry in ${filePath}.
+`
+  };
+}
+function entriesEqual(a, b) {
+  if (a === null || typeof a !== "object") return false;
+  const left = a;
+  if (left.command !== b.command) return false;
+  if (!arraysEqual(left.args, b.args)) return false;
+  if (!recordsEqual(left.env, b.env)) return false;
+  return true;
+}
+function arraysEqual(a, b) {
+  const left = Array.isArray(a) ? a : void 0;
+  const right = b;
+  if (left === void 0 && right === void 0) return true;
+  if (left === void 0 || right === void 0)
+    return (left ?? []).length === 0 && (right ?? []).length === 0;
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i++) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
+function recordsEqual(a, b) {
+  const left = a !== null && typeof a === "object" && !Array.isArray(a) ? a : void 0;
+  const right = b;
+  if (left === void 0 && right === void 0) return true;
+  const leftKeys = left ? Object.keys(left) : [];
+  const rightKeys = right ? Object.keys(right) : [];
+  if (leftKeys.length === 0 && rightKeys.length === 0) return true;
+  if (leftKeys.length !== rightKeys.length) return false;
+  for (const k of leftKeys) {
+    if (left?.[k] !== right?.[k]) return false;
+  }
+  return true;
+}
+function indent(text) {
+  return text.split("\n").map((line) => `  ${line}`).join("\n");
+}
+
+// src/cli/commands/mcp-install.ts
 var VALID_SCOPES = /* @__PURE__ */ new Set(["local", "user", "project"]);
 var SERVER_NAME = "pyx-memory";
+var ENTRY = { command: "pyx-mem", args: ["mcp"] };
 function mcpInstallClaudeCodeCommand(opts = {}) {
   const scope = opts.scope ?? "local";
-  if (!VALID_SCOPES.has(scope)) {
-    process.stderr.write(
-      `Error: invalid --scope \`${scope}\`. Expected: local | user | project.
-`
-    );
-    return EXIT.USAGE;
-  }
-  const claudeProbe = spawnSync("claude", ["--version"], { stdio: "pipe" });
-  if (claudeProbe.error || claudeProbe.status !== 0) {
-    printManualInstructions(scope);
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const spawnSync = opts._spawnSync ?? nodeSpawnSync;
+  const probe = spawnSync("claude", ["--version"], { stdio: "pipe" });
+  if (probe.error || probe.status !== 0) {
+    printClaudeCodeManualInstructions(scope);
     return EXIT.OK;
   }
   const cmd = ["mcp", "add", SERVER_NAME, "-s", scope, "--", "pyx-mem", "mcp"];
@@ -15540,7 +15655,7 @@ function mcpInstallClaudeCodeCommand(opts = {}) {
   if (res.status !== 0) {
     process.stderr.write(`\`claude ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
 `);
-    printManualInstructions(scope);
+    printClaudeCodeManualInstructions(scope);
     return EXIT.USAGE;
   }
   process.stdout.write(
@@ -15550,7 +15665,7 @@ Restart Claude Code to make the tools available. No API key was written to .mcp.
   );
   return EXIT.OK;
 }
-function printManualInstructions(scope) {
+function printClaudeCodeManualInstructions(scope) {
   process.stdout.write(
     [
       "The `claude` CLI is not on PATH, or the install command failed.",
@@ -15560,19 +15675,182 @@ function printManualInstructions(scope) {
       "",
       "Or add this entry manually to your Claude Code MCP config (.mcp.json):",
       JSON.stringify(
-        {
-          mcpServers: {
-            [SERVER_NAME]: { command: "pyx-mem", args: ["mcp"] }
-          }
-        },
+        { mcpServers: { [SERVER_NAME]: { command: "pyx-mem", args: ["mcp"] } } },
+        null,
+        2
+      ),
+      "",
+      "Do NOT add your pyx-memory API key here. Run `pyx-mem login` to store it in the OS credential store.",
+      ""
+    ].join("\n")
+  );
+}
+function mcpInstallCodexCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const spawnSync = opts._spawnSync ?? nodeSpawnSync;
+  const home = opts._homeDir ?? homedir();
+  const probe = spawnSync("codex", ["--version"], { stdio: "pipe" });
+  if (probe.error || probe.status !== 0) {
+    printCodexManualInstructions(home);
+    return EXIT.OK;
+  }
+  const cmd = ["mcp", "add", SERVER_NAME, "--", "pyx-mem", "mcp"];
+  const res = spawnSync("codex", cmd, { stdio: "inherit" });
+  if (res.status !== 0) {
+    process.stderr.write(`\`codex ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
+`);
+    printCodexManualInstructions(home);
+    return EXIT.USAGE;
+  }
+  process.stdout.write(
+    `Installed pyx-memory MCP server in Codex CLI.
+Restart Codex CLI to make the tools available. No API key was written to config.toml \u2014 credentials live in the OS credential store.
+`
+  );
+  return EXIT.OK;
+}
+function printCodexManualInstructions(home) {
+  const configPath = join(home, ".codex", "config.toml");
+  process.stdout.write(
+    [
+      "The `codex` CLI is not on PATH, or the install command failed.",
+      "",
+      "Run this once Codex CLI is installed:",
+      `  codex mcp add ${SERVER_NAME} -- pyx-mem mcp`,
+      "",
+      `Or add this section manually to ${configPath}:`,
+      "",
+      `[mcp_servers.${SERVER_NAME}]`,
+      `command = "pyx-mem"`,
+      `args = ["mcp"]`,
+      "",
+      "Do NOT add your pyx-memory API key here. Run `pyx-mem login` to store it in the OS credential store.",
+      ""
+    ].join("\n")
+  );
+}
+function mcpInstallCursorCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const home = opts._homeDir ?? homedir();
+  const filePath = scope === "project" ? join(process.cwd(), ".cursor", "mcp.json") : join(home, ".cursor", "mcp.json");
+  return writeJsonAndReport(filePath, "Cursor");
+}
+function mcpInstallClineCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  process.stdout.write(
+    [
+      "Cline MCP config is managed through the Cline UI in VS Code (the file",
+      "path differs by OS, VS Code variant, and Cline version).",
+      "",
+      "1. Open VS Code (or Cursor / Windsurf running the Cline extension).",
+      "2. Click the Cline icon in the sidebar.",
+      '3. Click "MCP Servers" \u2192 "Configure MCP Servers".',
+      `4. Add this entry under "mcpServers":`,
+      "",
+      JSON.stringify(
+        { mcpServers: { [SERVER_NAME]: { command: "pyx-mem", args: ["mcp"] } } },
         null,
         2
       ),
       "",
+      "5. Save the file. Cline will reload the MCP servers automatically.",
+      "",
       "Do NOT add your pyx-memory API key here. Run `pyx-mem login` to store it in the OS credential store.",
       ""
     ].join("\n")
   );
+  return EXIT.OK;
+}
+function mcpInstallContinueCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const home = opts._homeDir ?? homedir();
+  const yamlPath = join(home, ".continue", "mcpServers", `${SERVER_NAME}.yaml`);
+  process.stdout.write(
+    [
+      "Continue uses YAML config. The recommended way to add an MCP server is a",
+      "standalone block file:",
+      "",
+      `  ${yamlPath}`,
+      "",
+      "Create that file with these contents:",
+      "",
+      `name: ${SERVER_NAME}`,
+      "version: 0.0.1",
+      "schema: v1",
+      "mcpServers:",
+      `  - name: ${SERVER_NAME}`,
+      `    command: pyx-mem`,
+      `    args:`,
+      `      - mcp`,
+      "",
+      "Continue auto-loads new YAML blocks on next chat session \u2014 no restart",
+      "needed in most setups.",
+      "",
+      "Do NOT add your pyx-memory API key here. Run `pyx-mem login` to store it in the OS credential store.",
+      ""
+    ].join("\n")
+  );
+  return EXIT.OK;
+}
+function mcpInstallWindsurfCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const home = opts._homeDir ?? homedir();
+  const filePath = join(home, ".codeium", "windsurf", "mcp_config.json");
+  return writeJsonAndReport(filePath, "Windsurf");
+}
+function mcpInstallGeminiCliCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const spawnSync = opts._spawnSync ?? nodeSpawnSync;
+  const home = opts._homeDir ?? homedir();
+  const probe = spawnSync("gemini", ["--version"], { stdio: "pipe" });
+  if (probe.error || probe.status !== 0) {
+    return writeJsonAndReport(geminiConfigPath(home, scope), "Gemini CLI");
+  }
+  const geminiScope = scope === "local" ? "project" : scope;
+  const cmd = ["mcp", "add", "-s", geminiScope, SERVER_NAME, "pyx-mem", "mcp"];
+  const res = spawnSync("gemini", cmd, { stdio: "inherit" });
+  if (res.status !== 0) {
+    process.stderr.write(`\`gemini ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
+`);
+    return writeJsonAndReport(geminiConfigPath(home, scope), "Gemini CLI");
+  }
+  process.stdout.write(
+    `Installed pyx-memory MCP server in Gemini CLI (scope: ${geminiScope}).
+Restart Gemini CLI to make the tools available. No API key was written to settings.json \u2014 credentials live in the OS credential store.
+`
+  );
+  return EXIT.OK;
+}
+function geminiConfigPath(home, scope) {
+  return scope === "project" ? join(process.cwd(), ".gemini", "settings.json") : join(home, ".gemini", "settings.json");
+}
+function validateScope(scope) {
+  if (VALID_SCOPES.has(scope)) return true;
+  process.stderr.write(`Error: invalid --scope \`${scope}\`. Expected: local | user | project.
+`);
+  return false;
+}
+function writeJsonAndReport(filePath, agentLabel) {
+  const result = mergeWriteJsonMcpEntry({
+    filePath,
+    serverName: SERVER_NAME,
+    entry: ENTRY
+  });
+  const stream = result.exitCode === EXIT.OK ? process.stdout : process.stderr;
+  stream.write(result.message);
+  if (result.status === "installed") {
+    process.stdout.write(
+      `Restart ${agentLabel} to make the tools available. No API key was written \u2014 credentials live in the OS credential store.
+`
+    );
+  }
+  return result.exitCode;
 }
 
 // src/cli/commands/status.ts
@@ -15630,8 +15908,9 @@ Commands:
   logout                                       Delete stored pyx-memory credentials.
   doctor [--json]                              Diagnose keychain, credentials, backend, MCP startup.
   mcp                                          Start stdio MCP server.
-  mcp install claude-code [--scope user|local|project]
-                                               Install Claude Code MCP config for pyx-mem mcp.
+  mcp install <target> [--scope user|local|project]
+                                               Install pyx-memory MCP config for your AI agent.
+                                               Targets: claude-code, codex, cursor, cline, continue, windsurf, gemini-cli.
 
 Notes:
   - Credentials are stored only in the OS credential store (Keychain / libsecret / Credential Manager).
@@ -15684,6 +15963,15 @@ function parseArgs(argv) {
 }
 
 // src/cli/pyx-mem.ts
+var VALID_TARGETS = [
+  "claude-code",
+  "codex",
+  "cursor",
+  "cline",
+  "continue",
+  "windsurf",
+  "gemini-cli"
+];
 async function main() {
   const parsed = parseArgs(process.argv.slice(2));
   if (parsed.flags.help === true || parsed.flags.h === true) {
@@ -15710,15 +15998,29 @@ async function main() {
       if (parsed.subcommand === void 0) return mcpCommand();
       if (parsed.subcommand === "install") {
         const target = parsed.positional[0];
-        if (target === "claude-code") {
-          const scope = typeof parsed.flags.scope === "string" ? parsed.flags.scope : void 0;
-          return mcpInstallClaudeCodeCommand({ scope });
-        }
-        process.stderr.write(
-          `Error: unknown install target \`${target ?? ""}\`. Expected: claude-code.
+        const scope = typeof parsed.flags.scope === "string" ? parsed.flags.scope : void 0;
+        switch (target) {
+          case "claude-code":
+            return mcpInstallClaudeCodeCommand({ scope });
+          case "codex":
+            return mcpInstallCodexCommand({ scope });
+          case "cursor":
+            return mcpInstallCursorCommand({ scope });
+          case "cline":
+            return mcpInstallClineCommand({ scope });
+          case "continue":
+            return mcpInstallContinueCommand({ scope });
+          case "windsurf":
+            return mcpInstallWindsurfCommand({ scope });
+          case "gemini-cli":
+            return mcpInstallGeminiCliCommand({ scope });
+          default:
+            process.stderr.write(
+              `Error: unknown install target \`${target ?? ""}\`. Expected: ${VALID_TARGETS.join(", ")}.
 `
-        );
-        return EXIT.USAGE;
+            );
+            return EXIT.USAGE;
+        }
       }
       process.stderr.write(
         `Error: unknown subcommand \`mcp ${parsed.subcommand}\`. Run \`pyx-mem --help\`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyxmate/memory",
-  "version": "0.22.4",
+  "version": "0.22.5",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",