rex-claude 4.0.0 → 6.0.0

package/dist/preload-I3MYBVNU.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import {
+  findProject
+} from "./chunk-LTOM55UV.js";
+import "./chunk-PPGYFMU5.js";
+import {
+  createLogger
+} from "./chunk-5ND7JYY3.js";
+import {
+  MEMORY_DB_PATH
+} from "./chunk-6SRV2I2H.js";
+import "./chunk-PDX44BCA.js";
+
+// src/preload.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { existsSync } from "fs";
+var log = createLogger("preload");
+var MAX_TOKENS = 200;
+async function preload(cwd) {
+  if (!existsSync(MEMORY_DB_PATH)) {
+    log.debug("No memory DB found, skipping preload");
+    return "";
+  }
+  const project = findProject(cwd);
+  const sections = [];
+  let db;
+  try {
+    db = new Database(MEMORY_DB_PATH, { readonly: true });
+    sqliteVec.load(db);
+    db.pragma("journal_mode = WAL");
+  } catch (e) {
+    log.error(`Failed to open memory DB: ${e.message?.slice(0, 100)}`);
+    return "";
+  }
+  try {
+    if (project) {
+      const recent = db.prepare(
+        "SELECT summary, category FROM memories WHERE content LIKE ? AND category != 'session' AND summary IS NOT NULL ORDER BY created_at DESC LIMIT 3"
+      ).all(`%${project.name}%`);
+      if (recent.length) {
+        sections.push(`[REX Context] Project: ${project.name} | ${project.stack.join(", ")}`);
+        sections.push(`Last: ${recent[0].summary.slice(0, 80)}`);
+      }
+    }
+    const lessons = db.prepare(
+      "SELECT summary FROM memories WHERE category = 'lesson' AND summary IS NOT NULL ORDER BY created_at DESC LIMIT 3"
+    ).all();
+    if (lessons.length) {
+      sections.push("Lessons:");
+      for (const l of lessons) {
+        sections.push(`  - ${l.summary.slice(0, 100)}`);
+      }
+    }
+    if (project) {
+      const patterns = db.prepare(
+        "SELECT summary FROM memories WHERE category = 'pattern' AND summary IS NOT NULL AND content LIKE ? ORDER BY created_at DESC LIMIT 2"
+      ).all(`%${project.name}%`);
+      if (patterns.length) {
+        sections.push("Patterns:");
+        for (const p of patterns) {
+          sections.push(`  - ${p.summary.slice(0, 100)}`);
+        }
+      }
+    }
+  } finally {
+    db.close();
+  }
+  const output = sections.join("\n");
+  log.info(`Preloaded ${sections.length} sections for ${project?.name || cwd} (${output.length} chars)`);
+  if (output.length > MAX_TOKENS * 4) {
+    return output.slice(0, MAX_TOKENS * 4);
+  }
+  return output;
+}
+export {
+  preload
+};

package/dist/projects-V6TSLO7E.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  findProject,
+  loadProjectIndex,
+  saveProjectIndex,
+  scanProjects
+} from "./chunk-LTOM55UV.js";
+import "./chunk-PPGYFMU5.js";
+import "./chunk-5ND7JYY3.js";
+import "./chunk-6SRV2I2H.js";
+import "./chunk-PDX44BCA.js";
+export {
+  findProject,
+  loadProjectIndex,
+  saveProjectIndex,
+  scanProjects
+};

package/dist/{prune-2PPIVDXK.js → prune-B7F5B5OF.js}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
 
 // src/prune.ts
 import { existsSync, statSync } from "fs";
