rex-claude 1.1.7 → 2.0.0

package/dist/guards/completion-guard.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# REX Guard: Completion Verification
+# Hook: Stop — runs when Claude considers stopping
+# Prevents the "70-80% problem" — Claude declaring done with incomplete work
+
+# Check for TODO/placeholder/stub patterns in recently modified files
+MODIFIED_FILES=$(git diff --name-only HEAD 2>/dev/null)
+if [ -z "$MODIFIED_FILES" ]; then
+  exit 0
+fi
+
+ISSUES=""
+
+# Check for incomplete implementation markers
+for file in $MODIFIED_FILES; do
+  if [ ! -f "$file" ]; then continue; fi
+
+  # Skip non-code files
+  case "$file" in
+    *.md|*.json|*.lock|*.yaml|*.yml|*.txt|*.log) continue ;;
+  esac
+
+  TODOS=$(grep -n "TODO\|FIXME\|HACK\|XXX\|placeholder\|not.implemented\|throw new Error.*TODO" "$file" 2>/dev/null | head -5)
+  if [ -n "$TODOS" ]; then
+    ISSUES="${ISSUES}\n⚠ Incomplete markers in ${file}:\n${TODOS}\n"
+  fi
+
+  # Check for empty function bodies (common LLM pattern)
+  EMPTY_FN=$(grep -n "{\s*}" "$file" 2>/dev/null | grep -v "import\|interface\|type " | head -3)
+  if [ -n "$EMPTY_FN" ]; then
+    ISSUES="${ISSUES}\n⚠ Empty function bodies in ${file}:\n${EMPTY_FN}\n"
+  fi
+done
+
+if [ -n "$ISSUES" ]; then
+  echo "REX Guard: Found potential incomplete implementation:"
+  echo -e "$ISSUES"
+  echo ""
+  echo "Verify these are intentional before declaring the task done."
+fi

package/dist/guards/dangerous-cmd-guard.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# REX Guard: Dangerous Command Blocker
+# Hook: PreToolUse (matcher: Bash)
+# Prevents destructive commands from running without confirmation
+
+# $TOOL_INPUT contains the command about to be executed
+CMD="$TOOL_INPUT"
+
+# Patterns that should ALWAYS be blocked or warned
+BLOCKED_PATTERNS=(
+  "rm -rf /"
+  "rm -rf ~"
+  "rm -rf \$HOME"
+  "git push --force main"
+  "git push --force master"
+  "git push -f origin main"
+  "git push -f origin master"
+  "git reset --hard"
+  "git clean -fd"
+  "DROP TABLE"
+  "DROP DATABASE"
+  "truncate "
+  "--dangerously-skip"
+  "--no-verify"
+)
+
+for pattern in "${BLOCKED_PATTERNS[@]}"; do
+  if echo "$CMD" | grep -qi "$pattern"; then
+    echo '{"decision": "block", "reason": "REX Guard: Dangerous command detected — '"$pattern"'. Use a safer alternative."}'
+    exit 0
+  fi
+done
+
+# Warn on potentially risky commands (don't block, just flag)
+WARN_PATTERNS=(
+  "git push --force"
+  "rm -rf"
+  "chmod 777"
+  "curl.*| sh"
+  "curl.*| bash"
+  "npm publish"
+  "npx wrangler deploy"
+)
+
+for pattern in "${WARN_PATTERNS[@]}"; do
+  if echo "$CMD" | grep -qi "$pattern"; then
+    echo "REX Guard: Risky command detected ($pattern). Proceeding with caution."
+    exit 0
+  fi
+done

package/dist/guards/scope-guard.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# REX Guard: Scope Creep Detector
+# Hook: PostToolUse (matcher: Edit|Write)
+# Detects when Claude modifies too many files — sign of scope creep
+
+# Count files modified in current session (unstaged changes)
+MODIFIED_COUNT=$(git diff --name-only 2>/dev/null | wc -l | tr -d ' ')
+STAGED_COUNT=$(git diff --cached --name-only 2>/dev/null | wc -l | tr -d ' ')
+TOTAL=$((MODIFIED_COUNT + STAGED_COUNT))
+
+if [ "$TOTAL" -gt 12 ]; then
+  echo "REX Guard: $TOTAL files changed in this session. This may indicate scope creep."
+  echo "Consider committing current work and splitting remaining changes into a separate task."
+elif [ "$TOTAL" -gt 8 ]; then
+  echo "REX Guard: $TOTAL files modified. Getting large — consider a checkpoint commit."
+fi

