@askexenow/exe-os 0.9.292 → 0.9.293

package/dist/chunk-7P5TUGTL.js

@@ -0,0 +1,456 @@
+import {
+  getGitRoot,
+  isWorktreeDirty
+} from "./chunk-XADXYWPE.js";
+
+// src/lib/worktree-sweep.ts
+import { execFileSync } from "child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+var GIT_TIMEOUT_MS = 1e4;
+var DIRTY_ORPHAN_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function isWorktreeUnpushed(wtPath, branch) {
+  if (!branch) return false;
+  try {
+    const remote = execFileSync("git", ["-C", wtPath, "rev-parse", "--abbrev-ref", `${branch}@{upstream}`], { encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "ignore"] }).trim();
+    if (!remote) return true;
+    const ahead = execFileSync("git", ["-C", wtPath, "rev-list", `${remote}..${branch}`, "--count"], { encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "ignore"] }).trim();
+    return parseInt(ahead, 10) > 0;
+  } catch {
+    try {
+      let ahead = "";
+      try {
+        ahead = execFileSync("git", ["-C", wtPath, "rev-list", `main..${branch}`, "--count"], { encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "ignore"] }).trim();
+      } catch {
+        ahead = execFileSync("git", ["-C", wtPath, "rev-list", `master..${branch}`, "--count"], { encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "ignore"] }).trim();
+      }
+      return parseInt(ahead, 10) > 0;
+    } catch {
+      return true;
+    }
+  }
+}
+var REPO_ALIASES = {
+  "exe-crm": ["openclaw", "exe-crm"],
+  "exe-wiki": ["ink", "exe-wiki"]
+};
+function discoverRepoPaths() {
+  const roots = [];
+  let exeOsRoot = null;
+  let dir = path.dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "@askexenow/exe-os") {
+          exeOsRoot = dir;
+          break;
+        }
+      } catch {
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  if (!exeOsRoot) {
+    exeOsRoot = process.cwd();
+  }
+  roots.push(exeOsRoot);
+  const parentDir = path.dirname(exeOsRoot);
+  try {
+    const siblings = readdirSync(parentDir);
+    for (const sibling of siblings) {
+      if (sibling.startsWith(".")) continue;
+      const siblingPath = path.join(parentDir, sibling);
+      if (siblingPath === exeOsRoot) continue;
+      const root = getGitRoot(siblingPath);
+      if (root && !roots.includes(root)) {
+        roots.push(root);
+      }
+    }
+  } catch {
+  }
+  for (const aliases of Object.values(REPO_ALIASES)) {
+    for (const alias of aliases) {
+      const aliasPath = path.join(parentDir, alias);
+      if (existsSync(aliasPath)) {
+        const root = getGitRoot(aliasPath);
+        if (root && !roots.includes(root)) {
+          roots.push(root);
+        }
+      }
+    }
+  }
+  return roots;
+}
+function listWorktrees(repoRoot) {
+  try {
+    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const worktrees = [];
+    let currentPath = "";
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        currentPath = line.slice("worktree ".length);
+      } else if (line.startsWith("branch ") && currentPath) {
+        const branch = line.slice("branch refs/heads/".length);
+        worktrees.push({ path: currentPath, branch });
+        currentPath = "";
+      }
+    }
+    return worktrees;
+  } catch {
+    return [];
+  }
+}
+function detectMainBranch(repoRoot) {
+  for (const candidate of ["main", "master"]) {
+    try {
+      execFileSync("git", ["rev-parse", "--verify", `refs/heads/${candidate}`], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function isBranchMerged(repoRoot, branch, into) {
+  try {
+    const merged = execFileSync("git", ["branch", "--merged", into], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return merged.split("\n").map((l) => l.replace(/^[*+]?\s+/, "").trim()).includes(branch);
+  } catch {
+    return false;
+  }
+}
+function hasLiveTmuxSession(agentName) {
+  try {
+    const sessions = execFileSync("tmux", ["list-sessions", "-F", "#S"], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    if (!sessions) return false;
+    for (const session of sessions.split("\n")) {
+      const agentPart = session.split("-")[0];
+      if (!agentPart) continue;
+      const baseName = agentPart.replace(/\d+$/, "");
+      if (baseName === agentName || agentPart === agentName) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function removeWorktree(repoRoot, wtPath) {
+  try {
+    execFileSync("git", ["worktree", "remove", wtPath, "--force"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteBranch(repoRoot, branch) {
+  try {
+    execFileSync("git", ["branch", "-D", branch], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteRemoteBranch(repoRoot, branch) {
+  try {
+    execFileSync("git", ["push", "origin", "--delete", branch], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pruneWorktreeRegistry(repoRoot) {
+  try {
+    execFileSync("git", ["worktree", "prune"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+}
+function clearStashes(repoRoot) {
+  try {
+    const stashList = execFileSync("git", ["stash", "list"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!stashList) return 0;
+    const count = stashList.split("\n").length;
+    execFileSync("git", ["stash", "clear"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function parseAgentName(wtPath) {
+  const dirName = path.basename(wtPath);
+  if (!dirName) return null;
+  return dirName.replace(/\d+$/, "") || dirName;
+}
+function getDirMtimeMs(dirPath) {
+  try {
+    return statSync(dirPath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function archiveDirtyWorktree(wtPath, agentName) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const quarantineBranch = `quarantine/${agentName}-${timestamp}`;
+  try {
+    execFileSync("git", ["-C", wtPath, "checkout", "-b", quarantineBranch], {
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    execFileSync("git", ["-C", wtPath, "add", "-A"], {
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    execFileSync("git", [
+      "-C",
+      wtPath,
+      "commit",
+      "-m",
+      `[quarantine] Auto-archived dirty orphan worktree
+
+Agent: ${agentName}
+Original worktree: ${wtPath}
+Archived by worktree-sweep after ${DIRTY_ORPHAN_MAX_AGE_MS / 864e5}-day dirty orphan threshold.`
+    ], {
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: "exe-os daemon",
+        GIT_AUTHOR_EMAIL: "daemon@exe-os.local",
+        GIT_COMMITTER_NAME: "exe-os daemon",
+        GIT_COMMITTER_EMAIL: "daemon@exe-os.local"
+      }
+    });
+    process.stderr.write(`[worktree-sweep] Archived dirty changes to branch ${quarantineBranch}
+`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function sweepWorktrees(options = {}) {
+  const dryRun = options.dryRun ?? false;
+  const repoPaths = options.repoPaths ?? discoverRepoPaths();
+  const result = {
+    reposScanned: 0,
+    removed: [],
+    branchesDeleted: [],
+    stashesCleared: 0,
+    skipped: [],
+    errors: []
+  };
+  for (const repoPath of repoPaths) {
+    const repoRoot = getGitRoot(repoPath);
+    if (!repoRoot) continue;
+    result.reposScanned++;
+    const repoName = path.basename(repoRoot);
+    const mainBranch = detectMainBranch(repoRoot);
+    if (!dryRun) {
+      pruneWorktreeRegistry(repoRoot);
+    }
+    const worktrees = listWorktrees(repoRoot);
+    for (const wt of worktrees) {
+      if (!wt.path.includes("/.worktrees/")) continue;
+      const agentName = parseAgentName(wt.path);
+      const wtName = path.basename(wt.path);
+      if (agentName && hasLiveTmuxSession(agentName)) {
+        result.skipped.push({
+          repo: repoName,
+          worktree: wtName,
+          branch: wt.branch,
+          reason: "live tmux session"
+        });
+        continue;
+      }
+      if (existsSync(wt.path) && isWorktreeDirty(wt.path)) {
+        const mtimeMs = getDirMtimeMs(wt.path);
+        const ageMs = mtimeMs !== null ? Date.now() - mtimeMs : 0;
+        if (ageMs >= DIRTY_ORPHAN_MAX_AGE_MS && agentName && !dryRun) {
+          const ageD = Math.round(ageMs / 864e5);
+          process.stderr.write(
+            `[worktree-sweep] Dirty orphan aged out (${ageD}d), archiving: ${repoName}/.worktrees/${wtName}
+`
+          );
+          const archived = archiveDirtyWorktree(wt.path, agentName);
+          if (archived) {
+          } else {
+            result.skipped.push({
+              repo: repoName,
+              worktree: wtName,
+              branch: wt.branch,
+              reason: `uncommitted changes (archive failed after ${ageD}d)`
+            });
+            continue;
+          }
+        } else if (ageMs >= DIRTY_ORPHAN_MAX_AGE_MS && dryRun) {
+          const ageD = Math.round(ageMs / 864e5);
+          result.removed.push({ repo: repoName, worktree: wtName, branch: wt.branch });
+          process.stderr.write(
+            `[worktree-sweep] [DRY-RUN] Would archive+remove dirty orphan (${ageD}d): ${repoName}/.worktrees/${wtName}
+`
+          );
+          continue;
+        } else {
+          result.skipped.push({
+            repo: repoName,
+            worktree: wtName,
+            branch: wt.branch,
+            reason: "uncommitted changes"
+          });
+          continue;
+        }
+      }
+      if (existsSync(wt.path) && isWorktreeUnpushed(wt.path, wt.branch)) {
+        result.skipped.push({
+          repo: repoName,
+          worktree: wtName,
+          branch: wt.branch,
+          reason: "unpushed commits \u2014 push first or use --force"
+        });
+        continue;
+      }
+      const isMerged = mainBranch ? isBranchMerged(repoRoot, wt.branch, mainBranch) : false;
+      if (dryRun) {
+        result.removed.push({ repo: repoName, worktree: wtName, branch: wt.branch });
+        if (isMerged || !mainBranch) {
+          result.branchesDeleted.push({ repo: repoName, branch: wt.branch, remote: true });
+        } else {
+          result.branchesDeleted.push({ repo: repoName, branch: wt.branch, remote: false });
+        }
+        continue;
+      }
+      const removed = removeWorktree(repoRoot, wt.path);
+      if (!removed) {
+        result.errors.push(`${repoName}: failed to remove worktree ${wtName}`);
+        continue;
+      }
+      result.removed.push({ repo: repoName, worktree: wtName, branch: wt.branch });
+      process.stderr.write(`[worktree-sweep] Removed ${repoName}/.worktrees/${wtName} (branch: ${wt.branch})
+`);
+      const localDeleted = deleteBranch(repoRoot, wt.branch);
+      let remoteDeleted = false;
+      if (localDeleted) {
+        remoteDeleted = deleteRemoteBranch(repoRoot, wt.branch);
+      }
+      if (localDeleted) {
+        result.branchesDeleted.push({ repo: repoName, branch: wt.branch, remote: remoteDeleted });
+      }
+    }
+    if (!dryRun) {
+      const cleared = clearStashes(repoRoot);
+      if (cleared > 0) {
+        result.stashesCleared += cleared;
+        process.stderr.write(`[worktree-sweep] Cleared ${cleared} stash(es) in ${repoName}
+`);
+      }
+    }
+    if (!dryRun) {
+      pruneWorktreeRegistry(repoRoot);
+    }
+  }
+  return result;
+}
+function cleanupAgentWorktree(repoRoot, agentName) {
+  const worktreesDir = path.join(repoRoot, ".worktrees");
+  if (!existsSync(worktreesDir)) return "";
+  const notes = [];
+  try {
+    const entries = readdirSync(worktreesDir);
+    for (const entry of entries) {
+      const baseName = entry.replace(/\d+$/, "") || entry;
+      const agentBase = agentName.replace(/\d+$/, "") || agentName;
+      if (baseName !== agentBase) continue;
+      const wtPath = path.join(worktreesDir, entry);
+      const branch = getWorktreeBranch(repoRoot, wtPath);
+      if (isWorktreeDirty(wtPath)) {
+        notes.push(`Worktree .worktrees/${entry} has uncommitted changes \u2014 preserved`);
+        continue;
+      }
+      if (isWorktreeUnpushed(wtPath, branch)) {
+        notes.push(`Worktree .worktrees/${entry} has unpushed commits \u2014 preserved`);
+        continue;
+      }
+      if (removeWorktree(repoRoot, wtPath)) {
+        notes.push(`Removed worktree .worktrees/${entry}`);
+        if (branch && deleteBranch(repoRoot, branch)) {
+          notes.push(`Deleted branch ${branch}`);
+          if (deleteRemoteBranch(repoRoot, branch)) {
+            notes.push(`Deleted remote branch ${branch}`);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  pruneWorktreeRegistry(repoRoot);
+  return notes.join("\n");
+}
+function getWorktreeBranch(repoRoot, wtPath) {
+  try {
+    const worktrees = listWorktrees(repoRoot);
+    for (const wt of worktrees) {
+      if (wt.path === wtPath) return wt.branch;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  discoverRepoPaths,
+  sweepWorktrees,
+  cleanupAgentWorktree
+};

package/dist/chunk-7XDF7BZQ.js

@@ -0,0 +1,192 @@
+// src/lib/retrieval-health.ts
+async function getRetrievalHealth() {
+  let embedDaemon = "unavailable";
+  try {
+    const { isDaemonAlive } = await import("./mcp-health-WDOB6XUB.js");
+    const { alive } = isDaemonAlive();
+    if (alive) {
+      try {
+        const { pingDaemon } = await import("./lib/exe-daemon-client.js");
+        const health = await pingDaemon();
+        if (health) {
+          const embeddingField = health.embedding;
+          if (embeddingField === "ok") {
+            embedDaemon = "running";
+          } else if (embeddingField === "disabled") {
+            embedDaemon = "disabled";
+          } else {
+            embedDaemon = "stopped";
+          }
+        } else {
+          embedDaemon = "stopped";
+        }
+      } catch {
+        embedDaemon = "stopped";
+      }
+    } else {
+      embedDaemon = "unavailable";
+    }
+  } catch {
+    embedDaemon = "unavailable";
+  }
+  let configuredSearchMode = "hybrid";
+  let selfQueryRouterEnabled = true;
+  try {
+    const { loadConfigSync } = await import("./lib/config.js");
+    const cfg = loadConfigSync();
+    configuredSearchMode = cfg.searchMode ?? "hybrid";
+    selfQueryRouterEnabled = cfg.selfQueryRouter ?? true;
+  } catch {
+  }
+  let actualSearchMode;
+  if (configuredSearchMode === "fts") {
+    actualSearchMode = "fts+graph";
+  } else if (embedDaemon === "running") {
+    actualSearchMode = "hybrid (vector+fts+graph)";
+  } else {
+    actualSearchMode = "fts+graph (degraded from hybrid)";
+  }
+  let queryRouter;
+  if (!selfQueryRouterEnabled) {
+    queryRouter = "disabled";
+  } else if (embedDaemon === "running" || embedDaemon === "disabled") {
+    queryRouter = process.env.ANTHROPIC_API_KEY ? "active" : "fallback";
+  } else {
+    queryRouter = "fallback";
+  }
+  let totalMemories = 0;
+  let memoriesWithVectors = 0;
+  let entities = 0;
+  let relationships = 0;
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const [totalRes, vectorRes] = await Promise.all([
+      client.execute("SELECT COUNT(*) as cnt FROM memories WHERE status IS NULL OR status != 'deleted'"),
+      client.execute("SELECT COUNT(*) as cnt FROM memories WHERE vector IS NOT NULL AND (status IS NULL OR status != 'deleted')")
+    ]);
+    totalMemories = Number(totalRes.rows[0]?.cnt ?? 0);
+    memoriesWithVectors = Number(vectorRes.rows[0]?.cnt ?? 0);
+    try {
+      const { getGraphStats } = await import("./graph-query-AP5R6ZHO.js");
+      const stats = await getGraphStats(client);
+      entities = stats.entities;
+      relationships = stats.relationships;
+    } catch {
+    }
+  } catch {
+  }
+  const staleCount = totalMemories - memoriesWithVectors;
+  const coveragePct = totalMemories > 0 ? Math.round(memoriesWithVectors / totalMemories * 100) : null;
+  let dbRestore = { hasEvents: false, count: 0, last: null, quarantineFiles: 0 };
+  try {
+    const { getDbRestoreHealth } = await import("./db-restore-events-GNZS42YO.js");
+    dbRestore = getDbRestoreHealth();
+  } catch {
+  }
+  const summary = {
+    embedDaemon,
+    searchMode: {
+      configured: configuredSearchMode,
+      actual: actualSearchMode
+    },
+    queryRouter,
+    vectorBackfill: {
+      totalMemories,
+      memoriesWithVectors,
+      staleCount,
+      coveragePct
+    },
+    graph: {
+      entities,
+      relationships
+    },
+    dbRestore
+  };
+  return {
+    ...summary,
+    degradations: computeDegradations(summary)
+  };
+}
+function computeDegradations(h) {
+  const out = [];
+  const isRuntimeDowngrade = h.searchMode.actual.includes("degraded");
+  if (isRuntimeDowngrade) {
+    out.push({
+      code: "retrieval_downgraded",
+      severity: "warn",
+      message: `Retrieval running as "${h.searchMode.actual}" (configured: "${h.searchMode.configured}")`,
+      remediation: h.embedDaemon === "disabled" ? "Embeddings are disabled. Enable them in settings if you want vector retrieval." : "Embed daemon is not running. Start the daemon / embed worker to restore hybrid retrieval."
+    });
+  } else if (h.searchMode.configured === "fts") {
+    out.push({
+      code: "embeddings_off",
+      severity: "info",
+      message: "Search mode is FTS-only by configuration (keyword + graph; no vector retrieval)",
+      remediation: 'Switch searchMode to "hybrid" in settings to enable vector retrieval.'
+    });
+  }
+  if (h.queryRouter === "fallback") {
+    out.push({
+      code: "query_router_fallback",
+      severity: "warn",
+      message: "Self-query-router using rule-based fallback (no LLM routing)",
+      remediation: "Set ANTHROPIC_API_KEY (and ensure the embed daemon is reachable) to enable LLM-based query routing."
+    });
+  }
+  if (h.dbRestore.hasEvents) {
+    const last = h.dbRestore.last;
+    if (last && (last.kind === "restore-failed" || last.kind === "zeroed-no-wal")) {
+      out.push({
+        code: "db_corruption_unrecovered",
+        severity: "critical",
+        message: `DB corruption could not be auto-recovered: ${last.detail ?? last.kind} (${last.at})`,
+        remediation: "Restore from a known-good backup (`exe-os cloud reupload` or restore a backup); preserved corrupt DB is in ~/.exe-os/."
+      });
+    } else if (last && (last.kind === "auto-restore" || last.kind === "wal-recovery")) {
+      out.push({
+        code: "db_auto_restored",
+        severity: "warn",
+        message: last.kind === "auto-restore" ? `DB was auto-restored from backup${last.restoredFrom ? ` (${last.restoredFrom})` : ""}${typeof last.hoursLost === "number" ? `, ~${last.hoursLost}h data-loss window` : ""} at ${last.at}` : `DB was reconstructed from WAL after a 0-byte corruption at ${last.at}`,
+        remediation: "Recent memories may be missing. Run a cloud sync to reconcile and verify recent data."
+      });
+    } else if (h.dbRestore.quarantineFiles > 0) {
+      out.push({
+        code: "db_corruption_quarantine",
+        severity: "warn",
+        message: `${h.dbRestore.quarantineFiles} quarantined corrupt DB file(s) present in ~/.exe-os/ (prior corruption event)`,
+        remediation: "Verify data integrity; remove quarantined .corrupt-*/.zeroed-* files once you've confirmed no data is needed."
+      });
+    }
+  }
+  return out;
+}
+var SEVERITY_ICON = {
+  info: "\u2139\uFE0F",
+  // ℹ️
+  warn: "\u{1F7E0}",
+  // 🟠
+  critical: "\u{1F534}"
+  // 🔴
+};
+function formatDegradations(degradations, heading = "Degradations") {
+  const lines = [];
+  lines.push(`### ${heading}`);
+  if (degradations.length === 0) {
+    lines.push("\u{1F7E2} None \u2014 all retrieval and storage subsystems nominal.");
+    return lines.join("\n");
+  }
+  const order = { critical: 0, warn: 1, info: 2 };
+  const sorted = [...degradations].sort((a, b) => order[a.severity] - order[b.severity]);
+  for (const d of sorted) {
+    lines.push(`${SEVERITY_ICON[d.severity]} ${d.message}`);
+    if (d.remediation) lines.push(`   \u2192 ${d.remediation}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  getRetrievalHealth,
+  computeDegradations,
+  formatDegradations
+};