rex-claude 4.0.0 → 6.0.0

package/dist/{init-DLFEGD6O.js → chunk-KR7ISYZH.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/init.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync, statSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, chmodSync, unlinkSync, readdirSync, statSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { execSync } from "child_process";
@@ -43,6 +43,8 @@ function ensureDir(dir) {
 var PLIST_LABEL = "com.dstudio.rex";
 var INGEST_PLIST_LABEL = "com.dstudio.rex-ingest";
 var GATEWAY_PLIST_LABEL = "com.dstudio.rex-gateway";
+var CALL_WATCH_PLIST_LABEL = "com.dstudio.rex-call-watch";
+var DAEMON_PLIST_LABEL = "com.dstudio.rex-daemon";
 function installIngestAgent() {
   if (process.platform !== "darwin") {
     info("Auto-ingest only supported on macOS");
@@ -193,6 +195,74 @@ function installGatewayAgent() {
   }
   ok("Gateway LaunchAgent installed \u2014 Telegram bot always-on (auto-restart)");
 }
+function installDaemonAgent() {
+  if (process.platform !== "darwin") {
+    info("Daemon LaunchAgent only supported on macOS");
+    return;
+  }
+  const launchAgentsDir = join(homedir(), "Library", "LaunchAgents");
+  ensureDir(launchAgentsDir);
+  const plistPath = join(launchAgentsDir, `${DAEMON_PLIST_LABEL}.plist`);
+  let rexBin = "";
+  try {
+    rexBin = execSync("which rex", { encoding: "utf-8" }).trim();
+  } catch {
+  }
+  if (!rexBin) {
+    info("rex binary not in PATH \u2014 skipping daemon LaunchAgent");
+    return;
+  }
+  if (existsSync(plistPath)) {
+    skip("Daemon LaunchAgent already installed (unified background daemon)");
+    return;
+  }
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  let botToken = "";
+  let chatIdVal = "";
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    botToken = settings.env?.REX_TELEGRAM_BOT_TOKEN || "";
+    chatIdVal = settings.env?.REX_TELEGRAM_CHAT_ID || "";
+  } catch {
+  }
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${DAEMON_PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${rexBin}</string>
+    <string>daemon</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(homedir(), ".claude", "rex", "daemon.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(homedir(), ".claude", "rex", "daemon.log")}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:${dirname(rexBin)}</string>
+    <key>REX_TELEGRAM_BOT_TOKEN</key>
+    <string>${botToken}</string>
+    <key>REX_TELEGRAM_CHAT_ID</key>
+    <string>${chatIdVal}</string>
+  </dict>
+</dict>
+</plist>
+`;
+  writeFileSync(plistPath, plist);
+  try {
+    execSync(`launchctl load ${plistPath}`, { stdio: "ignore" });
+  } catch {
+  }
+  ok("Daemon LaunchAgent installed \u2014 unified background daemon (KeepAlive)");
+}
 function uninstallGatewayAgent() {
   if (process.platform !== "darwin") return;
   const plistPath = join(homedir(), "Library", "LaunchAgents", `${GATEWAY_PLIST_LABEL}.plist`);
@@ -210,30 +280,173 @@ function uninstallGatewayAgent() {
   }
   ok("Gateway LaunchAgent removed");
 }
+function installHammerspoonCallWatcher() {
+  if (process.platform !== "darwin") {
+    info("Hammerspoon call watcher only supported on macOS");
+    return;
+  }
+  let hsBin = "";
+  try {
+    hsBin = execSync("which hs", { encoding: "utf-8" }).trim();
+  } catch {
+  }
+  if (!hsBin) {
+    info("Hammerspoon CLI (hs) not found \u2014 skipping call watcher install");
+    return;
+  }
+  const hsDir = join(homedir(), ".hammerspoon");
+  ensureDir(hsDir);
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const sourceWatcher = join(thisDir, "hammerspoon", "rex-call-watcher.lua");
+  const targetWatcher = join(hsDir, "rex-call-watcher.lua");
+  if (!existsSync(sourceWatcher)) {
+    info("Bundled call watcher not found in rex-cli package");
+    return;
+  }
+  try {
+    copyFileSync(sourceWatcher, targetWatcher);
+    chmodSync(targetWatcher, 420);
+    ok("Hammerspoon call watcher installed");
+  } catch {
+    info("Could not install Hammerspoon call watcher");
+    return;
+  }
+  const initLuaPath = join(hsDir, "init.lua");
+  const loaderBlock = `
+-- REX Call Watcher (installed by rex init)
+do
+  local ok_rex_call, rex_call = pcall(dofile, os.getenv("HOME") .. "/.hammerspoon/rex-call-watcher.lua")
+  if ok_rex_call and rex_call and rex_call.start then
+    rex_call.start()
+  end
+end
+`;
+  try {
+    const current = existsSync(initLuaPath) ? readFileSync(initLuaPath, "utf-8") : "";
+    if (current.includes("rex-call-watcher.lua")) {
+      skip("Hammerspoon init.lua already loads REX call watcher");
+    } else {
+      const next = current.endsWith("\n") || current.length === 0 ? current + loaderBlock : `${current}
+${loaderBlock}`;
+      writeFileSync(initLuaPath, next);
+      ok("Hammerspoon init.lua patched to start call watcher");
+    }
+  } catch {
+    info("Could not patch ~/.hammerspoon/init.lua automatically");
+  }
+  try {
+    execSync(`${hsBin} -c "hs.reload()"`, { stdio: "ignore" });
+    ok("Hammerspoon config reloaded");
+  } catch {
+    skip("Could not auto-reload Hammerspoon config (reload manually in Hammerspoon)");
+  }
+}
+function installCallWatchAgent() {
+  if (process.platform !== "darwin") {
+    info("Call watch LaunchAgent only supported on macOS");
+    return;
+  }
+  const watcherPath = join(homedir(), ".hammerspoon", "rex-call-watcher.lua");
+  if (!existsSync(watcherPath)) {
+    info("Hammerspoon call watcher not installed \u2014 skipping call watch LaunchAgent");
+    return;
+  }
+  const launchAgentsDir = join(homedir(), "Library", "LaunchAgents");
+  ensureDir(launchAgentsDir);
+  const plistPath = join(launchAgentsDir, `${CALL_WATCH_PLIST_LABEL}.plist`);
+  let rexBin = "";
+  try {
+    rexBin = execSync("which rex", { encoding: "utf-8" }).trim();
+  } catch {
+  }
+  if (!rexBin) {
+    info("rex binary not in PATH \u2014 skipping call watch LaunchAgent");
+    return;
+  }
+  if (existsSync(plistPath)) {
+    skip("Call watch LaunchAgent already installed (auto audio logger)");
+    return;
+  }
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${CALL_WATCH_PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${rexBin}</string>
+    <string>call</string>
+    <string>watch</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(homedir(), ".claude", "rex-call-watch.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(homedir(), ".claude", "rex-call-watch.log")}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:${dirname(rexBin)}</string>
+  </dict>
+</dict>
+</plist>
+`;
+  writeFileSync(plistPath, plist);
+  try {
+    execSync(`launchctl load ${plistPath}`, { stdio: "ignore" });
+  } catch {
+  }
+  ok("Call watch LaunchAgent installed \u2014 auto audio logger on call start/end");
+}
+function uninstallCallWatchAgent() {
+  if (process.platform !== "darwin") return;
+  const plistPath = join(homedir(), "Library", "LaunchAgents", `${CALL_WATCH_PLIST_LABEL}.plist`);
+  if (!existsSync(plistPath)) return;
+  try {
+    execSync(`launchctl unload ${plistPath}`, { stdio: "ignore" });
+  } catch {
+  }
+  try {
+    unlinkSync(plistPath);
+  } catch {
+  }
+  ok("Call watch LaunchAgent removed");
+}
 function installApp() {
   if (process.platform !== "darwin") return;
   const thisDir = new URL(".", import.meta.url).pathname;
-  const buildApp = join(thisDir, "..", "..", "flutter_app", "build", "macos", "Build", "Products", "Release", "rex_app.app");
-  const installedApp = "/Applications/REX.app";
+  const releaseBuild = join(thisDir, "..", "..", "flutter_app", "build", "macos", "Build", "Products", "Release", "rex_app.app");
+  const debugBuild = join(thisDir, "..", "..", "flutter_app", "build", "macos", "Build", "Products", "Debug", "rex_app.app");
+  const buildApp = existsSync(releaseBuild) ? releaseBuild : debugBuild;
+  const installedApp = "/Applications/rex_app.app";
+  const legacyApp = "/Applications/REX.app";
   if (existsSync(installedApp)) {
-    skip("REX.app already in /Applications");
+    skip("rex_app.app already in /Applications");
   } else if (existsSync(buildApp)) {
     try {
-      execSync(`cp -R "${buildApp}" "${installedApp}"`, { stdio: "ignore" });
-      ok("REX.app installed to /Applications");
+      execSync(`ditto "${buildApp}" "${installedApp}"`, { stdio: "ignore" });
+      ok("rex_app.app installed to /Applications");
+      try {
+        execSync(`ln -sfn "${installedApp}" "${legacyApp}"`, { stdio: "ignore" });
+      } catch {
+      }
     } catch {
-      info("Could not copy REX.app to /Applications (try manually)");
+      info("Could not copy rex_app.app to /Applications (try manually)");
       return;
     }
   } else {
-    info("REX.app not built \u2014 run `pnpm tauri build` in packages/app first");
+    info("App not built \u2014 run `rex app update` (or `flutter build macos --debug`) in packages/flutter_app first");
     return;
   }
   try {
     execSync(`osascript -e 'tell application "System Events" to make login item at end with properties {path:"${installedApp}", hidden:false}'`, { stdio: "ignore" });
-    ok("REX.app added to Login Items (auto-start on login)");
+    ok("rex_app.app added to Login Items (auto-start on login)");
   } catch {
-    skip("REX.app already in Login Items");
+    skip("rex_app.app already in Login Items");
   }
 }
 function installStartup() {
@@ -310,6 +523,7 @@ function uninstallStartup() {
   }
   uninstallIngestAgent();
   uninstallGatewayAgent();
+  uninstallCallWatchAgent();
 }
 async function init() {
   const claudeDir = join(homedir(), ".claude");
@@ -351,6 +565,30 @@ ${line}`);
   } else {
     info("Memory package not found \u2014 install @rex/memory or run from monorepo");
   }
+  const registryPath = join(homedir(), ".rex-memory", "mcp-registry.json");
+  if (existsSync(registryPath)) {
+    try {
+      const registry = readJson(registryPath);
+      const registryServers = registry?.servers;
+      if (registryServers && typeof registryServers === "object") {
+        let added = 0;
+        for (const [name, cfg] of Object.entries(registryServers)) {
+          if (!settings.mcpServers[name]) {
+            settings.mcpServers[name] = cfg;
+            added++;
+          }
+        }
+        if (added > 0) {
+          writeJson(settingsPath, settings);
+          ok(`MCP registry synced (${added} server${added > 1 ? "s" : ""} added)`);
+        } else {
+          skip("MCP registry already synced");
+        }
+      }
+    } catch {
+      info("MCP registry exists but could not be parsed");
+    }
+  }
   if (!settings.hooks) settings.hooks = {};
   const hasIngestHook = settings.hooks.SessionEnd?.some?.(
     (h) => h.hooks?.some?.((hh) => hh.command?.includes("rex") && hh.command?.includes("ingest"))
@@ -371,12 +609,8 @@ ${line}`);
   const hasContextHook = settings.hooks.SessionStart?.some?.(
     (h) => h.hooks?.some?.((hh) => hh.command?.includes("rex-context"))
   );
-  if (hasContextHook) {
-    skip("Context injection hook (SessionStart) already configured");
-  } else {
-    const contextScript = join(claudeDir, "rex-context.sh");
-    if (!existsSync(contextScript)) {
-      writeFileSync(contextScript, `#!/bin/bash
+  const contextScript = join(claudeDir, "rex-context.sh");
+  writeFileSync(contextScript, `#!/bin/bash
 # REX Context Injection \u2014 runs at session start
 # Outputs relevant memory context to CLAUDE_ENV_FILE
 
@@ -384,20 +618,31 @@ if [ -z "$CLAUDE_ENV_FILE" ]; then
   exit 0
 fi
 
+PROJECT_PATH="\${CLAUDE_PROJECT_DIR:-$PWD}"
+
 # Quick check if rex-memory MCP is available
 if command -v npx &>/dev/null; then
   # Context will be loaded via MCP rex_context tool
   # This hook just ensures the env is ready
   echo "REX_MEMORY_AVAILABLE=true" >> "$CLAUDE_ENV_FILE"
 fi
+
+# Auto tool/skill recommendations (LLM-assisted)
+if command -v rex &>/dev/null; then
+  rex agents recommend "$PROJECT_PATH" --quiet --env-file "$CLAUDE_ENV_FILE" >/dev/null 2>&1 || true
+elif command -v npx &>/dev/null; then
+  npx rex-cli agents recommend "$PROJECT_PATH" --quiet --env-file "$CLAUDE_ENV_FILE" >/dev/null 2>&1 || true
+fi
 `, { mode: 493 });
-    }
+  if (hasContextHook) {
+    skip("Context injection hook (SessionStart) already configured");
+  } else {
     if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
     settings.hooks.SessionStart.push({
       hooks: [{
         type: "command",
         command: `bash ${contextScript}`,
-        timeout: 5
+        timeout: 20
       }]
     });
     ok("Context injection hook configured (SessionStart)");
@@ -491,6 +736,9 @@ fi
   installStartup();
   installIngestAgent();
   installGatewayAgent();
+  installDaemonAgent();
+  installHammerspoonCallWatcher();
+  installCallWatchAgent();
   installApp();
   let ollamaOk = false;
   try {
@@ -551,12 +799,58 @@ fi
   }
   const memoryMonorepoDir = join(thisDir, "..", "..", "memory");
   const memoryTargetDir = join(homedir(), ".rex-memory");
-  if (existsSync(join(memoryMonorepoDir, "package.json")) && !existsSync(join(memoryTargetDir, "package.json"))) {
-    try {
-      execSync(`cp -R "${memoryMonorepoDir}" "${memoryTargetDir}"`, { stdio: "ignore" });
+  ensureDir(memoryTargetDir);
+  const runtimePkgPath = join(memoryTargetDir, "package.json");
+  const runtimePkg = {
+    name: "rex-memory-runtime",
+    private: true,
+    type: "module",
+    dependencies: {
+      "better-sqlite3": "^11.8.1",
+      "sqlite-vec": "^0.1.6"
+    }
+  };
+  try {
+    let shouldInstall = false;
+    if (!existsSync(runtimePkgPath)) {
+      writeJson(runtimePkgPath, runtimePkg);
+      shouldInstall = true;
+    } else {
+      const existing = readJson(runtimePkgPath) || {};
+      const deps = existing.dependencies || {};
+      if (!deps["better-sqlite3"] || !deps["sqlite-vec"]) {
+        writeJson(runtimePkgPath, {
+          ...existing,
+          private: true,
+          type: existing.type || "module",
+          dependencies: {
+            ...deps,
+            "better-sqlite3": deps["better-sqlite3"] || "^11.8.1",
+            "sqlite-vec": deps["sqlite-vec"] || "^0.1.6"
+          }
+        });
+        shouldInstall = true;
+      }
+    }
+    if (!existsSync(join(memoryTargetDir, "node_modules", "better-sqlite3"))) {
+      shouldInstall = true;
+    }
+    if (shouldInstall) {
       execSync("npm install --production 2>/dev/null", { cwd: memoryTargetDir, stdio: "ignore" });
-      ok("@rex/memory synced to ~/.rex-memory/");
-    } catch {
+      ok("Memory runtime dependencies installed in ~/.rex-memory/");
+    } else {
+      skip("Memory runtime dependencies already present");
+    }
+  } catch {
+    if (existsSync(join(memoryMonorepoDir, "package.json")) && !existsSync(join(memoryTargetDir, "src"))) {
+      try {
+        execSync(`cp -R "${memoryMonorepoDir}/." "${memoryTargetDir}/"`, { stdio: "ignore" });
+        execSync("npm install --production 2>/dev/null", { cwd: memoryTargetDir, stdio: "ignore" });
+        ok("@rex/memory synced to ~/.rex-memory/");
+      } catch {
+        info("Could not sync @rex/memory \u2014 install manually");
+      }
+    } else {
       info("Could not sync @rex/memory \u2014 install manually");
     }
   }
@@ -577,13 +871,18 @@ ${COLORS.bold}  REX initialized!${COLORS.reset}`);
   console.log(`    \u2022  Run ${COLORS.cyan}rex doctor${COLORS.reset} to verify setup`);
   console.log();
 }
+
 export {
-  init,
-  installApp,
-  installGatewayAgent,
   installIngestAgent,
-  installStartup,
-  uninstallGatewayAgent,
   uninstallIngestAgent,
-  uninstallStartup
+  installGatewayAgent,
+  installDaemonAgent,
+  uninstallGatewayAgent,
+  installHammerspoonCallWatcher,
+  installCallWatchAgent,
+  uninstallCallWatchAgent,
+  installApp,
+  installStartup,
+  uninstallStartup,
+  init
 };

package/dist/chunk-LTOM55UV.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import {
+  loadConfig
+} from "./chunk-PPGYFMU5.js";
+import {
+  createLogger
+} from "./chunk-5ND7JYY3.js";
+import {
+  PROJECTS_DIR,
+  ensureRexDirs
+} from "./chunk-6SRV2I2H.js";
+
+// src/projects.ts
+import { readdirSync, readFileSync, existsSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+var log = createLogger("projects");
+function detectStack(projectPath) {
+  const stack = [];
+  const pkgPath = join(projectPath, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps["next"]) stack.push("next.js");
+      else if (allDeps["react"]) stack.push("react");
+      if (allDeps["vue"]) stack.push("vue");
+      if (allDeps["@angular/core"]) stack.push("angular");
+      if (allDeps["@ionic/angular"] || allDeps["@ionic/react"]) stack.push("ionic");
+      if (allDeps["typescript"]) stack.push("typescript");
+      if (allDeps["tailwindcss"]) stack.push("tailwind");
+      if (allDeps["drizzle-orm"]) stack.push("drizzle");
+      if (allDeps["hono"]) stack.push("hono");
+      if (allDeps["wrangler"] || allDeps["@cloudflare/workers-types"]) stack.push("cloudflare-workers");
+      if (allDeps["better-sqlite3"] || allDeps["sqlite3"]) stack.push("sqlite");
+      if (allDeps["express"]) stack.push("express");
+      if (stack.length === 0) stack.push("node");
+    } catch {
+    }
+  }
+  if (existsSync(join(projectPath, "pubspec.yaml"))) {
+    stack.push("flutter");
+    try {
+      const pubspec = readFileSync(join(projectPath, "pubspec.yaml"), "utf-8");
+      if (pubspec.includes("macos_ui")) stack.push("macos");
+    } catch {
+    }
+  }
+  if (existsSync(join(projectPath, "composer.json"))) {
+    stack.push("php");
+    try {
+      const composer = JSON.parse(readFileSync(join(projectPath, "composer.json"), "utf-8"));
+      if (composer.require?.["cakephp/cakephp"]) stack.push("cakephp");
+      if (composer.require?.["laravel/framework"]) stack.push("laravel");
+    } catch {
+    }
+  }
+  if (existsSync(join(projectPath, "Cargo.toml"))) stack.push("rust");
+  if (existsSync(join(projectPath, "go.mod"))) stack.push("go");
+  return stack;
+}
+function getLastModified(projectPath) {
+  try {
+    const date = execSync("git log -1 --format=%ci 2>/dev/null", { cwd: projectPath, encoding: "utf-8" }).trim();
+    if (date) return date.split(" ")[0];
+  } catch {
+  }
+  try {
+    return statSync(projectPath).mtime.toISOString().split("T")[0];
+  } catch {
+    return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  }
+}
+function getGitRemote(projectPath) {
+  try {
+    return execSync("git remote get-url origin 2>/dev/null", { cwd: projectPath, encoding: "utf-8" }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+var MANIFEST_FILES = ["package.json", "pubspec.yaml", "composer.json", "Cargo.toml", "go.mod"];
+function scanProjects() {
+  const config = loadConfig();
+  const HOME = process.env.HOME || "~";
+  const projects = [];
+  for (const scanPath of config.ingest.scanPaths) {
+    const resolved = scanPath.replace("~", HOME);
+    if (!existsSync(resolved)) continue;
+    const entries = readdirSync(resolved, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      if (config.ingest.excludePaths.includes(entry.name)) continue;
+      const fullPath = join(resolved, entry.name);
+      const hasManifest = MANIFEST_FILES.some((f) => existsSync(join(fullPath, f)));
+      if (hasManifest) {
+        const status = entry.name.startsWith("_") ? entry.name === "_templates" ? "template" : "archived" : "active";
+        projects.push({
+          name: entry.name,
+          path: fullPath,
+          stack: detectStack(fullPath),
+          lastActive: getLastModified(fullPath),
+          status,
+          repo: getGitRemote(fullPath)
+        });
+      } else {
+        try {
+          const subEntries = readdirSync(fullPath, { withFileTypes: true });
+          for (const sub of subEntries) {
+            if (!sub.isDirectory() || sub.name.startsWith(".")) continue;
+            if (config.ingest.excludePaths.includes(sub.name)) continue;
+            const subPath = join(fullPath, sub.name);
+            if (MANIFEST_FILES.some((f) => existsSync(join(subPath, f)))) {
+              projects.push({
+                name: sub.name,
+                path: subPath,
+                stack: detectStack(subPath),
+                lastActive: getLastModified(subPath),
+                status: "active",
+                repo: getGitRemote(subPath)
+              });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  log.info(`Scanned ${projects.length} projects across ${config.ingest.scanPaths.length} paths`);
+  return projects.sort((a, b) => b.lastActive.localeCompare(a.lastActive));
+}
+function saveProjectIndex(projects) {
+  ensureRexDirs();
+  writeFileSync(join(PROJECTS_DIR, "index.json"), JSON.stringify(projects, null, 2));
+}
+function loadProjectIndex() {
+  const indexPath = join(PROJECTS_DIR, "index.json");
+  if (!existsSync(indexPath)) return [];
+  try {
+    return JSON.parse(readFileSync(indexPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function findProject(cwd) {
+  const projects = loadProjectIndex();
+  return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
+}
+
+export {
+  scanProjects,
+  saveProjectIndex,
+  loadProjectIndex,
+  findProject
+};

package/dist/chunk-PDX44BCA.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-PPGYFMU5.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import {
+  CONFIG_PATH
+} from "./chunk-6SRV2I2H.js";
+
+// src/config.ts
+import { readFileSync, writeFileSync, copyFileSync, existsSync } from "fs";
+var DEFAULTS = {
+  llm: {
+    embedModel: "nomic-embed-text",
+    classifyModel: "auto",
+    routing: "ollama-first",
+    claudeFallback: "haiku"
+  },
+  ingest: {
+    scanPaths: ["~/Documents/Developer/"],
+    excludePaths: ["node_modules", ".git", "_archive", "dist", "build"],
+    autoIngestInterval: 1800
+  },
+  selfImprovement: {
+    enabled: true,
+    ruleThreshold: 3,
+    reviewInterval: 86400
+  },
+  daemon: {
+    healthCheckInterval: 300,
+    ingestInterval: 1800,
+    maintenanceInterval: 3600,
+    selfReviewInterval: 86400
+  },
+  notifications: {
+    silent: ["ollama-restart", "pending-flush", "categorize-batch"],
+    warn: ["db-corrupt", "disk-low", "config-corrupt"],
+    daily: true,
+    weekly: true
+  }
+};
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return DEFAULTS;
+  try {
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    return {
+      ...DEFAULTS,
+      ...raw,
+      llm: { ...DEFAULTS.llm, ...raw.llm },
+      ingest: { ...DEFAULTS.ingest, ...raw.ingest },
+      selfImprovement: { ...DEFAULTS.selfImprovement, ...raw.selfImprovement },
+      daemon: { ...DEFAULTS.daemon, ...raw.daemon },
+      notifications: { ...DEFAULTS.notifications, ...raw.notifications }
+    };
+  } catch {
+    const bakPath = CONFIG_PATH + ".bak";
+    if (existsSync(bakPath)) {
+      try {
+        const bak = JSON.parse(readFileSync(bakPath, "utf-8"));
+        writeFileSync(CONFIG_PATH, JSON.stringify(bak, null, 2));
+        return { ...DEFAULTS, ...bak };
+      } catch {
+      }
+    }
+    return DEFAULTS;
+  }
+}
+
+export {
+  loadConfig
+};