package/dist/guards/session-summary.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# REX Guard: Session Summary
+# Hook: Stop — auto-saves session state to memory
+# Prevents context loss after compaction by persisting key decisions
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+PROJECT_NAME=$(basename "$PROJECT_DIR")
+MEMORY_DIR="$HOME/.claude/projects/-$(echo "$PROJECT_DIR" | tr '/' '-')/memory"
+SUMMARY_FILE="$MEMORY_DIR/last-session.md"
+
+mkdir -p "$MEMORY_DIR"
+
+# Capture current state
+BRANCH=$(git -C "$PROJECT_DIR" branch --show-current 2>/dev/null || echo "unknown")
+MODIFIED=$(git -C "$PROJECT_DIR" diff --name-only 2>/dev/null | head -20)
+STAGED=$(git -C "$PROJECT_DIR" diff --cached --name-only 2>/dev/null | head -20)
+RECENT_COMMITS=$(git -C "$PROJECT_DIR" log --oneline -5 2>/dev/null)
+UNTRACKED=$(git -C "$PROJECT_DIR" ls-files --others --exclude-standard 2>/dev/null | head -10)
+
+cat > "$SUMMARY_FILE" << SUMMARY
+# Last Session Summary
+Updated: $(date -u '+%Y-%m-%d %H:%M UTC')
+
+## Branch: $BRANCH
+
+## Recent commits
+$RECENT_COMMITS
+
+## Modified files (unstaged)
+$MODIFIED
+
+## Staged files
+$STAGED
+
+## Untracked files
+$UNTRACKED
+SUMMARY
+
+# Also try to ingest the session transcript (background, non-blocking)
+if command -v npx &>/dev/null; then
+  (npx rex-cli ingest 2>/dev/null &)
+fi

package/dist/guards/test-protect-guard.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+# REX Guard: Test File Protection
+# Hook: PostToolUse (matcher: Edit|Write)
+# Prevents the #1 LLM anti-pattern: modifying tests to match broken code
+
+# $TOOL_INPUT contains the file path and changes
+INPUT="$TOOL_INPUT"
+
+# Check if a test file was modified
+if echo "$INPUT" | grep -qE '\.(test|spec)\.(ts|tsx|js|jsx|py)'; then
+  # Check if assertions were changed (likely making tests pass by changing expectations)
+  if echo "$INPUT" | grep -qE 'expect\(|assert\.|assertEqual|toBe\(|toEqual\(|toMatch\('; then
+    echo "REX Guard: Test assertions modified. Remember: fix the CODE, not the tests. Tests define truth."
+  fi
+fi

package/dist/guards/ui-checklist-guard.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# REX Guard: UI States Checklist
+# Hook: PostToolUse (matcher: Edit|Write)
+# Prevents the "missing states" anti-pattern: LLMs generate happy path only
+
+INPUT="$TOOL_INPUT"
+
+# Only check UI component files
+if ! echo "$INPUT" | grep -qE '\.(tsx|jsx|vue|svelte)'; then
+  exit 0
+fi
+
+# Extract file path from tool input
+FILE_PATH=$(echo "$INPUT" | grep -oE '[a-zA-Z0-9_./-]+\.(tsx|jsx|vue|svelte)' | head -1)
+if [ -z "$FILE_PATH" ] || [ ! -f "$FILE_PATH" ]; then
+  exit 0
+fi
+
+ISSUES=""
+
+# Check if component does any data fetching
+if grep -qE 'fetch\(|useQuery|useSWR|axios\.|\.get\(|\.post\(|trpc\.' "$FILE_PATH" 2>/dev/null; then
+  # Must have loading state
+  if ! grep -qE 'loading|isLoading|isPending|Skeleton|Spinner|Loading' "$FILE_PATH" 2>/dev/null; then
+    ISSUES="${ISSUES}\n  - Missing loading state (no spinner/skeleton while fetching)"
+  fi
+
+  # Must have error state
+  if ! grep -qE 'error|isError|Error|catch|onError' "$FILE_PATH" 2>/dev/null; then
+    ISSUES="${ISSUES}\n  - Missing error state (no error handling for failed fetch)"
+  fi
+
+  # Must have empty state
+  if ! grep -qE 'empty|no.results|no.data|\.length\s*[=!]==?\s*0|isEmpty' "$FILE_PATH" 2>/dev/null; then
+    ISSUES="${ISSUES}\n  - Missing empty state (no UI for zero results)"
+  fi
+fi
+
+if [ -n "$ISSUES" ]; then
+  echo "REX Guard: UI component may be missing required states:"
+  echo -e "$ISSUES"
+  echo ""
+  echo "Every component that fetches data needs: loading + error + empty states."
+fi

