rex-claude 4.0.0 → 6.0.0

package/dist/{llm-YRORUH7E.js → llm-RALIPIMI.js}

@@ -2,7 +2,8 @@
 import {
   detectModel,
   llm
-} from "./chunk-7AGI43F5.js";
+} from "./chunk-WBMVBMWB.js";
+import "./chunk-PDX44BCA.js";
 export {
   detectModel,
   llm

package/dist/mcp_registry-DX4GGSP6.js

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/mcp_registry.ts
+import { homedir } from "os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { execSync, execFileSync } from "child_process";
+var HOME = homedir();
+var ROOT_DIR = join(HOME, ".rex-memory");
+var REGISTRY_FILE = join(ROOT_DIR, "mcp-registry.json");
+function ensureDir() {
+  if (!existsSync(ROOT_DIR)) mkdirSync(ROOT_DIR, { recursive: true });
+}
+function readRegistry() {
+  ensureDir();
+  try {
+    if (existsSync(REGISTRY_FILE)) {
+      const parsed = JSON.parse(readFileSync(REGISTRY_FILE, "utf-8"));
+      if (Array.isArray(parsed.servers)) return parsed;
+    }
+  } catch {
+  }
+  return { servers: [] };
+}
+function writeRegistry(registry) {
+  ensureDir();
+  writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2));
+}
+function slug(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "mcp";
+}
+function parseFlag(args, name) {
+  const idx = args.findIndex((a) => a === name);
+  if (idx < 0) return null;
+  return args[idx + 1] || null;
+}
+function findServer(registry, idOrName) {
+  return registry.servers.find((s) => s.id === idOrName || s.name === idOrName) || null;
+}
+function printList(jsonMode) {
+  const registry = readRegistry();
+  if (jsonMode) {
+    console.log(JSON.stringify(registry, null, 2));
+    return;
+  }
+  if (registry.servers.length === 0) {
+    console.log("No MCP servers in registry.");
+    return;
+  }
+  for (const s of registry.servers) {
+    const target = s.type === "stdio" ? `${s.command || "n/a"} ${(s.args || []).join(" ")}`.trim() : s.url || "n/a";
+    console.log(`${s.id}  ${s.name}  type=${s.type}  enabled=${s.enabled}  target=${target}`);
+  }
+}
+function addStdio(args) {
+  const name = args[0];
+  if (!name) {
+    console.log("Usage: rex mcp add <name> --command <cmd> [--args a,b,c] [--cwd path] [--tags t1,t2]");
+    process.exit(1);
+  }
+  const command = parseFlag(args, "--command");
+  if (!command) {
+    console.log("Missing --command");
+    process.exit(1);
+  }
+  const argsCsv = parseFlag(args, "--args");
+  const cwd = parseFlag(args, "--cwd");
+  const tagsCsv = parseFlag(args, "--tags");
+  const registry = readRegistry();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    id: `${slug(name)}-${Date.now().toString().slice(-6)}`,
+    name,
+    type: "stdio",
+    command,
+    args: argsCsv ? argsCsv.split(",").map((v) => v.trim()).filter(Boolean) : [],
+    cwd: cwd || void 0,
+    enabled: true,
+    tags: tagsCsv ? tagsCsv.split(",").map((v) => v.trim()).filter(Boolean) : [],
+    createdAt: now,
+    updatedAt: now
+  };
+  registry.servers.push(entry);
+  writeRegistry(registry);
+  console.log(JSON.stringify({ ok: true, server: entry }, null, 2));
+}
+function addUrl(args) {
+  const name = args[0];
+  const url = args[1];
+  if (!name || !url) {
+    console.log("Usage: rex mcp add-url <name> <url> [--type sse|http] [--tags t1,t2]");
+    process.exit(1);
+  }
+  const typeRaw = (parseFlag(args, "--type") || "sse").toLowerCase();
+  const type = typeRaw === "http" ? "http" : "sse";
+  const tagsCsv = parseFlag(args, "--tags");
+  const registry = readRegistry();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    id: `${slug(name)}-${Date.now().toString().slice(-6)}`,
+    name,
+    type,
+    url,
+    enabled: true,
+    tags: tagsCsv ? tagsCsv.split(",").map((v) => v.trim()).filter(Boolean) : [],
+    createdAt: now,
+    updatedAt: now
+  };
+  registry.servers.push(entry);
+  writeRegistry(registry);
+  console.log(JSON.stringify({ ok: true, server: entry }, null, 2));
+}
+function removeServer(args) {
+  const idOrName = args[0];
+  if (!idOrName) {
+    console.log("Usage: rex mcp remove <id|name>");
+    process.exit(1);
+  }
+  const registry = readRegistry();
+  const idx = registry.servers.findIndex((s) => s.id === idOrName || s.name === idOrName);
+  if (idx < 0) {
+    console.log(`Server not found: ${idOrName}`);
+    process.exit(1);
+  }
+  const removed = registry.servers[idx];
+  registry.servers.splice(idx, 1);
+  writeRegistry(registry);
+  console.log(JSON.stringify({ ok: true, removed }, null, 2));
+}
+function setEnabled(args, enabled) {
+  const idOrName = args[0];
+  if (!idOrName) {
+    console.log(`Usage: rex mcp ${enabled ? "enable" : "disable"} <id|name>`);
+    process.exit(1);
+  }
+  const registry = readRegistry();
+  const server = findServer(registry, idOrName);
+  if (!server) {
+    console.log(`Server not found: ${idOrName}`);
+    process.exit(1);
+  }
+  server.enabled = enabled;
+  server.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeRegistry(registry);
+  console.log(JSON.stringify({ ok: true, id: server.id, enabled }, null, 2));
+}
+async function checkServer(args) {
+  const idOrName = args[0];
+  if (!idOrName) {
+    console.log("Usage: rex mcp check <id|name>");
+    process.exit(1);
+  }
+  const registry = readRegistry();
+  const server = findServer(registry, idOrName);
+  if (!server) {
+    console.log(`Server not found: ${idOrName}`);
+    process.exit(1);
+  }
+  if (server.type === "stdio") {
+    if (!server.command) {
+      console.log(JSON.stringify({ ok: false, reason: "missing command" }, null, 2));
+      process.exit(1);
+    }
+    try {
+      execFileSync("which", [server.command], { stdio: "ignore" });
+      console.log(JSON.stringify({ ok: true, type: "stdio", command: server.command }, null, 2));
+    } catch {
+      console.log(JSON.stringify({ ok: false, type: "stdio", reason: `command not found: ${server.command}` }, null, 2));
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (!server.url) {
+    console.log(JSON.stringify({ ok: false, reason: "missing url" }, null, 2));
+    process.exit(1);
+  }
+  const controller = new AbortController();
+  const t = setTimeout(() => controller.abort(), 8e3);
+  try {
+    const res = await fetch(server.url, { signal: controller.signal });
+    clearTimeout(t);
+    console.log(JSON.stringify({ ok: res.ok, status: res.status, type: server.type, url: server.url }, null, 2));
+    if (!res.ok) process.exitCode = 1;
+  } catch (e) {
+    clearTimeout(t);
+    const err = e instanceof Error ? e.message : String(e);
+    console.log(JSON.stringify({ ok: false, type: server.type, url: server.url, error: err }, null, 2));
+    process.exitCode = 1;
+  }
+}
+function syncClaudeSettings() {
+  const registry = readRegistry();
+  const settingsPath = join(HOME, ".claude", "settings.json");
+  const claudeDir = join(HOME, ".claude");
+  if (!existsSync(claudeDir)) mkdirSync(claudeDir, { recursive: true });
+  let settings = {};
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+  } catch {
+  }
+  if (!settings.mcpServers) settings.mcpServers = {};
+  const enabledStdio = registry.servers.filter((s) => s.enabled && s.type === "stdio" && s.command);
+  for (const s of enabledStdio) {
+    settings.mcpServers[s.name] = {
+      command: s.command,
+      args: s.args || [],
+      ...s.cwd ? { cwd: s.cwd } : {}
+    };
+  }
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  console.log(JSON.stringify({ ok: true, synced: enabledStdio.length, settingsPath }, null, 2));
+}
+var MARKETPLACE_DIR = join(HOME, ".claude", "rex");
+var MARKETPLACE_FILE = join(MARKETPLACE_DIR, "mcp-marketplace.json");
+var DEFAULT_MARKETPLACE = [
+  { name: "context7", description: "Versioned docs for any library (npm, PyPI)", command: "npx", args: ["-y", "@upstash/context7-mcp"], installCmd: "npx -y @upstash/context7-mcp", type: "stdio", tags: ["docs", "libraries"], source: "builtin" },
+  { name: "playwright", description: "Browser automation and testing", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-playwright"], installCmd: "npx -y @anthropic-ai/mcp-server-playwright", type: "stdio", tags: ["browser", "testing", "automation"], source: "builtin" },
+  { name: "filesystem", description: "Local filesystem access (read/write/search)", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-filesystem"], installCmd: "npx -y @anthropic-ai/mcp-server-filesystem", type: "stdio", tags: ["files", "local"], source: "builtin" },
+  { name: "github", description: "GitHub API (repos, issues, PRs, actions)", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-github"], installCmd: "npm install -g @anthropic-ai/mcp-server-github", type: "stdio", tags: ["git", "github", "ci"], source: "builtin" },
+  { name: "slack", description: "Slack messaging and channel management", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-slack"], installCmd: "npx -y @anthropic-ai/mcp-server-slack", type: "stdio", tags: ["messaging", "slack"], source: "builtin" },
+  { name: "linear", description: "Linear issue tracker integration", command: "npx", args: ["-y", "mcp-linear"], installCmd: "npx -y mcp-linear", type: "stdio", tags: ["issues", "project-management"], source: "builtin" },
+  { name: "figma", description: "Figma design file access and inspection", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-figma"], installCmd: "npx -y @anthropic-ai/mcp-server-figma", type: "stdio", tags: ["design", "figma", "ui"], source: "builtin" },
+  { name: "brave-search", description: "Web search via Brave Search API", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-brave-search"], installCmd: "npx -y @anthropic-ai/mcp-server-brave-search", type: "stdio", tags: ["search", "web"], source: "builtin" },
+  { name: "puppeteer", description: "Headless Chrome browser automation", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-puppeteer"], installCmd: "npx -y @anthropic-ai/mcp-server-puppeteer", type: "stdio", tags: ["browser", "scraping"], source: "builtin" },
+  { name: "sequential-thinking", description: "Step-by-step reasoning and problem solving", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-sequential-thinking"], installCmd: "npx -y @anthropic-ai/mcp-server-sequential-thinking", type: "stdio", tags: ["reasoning", "thinking"], source: "builtin" },
+  { name: "memory", description: "Persistent memory via knowledge graph", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-memory"], installCmd: "npx -y @anthropic-ai/mcp-server-memory", type: "stdio", tags: ["memory", "knowledge"], source: "builtin" },
+  { name: "postgres", description: "PostgreSQL database access", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-postgres"], installCmd: "npx -y @anthropic-ai/mcp-server-postgres", type: "stdio", tags: ["database", "postgres", "sql"], source: "builtin" },
+  { name: "sqlite", description: "SQLite database access", command: "npx", args: ["-y", "@anthropic-ai/mcp-server-sqlite"], installCmd: "npx -y @anthropic-ai/mcp-server-sqlite", type: "stdio", tags: ["database", "sqlite", "sql"], source: "builtin" },
+  { name: "docker", description: "Docker container management", command: "npx", args: ["-y", "mcp-docker"], installCmd: "npx -y mcp-docker", type: "stdio", tags: ["docker", "containers", "devops"], source: "builtin" },
+  { name: "kubernetes", description: "Kubernetes cluster management", command: "npx", args: ["-y", "mcp-kubernetes"], installCmd: "npx -y mcp-kubernetes", type: "stdio", tags: ["kubernetes", "k8s", "devops"], source: "builtin" },
+  { name: "sentry", description: "Sentry error tracking integration", command: "npx", args: ["-y", "mcp-sentry"], installCmd: "npx -y mcp-sentry", type: "stdio", tags: ["monitoring", "errors", "sentry"], source: "builtin" },
+  { name: "notion", description: "Notion workspace access", command: "npx", args: ["-y", "mcp-notion"], installCmd: "npx -y mcp-notion", type: "stdio", tags: ["notion", "docs", "wiki"], source: "builtin" },
+  { name: "google-drive", description: "Google Drive file access", command: "npx", args: ["-y", "mcp-google-drive"], installCmd: "npx -y mcp-google-drive", type: "stdio", tags: ["google", "drive", "files"], source: "builtin" },
+  { name: "exa", description: "Exa AI-powered web search", command: "npx", args: ["-y", "mcp-exa"], installCmd: "npx -y mcp-exa", type: "stdio", tags: ["search", "web", "ai"], source: "builtin" },
+  { name: "firecrawl", description: "Web scraping and crawling", command: "npx", args: ["-y", "mcp-firecrawl"], installCmd: "npx -y mcp-firecrawl", type: "stdio", tags: ["scraping", "crawling", "web"], source: "builtin" }
+];
+function readMarketplace() {
+  try {
+    if (existsSync(MARKETPLACE_FILE)) {
+      const parsed = JSON.parse(readFileSync(MARKETPLACE_FILE, "utf-8"));
+      if (Array.isArray(parsed) && parsed.length > 0) return parsed;
+    }
+  } catch {
+  }
+  if (!existsSync(MARKETPLACE_DIR)) mkdirSync(MARKETPLACE_DIR, { recursive: true });
+  writeFileSync(MARKETPLACE_FILE, JSON.stringify(DEFAULT_MARKETPLACE, null, 2));
+  return DEFAULT_MARKETPLACE;
+}
+async function discoverServer(args, jsonMode) {
+  const idOrName = args[0];
+  if (!idOrName) {
+    console.log("Usage: rex mcp discover <id|name>");
+    process.exit(1);
+  }
+  const registry = readRegistry();
+  const server = findServer(registry, idOrName);
+  if (!server) {
+    console.log(`Server not found: ${idOrName}`);
+    process.exit(1);
+  }
+  if (server.type !== "stdio" && server.url) {
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), 1e4);
+    try {
+      const res = await fetch(server.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", method: "tools/list", id: 1 }),
+        signal: controller.signal
+      });
+      clearTimeout(t);
+      if (!res.ok) {
+        console.log(`Could not discover tools for ${server.name} (HTTP ${res.status})`);
+        return;
+      }
+      const body = await res.json();
+      const tools = body?.result?.tools || [];
+      if (jsonMode) {
+        console.log(JSON.stringify(tools, null, 2));
+      } else if (tools.length === 0) {
+        console.log(`No tools found for ${server.name}`);
+      } else {
+        for (const tool of tools) {
+          console.log(`  ${tool.name || "unnamed"}  ${tool.description || ""}`);
+        }
+      }
+    } catch {
+      clearTimeout(t);
+      console.log(`Could not discover tools for ${server.name}`);
+    }
+    return;
+  }
+  if (!server.command) {
+    console.log(`Could not discover tools for ${server.name} (no command)`);
+    return;
+  }
+  try {
+    const { spawn } = await import("child_process");
+    const child = spawn(server.command, [...server.args || []], {
+      cwd: server.cwd || void 0,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let output = "";
+    let done = false;
+    const timeout = setTimeout(() => {
+      if (!done) {
+        done = true;
+        child.kill();
+      }
+    }, 1e4);
+    child.stdout.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    const initMsg = JSON.stringify({ jsonrpc: "2.0", method: "initialize", id: 0, params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "rex", version: "1.0" } } }) + "\n";
+    const toolsMsg = JSON.stringify({ jsonrpc: "2.0", method: "tools/list", id: 1 }) + "\n";
+    child.stdin.write(initMsg);
+    setTimeout(() => {
+      child.stdin.write(toolsMsg);
+    }, 500);
+    setTimeout(() => {
+      if (!done) {
+        done = true;
+        clearTimeout(timeout);
+        child.kill();
+        const lines = output.split("\n").filter(Boolean);
+        let tools = [];
+        for (const line of lines) {
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.id === 1 && parsed.result?.tools) {
+              tools = parsed.result.tools;
+              break;
+            }
+          } catch {
+          }
+        }
+        if (jsonMode) {
+          console.log(JSON.stringify(tools, null, 2));
+        } else if (tools.length === 0) {
+          console.log(`Could not discover tools for ${server.name}`);
+        } else {
+          console.log(`Tools for ${server.name}:`);
+          for (const tool of tools) {
+            console.log(`  ${tool.name || "unnamed"}  ${tool.description || ""}`);
+          }
+        }
+      }
+    }, 3e3);
+    await new Promise((resolve) => {
+      child.on("close", () => resolve());
+      child.on("error", () => {
+        if (!done) {
+          done = true;
+          clearTimeout(timeout);
+        }
+        ;
+        resolve();
+      });
+      setTimeout(() => resolve(), 12e3);
+    });
+  } catch {
+    console.log(`Could not discover tools for ${server.name}`);
+  }
+}
+function searchMarketplace(args, jsonMode) {
+  const query = args.filter((a) => !a.startsWith("--")).join(" ").toLowerCase();
+  if (!query) {
+    console.log("Usage: rex mcp search <query>");
+    process.exit(1);
+  }
+  const marketplace = readMarketplace();
+  const matches = marketplace.filter((entry) => {
+    const haystack = `${entry.name} ${entry.description} ${entry.tags.join(" ")}`.toLowerCase();
+    return query.split(/\s+/).every((word) => haystack.includes(word));
+  });
+  if (jsonMode) {
+    console.log(JSON.stringify(matches, null, 2));
+    return;
+  }
+  if (matches.length === 0) {
+    console.log(`No servers found matching "${query}"`);
+    return;
+  }
+  console.log(`Found ${matches.length} server(s):
+`);
+  for (const entry of matches) {
+    console.log(`  ${entry.name.padEnd(22)} ${entry.description}`);
+    if (entry.installCmd) console.log(`    install: ${entry.installCmd}`);
+    if (entry.tags.length) console.log(`    tags: ${entry.tags.join(", ")}`);
+    console.log("");
+  }
+}
+async function installFromMarketplace(args) {
+  const name = args[0];
+  if (!name) {
+    console.log("Usage: rex mcp install <name>");
+    process.exit(1);
+  }
+  const marketplace = readMarketplace();
+  const entry = marketplace.find((e) => e.name === name);
+  if (!entry) {
+    console.log(`Server "${name}" not found in marketplace. Run "rex mcp search ${name}" to check.`);
+    process.exit(1);
+  }
+  if (!entry.installCmd) {
+    console.log(`No install command for "${name}".`);
+    if (entry.command) {
+      console.log(`You can add it manually: rex mcp add ${name} --command ${entry.command} --args ${(entry.args || []).join(",")}`);
+    }
+    return;
+  }
+  console.log(`Installing ${name}...`);
+  console.log(`  $ ${entry.installCmd}
+`);
+  const safePrefix = ["npx ", "npm ", "pip ", "pip3 ", "brew ", "docker "];
+  if (!safePrefix.some((p) => entry.installCmd.startsWith(p))) {
+    console.log(`
+\u26A0\uFE0F Install command rejected (unsafe prefix): ${entry.installCmd}`);
+    return;
+  }
+  try {
+    execSync(entry.installCmd, { stdio: "inherit", timeout: 12e4 });
+  } catch {
+    console.log(`
+Install command failed. You may need to run it manually: ${entry.installCmd}`);
+    return;
+  }
+  const registry = readRegistry();
+  const existing = findServer(registry, name);
+  if (existing) {
+    console.log(`
+Server "${name}" already in registry (id=${existing.id}). Skipping auto-add.`);
+    return;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newEntry = {
+    id: `${slug(name)}-${Date.now().toString().slice(-6)}`,
+    name: entry.name,
+    type: entry.type,
+    command: entry.command,
+    args: entry.args || [],
+    enabled: true,
+    tags: entry.tags,
+    createdAt: now,
+    updatedAt: now
+  };
+  registry.servers.push(newEntry);
+  writeRegistry(registry);
+  console.log(`
+Added to registry: ${newEntry.id}`);
+  console.log(JSON.stringify({ ok: true, server: newEntry }, null, 2));
+}
+function showExport() {
+  const registry = readRegistry();
+  const enabledStdio = registry.servers.filter((s) => s.enabled && s.type === "stdio" && s.command);
+  const exported = {};
+  for (const s of enabledStdio) {
+    exported[s.name] = {
+      command: s.command,
+      args: s.args || [],
+      ...s.cwd ? { cwd: s.cwd } : {}
+    };
+  }
+  console.log(JSON.stringify({ mcpServers: exported }, null, 2));
+}
+async function mcpRegistry(args) {
+  const sub = args[0] || "list";
+  const rest = args.slice(1);
+  const jsonMode = args.includes("--json");
+  switch (sub) {
+    case "list":
+      printList(jsonMode);
+      return;
+    case "add":
+      addStdio(rest);
+      return;
+    case "add-url":
+      addUrl(rest);
+      return;
+    case "remove":
+      removeServer(rest);
+      return;
+    case "enable":
+      setEnabled(rest, true);
+      return;
+    case "disable":
+      setEnabled(rest, false);
+      return;
+    case "check":
+      await checkServer(rest);
+      return;
+    case "sync-claude":
+      syncClaudeSettings();
+      return;
+    case "export":
+      showExport();
+      return;
+    case "discover":
+      await discoverServer(rest, jsonMode);
+      return;
+    case "search":
+      searchMarketplace(rest, jsonMode);
+      return;
+    case "install":
+      await installFromMarketplace(rest);
+      return;
+    default:
+      console.log("Usage: rex mcp <list|add|add-url|remove|enable|disable|check|sync-claude|export|discover|search|install> ...");
+  }
+}
+export {
+  mcpRegistry
+};

package/dist/migrate-GDO37TI5.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import {
+  createLogger
+} from "./chunk-5ND7JYY3.js";
+import {
+  LEGACY_DB_PATH,
+  LEGACY_MEMORY_DIR,
+  MEMORY_DB_PATH,
+  MEMORY_DIR,
+  PENDING_DIR,
+  ensureRexDirs
+} from "./chunk-6SRV2I2H.js";
+import "./chunk-PDX44BCA.js";
+
+// src/migrate.ts
+import { existsSync, copyFileSync, mkdirSync, symlinkSync, renameSync, readdirSync, lstatSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+var log = createLogger("migrate");
+var COLORS = { green: "\x1B[32m", yellow: "\x1B[33m", dim: "\x1B[2m", reset: "\x1B[0m" };
+async function migrate() {
+  log.info("Migration started");
+  ensureRexDirs();
+  if (existsSync(LEGACY_DB_PATH) && !existsSync(MEMORY_DB_PATH)) {
+    console.log(`${COLORS.yellow}Migrating${COLORS.reset} rex.sqlite to ~/.claude/rex/memory/`);
+    copyFileSync(LEGACY_DB_PATH, MEMORY_DB_PATH);
+    for (const ext of ["-wal", "-shm"]) {
+      const src = LEGACY_DB_PATH + ext;
+      if (existsSync(src)) copyFileSync(src, MEMORY_DB_PATH + ext);
+    }
+    console.log(`${COLORS.green}Done${COLORS.reset} \u2014 DB migrated`);
+  } else if (existsSync(MEMORY_DB_PATH)) {
+    console.log(`${COLORS.dim}DB already at ~/.claude/rex/memory/ \u2014 skipping${COLORS.reset}`);
+  } else {
+    console.log(`${COLORS.dim}No legacy DB found \u2014 fresh install${COLORS.reset}`);
+  }
+  const legacyPending = join(LEGACY_MEMORY_DIR, "pending");
+  if (existsSync(legacyPending)) {
+    const files = readdirSync(legacyPending).filter((f) => f.endsWith(".json"));
+    for (const f of files) {
+      const src = join(legacyPending, f);
+      const dest = join(PENDING_DIR, f);
+      if (!existsSync(dest)) copyFileSync(src, dest);
+    }
+    if (files.length) console.log(`${COLORS.green}Migrated${COLORS.reset} ${files.length} pending files`);
+  }
+  if (existsSync(LEGACY_MEMORY_DIR)) {
+    try {
+      const stat = lstatSync(LEGACY_MEMORY_DIR);
+      if (!stat.isSymbolicLink()) {
+        renameSync(LEGACY_MEMORY_DIR, LEGACY_MEMORY_DIR + ".bak");
+        console.log(`${COLORS.dim}Renamed ~/.rex-memory/ to ~/.rex-memory.bak/${COLORS.reset}`);
+      }
+    } catch {
+    }
+  }
+  if (!existsSync(LEGACY_MEMORY_DIR)) {
+    mkdirSync(LEGACY_MEMORY_DIR, { recursive: true });
+    const legacyDbDir = join(LEGACY_MEMORY_DIR, "db");
+    if (!existsSync(legacyDbDir)) {
+      symlinkSync(MEMORY_DIR, legacyDbDir);
+      console.log(`${COLORS.green}Symlinked${COLORS.reset} ~/.rex-memory/db/ -> ~/.claude/rex/memory/`);
+    }
+  }
+  if (existsSync(MEMORY_DB_PATH)) {
+    try {
+      const colsRaw = execSync(`sqlite3 "${MEMORY_DB_PATH}" "PRAGMA table_info(memories)"`, { encoding: "utf-8" });
+      const colNames = colsRaw.split("\n").map((line) => line.split("|")[1]).filter(Boolean);
+      if (!colNames.includes("summary")) {
+        execSync(`sqlite3 "${MEMORY_DB_PATH}" "ALTER TABLE memories ADD COLUMN summary TEXT"`);
+        console.log(`${COLORS.green}Added${COLORS.reset} summary column`);
+      }
+      if (!colNames.includes("needs_reprocess")) {
+        execSync(`sqlite3 "${MEMORY_DB_PATH}" "ALTER TABLE memories ADD COLUMN needs_reprocess INTEGER DEFAULT 0"`);
+        console.log(`${COLORS.green}Added${COLORS.reset} needs_reprocess column`);
+      }
+    } catch (e) {
+      console.log(`${COLORS.yellow}Schema upgrade skipped${COLORS.reset} \u2014 sqlite3 CLI not available: ${e.message?.slice(0, 80)}`);
+    }
+  }
+  log.info("Migration complete");
+  console.log(`
+${COLORS.green}Migration complete.${COLORS.reset} REX hub at ~/.claude/rex/`);
+}
+export {
+  migrate
+};

package/dist/{optimize-UKMAGQQE.js → optimize-5TE5RKZV.js}

@@ -2,7 +2,8 @@
 import {
   detectModel,
   llm
-} from "./chunk-7AGI43F5.js";
+} from "./chunk-WBMVBMWB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/optimize.ts
 import { readFileSync, writeFileSync, existsSync, readdirSync } from "fs";

package/dist/paths-4SECM6E6.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  BACKUPS_DIR,
+  CONFIG_PATH,
+  DAEMON_LOG_PATH,
+  INSPIRATIONS_DIR,
+  LEGACY_DB_PATH,
+  LEGACY_MEMORY_DIR,
+  MEMORY_DB_PATH,
+  MEMORY_DIR,
+  PENDING_DIR,
+  PROJECTS_DIR,
+  REFERENCES_DIR,
+  REX_DIR,
+  SELF_IMPROVEMENT_DIR,
+  SUMMARIES_DIR,
+  VAULT_PATH,
+  ensureRexDirs
+} from "./chunk-6SRV2I2H.js";
+import "./chunk-PDX44BCA.js";
+export {
+  BACKUPS_DIR,
+  CONFIG_PATH,
+  DAEMON_LOG_PATH,
+  INSPIRATIONS_DIR,
+  LEGACY_DB_PATH,
+  LEGACY_MEMORY_DIR,
+  MEMORY_DB_PATH,
+  MEMORY_DIR,
+  PENDING_DIR,
+  PROJECTS_DIR,
+  REFERENCES_DIR,
+  REX_DIR,
+  SELF_IMPROVEMENT_DIR,
+  SUMMARIES_DIR,
+  VAULT_PATH,
+  ensureRexDirs
+};