@pyxmate/memory 0.23.1 → 0.24.0

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.23.1" : "0.0.0-dev");
+  const version2 = opts.version ?? (true ? "0.24.0" : "0.0.0-dev");
   const server = new McpServer(
     { name: "pyx-memory", version: version2 },
     { instructions: PYX_MEMORY_INSTRUCTIONS, capabilities: { tools: {} } }
@@ -15830,13 +15830,113 @@ Restart Gemini CLI to make the tools available. No API key was written to settin
 function geminiConfigPath(home, scope) {
   return scope === "project" ? join(process.cwd(), ".gemini", "settings.json") : join(home, ".gemini", "settings.json");
 }
+function mcpInstallPiCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const home = opts._homeDir ?? homedir();
+  const filePath = scope === "user" ? join(home, ".pi", "agent", "mcp.json") : join(process.cwd(), ".pi", "mcp.json");
+  return writeJsonAndReport(filePath, "Pi", {
+    prereq: "pi has no native MCP support \u2014 install the third-party adapter once:\n  pi install npm:pi-mcp-adapter"
+  });
+}
+function mcpInstallOpenClawCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const spawnSync = opts._spawnSync ?? nodeSpawnSync;
+  const probe = spawnSync("openclaw", ["--version"], { stdio: "pipe" });
+  if (probe.error || probe.status !== 0) {
+    printOpenClawManualInstructions();
+    return EXIT.OK;
+  }
+  const entryJson = JSON.stringify(ENTRY);
+  const cmd = ["mcp", "set", SERVER_NAME, entryJson];
+  const res = spawnSync("openclaw", cmd, { stdio: "inherit" });
+  if (res.status !== 0) {
+    process.stderr.write(
+      `\`openclaw ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
+`
+    );
+    printOpenClawManualInstructions();
+    return EXIT.USAGE;
+  }
+  process.stdout.write(
+    `Installed pyx-memory MCP server in OpenClaw.
+Restart OpenClaw to make the tools available. No API key was written to openclaw.json \u2014 credentials live in the OS credential store.
+`
+  );
+  return EXIT.OK;
+}
+function printOpenClawManualInstructions() {
+  const entryJson = JSON.stringify(ENTRY);
+  process.stdout.write(
+    [
+      "The `openclaw` CLI is not on PATH, or the install command failed.",
+      "",
+      "Run this once OpenClaw is installed:",
+      `  openclaw mcp set ${SERVER_NAME} '${entryJson}'`,
+      "",
+      "Or add this entry manually under `mcp.servers` in your OpenClaw config",
+      "(run `openclaw config file` to print the active config path):",
+      "",
+      JSON.stringify({ mcp: { servers: { [SERVER_NAME]: ENTRY } } }, 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 mcpInstallHermesCommand(opts = {}) {
+  const scope = opts.scope ?? "user";
+  if (!validateScope(scope)) return EXIT.USAGE;
+  const spawnSync = opts._spawnSync ?? nodeSpawnSync;
+  const probe = spawnSync("hermes", ["--version"], { stdio: "pipe" });
+  if (probe.error || probe.status !== 0) {
+    printHermesManualInstructions();
+    return EXIT.OK;
+  }
+  const cmd = ["mcp", "add", SERVER_NAME, "--command", "pyx-mem", "--args", "mcp"];
+  const res = spawnSync("hermes", cmd, { stdio: "inherit" });
+  if (res.status !== 0) {
+    process.stderr.write(`\`hermes ${cmd.join(" ")}\` exited with code ${res.status ?? "null"}.
+`);
+    printHermesManualInstructions();
+    return EXIT.USAGE;
+  }
+  process.stdout.write(
+    `Installed pyx-memory MCP server in Hermes.
+Restart Hermes to make the tools available. No API key was written to config.yaml \u2014 credentials live in the OS credential store.
+`
+  );
+  return EXIT.OK;
+}
+function printHermesManualInstructions() {
+  process.stdout.write(
+    [
+      "The `hermes` CLI is not on PATH, or the install command failed.",
+      "",
+      "Run this once Hermes is installed:",
+      `  hermes mcp add ${SERVER_NAME} --command pyx-mem --args mcp`,
+      "",
+      "Or add this block under `mcp_servers:` in your Hermes config",
+      "(typically ~/.hermes/config.yaml):",
+      "",
+      `${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 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) {
+function writeJsonAndReport(filePath, agentLabel, opts = {}) {
   const result = mergeWriteJsonMcpEntry({
     filePath,
     serverName: SERVER_NAME,
@@ -15850,6 +15950,10 @@ function writeJsonAndReport(filePath, agentLabel) {
 `
     );
   }
+  if ((result.status === "installed" || result.status === "already-installed") && opts.prereq) {
+    process.stdout.write(`Prerequisite: ${opts.prereq}
+`);
+  }
   return result.exitCode;
 }
 
@@ -15910,7 +16014,7 @@ Commands:
   mcp                                          Start stdio MCP server.
   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.
+                                               Targets: claude-code, codex, cursor, cline, continue, windsurf, gemini-cli, pi, openclaw, hermes.
 
 Notes:
   - Credentials are stored only in the OS credential store (Keychain / libsecret / Credential Manager).
@@ -15963,15 +16067,43 @@ function parseArgs(argv) {
 }
 
 // src/cli/pyx-mem.ts
-var VALID_TARGETS = [
-  "claude-code",
-  "codex",
-  "cursor",
-  "cline",
-  "continue",
-  "windsurf",
-  "gemini-cli"
-];
+var INSTALL_TARGETS = {
+  "claude-code": mcpInstallClaudeCodeCommand,
+  codex: mcpInstallCodexCommand,
+  cursor: mcpInstallCursorCommand,
+  cline: mcpInstallClineCommand,
+  continue: mcpInstallContinueCommand,
+  windsurf: mcpInstallWindsurfCommand,
+  "gemini-cli": mcpInstallGeminiCliCommand,
+  pi: mcpInstallPiCommand,
+  openclaw: mcpInstallOpenClawCommand,
+  hermes: mcpInstallHermesCommand
+};
+var VALID_TARGETS = Object.keys(INSTALL_TARGETS);
+function runMcpInstall(target, scope) {
+  if (target === void 0 || !Object.hasOwn(INSTALL_TARGETS, target)) {
+    process.stderr.write(
+      `Error: unknown install target \`${target ?? ""}\`. Expected: ${VALID_TARGETS.join(", ")}.
+`
+    );
+    return EXIT.USAGE;
+  }
+  const handler = INSTALL_TARGETS[target];
+  return handler({ scope });
+}
+function runMcpCommand(parsed) {
+  if (parsed.subcommand === void 0) return mcpCommand();
+  if (parsed.subcommand === "install") {
+    const target = parsed.positional[0];
+    const scope = typeof parsed.flags.scope === "string" ? parsed.flags.scope : void 0;
+    return runMcpInstall(target, scope);
+  }
+  process.stderr.write(
+    `Error: unknown subcommand \`mcp ${parsed.subcommand}\`. Run \`pyx-mem --help\`.
+`
+  );
+  return EXIT.USAGE;
+}
 async function main() {
   const parsed = parseArgs(process.argv.slice(2));
   if (parsed.flags.help === true || parsed.flags.h === true) {
@@ -15994,40 +16126,8 @@ async function main() {
       return logoutCommand();
     case "doctor":
       return doctorCommand({ json: parsed.flags.json === true });
-    case "mcp": {
-      if (parsed.subcommand === void 0) return mcpCommand();
-      if (parsed.subcommand === "install") {
-        const target = parsed.positional[0];
-        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;
-        }
-      }
-      process.stderr.write(
-        `Error: unknown subcommand \`mcp ${parsed.subcommand}\`. Run \`pyx-mem --help\`.
-`
-      );
-      return EXIT.USAGE;
-    }
+    case "mcp":
+      return runMcpCommand(parsed);
     default:
       process.stderr.write(
         `Error: unknown command \`${parsed.command}\`. Run \`pyx-mem --help\`.

package/package.json

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