package/dist/index.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+
+// ../core/dist/index.js
+import { homedir } from "os";
+import { join as join9 } from "path";
+import { readFile, access } from "fs/promises";
+import { join } from "path";
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { readFile as readFile3, access as access2 } from "fs/promises";
+import { join as join3, dirname } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join4 } from "path";
+import { execSync } from "child_process";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join5 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join6 } from "path";
+import { access as access3 } from "fs/promises";
+import { join as join7 } from "path";
+import { readdir as readdir3, stat } from "fs/promises";
+import { join as join8 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { platform, release, arch } from "os";
+async function checkConfig(claudeDir) {
+  const results = [];
+  const claudeMdPath = join(claudeDir, "CLAUDE.md");
+  try {
+    const content = await readFile(claudeMdPath, "utf-8");
+    results.push(
+      content.trim().length > 0 ? { name: "CLAUDE.md", status: "pass", message: "Present and non-empty" } : { name: "CLAUDE.md", status: "warn", message: "File exists but is empty" }
+    );
+  } catch {
+    results.push({ name: "CLAUDE.md", status: "fail", message: "Not found" });
+  }
+  const settingsPath = join(claudeDir, "settings.json");
+  try {
+    const content = await readFile(settingsPath, "utf-8");
+    JSON.parse(content);
+    results.push({ name: "settings.json", status: "pass", message: "Valid JSON" });
+  } catch (err) {
+    const message = err instanceof SyntaxError ? "Invalid JSON" : "Not found";
+    results.push({ name: "settings.json", status: "fail", message });
+  }
+  const vaultPath = join(claudeDir, "vault.md");
+  try {
+    await access(vaultPath);
+    results.push({ name: "vault.md", status: "pass", message: "Present" });
+  } catch {
+    results.push({ name: "vault.md", status: "warn", message: "Not found (optional)" });
+  }
+  return { name: "Config", icon: "\u2699", results };
+}
+async function checkRules(claudeDir) {
+  const results = [];
+  const rulesDir = join2(claudeDir, "rules");
+  try {
+    const files = await readdir(rulesDir);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      try {
+        const content = await readFile2(join2(rulesDir, file), "utf-8");
+        results.push(
+          content.trim().length > 0 ? { name: file, status: "pass", message: "Present and non-empty" } : { name: file, status: "warn", message: "Empty file" }
+        );
+      } catch {
+        results.push({ name: file, status: "fail", message: "Cannot read" });
+      }
+    }
+    if (mdFiles.length === 0) {
+      results.push({ name: "Rules directory", status: "warn", message: "No rule files found" });
+    }
+  } catch {
+    results.push({ name: "Rules directory", status: "fail", message: "Directory not found" });
+  }
+  return { name: "Rules", icon: "\u{1F4CF}", results };
+}
+async function checkMemory(claudeDir) {
+  const results = [];
+  const projectsDir = join3(claudeDir, "projects");
+  try {
+    const { readdir: readdir4 } = await import("fs/promises");
+    const entries = await readdir4(projectsDir, { recursive: true });
+    const memoryFiles = entries.filter((e) => typeof e === "string" && e.endsWith("MEMORY.md"));
+    if (memoryFiles.length === 0) {
+      results.push({ name: "MEMORY.md", status: "warn", message: "No memory files found" });
+    }
+    for (const memFile of memoryFiles) {
+      const fullPath = join3(projectsDir, memFile);
+      try {
+        const content = await readFile3(fullPath, "utf-8");
+        if (content.trim().length === 0) {
+          results.push({ name: memFile, status: "warn", message: "Empty" });
+          continue;
+        }
+        results.push({ name: memFile, status: "pass", message: "Present and non-empty" });
+        const linkRegex = /\[([^\]]+)\]\(([^)]+\.md)\)/g;
+        let match;
+        while ((match = linkRegex.exec(content)) !== null) {
+          const linkedPath = join3(dirname(fullPath), match[2]);
+          try {
+            await access2(linkedPath);
+            results.push({ name: match[2], status: "pass", message: "Linked file exists" });
+          } catch {
+            results.push({ name: match[2], status: "warn", message: "Linked file missing" });
+          }
+        }
+      } catch {
+        results.push({ name: memFile, status: "fail", message: "Cannot read" });
+      }
+    }
+  } catch {
+    results.push({ name: "Projects directory", status: "warn", message: "Not found" });
+  }
+  return { name: "Memory", icon: "\u{1F9E0}", results };
+}
+async function checkMcpServers(claudeDir) {
+  const results = [];
+  const settingsPath = join4(claudeDir, "settings.json");
+  try {
+    const content = await readFile4(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    const servers = settings.mcpServers ?? {};
+    const serverNames = Object.keys(servers);
+    if (serverNames.length === 0) {
+      results.push({ name: "MCP Servers", status: "warn", message: "None configured" });
+      return { name: "MCP Servers", icon: "\u{1F50C}", results };
+    }
+    for (const name of serverNames) {
+      const server = servers[name];
+      const command = server.command;
+      if (!command) {
+        results.push({ name, status: "warn", message: "No command specified" });
+        continue;
+      }
+      try {
+        execSync(`which ${command}`, { stdio: "ignore" });
+        results.push({ name, status: "pass", message: `${command} found` });
+      } catch {
+        results.push({ name, status: "warn", message: `${command} not found in PATH` });
+      }
+    }
+  } catch {
+    results.push({ name: "settings.json", status: "fail", message: "Cannot read MCP config" });
+  }
+  return { name: "MCP Servers", icon: "\u{1F50C}", results };
+}
+async function checkPlugins(claudeDir) {
+  const results = [];
+  const pluginsDir = join5(claudeDir, "plugins", "cache");
+  try {
+    const entries = await readdir2(pluginsDir);
+    if (entries.length === 0) {
+      results.push({ name: "Plugins", status: "warn", message: "No plugins installed" });
+    }
+    for (const entry of entries) {
+      results.push({ name: entry, status: "pass", message: "Installed" });
+    }
+  } catch {
+    results.push({ name: "Plugins directory", status: "warn", message: "Not found" });
+  }
+  return { name: "Plugins", icon: "\u{1F9E9}", results };
+}
+var EXPECTED_HOOKS = ["UserPromptSubmit", "PreToolUse", "Stop", "SessionStart", "SessionEnd"];
+async function checkHooks(claudeDir) {
+  const results = [];
+  const settingsPath = join6(claudeDir, "settings.json");
+  try {
+    const content = await readFile5(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    const hooks = settings.hooks ?? {};
+    for (const hookName of EXPECTED_HOOKS) {
+      if (hooks[hookName] && Array.isArray(hooks[hookName]) && hooks[hookName].length > 0) {
+        results.push({ name: hookName, status: "pass", message: `${hooks[hookName].length} handler(s)` });
+      } else {
+        results.push({ name: hookName, status: "warn", message: "Not configured" });
+      }
+    }
+    const extraHooks = Object.keys(hooks).filter((h) => !EXPECTED_HOOKS.includes(h));
+    for (const hook of extraHooks) {
+      results.push({ name: hook, status: "pass", message: "Custom hook" });
+    }
+  } catch {
+    results.push({ name: "Hooks config", status: "fail", message: "Cannot read settings.json" });
+  }
+  return { name: "Hooks", icon: "\u{1FA9D}", results };
+}
+var EXPECTED_GUARDS = [
+  "completion-guard.sh",
+  "dangerous-cmd-guard.sh",
+  "test-protect-guard.sh",
+  "session-summary.sh",
+  "ui-checklist-guard.sh",
+  "scope-guard.sh"
+];
+async function checkGuards(claudeDir) {
+  const results = [];
+  const guardsDir = join7(claudeDir, "rex-guards");
+  for (const guard of EXPECTED_GUARDS) {
+    const guardPath = join7(guardsDir, guard);
+    try {
+      await access3(guardPath);
+      results.push({ name: guard, status: "pass", message: "Installed" });
+    } catch {
+      results.push({ name: guard, status: "warn", message: "Not installed \u2014 run rex init" });
+    }
+  }
+  return { name: "Guards", icon: "\u{1F6E1}", results };
+}
+async function checkDocsCache(claudeDir) {
+  const results = [];
+  const docsDir = join8(claudeDir, "docs");
+  try {
+    const files = await readdir3(docsDir);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    if (mdFiles.length === 0) {
+      results.push({ name: "Docs cache", status: "warn", message: "No cached docs" });
+    }
+    for (const file of mdFiles) {
+      const fileStat = await stat(join8(docsDir, file));
+      const sizeKb = Math.round(fileStat.size / 1024);
+      results.push({ name: file, status: "pass", message: `${sizeKb}KB` });
+    }
+  } catch {
+    results.push({ name: "Docs directory", status: "warn", message: "Not found" });
+  }
+  return { name: "Docs Cache", icon: "\u{1F4DA}", results };
+}
+function getVersion(command) {
+  try {
+    return execSync2(command, { encoding: "utf-8", timeout: 5e3 }).trim();
+  } catch {
+    return null;
+  }
+}
+async function checkEnvironment() {
+  const results = [];
+  const claudeVersion = getVersion("claude --version 2>/dev/null");
+  results.push(
+    claudeVersion ? { name: "Claude Code", status: "pass", message: claudeVersion } : { name: "Claude Code", status: "fail", message: "Not found" }
+  );
+  const nodeVersion = getVersion("node --version");
+  results.push(
+    nodeVersion ? { name: "Node.js", status: "pass", message: nodeVersion } : { name: "Node.js", status: "fail", message: "Not found" }
+  );
+  const gitVersion = getVersion("git --version");
+  results.push(
+    gitVersion ? { name: "Git", status: "pass", message: gitVersion } : { name: "Git", status: "fail", message: "Not found" }
+  );
+  results.push({
+    name: "OS",
+    status: "pass",
+    message: `${platform()} ${release()} (${arch()})`
+  });
+  const shell = process.env.SHELL ?? "unknown";
+  results.push({ name: "Shell", status: "pass", message: shell });
+  return { name: "Environment", icon: "\u{1F4BB}", results };
+}
+async function runAllChecks(claudeDir) {
+  const dir = claudeDir ?? join9(homedir(), ".claude");
+  const groups = await Promise.all([
+    checkConfig(dir),
+    checkRules(dir),
+    checkMemory(dir),
+    checkMcpServers(dir),
+    checkPlugins(dir),
+    checkHooks(dir),
+    checkGuards(dir),
+    checkDocsCache(dir),
+    checkEnvironment()
+  ]);
+  const allResults = groups.flatMap((g) => g.results);
+  const failCount = allResults.filter((r) => r.status === "fail").length;
+  const warnCount = allResults.filter((r) => r.status === "warn").length;
+  let status = "healthy";
+  if (failCount > 0) status = "broken";
+  else if (warnCount > 2) status = "degraded";
+  return {
+    groups,
+    status,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "0.1.0"
+  };
+}
+
+// src/index.ts
+import { existsSync } from "fs";
+import { join as join10 } from "path";
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m"
+};
+function statusIcon(status) {
+  switch (status) {
+    case "pass":
+      return `${COLORS.green}\u2713${COLORS.reset}`;
+    case "fail":
+      return `${COLORS.red}\u2717${COLORS.reset}`;
+    case "warn":
+      return `${COLORS.yellow}!${COLORS.reset}`;
+    default:
+      return " ";
+  }
+}
+function formatGroup(group) {
+  const passed = group.results.filter((r) => r.status === "pass").length;
+  const total = group.results.length;
+  let out = `
+  ${COLORS.bold}${group.icon} ${group.name}${COLORS.reset}`;
+  out += `  ${COLORS.dim}${passed}/${total}${COLORS.reset}
+`;
+  for (const result of group.results) {
+    out += `    ${statusIcon(result.status)} ${result.name} ${COLORS.dim}\u2014 ${result.message}${COLORS.reset}
+`;
+  }
+  return out;
+}
+function formatReport(report) {
+  const line = "\u2550".repeat(45);
+  const thinLine = "\u2500".repeat(45);
+  let statusColor = COLORS.green;
+  if (report.status === "degraded") statusColor = COLORS.yellow;
+  if (report.status === "broken") statusColor = COLORS.red;
+  let out = `
+${line}
+`;
+  out += `${COLORS.bold}        REX DOCTOR \u2014 Health Check${COLORS.reset}
+`;
+  out += `${line}
+`;
+  for (const group of report.groups) {
+    out += formatGroup(group);
+  }
+  const allResults = report.groups.flatMap((g) => g.results);
+  const passed = allResults.filter((r) => r.status === "pass").length;
+  const total = allResults.length;
+  out += `
+${thinLine}
+`;
+  out += `  Summary: ${COLORS.bold}${passed}/${total}${COLORS.reset} checks passed
+`;
+  out += `  Status:  ${statusColor}${COLORS.bold}${report.status.toUpperCase()}${COLORS.reset}
+`;
+  out += `${line}
+`;
+  return out;
+}
+async function main() {
+  const command = process.argv[2] ?? "help";
+  switch (command) {
+    case "doctor": {
+      const report = await runAllChecks();
+      console.log(formatReport(report));
+      process.exit(report.status === "broken" ? 1 : 0);
+      break;
+    }
+    case "status": {
+      const report = await runAllChecks();
+      const allResults = report.groups.flatMap((g) => g.results);
+      const passed = allResults.filter((r) => r.status === "pass").length;
+      const total = allResults.length;
+      const dot = report.status === "healthy" ? `${COLORS.green}\u25CF${COLORS.reset}` : report.status === "degraded" ? `${COLORS.yellow}\u25CF${COLORS.reset}` : `${COLORS.red}\u25CB${COLORS.reset}`;
+      console.log(`REX ${dot} ${report.status.toUpperCase()} \u2014 ${passed}/${total} checks passed`);
+      break;
+    }
+    case "init": {
+      const { init } = await import("./init-YMRG5ZXU.js");
+      await init();
+      break;
+    }
+    case "ingest": {
+      try {
+        const { execSync: execSync3 } = await import("child_process");
+        const memDir = findMemoryPackage();
+        if (!memDir) {
+          console.log(`${COLORS.yellow}Memory package not found.${COLORS.reset} This feature requires @rex/memory.`);
+          console.log(`Run from the REX monorepo or install @rex/memory separately.`);
+          process.exit(1);
+        }
+        console.log(`${COLORS.cyan}Ingesting sessions...${COLORS.reset}`);
+        execSync3("npx tsx src/ingest.ts", { cwd: memDir, stdio: "inherit" });
+      } catch {
+        process.exit(1);
+      }
+      break;
+    }
+    case "search": {
+      const query = process.argv.slice(3).join(" ");
+      if (!query) {
+        console.error("Usage: rex search <query>");
+        process.exit(1);
+      }
+      try {
+        const memDir = findMemoryPackage();
+        if (!memDir) {
+          console.log(`${COLORS.yellow}Memory package not found.${COLORS.reset} This feature requires @rex/memory + Ollama.`);
+          process.exit(1);
+        }
+        const { execSync: execSync3 } = await import("child_process");
+        execSync3(`npx tsx src/cli-search.ts ${query.split(" ").map((w) => JSON.stringify(w)).join(" ")}`, { cwd: memDir, stdio: "inherit" });
+      } catch {
+        process.exit(1);
+      }
+      break;
+    }
+    case "optimize": {
+      const { optimize } = await import("./optimize-NE47FMOP.js");
+      await optimize();
+      break;
+    }
+    case "--version":
+    case "-v":
+      console.log("rex-cli v0.1.0");
+      break;
+    case "help":
+    default:
+      console.log(`
+${COLORS.bold}REX${COLORS.reset} \u2014 Claude Code sous steroides
+
+${COLORS.bold}Commands:${COLORS.reset}
+  rex init        Setup REX (guards, hooks, MCP)
+  rex doctor      Full health check (9 categories)
+  rex status      Quick one-line status
+
+${COLORS.bold}Memory (requires Ollama):${COLORS.reset}
+  rex ingest      Sync session history to vector DB
+  rex search      Semantic search across past sessions
+  rex optimize    Analyze CLAUDE.md with local LLM
+
+${COLORS.bold}Info:${COLORS.reset}
+  rex help        Show this help
+  rex --version   Show version
+
+${COLORS.dim}After install: rex init \u2014 everything else is automatic.${COLORS.reset}
+`);
+  }
+}
+function findMemoryPackage() {
+  const thisDir = new URL(".", import.meta.url).pathname;
+  const candidates = [
+    join10(thisDir, "..", "..", "memory"),
+    join10(process.env.HOME || "~", ".rex-memory")
+  ];
+  for (const c of candidates) {
+    if (existsSync(join10(c, "src", "ingest.ts"))) return c;
+  }
+  return null;
+}
+main().catch(console.error);