@@ -49,7 +50,7 @@ ${line}`);
     }
     try {
       Database = (await import(join(memDir, "node_modules", "better-sqlite3", "lib", "index.js"))).default;
-      sqliteVec = await import(join(memDir, "node_modules", "sqlite-vec", "src", "index.js"));
+      sqliteVec = await import(join(memDir, "node_modules", "sqlite-vec", "index.mjs"));
     } catch (err) {
       console.log(`  ${COLORS.red}Cannot load database modules:${COLORS.reset} ${err.message}
 `);

package/dist/recategorize-YXYIMQLZ.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import {
+  pickModel
+} from "./chunk-E5UYN3W7.js";
+import {
+  loadConfig
+} from "./chunk-PPGYFMU5.js";
+import {
+  createLogger
+} from "./chunk-5ND7JYY3.js";
+import {
+  MEMORY_DB_PATH
+} from "./chunk-6SRV2I2H.js";
+import {
+  llm
+} from "./chunk-WBMVBMWB.js";
+import "./chunk-PDX44BCA.js";
+
+// src/recategorize.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+var log = createLogger("recategorize");
+var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
+var VALID_CATEGORIES = ["debug", "fix", "pattern", "lesson", "architecture", "config", "project", "reference", "session"];
+var CLASSIFY_PROMPT = (content) => `Classify this developer memory chunk. Output ONLY valid JSON, no markdown.
+
+Categories: debug, fix, pattern, lesson, architecture, config, project, reference, session
+
+- debug: debugging an issue, tracing errors
+- fix: applying a fix or patch, solution found
+- pattern: reusable code patterns, techniques
+- lesson: lessons learned, mistakes to avoid
+- architecture: system design, structure decisions
+- config: configuration changes, setup steps
+- project: project overview, stack, status
+- reference: API docs, external knowledge, lib behavior
+- session: general content (default fallback)
+
+Content:
+${content.slice(0, 1500)}
+
+JSON output: {"category": "<one of the above>", "summary": "<1-2 sentence summary>"}`;
+async function classifyChunk(content, routing, claudeFallback) {
+  const prompt = CLASSIFY_PROMPT(content);
+  if (routing !== "claude-only") {
+    try {
+      const model = await pickModel("categorize");
+      const res = await fetch(`${OLLAMA_URL}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model, prompt, stream: false, options: { temperature: 0.3, num_ctx: 4096 } }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const parsed = parseJsonResponse(data.response);
+        if (parsed) return parsed;
+      }
+    } catch {
+    }
+  }
+  if (routing !== "ollama-only") {
+    try {
+      const result = await llm(prompt, void 0, claudeFallback);
+      return parseJsonResponse(result);
+    } catch {
+    }
+  }
+  return null;
+}
+function parseJsonResponse(raw) {
+  let parsed = null;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+  }
+  if (!parsed) {
+    const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fence) {
+      try {
+        parsed = JSON.parse(fence[1].trim());
+      } catch {
+      }
+    }
+  }
+  if (!parsed) {
+    const brace = raw.match(/\{[\s\S]*\}/);
+    if (brace) {
+      try {
+        parsed = JSON.parse(brace[0]);
+      } catch {
+      }
+    }
+  }
+  if (!parsed) return null;
+  const category = VALID_CATEGORIES.includes(parsed.category) ? parsed.category : "session";
+  const summary = typeof parsed.summary === "string" && parsed.summary.length > 5 ? parsed.summary : null;
+  if (!summary) return null;
+  return { category, summary };
+}
+async function recategorize(options = {}) {
+  const COLORS = { green: "\x1B[32m", yellow: "\x1B[33m", red: "\x1B[31m", cyan: "\x1B[36m", dim: "\x1B[2m", reset: "\x1B[0m", bold: "\x1B[1m" };
+  const config = loadConfig();
+  const batchSize = options.batch ?? 50;
+  const db = new Database(MEMORY_DB_PATH);
+  sqliteVec.load(db);
+  db.pragma("journal_mode = WAL");
+  const rows = db.prepare(
+    "SELECT id, content FROM memories WHERE category IN ('session', 'general') OR needs_reprocess = 1 LIMIT ?"
+  ).all(batchSize);
+  log.info(`Starting recategorize: ${rows.length} memories to process (batch: ${batchSize})`);
+  console.log(`
+${COLORS.bold}REX Recategorize${COLORS.reset}`);
+  console.log(`${COLORS.dim}Found ${rows.length} memories to process (batch: ${batchSize})${COLORS.reset}
+`);
+  if (rows.length === 0) {
+    console.log(`${COLORS.green}All memories are already categorized.${COLORS.reset}`);
+    db.close();
+    return;
+  }
+  if (options.dryRun) {
+    console.log(`${COLORS.yellow}[dry-run] Would process ${rows.length} memories. Nothing saved.${COLORS.reset}`);
+    db.close();
+    return;
+  }
+  const update = db.prepare("UPDATE memories SET category = ?, summary = ?, needs_reprocess = 0 WHERE id = ?");
+  let processed = 0;
+  let failed = 0;
+  const stats = {};
+  for (const row of rows) {
+    const result = await classifyChunk(row.content, config.llm.routing, config.llm.claudeFallback);
+    if (result) {
+      update.run(result.category, result.summary, row.id);
+      stats[result.category] = (stats[result.category] || 0) + 1;
+      processed++;
+      process.stdout.write(`\r  ${COLORS.cyan}${processed}/${rows.length}${COLORS.reset} processed`);
+    } else {
+      log.warn(`Failed to classify memory id=${row.id}, flagged for retry`);
+      db.prepare("UPDATE memories SET needs_reprocess = 1 WHERE id = ?").run(row.id);
+      failed++;
+    }
+  }
+  log.info(`Done: ${processed} categorized, ${failed} failed`);
+  console.log(`
+
+${COLORS.green}Done:${COLORS.reset} ${processed} categorized, ${failed} failed (flagged for retry)
+`);
+  for (const [cat, count] of Object.entries(stats).sort((a, b) => b[1] - a[1])) {
+    console.log(`  ${cat.padEnd(15)} ${count}`);
+  }
+  db.close();
+}
+export {
+  recategorize
+};

