@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/bin/backfill-vectors.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import {
+  politeBatchPause,
+  startManagedJob
+} from "../chunk-X3AVWFWW.js";
+import {
+  cleanupWorkerPid,
+  registerWorkerPid,
+  releaseBackfillLock,
+  tryAcquireBackfillLock
+} from "../chunk-NFB4N53K.js";
+import {
+  connectEmbedDaemon,
+  embedViaClient
+} from "../chunk-L24HYX62.js";
+import "../chunk-YADYM2DE.js";
+import {
+  initStore,
+  vectorToBlob
+} from "../chunk-HTCBLSIB.js";
+import "../chunk-CHCA3ZM2.js";
+import "../chunk-IW53DAYO.js";
+import "../chunk-F7LU65PQ.js";
+import "../chunk-MP2AFCGL.js";
+import "../chunk-PWMMIGVQ.js";
+import {
+  getClient
+} from "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-7NNXBDOO.js";
+import {
+  EXE_AI_DIR
+} from "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import {
+  isMainModule
+} from "../chunk-6Y4B3QF6.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/backfill-vectors.ts
+import { existsSync, unlinkSync } from "fs";
+import path from "path";
+var BATCH_SIZE = 100;
+var BACKFILL_FLAG = path.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+async function backfillVectors() {
+  const job = startManagedJob({ type: "vector-backfill", name: "Vector embedding backfill", lowPriority: true });
+  if (!job) {
+    process.stderr.write("[backfill] Vector backfill is already running \u2014 exiting\n");
+    return { processed: 0, failed: 0, remaining: -1 };
+  }
+  if (!tryAcquireBackfillLock()) {
+    process.stderr.write("[backfill] Another backfill is already running \u2014 exiting\n");
+    job.cancel();
+    return { processed: 0, failed: 0, remaining: -1 };
+  }
+  registerWorkerPid(process.pid);
+  const cleanup = () => {
+    cleanupWorkerPid();
+    releaseBackfillLock();
+  };
+  process.on("exit", cleanup);
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  await initStore();
+  const connected = await connectEmbedDaemon();
+  if (!connected) {
+    process.stderr.write("[backfill] Cannot connect to embedding daemon \u2014 aborting\n");
+    job.fail(new Error("Cannot connect to embedding daemon"));
+    return { processed: 0, failed: 0, remaining: -1 };
+  }
+  const client = getClient();
+  let totalProcessed = 0;
+  let totalFailed = 0;
+  while (true) {
+    const batch = await client.execute({
+      sql: "SELECT id, raw_text FROM memories WHERE vector IS NULL LIMIT ?",
+      args: [BATCH_SIZE]
+    });
+    if (batch.rows.length === 0) break;
+    process.stderr.write(`[backfill] Processing batch of ${batch.rows.length} memories...
+`);
+    job.update({ current: totalProcessed, label: `Processing batch of ${batch.rows.length} memories` });
+    for (const row of batch.rows) {
+      const id = row.id;
+      const rawText = row.raw_text;
+      try {
+        const vector = await embedViaClient(rawText, "low");
+        if (!vector) {
+          totalFailed++;
+          process.stderr.write(`[backfill] Failed to embed memory ${id} \u2014 daemon returned null
+`);
+          continue;
+        }
+        await client.execute({
+          sql: "UPDATE memories SET vector = vector32(?) WHERE id = ?",
+          args: [vectorToBlob(vector), id]
+        });
+        totalProcessed++;
+      } catch (err) {
+        totalFailed++;
+        process.stderr.write(`[backfill] Error embedding ${id}: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+    process.stderr.write(`[backfill] Batch done. Processed: ${totalProcessed}, Failed: ${totalFailed}
+`);
+    job.update({ current: totalProcessed, label: `Processed ${totalProcessed}, failed ${totalFailed}` });
+    await politeBatchPause(500);
+  }
+  const remaining = await client.execute({
+    sql: "SELECT COUNT(*) as cnt FROM memories WHERE vector IS NULL",
+    args: []
+  });
+  const remainingCount = Number(remaining.rows[0]?.cnt) || 0;
+  if (remainingCount === 0) {
+    try {
+      unlinkSync(BACKFILL_FLAG);
+    } catch {
+    }
+  }
+  process.stderr.write(`[backfill] Complete. Processed: ${totalProcessed}, Failed: ${totalFailed}, Remaining: ${remainingCount}
+`);
+  if (totalFailed > 0) job.fail(new Error(`${totalFailed} embeddings failed`));
+  else job.complete();
+  return { processed: totalProcessed, failed: totalFailed, remaining: remainingCount };
+}
+function isBackfillNeeded() {
+  return existsSync(BACKFILL_FLAG);
+}
+if (isMainModule(import.meta.url)) {
+  backfillVectors().then((result) => {
+    console.log(JSON.stringify(result));
+    process.exit(result.failed > 0 ? 1 : 0);
+  }).catch((err) => {
+    console.error("Backfill failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}
+export {
+  backfillVectors,
+  isBackfillNeeded
+};

package/dist/bin/bulk-sync-postgres.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import {
+  pushToPostgres
+} from "../chunk-JBKA7F5V.js";
+import "../chunk-EEAKFEEA.js";
+import "../chunk-HOKOOBDL.js";
+import {
+  disposeStore,
+  initStore
+} from "../chunk-HTCBLSIB.js";
+import "../chunk-CHCA3ZM2.js";
+import "../chunk-IW53DAYO.js";
+import "../chunk-F7LU65PQ.js";
+import "../chunk-MP2AFCGL.js";
+import {
+  getClient
+} from "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-7NNXBDOO.js";
+import "../chunk-D4IVTUNN.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/bulk-sync-postgres.ts
+var BATCH_SIZE = 500;
+async function main() {
+  process.env.EXE_IS_DAEMON = "1";
+  await initStore({ lightweight: true });
+  const client = getClient();
+  const countResult = await client.execute(
+    "SELECT COUNT(*) as cnt FROM memories WHERE scope IS NULL OR scope != 'personal'"
+  );
+  const total = Number(countResult.rows[0]?.cnt ?? 0);
+  if (total === 0) {
+    process.stderr.write("[bulk-sync] No memories to sync.\n");
+    await disposeStore();
+    return;
+  }
+  process.stderr.write(`[bulk-sync] Starting bulk sync of ${total.toLocaleString()} memories to Postgres raw.*
+`);
+  let offset = 0;
+  let totalInserted = 0;
+  while (offset < total) {
+    const result = await client.execute({
+      sql: `SELECT id, agent_id, agent_role, session_id, timestamp,
+                   tool_name, project_name, has_error, raw_text, version,
+                   author_device_id, scope, memory_type
+            FROM memories
+            WHERE scope IS NULL OR scope != 'personal'
+            ORDER BY version ASC
+            LIMIT ? OFFSET ?`,
+      args: [BATCH_SIZE, offset]
+    });
+    if (result.rows.length === 0) break;
+    const records = result.rows.map((row) => ({
+      id: row.id,
+      agent_id: row.agent_id,
+      agent_role: row.agent_role,
+      session_id: row.session_id,
+      timestamp: row.timestamp,
+      tool_name: row.tool_name,
+      project_name: row.project_name,
+      has_error: row.has_error,
+      raw_text: row.raw_text,
+      version: row.version,
+      author_device_id: row.author_device_id,
+      scope: row.scope,
+      memory_type: row.memory_type
+    }));
+    const inserted = await pushToPostgres(records);
+    totalInserted += inserted;
+    offset += result.rows.length;
+    const pct = Math.round(offset / total * 100);
+    process.stderr.write(`\r[bulk-sync] ${offset.toLocaleString()} / ${total.toLocaleString()} (${pct}%) \u2014 ${totalInserted.toLocaleString()} inserted`);
+  }
+  process.stderr.write(`
+[bulk-sync] Done. ${totalInserted.toLocaleString()} memories pushed to raw.raw_events.
+`);
+  await disposeStore();
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((err) => {
+    process.stderr.write(`[bulk-sync] FATAL: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  main
+};

package/dist/bin/cc-doctor.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import {
+  checkClaudeCodeInstall
+} from "../chunk-DGOGCPYU.js";
+import "../chunk-YZKJLGWL.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import {
+  isMainModule
+} from "../chunk-6Y4B3QF6.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/cc-doctor.ts
+var LABELS = {
+  "cc/execpath-clean": "EXECPATH",
+  "cc/cli-binary": "Symlink",
+  "cc/native-cache-clean": "Native cache",
+  "cc/autoupdater-disabled": "Auto-updater",
+  "cc/version": "Version"
+};
+function formatResult(r) {
+  const icon = r.pass ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+  const label = LABELS[r.name] ?? r.name;
+  return `${icon} ${label}: ${r.detail}`;
+}
+function runCcDoctor() {
+  const results = checkClaudeCodeInstall();
+  const passed = results.filter((r) => r.pass).length;
+  const failed = results.filter((r) => !r.pass).length;
+  return { results, passed, failed };
+}
+if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("cc-doctor")) {
+  const { results, passed, failed } = runCcDoctor();
+  console.log("\n  CC Install Health Check\n");
+  for (const r of results) {
+    console.log(`  ${formatResult(r)}`);
+  }
+  if (failed === 0) {
+    console.log(`
+  \x1B[32mStatus: CLEAN\x1B[0m \u2014 no 20K billing risk (${passed} checks passed)
+`);
+  } else {
+    console.log(`
+  \x1B[31mStatus: ${failed} ISSUE${failed > 1 ? "S" : ""} FOUND\x1B[0m \u2014 ${passed} passed, ${failed} failed`);
+    console.log("  Fix: npm install -g @anthropic-ai/claude-code@2.1.98\n");
+  }
+  process.exit(failed > 0 ? 1 : 0);
+}
+export {
+  runCcDoctor
+};

package/dist/bin/cleanup-stale-review-tasks.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import {
+  fastDbInit
+} from "../chunk-DKRTWILB.js";
+import {
+  sessionScopeFilter
+} from "../chunk-UBMGUX6T.js";
+import "../chunk-I2CDSGQW.js";
+import "../chunk-QI4IXJN7.js";
+import "../chunk-4JERP7NT.js";
+import "../chunk-G4LLKD4Z.js";
+import "../chunk-MVW62NIZ.js";
+import "../chunk-OYNKIAVW.js";
+import "../chunk-CX6GL3ZJ.js";
+import "../chunk-CTFKTUYN.js";
+import "../chunk-GVP5U4WL.js";
+import "../chunk-NGP6LSV2.js";
+import "../chunk-V3QAAU2U.js";
+import "../chunk-CVYC6DUW.js";
+import "../chunk-OPU3NYOO.js";
+import "../chunk-GJV3WDWM.js";
+import "../chunk-MP2AFCGL.js";
+import "../chunk-RMPAMMYW.js";
+import "../chunk-HYZV25LY.js";
+import {
+  getClient
+} from "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-D4IVTUNN.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import {
+  isMainModule
+} from "../chunk-6Y4B3QF6.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/cleanup-stale-review-tasks.ts
+async function findZombies(beforeIso, assignedTo) {
+  const client = getClient();
+  const args = [];
+  let beforeClause = "";
+  let assigneeClause = "";
+  if (beforeIso) {
+    beforeClause = "AND created_at < ?";
+    args.push(beforeIso);
+  }
+  if (assignedTo) {
+    assigneeClause = "AND assigned_to = ?";
+    args.push(assignedTo);
+  }
+  const csScope = sessionScopeFilter();
+  const result = await client.execute({
+    sql: `SELECT id, assigned_to, title, created_at
+          FROM tasks
+          WHERE status IN ('open', 'in_progress')
+            AND title LIKE 'Review:%'
+            ${beforeClause}
+            ${assigneeClause}${csScope.sql}
+          ORDER BY created_at ASC`,
+    args: [...args, ...csScope.args]
+  });
+  return result.rows.map((r) => ({
+    id: String(r.id),
+    assigned_to: String(r.assigned_to),
+    title: String(r.title),
+    created_at: String(r.created_at)
+  }));
+}
+async function statsByAssignee() {
+  const client = getClient();
+  const sbScope = sessionScopeFilter();
+  const r = await client.execute({
+    sql: `SELECT assigned_to, COUNT(*) as n, MIN(created_at) as oldest, MAX(created_at) as newest
+          FROM tasks
+          WHERE status IN ('open','in_progress') AND title LIKE 'Review:%'${sbScope.sql}
+          GROUP BY assigned_to ORDER BY n DESC`,
+    args: [...sbScope.args]
+  });
+  console.log("Stats by assignee:");
+  for (const row of r.rows) {
+    console.log(`  ${row.assigned_to}: ${row.n} (oldest ${row.oldest}, newest ${row.newest})`);
+  }
+}
+async function cancelZombies(ids) {
+  if (ids.length === 0) return 0;
+  const client = getClient();
+  const placeholders = ids.map(() => "?").join(",");
+  const result = await client.execute({
+    sql: `UPDATE tasks
+          SET status='cancelled',
+              result='Dangling pre-refactor review (commit ebb5d47, needs_review status replaced this workflow). Underlying work shipped + approved.',
+              updated_at=CURRENT_TIMESTAMP
+          WHERE id IN (${placeholders})`,
+    args: ids
+  });
+  return Number(result.rowsAffected ?? 0);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const apply = args.includes("--apply");
+  const stats = args.includes("--stats");
+  const beforeIdx = args.indexOf("--before");
+  const beforeIso = beforeIdx >= 0 ? args[beforeIdx + 1] : void 0;
+  const assigneeIdx = args.indexOf("--assignee");
+  const assignee = assigneeIdx >= 0 ? args[assigneeIdx + 1] : void 0;
+  await fastDbInit();
+  if (stats) {
+    await statsByAssignee();
+    process.exit(0);
+  }
+  const zombies = await findZombies(beforeIso, assignee);
+  console.log(`Found ${zombies.length} zombie review task(s)${beforeIso ? ` created before ${beforeIso}` : ""}`);
+  if (zombies.length === 0) {
+    process.exit(0);
+  }
+  const sample = zombies.slice(0, 10);
+  console.log("Sample (oldest 10):");
+  for (const z of sample) {
+    console.log(`  ${z.created_at}  \u2192  ${z.assigned_to}  |  ${z.title.slice(0, 90)}`);
+  }
+  if (zombies.length > 10) {
+    console.log(`  ...and ${zombies.length - 10} more`);
+  }
+  if (!apply) {
+    console.log("\nDRY RUN \u2014 pass --apply to cancel these tasks.");
+    process.exit(0);
+  }
+  const updated = await cancelZombies(zombies.map((z) => z.id));
+  console.log(`
+Cancelled ${updated} zombie review task(s).`);
+}
+if (isMainModule(import.meta.url)) {
+  main().catch((err) => {
+    process.stderr.write(`[cleanup-stale-review-tasks] FATAL: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}