rex-claude 4.0.0 → 6.0.0

package/dist/chunk-6SRV2I2H.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+// src/paths.ts
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+var HOME = process.env.HOME || "~";
+var REX_DIR = join(HOME, ".claude", "rex");
+var MEMORY_DIR = join(REX_DIR, "memory");
+var MEMORY_DB_PATH = join(MEMORY_DIR, "rex.sqlite");
+var PENDING_DIR = join(MEMORY_DIR, "pending");
+var BACKUPS_DIR = join(MEMORY_DIR, "backups");
+var PROJECTS_DIR = join(REX_DIR, "projects");
+var SUMMARIES_DIR = join(PROJECTS_DIR, "summaries");
+var SELF_IMPROVEMENT_DIR = join(REX_DIR, "self-improvement");
+var CONFIG_PATH = join(REX_DIR, "config.json");
+var VAULT_PATH = join(REX_DIR, "vault.md");
+var DAEMON_LOG_PATH = join(REX_DIR, "daemon.log");
+var REFERENCES_DIR = join(REX_DIR, "references");
+var INSPIRATIONS_DIR = join(REX_DIR, "inspirations");
+var LEGACY_MEMORY_DIR = join(HOME, ".rex-memory");
+var LEGACY_DB_PATH = join(LEGACY_MEMORY_DIR, "db", "rex.sqlite");
+function ensureRexDirs() {
+  const dirs = [
+    REX_DIR,
+    MEMORY_DIR,
+    PENDING_DIR,
+    BACKUPS_DIR,
+    PROJECTS_DIR,
+    SUMMARIES_DIR,
+    SELF_IMPROVEMENT_DIR,
+    REFERENCES_DIR,
+    INSPIRATIONS_DIR
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+export {
+  REX_DIR,
+  MEMORY_DIR,
+  MEMORY_DB_PATH,
+  PENDING_DIR,
+  BACKUPS_DIR,
+  PROJECTS_DIR,
+  SUMMARIES_DIR,
+  SELF_IMPROVEMENT_DIR,
+  CONFIG_PATH,
+  VAULT_PATH,
+  DAEMON_LOG_PATH,
+  REFERENCES_DIR,
+  INSPIRATIONS_DIR,
+  LEGACY_MEMORY_DIR,
+  LEGACY_DB_PATH,
+  ensureRexDirs
+};

package/dist/{setup-AO3MW46W.js → chunk-A7ZLQUOX.js}

@@ -3,7 +3,7 @@
 // src/setup.ts
 import { execSync } from "child_process";
 import { platform, totalmem, homedir } from "os";
-import { readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { createInterface } from "readline";
 var COLORS = {
@@ -25,14 +25,30 @@ function fail(msg) {
   console.log(`  ${COLORS.red}\u2717${COLORS.reset} ${msg}`);
 }
 var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
-async function isOllamaInstalled() {
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasBrew() {
+  return commandExists("brew");
+}
+function tryBrewInstall(formula, isCask = false) {
+  if (!hasBrew()) return false;
   try {
-    execSync("which ollama", { stdio: "ignore" });
+    const cmd = isCask ? `brew install --cask ${formula}` : `brew install ${formula}`;
+    execSync(cmd, { stdio: "inherit" });
     return true;
   } catch {
     return false;
   }
 }
+async function isOllamaInstalled() {
+  return commandExists("ollama");
+}
 async function isOllamaRunning() {
   try {
     const res = await fetch(`${OLLAMA_URL}/api/tags`);
@@ -92,10 +108,44 @@ function prompt(question) {
     });
   });
 }
-async function setupTelegram() {
+async function ensurePlatformDeps(os, autoInstallDeps) {
+  console.log(`
+  ${COLORS.bold}System Dependencies${COLORS.reset}`);
+  const deps = [
+    { cmd: "ffmpeg", formula: "ffmpeg", label: "ffmpeg (audio logger)" },
+    { cmd: "whisper-cli", formula: "whisper-cpp", label: "whisper-cli (transcription)" },
+    { cmd: "hs", formula: "hammerspoon", cask: true, label: "Hammerspoon CLI (call watcher)" }
+  ];
+  for (const dep of deps) {
+    if (commandExists(dep.cmd)) {
+      ok(`${dep.label} available`);
+      continue;
+    }
+    if (!autoInstallDeps) {
+      info(`${dep.label} missing`);
+      continue;
+    }
+    if (os !== "darwin") {
+      info(`${dep.label} missing (auto-install currently targets macOS)`);
+      continue;
+    }
+    if (!hasBrew()) {
+      info(`${dep.label} missing and Homebrew not found`);
+      continue;
+    }
+    info(`Installing ${dep.label}...`);
+    const installed = tryBrewInstall(dep.formula, dep.cask === true);
+    if (installed && commandExists(dep.cmd)) ok(`${dep.label} installed`);
+    else fail(`Could not install ${dep.label}`);
+  }
+}
+async function setupTelegram(options = {}) {
   console.log(`
   ${COLORS.bold}Telegram Gateway${COLORS.reset}`);
-  const settingsPath = join(homedir(), ".claude", "settings.json");
+  const nonInteractive = options.nonInteractive === true;
+  const settingsDir = join(homedir(), ".claude");
+  const settingsPath = join(settingsDir, "settings.json");
+  if (!existsSync(settingsDir)) mkdirSync(settingsDir, { recursive: true });
   let settings = {};
   try {
     settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
@@ -119,6 +169,23 @@ async function setupTelegram() {
     }
     info("Existing Telegram config found but not working \u2014 reconfiguring");
   }
+  if (options.skipTelegram) {
+    info("Skipping Telegram setup (flag enabled)");
+    return;
+  }
+  if (nonInteractive) {
+    const envToken = process.env.REX_TELEGRAM_BOT_TOKEN;
+    const envChat = process.env.REX_TELEGRAM_CHAT_ID;
+    if (envToken && envChat) {
+      settings.env.REX_TELEGRAM_BOT_TOKEN = envToken;
+      settings.env.REX_TELEGRAM_CHAT_ID = envChat;
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      ok("Telegram credentials loaded from environment");
+      return;
+    }
+    info("Telegram not configured (set REX_TELEGRAM_BOT_TOKEN + REX_TELEGRAM_CHAT_ID to enable)");
+    return;
+  }
   const botToken = await prompt("Telegram Bot Token (from @BotFather):");
   if (!botToken) {
     info("Skipped Telegram setup");
@@ -172,7 +239,9 @@ async function setupTelegram() {
     fail("Could not send test message");
   }
 }
-async function setup() {
+async function setup(options = {}) {
+  const nonInteractive = options.nonInteractive === true;
+  const autoInstallDeps = options.autoInstallDeps ?? nonInteractive;
   const line = "\u2550".repeat(45);
   console.log(`
 ${line}`);
@@ -182,24 +251,31 @@ ${line}`);
   const ramGB = Math.round(totalmem() / 1024 ** 3);
   const os = platform();
   info(`System: ${os}, ${ramGB}GB RAM`);
+  await ensurePlatformDeps(os, autoInstallDeps);
   if (!await isOllamaInstalled()) {
-    fail("Ollama not installed");
-    console.log(`
+    if (autoInstallDeps && os === "darwin" && hasBrew()) {
+      info("Installing Ollama via Homebrew...");
+      tryBrewInstall("ollama");
+    }
+    if (!await isOllamaInstalled()) {
+      fail("Ollama not installed");
+      console.log(`
   Install: ${COLORS.cyan}https://ollama.com/download${COLORS.reset}`);
-    if (os === "darwin") {
-      info("Opening download page...");
-      try {
-        execSync("open https://ollama.com/download", { stdio: "ignore" });
-      } catch {
+      if (os === "darwin" && !nonInteractive) {
+        info("Opening download page...");
+        try {
+          execSync("open https://ollama.com/download", { stdio: "ignore" });
+        } catch {
+        }
       }
+      return;
     }
-    return;
   }
   ok("Ollama installed");
   if (!await isOllamaRunning()) {
     info("Starting Ollama...");
     try {
-      execSync("ollama serve &", { stdio: "ignore" });
+      execSync("nohup ollama serve > ~/.claude/rex-ollama.log 2>&1 &", { stdio: "ignore" });
       await new Promise((r) => setTimeout(r, 3e3));
       if (await isOllamaRunning()) {
         ok("Ollama started");
@@ -235,7 +311,7 @@ ${line}`);
   else fail("Embedding test failed");
   if (genOk) ok("Generation test passed");
   else fail("Generation test failed");
-  await setupTelegram();
+  await setupTelegram(options);
   console.log(`
 ${COLORS.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${COLORS.reset}`);
   if (embedOk && genOk) {
@@ -247,6 +323,7 @@ ${COLORS.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\
   }
   console.log();
 }
+
 export {
   setup
 };

package/dist/chunk-E5UYN3W7.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+// src/router.ts
+var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
+var TASK_PREFERENCES = {
+  background: ["qwen2.5:1.5b", "qwen3.5:latest", "qwen3.5:9b"],
+  consolidate: ["qwen2.5:1.5b", "qwen3.5:latest", "qwen3.5:9b"],
+  categorize: ["qwen3.5:9b", "qwen3.5:latest", "qwen2.5:1.5b", "deepseek-r1:8b"],
+  gateway: ["qwen3.5:9b", "qwen3.5:latest", "deepseek-r1:8b", "qwen2.5:1.5b"],
+  optimize: ["qwen3.5:9b", "qwen3.5:latest", "deepseek-r1:8b"],
+  reason: ["deepseek-r1:8b", "qwen3.5:9b", "qwen3.5:latest"],
+  code: ["qwen3-coder:30b", "qwen2.5-coder:32b-instruct-q4_K_M", "qwen3.5:9b"]
+};
+var _cachedModels = null;
+var _cacheTime = 0;
+var CACHE_TTL = 6e4;
+async function getAvailableModels() {
+  const now = Date.now();
+  if (_cachedModels && now - _cacheTime < CACHE_TTL) return _cachedModels;
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/tags`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    const data = await res.json();
+    _cachedModels = data.models.map((m) => m.name);
+    _cacheTime = now;
+    return _cachedModels;
+  } catch {
+    return [];
+  }
+}
+async function pickModel(task) {
+  if (process.env.REX_LLM_MODEL) return process.env.REX_LLM_MODEL;
+  const available = await getAvailableModels();
+  const prefs = TASK_PREFERENCES[task];
+  for (const pref of prefs) {
+    if (available.includes(pref)) return pref;
+    const base = pref.split(":")[0];
+    const match = available.find((a) => (a === base || a.startsWith(base + ":")) && !a.includes("embed"));
+    if (match) return match;
+  }
+  const fallback = available.find((a) => !a.includes("embed") && !a.includes("nomic"));
+  return fallback ?? "qwen3.5:latest";
+}
+async function showModelRouter() {
+  const available = await getAvailableModels();
+  const embed = available.filter((m) => m.includes("embed") || m.includes("nomic"));
+  const gen = available.filter((m) => !m.includes("embed") && !m.includes("nomic"));
+  const line = "\u2500".repeat(52);
+  const tasks = ["background", "categorize", "consolidate", "gateway", "optimize", "reason", "code"];
+  console.log(`
+\x1B[1mREX Model Router\x1B[0m`);
+  console.log(line);
+  console.log(`\x1B[2mInstalled: ${gen.length} generation, ${embed.length} embedding\x1B[0m
+`);
+  for (const task of tasks) {
+    const chosen = await pickModel(task);
+    const prefs = TASK_PREFERENCES[task];
+    const isOptimal = prefs[0] === chosen || available.includes(prefs[0]);
+    const dot = isOptimal ? "\x1B[32m\u25CF\x1B[0m" : "\x1B[33m\u25CF\x1B[0m";
+    console.log(`  ${dot}  \x1B[1m${task.padEnd(12)}\x1B[0m \u2192 ${chosen}`);
+  }
+  console.log(`
+  \x1B[2membeddings  \u2192 ${embed[0] ?? "nomic-embed-text (not found)"}\x1B[0m`);
+  console.log(line);
+  if (gen.length === 0) {
+    console.log(`
+  \x1B[33m!\x1B[0m No Ollama models found \u2014 run: ollama pull qwen3.5:latest`);
+  } else {
+    const missingOptimal = tasks.filter((t) => {
+      const pref = TASK_PREFERENCES[t][0];
+      const base = pref.split(":")[0];
+      return !available.some((a) => a.startsWith(base));
+    });
+    if (missingOptimal.length > 0) {
+      console.log(`
+  \x1B[33m!\x1B[0m Optimal models missing for: ${missingOptimal.join(", ")}`);
+      console.log(`  \x1B[2mRecommended to pull:\x1B[0m`);
+      const toRecommend = /* @__PURE__ */ new Set();
+      for (const t of missingOptimal) {
+        const pref = TASK_PREFERENCES[t][0];
+        const base = pref.split(":")[0];
+        if (!available.some((a) => a.startsWith(base))) toRecommend.add(pref);
+      }
+      for (const m of toRecommend) {
+        console.log(`    ollama pull ${m}`);
+      }
+    }
+  }
+  console.log();
+}
+async function getRouterSnapshot() {
+  const tasks = ["background", "categorize", "consolidate", "gateway", "optimize", "reason", "code"];
+  const snap = {};
+  for (const t of tasks) {
+    snap[t] = await pickModel(t);
+  }
+  return snap;
+}
+
+export {
+  pickModel,
+  showModelRouter,
+  getRouterSnapshot
+};

package/dist/chunk-HAHJD3QH.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+// src/audit.ts
+import { spawnSync } from "child_process";
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m"
+};
+function runSelf(args, timeout = 3e4) {
+  const script = process.argv[1];
+  return spawnSync(process.execPath, [script, ...args], {
+    encoding: "utf-8",
+    timeout
+  });
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function add(checks, name, status, message) {
+  checks.push({ name, status, message });
+}
+function printChecks(checks) {
+  console.log(`
+${COLORS.bold}REX AUDIT${COLORS.reset}`);
+  for (const c of checks) {
+    const icon = c.status === "pass" ? `${COLORS.green}\u2713${COLORS.reset}` : c.status === "warn" ? `${COLORS.yellow}!${COLORS.reset}` : `${COLORS.red}\u2717${COLORS.reset}`;
+    console.log(`  ${icon} ${c.name} ${COLORS.dim}\u2014 ${c.message}${COLORS.reset}`);
+  }
+  const pass = checks.filter((c) => c.status === "pass").length;
+  const warn = checks.filter((c) => c.status === "warn").length;
+  const fail = checks.filter((c) => c.status === "fail").length;
+  console.log(`
+  Summary: ${pass} pass, ${warn} warn, ${fail} fail`);
+}
+async function audit(options = {}) {
+  const checks = [];
+  {
+    const res = runSelf(["--version"]);
+    if (res.status === 0 && (res.stdout || "").includes("rex-claude")) {
+      add(checks, "CLI version", "pass", (res.stdout || "").trim());
+    } else {
+      add(checks, "CLI version", "fail", (res.stderr || res.stdout || "version command failed").trim());
+    }
+  }
+  {
+    const res = runSelf(["doctor"], 6e4);
+    const out = `${res.stdout || ""}${res.stderr || ""}`;
+    if ((res.status === 0 || res.status === 1) && out.includes("REX DOCTOR")) {
+      add(checks, "Doctor command", "pass", "doctor output rendered");
+    } else {
+      add(checks, "Doctor command", "fail", (out || "doctor command failed").trim().slice(0, 200));
+    }
+  }
+  {
+    const res = runSelf(["status"]);
+    const out = (res.stdout || "").trim();
+    if (res.status === 0 && out.startsWith("REX")) {
+      add(checks, "Status command", "pass", out);
+    } else {
+      add(checks, "Status command", "fail", (res.stderr || out || "status command failed").slice(0, 200));
+    }
+  }
+  {
+    const res = runSelf(["call", "status", "--json"]);
+    const parsed = parseJson((res.stdout || "").trim());
+    if (res.status === 0 && parsed && typeof parsed.active === "boolean") {
+      add(checks, "Call watcher status", "pass", `active=${String(parsed.active)}`);
+    } else {
+      add(checks, "Call watcher status", "warn", "call state file not ready or watcher not running yet");
+    }
+  }
+  {
+    const res = runSelf(["audio", "status", "--json"]);
+    const parsed = parseJson((res.stdout || "").trim());
+    if (res.status === 0 && parsed && typeof parsed.capturing === "boolean") {
+      add(checks, "Audio logger status", "pass", `capturing=${String(parsed.capturing)}, recordings=${String(parsed.recordingsCount ?? 0)}`);
+    } else {
+      add(checks, "Audio logger status", "fail", (res.stderr || res.stdout || "audio status failed").trim().slice(0, 200));
+    }
+  }
+  {
+    const res = runSelf(["voice", "status", "--json"]);
+    const parsed = parseJson((res.stdout || "").trim());
+    if (res.status === 0 && parsed && typeof parsed.optimizeEnabled === "boolean") {
+      const whisper = parsed.whisperCliAvailable === true ? "ready" : "missing";
+      add(checks, "Voice pipeline status", parsed.whisperCliAvailable ? "pass" : "warn", `whisper=${whisper}, optimize=${String(parsed.optimizeEnabled)}`);
+    } else {
+      add(checks, "Voice pipeline status", "fail", (res.stderr || res.stdout || "voice status failed").trim().slice(0, 200));
+    }
+  }
+  {
+    const res = runSelf(["prune", "--stats"]);
+    if (res.status === 0) {
+      add(checks, "Memory stats", "pass", "prune --stats ok");
+    } else {
+      add(checks, "Memory stats", "warn", (res.stderr || res.stdout || "memory stats failed").trim().slice(0, 200));
+    }
+  }
+  {
+    const res = runSelf(["context"]);
+    if (res.status === 0) {
+      add(checks, "Context analysis", "pass", "context command ok");
+    } else {
+      add(checks, "Context analysis", "warn", (res.stderr || res.stdout || "context command failed").trim().slice(0, 200));
+    }
+  }
+  {
+    const res = runSelf(["agents", "profiles", "--json"]);
+    const parsed = parseJson((res.stdout || "").trim());
+    if (res.status === 0 && parsed && Array.isArray(parsed.profiles) && parsed.profiles.length > 0) {
+      add(checks, "Agents profiles", "pass", `${parsed.profiles.length} profiles available`);
+    } else {
+      add(checks, "Agents profiles", "fail", (res.stderr || res.stdout || "agents profiles failed").trim().slice(0, 200));
+    }
+  }
+  {
+    const res = runSelf(["mcp", "list", "--json"]);
+    const parsed = parseJson((res.stdout || "").trim());
+    if (res.status === 0 && parsed && Array.isArray(parsed.servers)) {
+      add(checks, "MCP registry", "pass", `servers=${parsed.servers.length}`);
+    } else {
+      add(checks, "MCP registry", "fail", (res.stderr || res.stdout || "mcp list failed").trim().slice(0, 200));
+    }
+  }
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  if (options.json) {
+    console.log(JSON.stringify({ checks, failCount, warnCount }, null, 2));
+  } else {
+    printChecks(checks);
+  }
+  if (failCount > 0 || options.strict && warnCount > 0) {
+    process.exitCode = 1;
+  }
+}
+
+export {
+  audit
+};