package/dist/router-2JD34COX.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  getRouterSnapshot,
+  pickModel,
+  showModelRouter
+} from "./chunk-E5UYN3W7.js";
+import "./chunk-PDX44BCA.js";
+export {
+  getRouterSnapshot,
+  pickModel,
+  showModelRouter
+};

package/dist/self-improve-YK7RCYF4.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import {
+  pickModel
+} from "./chunk-E5UYN3W7.js";
+import {
+  loadConfig
+} from "./chunk-PPGYFMU5.js";
+import {
+  createLogger
+} from "./chunk-5ND7JYY3.js";
+import {
+  MEMORY_DB_PATH,
+  SELF_IMPROVEMENT_DIR
+} from "./chunk-6SRV2I2H.js";
+import {
+  llm
+} from "./chunk-WBMVBMWB.js";
+import "./chunk-PDX44BCA.js";
+
+// src/self-improve.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+var log = createLogger("self-improve");
+function loadLessons() {
+  const path = join(SELF_IMPROVEMENT_DIR, "lessons.json");
+  if (!existsSync(path)) return [];
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveLessons(lessons) {
+  writeFileSync(join(SELF_IMPROVEMENT_DIR, "lessons.json"), JSON.stringify(lessons, null, 2));
+}
+function loadErrorPatterns() {
+  const path = join(SELF_IMPROVEMENT_DIR, "error-patterns.json");
+  if (!existsSync(path)) return [];
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveErrorPatterns(patterns) {
+  writeFileSync(join(SELF_IMPROVEMENT_DIR, "error-patterns.json"), JSON.stringify(patterns, null, 2));
+}
+async function selfReview() {
+  const COLORS = { green: "\x1B[32m", yellow: "\x1B[33m", dim: "\x1B[2m", reset: "\x1B[0m", bold: "\x1B[1m" };
+  const config = loadConfig();
+  if (!config.selfImprovement.enabled) {
+    log.info("Self-improvement disabled in config");
+    console.log(`${COLORS.dim}Self-improvement disabled in config.${COLORS.reset}`);
+    return { newLessons: 0, ruleCandidates: 0 };
+  }
+  if (!existsSync(MEMORY_DB_PATH)) {
+    log.warn(`No memory DB found at ${MEMORY_DB_PATH}`);
+    console.log(`${COLORS.yellow}No memory DB found at ${MEMORY_DB_PATH}${COLORS.reset}`);
+    return { newLessons: 0, ruleCandidates: 0 };
+  }
+  console.log(`
+${COLORS.bold}REX Self-Review${COLORS.reset}
+`);
+  const db = new Database(MEMORY_DB_PATH, { readonly: true });
+  sqliteVec.load(db);
+  db.pragma("journal_mode = WAL");
+  const recentLessons = db.prepare(
+    "SELECT id, summary, content, created_at FROM memories WHERE category = 'lesson' AND summary IS NOT NULL ORDER BY created_at DESC LIMIT 20"
+  ).all();
+  const existingLessons = loadLessons();
+  const existingTexts = new Set(existingLessons.map((l) => l.text.toLowerCase().trim()));
+  let newCount = 0;
+  for (const mem of recentLessons) {
+    const text = mem.summary.trim();
+    if (existingTexts.has(text.toLowerCase())) {
+      const existing = existingLessons.find((l) => l.text.toLowerCase().trim() === text.toLowerCase());
+      if (existing) {
+        existing.occurrences++;
+        existing.lastSeen = mem.created_at;
+      }
+      continue;
+    }
+    existingLessons.push({
+      id: `lesson-${Date.now()}-${mem.id}`,
+      text,
+      category: "lesson",
+      occurrences: 1,
+      firstSeen: mem.created_at,
+      lastSeen: mem.created_at,
+      promoted: false,
+      dismissed: false
+    });
+    newCount++;
+  }
+  saveLessons(existingLessons);
+  log.info(`Lessons: ${existingLessons.length} total, ${newCount} new`);
+  console.log(`  Lessons: ${existingLessons.length} total, ${newCount} new`);
+  const errorMemories = db.prepare(
+    "SELECT summary FROM memories WHERE category IN ('debug', 'fix') AND summary IS NOT NULL ORDER BY created_at DESC LIMIT 50"
+  ).all();
+  const patterns = loadErrorPatterns();
+  let ruleCandidates = 0;
+  if (errorMemories.length >= 5) {
+    const errorSummaries = errorMemories.map((m) => m.summary).join("\n");
+    try {
+      const model = await pickModel("reason");
+      console.log(`  Analyzing ${errorMemories.length} error/fix memories with ${model}...`);
+      const analysis = await llm(
+        `Analyze these error/fix summaries for recurring patterns. Output JSON array of patterns:
+
+${errorSummaries.slice(0, 3e3)}
+
+JSON: [{"pattern": "description", "count": estimated_occurrences, "suggestedRule": "rule text"}]`,
+        "You are a code pattern analyzer. Output ONLY valid JSON.",
+        model
+      );
+      let parsed = [];
+      try {
+        parsed = JSON.parse(analysis);
+      } catch {
+        const brace = analysis.match(/\[[\s\S]*\]/);
+        if (brace) {
+          try {
+            parsed = JSON.parse(brace[0]);
+          } catch {
+          }
+        }
+      }
+      for (const p of parsed) {
+        if (p.count >= config.selfImprovement.ruleThreshold) {
+          const exists = patterns.find((ep) => ep.pattern === p.pattern);
+          if (!exists) {
+            patterns.push({
+              pattern: p.pattern,
+              count: p.count,
+              firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              suggestedRule: p.suggestedRule
+            });
+            ruleCandidates++;
+          }
+        }
+      }
+    } catch (e) {
+      log.warn(`Pattern analysis skipped: ${e.message?.slice(0, 100)}`);
+      console.log(`  ${COLORS.yellow}Pattern analysis skipped (LLM unavailable)${COLORS.reset}`);
+    }
+  } else {
+    console.log(`  ${COLORS.dim}Not enough error memories for pattern analysis (need 5+, have ${errorMemories.length})${COLORS.reset}`);
+  }
+  saveErrorPatterns(patterns);
+  const activePatterns = patterns.filter((p) => p.count >= config.selfImprovement.ruleThreshold);
+  if (activePatterns.length) {
+    const md = `# Rule Candidates
+
+These patterns were detected ${config.selfImprovement.ruleThreshold}+ times. Review and approve with \`rex promote-rule <index>\`.
+
+` + activePatterns.map((p, i) => `## ${i + 1}. ${p.pattern}
+
+- Count: ${p.count}
+- First seen: ${p.firstSeen}
+- Suggested rule: ${p.suggestedRule || "N/A"}
+`).join("\n");
+    writeFileSync(join(SELF_IMPROVEMENT_DIR, "rule-candidates.md"), md);
+    console.log(`  Rule candidates: ${activePatterns.length} (see ~/.claude/rex/self-improvement/rule-candidates.md)`);
+  }
+  db.close();
+  log.info(`Self-review done: ${newCount} new lessons, ${ruleCandidates} rule candidates`);
+  console.log(`
+${COLORS.green}Done.${COLORS.reset} ${newCount} new lessons, ${ruleCandidates} rule candidates
+`);
+  return { newLessons: newCount, ruleCandidates };
+}
+async function promoteRule(index) {
+  const patterns = loadErrorPatterns();
+  const active = patterns.filter((p) => p.count >= loadConfig().selfImprovement.ruleThreshold);
+  if (index < 1 || index > active.length) return false;
+  const pattern = active[index - 1];
+  if (!pattern.suggestedRule) return false;
+  const HOME = process.env.HOME || "~";
+  const rulesDir = join(HOME, ".claude", "rules");
+  const ruleName = pattern.pattern.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40);
+  const rulePath = join(rulesDir, `${ruleName}.md`);
+  writeFileSync(rulePath, `# ${pattern.pattern}
+
+${pattern.suggestedRule}
+
+<!-- Auto-generated by REX self-improvement on ${(/* @__PURE__ */ new Date()).toISOString()} -->
+`);
+  return true;
+}
+export {
+  promoteRule,
+  selfReview
+};

package/dist/setup-KNDTVFO6.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  setup
+} from "./chunk-A7ZLQUOX.js";
+import "./chunk-PDX44BCA.js";
+export {
+  setup
+};