rex-claude 4.0.0 → 6.0.0

package/dist/{chunk-7AGI43F5.js → chunk-WBMVBMWB.js}

@@ -2,7 +2,7 @@
 
 // src/llm.ts
 var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
-var PREFERRED_MODELS = ["qwen3.5:9b", "qwen3.5:4b", "qwen2.5:1.5b", "llama3.2", "mistral"];
+var PREFERRED_MODELS = ["qwen2.5:1.5b", "qwen3.5:4b", "llama3.2", "mistral"];
 async function detectModel() {
   if (process.env.REX_LLM_MODEL) return process.env.REX_LLM_MODEL;
   try {
@@ -28,7 +28,9 @@ async function llm(prompt, system, model) {
       model: useModel,
       prompt,
       system,
-      stream: false
+      stream: false,
+      think: false,
+      keep_alive: "30s"
     })
   });
   if (!res.ok) throw new Error(`Ollama generate failed: ${res.status}`);

package/dist/{context-FN5O5YBI.js → context-XNCG2M5Q.js}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
 
 // src/context.ts
 import { existsSync, readFileSync } from "fs";
@@ -68,7 +69,7 @@ ${line}`);
   console.log(`${COLORS.bold}        REX CONTEXT${COLORS.reset}`);
   console.log(`${line}
 `);
-  const absPath = join(process.cwd(), targetPath === "." ? "" : targetPath);
+  const absPath = targetPath.startsWith("/") ? targetPath : join(process.cwd(), targetPath === "." ? "" : targetPath);
   const projectName = basename(absPath);
   console.log(`  ${COLORS.cyan}Project:${COLORS.reset} ${projectName}`);
   console.log(`  ${COLORS.cyan}Path:${COLORS.reset} ${absPath}

