memax-cli 0.1.0-alpha.5 → 0.1.0-alpha.7

package/src/commands/setup.ts

@@ -9,6 +9,8 @@ import {
 import { join, dirname } from "node:path";
 import { homedir, platform } from "node:os";
 import { execSync } from "node:child_process";
+import { apiPost } from "../lib/api.js";
+import { loadConfig } from "../lib/config.js";
 
 // --- Agent definitions ---
 
@@ -25,7 +27,7 @@ interface AgentDef {
 
 function getAgents(): AgentDef[] {
   const home = homedir();
-  const isWin = platform() === "win32";
+  const cwd = process.cwd();
 
   return [
     {
@@ -97,6 +99,26 @@ function getAgents(): AgentDef[] {
       hasHooks: false,
       detect: () => existsSync(join(home, ".codex")) || commandExists("codex"),
     },
+    {
+      name: "OpenClaw",
+      id: "openclaw",
+      configPath: join(home, ".openclaw", "openclaw.json"),
+      format: "json-mcpServers",
+      mcpKey: "mcp.servers",
+      hasHooks: false,
+      detect: () =>
+        existsSync(join(home, ".openclaw")) || commandExists("openclaw"),
+    },
+    {
+      name: "OpenCode",
+      id: "opencode",
+      configPath: join(cwd, ".opencode", "opencode.jsonc"),
+      format: "json-mcpServers",
+      mcpKey: "mcp",
+      hasHooks: false,
+      detect: () =>
+        existsSync(join(cwd, ".opencode")) || commandExists("opencode"),
+    },
   ];
 }
 
@@ -106,6 +128,8 @@ interface SetupOptions {
   mcp?: boolean;
   hooks?: boolean;
   all?: boolean;
+  local?: boolean;
+  print?: boolean;
   only?: string;
   skip?: string;
 }
@@ -114,20 +138,46 @@ export async function setupCommand(options: SetupOptions): Promise<void> {
   const enableMcp = options.all || options.mcp;
   const enableHooks = options.all || options.hooks;
 
-  if (!enableMcp && !enableHooks) {
+  if (!enableMcp && !enableHooks && !options.print) {
     printUsage();
     return;
   }
 
-  // Resolve memax binary
-  const memaxBin = resolveMemaxBin();
-  if (!memaxBin) {
-    console.error(
-      chalk.red(
-        "\n  Could not find memax binary.\n  Install globally: npm install -g memax-cli@alpha\n",
-      ),
-    );
-    process.exit(1);
+  // --print: just output config JSON for manual copy/paste
+  if (options.print) {
+    await printMcpConfigs(options.local ?? false);
+    return;
+  }
+
+  // Remote mode (default): need API key for auth
+  const useRemote = !options.local;
+  let apiKey: string | undefined;
+
+  if (useRemote && enableMcp) {
+    apiKey = await ensureApiKey();
+    if (!apiKey) {
+      console.error(
+        chalk.red(
+          "\n  Could not create API key. Log in first: memax login\n" +
+            "  Or use --local for local MCP server.\n",
+        ),
+      );
+      process.exit(1);
+    }
+  }
+
+  // Local mode: need memax binary
+  let memaxBin: MemaxBin | null = null;
+  if (!useRemote || enableHooks) {
+    memaxBin = resolveMemaxBin();
+    if (!memaxBin && !useRemote) {
+      console.error(
+        chalk.red(
+          "\n  Could not find memax binary.\n  Install globally: npm install -g memax-cli@alpha\n",
+        ),
+      );
+      process.exit(1);
+    }
   }
 
   // Filter agents
@@ -158,6 +208,11 @@ export async function setupCommand(options: SetupOptions): Promise<void> {
   }
 
   console.log(chalk.bold("\n  Memax Setup\n"));
+  if (useRemote) {
+    console.log(chalk.gray("  Mode: remote server (recommended)\n"));
+  } else {
+    console.log(chalk.gray("  Mode: local CLI\n"));
+  }
 
   const results: { agent: string; changes: string[] }[] = [];
 
@@ -167,8 +222,12 @@ export async function setupCommand(options: SetupOptions): Promise<void> {
     // MCP setup
     if (enableMcp) {
       try {
-        setupMcp(agent, memaxBin);
-        changes.push("MCP server");
+        if (useRemote) {
+          setupMcpRemote(agent, apiKey!);
+        } else {
+          setupMcp(agent, memaxBin!);
+        }
+        changes.push(useRemote ? "MCP server (remote)" : "MCP server (local)");
       } catch (err) {
         console.log(
           chalk.red(
@@ -178,8 +237,8 @@ export async function setupCommand(options: SetupOptions): Promise<void> {
       }
     }
 
-    // Hook setup (only for agents that support it)
-    if (enableHooks && agent.hasHooks) {
+    // Hook setup (only for agents that support it — needs local binary)
+    if (enableHooks && agent.hasHooks && memaxBin) {
       try {
         setupHooks(agent, memaxBin);
         changes.push("Context injection hook");
@@ -300,7 +359,182 @@ export async function teardownCommand(options: {
   );
 }
 
-// --- MCP setup per agent ---
+// --- Remote MCP setup ---
+
+async function ensureApiKey(): Promise<string | undefined> {
+  try {
+    const result = await apiPost<{ key: string }>("/v1/auth/api-keys", {
+      name: "mcp-setup",
+      expires_in_days: 0, // no expiry
+    });
+    return result.key;
+  } catch {
+    return undefined;
+  }
+}
+
+function getApiUrl(): string {
+  return loadConfig().api_url;
+}
+
+function setupMcpRemote(agent: AgentDef, apiKey: string): void {
+  const mcpUrl = `${getApiUrl()}/mcp`;
+
+  // Claude Code uses its own CLI
+  if (agent.id === "claude-code") {
+    if (!commandExists("claude")) {
+      throw new Error("claude CLI not found in PATH");
+    }
+    try {
+      execSync("claude mcp remove memax", { stdio: "pipe" });
+    } catch {
+      // Not installed yet
+    }
+    // Claude Code HTTP transport
+    execSync(
+      `claude mcp add memax --transport http ${mcpUrl} --header "Authorization: Bearer ${apiKey}"`,
+      { stdio: "pipe" },
+    );
+    return;
+  }
+
+  // Codex TOML
+  if (agent.format === "toml") {
+    mkdirSync(dirname(agent.configPath), { recursive: true });
+    let content = "";
+    if (existsSync(agent.configPath)) {
+      content = readFileSync(agent.configPath, "utf-8");
+    }
+    content = content.replace(/\[mcp_servers\.memax\][\s\S]*?(?=\n\[|$)/, "");
+    content = content.trim();
+    if (content) content += "\n\n";
+    content += `[mcp_servers.memax]\ntype = "url"\nurl = "${mcpUrl}"\n\n[mcp_servers.memax.headers]\nAuthorization = "Bearer ${apiKey}"\n`;
+    writeFileSync(agent.configPath, content);
+    return;
+  }
+
+  // JSON-based agents
+  mkdirSync(dirname(agent.configPath), { recursive: true });
+  let config: Record<string, unknown> = {};
+  if (existsSync(agent.configPath)) {
+    try {
+      config = JSON.parse(readFileSync(agent.configPath, "utf-8"));
+    } catch {
+      // Start fresh
+    }
+  }
+
+  const servers = (getNestedKey(config, agent.mcpKey) ?? {}) as Record<
+    string,
+    unknown
+  >;
+  servers.memax = {
+    type: "url",
+    url: mcpUrl,
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+    },
+  };
+  setNestedKey(config, agent.mcpKey, servers);
+  writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+async function printMcpConfigs(local: boolean): Promise<void> {
+  const apiUrl = getApiUrl();
+
+  console.log(chalk.bold("\n  Memax MCP Configuration\n"));
+
+  if (local) {
+    const bin = resolveMemaxBin();
+    const cmd = bin ? bin.command : "memax";
+    const args = bin ? [...bin.args, "mcp", "serve"] : ["mcp", "serve"];
+
+    console.log(chalk.gray("  Mode: local (stdio)\n"));
+    console.log(
+      chalk.white("  For most agents (Claude Code, Cursor, Gemini, etc.):\n"),
+    );
+    console.log(
+      JSON.stringify(
+        {
+          mcpServers: {
+            memax: { command: cmd, args },
+          },
+        },
+        null,
+        2,
+      )
+        .split("\n")
+        .map((l) => "  " + l)
+        .join("\n"),
+    );
+  } else {
+    let apiKey: string | undefined;
+    try {
+      apiKey = await ensureApiKey();
+    } catch {
+      // Not logged in
+    }
+
+    const keyDisplay = apiKey ?? "mxk_your_api_key_here";
+    const mcpUrl = `${apiUrl}/mcp`;
+
+    console.log(chalk.gray("  Mode: remote server (recommended)\n"));
+
+    console.log(chalk.white("  For Claude Code:\n"));
+    console.log(
+      chalk.gray(
+        `  claude mcp add memax --transport http ${mcpUrl} --header "Authorization: Bearer ${keyDisplay}"`,
+      ),
+    );
+
+    console.log(chalk.white("\n  For Cursor, Copilot, Gemini, Windsurf:\n"));
+    console.log(
+      JSON.stringify(
+        {
+          mcpServers: {
+            memax: {
+              type: "url",
+              url: mcpUrl,
+              headers: {
+                Authorization: `Bearer ${keyDisplay}`,
+              },
+            },
+          },
+        },
+        null,
+        2,
+      )
+        .split("\n")
+        .map((l) => "  " + l)
+        .join("\n"),
+    );
+
+    console.log(chalk.white("\n  For Codex CLI (~/.codex/config.toml):\n"));
+    console.log(chalk.gray(`  [mcp_servers.memax]`));
+    console.log(chalk.gray(`  type = "url"`));
+    console.log(chalk.gray(`  url = "${mcpUrl}"`));
+    console.log(chalk.gray(`\n  [mcp_servers.memax.headers]`));
+    console.log(chalk.gray(`  Authorization = "Bearer ${keyDisplay}"`));
+
+    if (apiKey) {
+      console.log(chalk.yellow("\n  API key created: mcp-setup"));
+      console.log(chalk.gray("  Manage keys: memax auth list-keys"));
+    } else {
+      console.log(
+        chalk.yellow(
+          "\n  Not logged in — replace mxk_your_api_key_here with a real key.",
+        ),
+      );
+      console.log(
+        chalk.gray("  Run: memax login && memax auth create-key --name mcp"),
+      );
+    }
+  }
+
+  console.log();
+}
+
+// --- Local MCP setup per agent ---
 
 function setupMcp(agent: AgentDef, bin: MemaxBin): void {
   // Claude Code has its own CLI for MCP management
@@ -326,12 +560,15 @@ function setupMcp(agent: AgentDef, bin: MemaxBin): void {
     }
   }
 
-  const servers = (config[agent.mcpKey] ?? {}) as Record<string, unknown>;
+  const servers = (getNestedKey(config, agent.mcpKey) ?? {}) as Record<
+    string,
+    unknown
+  >;
   servers.memax = {
     command: bin.command,
     args: [...bin.args, "mcp", "serve"],
   };
-  config[agent.mcpKey] = servers;
+  setNestedKey(config, agent.mcpKey, servers);
 
   writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
 }
@@ -468,11 +705,12 @@ function removeMcpJson(agent: AgentDef): boolean {
 
   try {
     const config = JSON.parse(readFileSync(agent.configPath, "utf-8"));
-    const servers = config[agent.mcpKey] as Record<string, unknown> | undefined;
+    const servers = getNestedKey(config, agent.mcpKey);
     if (!servers?.memax) return false;
 
     delete servers.memax;
-    if (Object.keys(servers).length === 0) delete config[agent.mcpKey];
+    if (Object.keys(servers).length === 0)
+      deleteNestedKey(config, agent.mcpKey);
 
     writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
     console.log(chalk.gray(`  Removed MCP from ${agent.name}`));
@@ -596,6 +834,46 @@ function commandExists(cmd: string): boolean {
   }
 }
 
+// Nested key helpers for configs like openclaw's "mcp.servers"
+function getNestedKey(
+  obj: Record<string, unknown>,
+  key: string,
+): Record<string, unknown> | undefined {
+  const parts = key.split(".");
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return undefined;
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current as Record<string, unknown> | undefined;
+}
+
+function setNestedKey(
+  obj: Record<string, unknown>,
+  key: string,
+  value: unknown,
+): void {
+  const parts = key.split(".");
+  let current: Record<string, unknown> = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!(parts[i] in current) || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]] as Record<string, unknown>;
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+function deleteNestedKey(obj: Record<string, unknown>, key: string): void {
+  const parts = key.split(".");
+  let current: Record<string, unknown> = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!(parts[i] in current) || typeof current[parts[i]] !== "object") return;
+    current = current[parts[i]] as Record<string, unknown>;
+  }
+  delete current[parts[parts.length - 1]];
+}
+
 function writeHookScript(bin: MemaxBin): string {
   const hooksDir = join(homedir(), ".memax", "hooks");
   mkdirSync(hooksDir, { recursive: true });
@@ -634,14 +912,21 @@ function printUsage(): void {
   console.log(chalk.gray("  Usage:\n"));
   console.log(
     chalk.gray(
-      "    memax setup --mcp          MCP tools for all detected agents",
+      "    memax setup --mcp          Remote MCP server for all detected agents (default)",
     ),
   );
   console.log(
     chalk.gray("    memax setup --all          MCP + hooks (where supported)"),
   );
+  console.log(
+    chalk.gray(
+      "    memax setup --mcp --local  Use local CLI instead of remote server",
+    ),
+  );
+  console.log(
+    chalk.gray("    memax setup --print        Print MCP config to copy/paste"),
+  );
   console.log(chalk.gray("    memax setup --mcp --only claude-code,cursor"));
-  console.log(chalk.gray("    memax setup --all --skip codex"));
   console.log(
     chalk.gray("    memax teardown             Remove all integrations\n"),
   );

package/src/commands/sync.ts

@@ -6,6 +6,7 @@ import {
   watch,
   existsSync,
 } from "node:fs";
+import { createInterface } from "node:readline";
 import { join, relative, extname, resolve, basename } from "node:path";
 import { homedir } from "node:os";
 import { apiPost } from "../lib/api.js";
@@ -17,6 +18,7 @@ interface SyncOptions {
   watch?: boolean;
   ignore?: string;
   agentMemory?: boolean;
+  yes?: boolean;
 }
 
 const DEFAULT_IGNORE = new Set([
@@ -85,6 +87,21 @@ export async function syncCommand(
   }
 
   console.log(chalk.gray(`Found ${files.length} files to sync`));
+
+  // Confirm if many files (>10) unless -y is passed
+  if (files.length > 10 && !options.yes) {
+    console.log(
+      chalk.yellow(
+        `\n  This will push ${files.length} files. Continue? (y/N) `,
+      ),
+    );
+    const confirmed = await confirmSync();
+    if (!confirmed) {
+      console.log(chalk.gray("  Cancelled.\n"));
+      return;
+    }
+  }
+
   console.log();
 
   let pushed = 0;
@@ -296,6 +313,79 @@ function discoverAgentMemoryFiles(): AgentMemoryLocation[] {
     label: "./.codex/instructions.md",
     path: join(cwd, ".codex", "instructions.md"),
   });
+  locations.push({
+    label: "~/.codex/AGENTS.md",
+    path: join(home, ".codex", "AGENTS.md"),
+  });
+
+  // Gemini CLI
+  locations.push({
+    label: "~/.gemini/GEMINI.md",
+    path: join(home, ".gemini", "GEMINI.md"),
+  });
+  locations.push({ label: "./GEMINI.md", path: join(cwd, "GEMINI.md") });
+
+  // GitHub Copilot
+  locations.push({
+    label: "./.github/copilot-instructions.md",
+    path: join(cwd, ".github", "copilot-instructions.md"),
+  });
+
+  // Windsurf
+  locations.push({
+    label: "./.windsurfrules",
+    path: join(cwd, ".windsurfrules"),
+  });
+  const windsurfRulesDir = join(cwd, ".windsurf", "rules");
+  if (existsSync(windsurfRulesDir)) {
+    try {
+      for (const file of readdirSync(windsurfRulesDir)) {
+        if (file.endsWith(".md")) {
+          locations.push({
+            label: `./.windsurf/rules/${file}`,
+            path: join(windsurfRulesDir, file),
+          });
+        }
+      }
+    } catch {
+      // Skip on error
+    }
+  }
+
+  // OpenClaw memory
+  const openclawMemoryDir = join(home, ".openclaw", "memory");
+  if (existsSync(openclawMemoryDir)) {
+    try {
+      for (const file of readdirSync(openclawMemoryDir)) {
+        if (file.endsWith(".md") || file.endsWith(".json")) {
+          locations.push({
+            label: `~/.openclaw/memory/${file}`,
+            path: join(openclawMemoryDir, file),
+          });
+        }
+      }
+    } catch {
+      // Skip on error
+    }
+  }
+
+  // OpenCode (anomalyco) context
+  const opencodePath = join(cwd, ".opencode");
+  if (existsSync(opencodePath)) {
+    // Check for any markdown context files in .opencode/
+    try {
+      for (const file of readdirSync(opencodePath)) {
+        if (file.endsWith(".md")) {
+          locations.push({
+            label: `./.opencode/${file}`,
+            path: join(opencodePath, file),
+          });
+        }
+      }
+    } catch {
+      // Skip on error
+    }
+  }
 
   // Generic agent config files in current directory
   locations.push({ label: "./AGENTS.md", path: join(cwd, "AGENTS.md") });
@@ -401,3 +491,16 @@ async function syncAgentMemory(): Promise<void> {
     ),
   );
 }
+
+function confirmSync(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question("  ", (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}

package/src/index.ts

@@ -39,7 +39,7 @@ program
 // --- Core commands ---
 
 program
-  .command("push")
+  .command("push [content]")
   .description("Save knowledge to your Memax workspace")
   .option("-f, --file <path>", "File to push")
   .option("-c, --category <category>", "Category (auto-detected if omitted)")
@@ -77,7 +77,24 @@ program
 program
   .command("delete <id>")
   .description("Delete a note")
-  .option("--confirm", "Skip confirmation")
+  .option("-y, --yes", "Skip confirmation")
+  .action(deleteCommand);
+
+// Aliases
+program
+  .command("remember [content]")
+  .description("Alias for push — save knowledge to your Memax workspace")
+  .option("-f, --file <path>", "File to push")
+  .option("-c, --category <category>", "Category (auto-detected if omitted)")
+  .option("-t, --tags <tags>", "Comma-separated tags")
+  .option("--title <title>", "Note title")
+  .option("--stdin", "Read content from stdin")
+  .action(pushCommand);
+
+program
+  .command("forget <id>")
+  .description("Alias for delete — remove a note from your workspace")
+  .option("-y, --yes", "Skip confirmation")
   .action(deleteCommand);
 
 // --- Sync ---
@@ -100,6 +117,7 @@ const syncCmd = program
     "--agent-memory",
     "Sync native AI agent memory files (Claude Code, Cursor, Codex)",
   )
+  .option("-y, --yes", "Skip confirmation for large syncs")
   .action(syncCommand);
 
 syncCmd
@@ -115,6 +133,8 @@ program
   .option("--mcp", "Enable MCP server (agent tools)")
   .option("--hooks", "Enable context injection hooks")
   .option("--all", "Enable both MCP and hooks")
+  .option("--local", "Use local stdio MCP instead of remote server")
+  .option("--print", "Print MCP config JSON to copy/paste (no changes made)")
   .option("--only <agents>", "Only configure these agents (comma-separated)")
   .option("--skip <agents>", "Skip these agents (comma-separated)")
   .action(setupCommand);