package/dist/daemon-5KNSNFTD.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import {
+  loadConfig
+} from "./chunk-PPGYFMU5.js";
+import {
+  createLogger,
+  rotateLog
+} from "./chunk-5ND7JYY3.js";
+import {
+  BACKUPS_DIR,
+  MEMORY_DB_PATH,
+  PENDING_DIR,
+  ensureRexDirs
+} from "./chunk-6SRV2I2H.js";
+import "./chunk-PDX44BCA.js";
+
+// src/daemon.ts
+import { existsSync, readdirSync, unlinkSync, copyFileSync, statSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
+var log = createLogger("daemon");
+async function checkOllama() {
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/tags`, { signal: AbortSignal.timeout(3e3) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function restartOllama() {
+  try {
+    execSync("ollama serve &", { timeout: 5e3, stdio: "ignore" });
+    await new Promise((r) => setTimeout(r, 3e3));
+    return checkOllama();
+  } catch {
+    return false;
+  }
+}
+function checkDiskSpace() {
+  try {
+    const output = execSync("df -g ~ | tail -1 | awk '{print $4}'", { encoding: "utf-8" }).trim();
+    return parseInt(output) || 999;
+  } catch {
+    return 999;
+  }
+}
+function checkDbIntegrity() {
+  if (!existsSync(MEMORY_DB_PATH)) return true;
+  try {
+    const result = execSync(`sqlite3 "${MEMORY_DB_PATH}" "PRAGMA integrity_check"`, { encoding: "utf-8" }).trim();
+    return result === "ok";
+  } catch {
+    return false;
+  }
+}
+function backupDb() {
+  if (!existsSync(MEMORY_DB_PATH)) return;
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const backupPath = join(BACKUPS_DIR, `rex-${date}.sqlite`);
+  if (existsSync(backupPath)) return;
+  copyFileSync(MEMORY_DB_PATH, backupPath);
+  log.info(`Backup: ${backupPath}`);
+}
+function pruneBackups(retainDays = 7) {
+  if (!existsSync(BACKUPS_DIR)) return;
+  const cutoff = Date.now() - retainDays * 864e5;
+  for (const f of readdirSync(BACKUPS_DIR)) {
+    const fPath = join(BACKUPS_DIR, f);
+    try {
+      if (statSync(fPath).mtimeMs < cutoff) {
+        unlinkSync(fPath);
+        log.debug(`Pruned backup: ${f}`);
+      }
+    } catch {
+    }
+  }
+}
+function countPending() {
+  if (!existsSync(PENDING_DIR)) return 0;
+  return readdirSync(PENDING_DIR).filter((f) => f.endsWith(".json")).length;
+}
+function runCmd(cmd, timeout = 12e4) {
+  try {
+    execSync(cmd, { timeout, encoding: "utf-8", stdio: "pipe" });
+  } catch (e) {
+    log.error(`Command error (${cmd.slice(0, 30)}): ${e.message?.slice(0, 200)}`);
+  }
+}
+async function sendTelegramNotify(message) {
+  try {
+    const token = process.env.REX_TELEGRAM_BOT_TOKEN;
+    const chatId = process.env.REX_TELEGRAM_CHAT_ID;
+    if (!token || !chatId) return;
+    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text: message, parse_mode: "Markdown" }),
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch {
+  }
+}
+async function healthCheck() {
+  const ollamaUp = await checkOllama();
+  if (!ollamaUp) {
+    log.warn("Ollama down \u2014 attempting restart");
+    const restarted = await restartOllama();
+    if (restarted) log.info("Ollama restarted successfully");
+    else log.error("Ollama restart failed");
+  }
+  if (await checkOllama()) {
+    const pending = countPending();
+    if (pending > 0) {
+      log.info(`Processing ${pending} pending files`);
+      runCmd("rex ingest");
+    }
+  }
+  if (!checkDbIntegrity()) {
+    log.error("DB integrity check FAILED");
+    const backups = existsSync(BACKUPS_DIR) ? readdirSync(BACKUPS_DIR).filter((f) => f.endsWith(".sqlite")).sort().reverse() : [];
+    if (backups.length) {
+      copyFileSync(join(BACKUPS_DIR, backups[0]), MEMORY_DB_PATH);
+      log.warn(`Restored DB from ${backups[0]}`);
+      await sendTelegramNotify("\u26A0\uFE0F REX: DB integrity fail \u2014 restored from backup");
+    }
+  }
+  const freeGb = checkDiskSpace();
+  if (freeGb < 1) {
+    log.warn(`Disk low: ${freeGb}GB free`);
+    pruneBackups(3);
+    await sendTelegramNotify(`\u26A0\uFE0F REX: Disk low (${freeGb}GB free)`);
+  }
+}
+async function ingestCycle() {
+  log.info("Ingest cycle start");
+  runCmd("rex ingest");
+  runCmd("rex categorize --batch=100", 18e4);
+  runCmd("rex recategorize --batch=20", 18e4);
+  log.info("Ingest cycle done");
+}
+async function maintenanceCycle() {
+  log.info("Maintenance cycle start");
+  backupDb();
+  pruneBackups(7);
+  runCmd("rex projects", 3e4);
+  rotateLog();
+  log.info("Maintenance cycle done");
+}
+async function selfReviewCycle() {
+  log.info("Self-review cycle start");
+  runCmd("rex self-review");
+  const config = loadConfig();
+  if (config.notifications.daily) {
+    try {
+      const Database = (await import("better-sqlite3")).default;
+      const db = new Database(MEMORY_DB_PATH, { readonly: true });
+      const total = db.prepare("SELECT COUNT(*) as c FROM memories").get().c;
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const todayCount = db.prepare("SELECT COUNT(*) as c FROM memories WHERE created_at >= ?").get(today).c;
+      const uncategorized = db.prepare("SELECT COUNT(*) as c FROM memories WHERE category IN ('session', 'general')").get().c;
+      db.close();
+      const msg = `\u{1F996} *REX Daily*
+
+Memories: ${total} total, +${todayCount} today
+Uncategorized: ${uncategorized}
+Disk: ${checkDiskSpace()}GB free`;
+      await sendTelegramNotify(msg);
+    } catch {
+    }
+  }
+  log.info("Self-review cycle done");
+}
+async function daemon() {
+  ensureRexDirs();
+  const config = loadConfig();
+  log.info("REX Daemon started");
+  log.info(`Health: ${config.daemon.healthCheckInterval}s | Ingest: ${config.daemon.ingestInterval}s | Maintenance: ${config.daemon.maintenanceInterval}s | Self-review: ${config.daemon.selfReviewInterval}s`);
+  await healthCheck();
+  let lastHealth = Date.now();
+  let lastIngest = Date.now();
+  let lastMaintenance = Date.now();
+  let lastSelfReview = Date.now();
+  await maintenanceCycle();
+  while (true) {
+    const now = Date.now();
+    if (now - lastHealth >= config.daemon.healthCheckInterval * 1e3) {
+      await healthCheck();
+      lastHealth = now;
+    }
+    if (now - lastIngest >= config.daemon.ingestInterval * 1e3) {
+      await ingestCycle();
+      lastIngest = now;
+    }
+    if (now - lastMaintenance >= config.daemon.maintenanceInterval * 1e3) {
+      await maintenanceCycle();
+      lastMaintenance = now;
+    }
+    if (now - lastSelfReview >= config.daemon.selfReviewInterval * 1e3) {
+      await selfReviewCycle();
+      lastSelfReview = now;
+    }
+    await new Promise((r) => setTimeout(r, 3e4));
+  }
+}
+export {
+  daemon
+};