@askexenow/exe-os 0.9.293 → 0.9.294

package/dist/bin/exe-boot.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   generateStatusBrief
-} from "../chunk-I35KAK3E.js";
+} from "../chunk-GM6W3IXQ.js";
 import {
   DEFAULT_EXE,
   getSessionPrompt
@@ -1025,6 +1025,26 @@ async function boot(options) {
     };
   } catch {
   }
+  try {
+    const { scanUnmergedBranches } = await import("../branch-hygiene-55TKIWAZ.js");
+    const STALE_HOURS = 24;
+    const scan = scanUnmergedBranches(process.cwd(), { staleHours: STALE_HOURS });
+    if (scan.total > 0) {
+      briefData.unmergedBranches = {
+        total: scan.total,
+        staleCount: scan.staleCount,
+        staleHours: STALE_HOURS,
+        truncated: scan.truncated,
+        branches: scan.branches.map((b) => ({
+          name: b.name,
+          ahead: b.ahead,
+          ageHours: b.ageHours,
+          filesChanged: b.filesChanged
+        }))
+      };
+    }
+  } catch {
+  }
   try {
     const { fileURLToPath } = await import("url");
     const thisFile = fileURLToPath(import.meta.url);

package/dist/bin/exe-doctor.js

@@ -21,9 +21,9 @@ import {
   parseFlags,
   runAudit,
   splitAtSentences
-} from "../chunk-LSTM35QE.js";
-import "../chunk-KQ4Z2G24.js";
+} from "../chunk-5ALAYSQY.js";
 import "../chunk-BNJ3YCPD.js";
+import "../chunk-KQ4Z2G24.js";
 import "../chunk-OTVEIJUQ.js";
 import "../chunk-L3TB7CC3.js";
 import "../chunk-6Y4B3QF6.js";

package/dist/bin/exe-forget.js

@@ -4,7 +4,7 @@ import {
 } from "../chunk-QAK47LG3.js";
 import {
   lightweightSearch
-} from "../chunk-XCP56OMR.js";
+} from "../chunk-CZYJEUNA.js";
 import "../chunk-AB4PAQYK.js";
 import "../chunk-EM5WXY6H.js";
 import "../chunk-CHCA3ZM2.js";

package/dist/bin/exe-search.js

@@ -2,7 +2,7 @@
 import {
   hybridSearch,
   lightweightSearch
-} from "../chunk-XCP56OMR.js";
+} from "../chunk-CZYJEUNA.js";
 import "../chunk-AB4PAQYK.js";
 import {
   initStore

package/dist/branch-hygiene-55TKIWAZ.js

@@ -0,0 +1,136 @@
+import "./chunk-MLKGABMK.js";
+
+// src/lib/branch-hygiene.ts
+import { execFileSync } from "child_process";
+var GIT_TIMEOUT_MS = 4e3;
+var MAX_BRANCHES_SCANNED = 60;
+var DEFAULT_LISTING_CAP = 10;
+function git(repoRoot, args) {
+  return execFileSync("git", args, {
+    cwd: repoRoot,
+    encoding: "utf8",
+    timeout: GIT_TIMEOUT_MS,
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function detectRemoteBase(repoRoot) {
+  for (const candidate of ["main", "master"]) {
+    try {
+      git(repoRoot, ["rev-parse", "--verify", `refs/remotes/origin/${candidate}`]);
+      return `origin/${candidate}`;
+    } catch {
+    }
+  }
+  return null;
+}
+function parseRefLine(line) {
+  const [name, committedAt] = line.split("");
+  if (!name) return null;
+  return { name: name.replace(/^origin\//, ""), committedAt: committedAt ?? "" };
+}
+function scanUnmergedBranches(repoRoot, options = {}) {
+  const staleHours = options.staleHours ?? 24;
+  const listingCap = options.listingCap ?? DEFAULT_LISTING_CAP;
+  const empty = { branches: [], total: 0, staleCount: 0, truncated: false };
+  let base;
+  try {
+    base = detectRemoteBase(repoRoot);
+  } catch {
+    return empty;
+  }
+  if (!base) return empty;
+  let lines;
+  try {
+    const raw = git(repoRoot, [
+      "for-each-ref",
+      `--no-merged=${base}`,
+      "--sort=-committerdate",
+      "--format=%(refname:short)%(committerdate:iso-strict)",
+      "refs/remotes/origin"
+    ]);
+    lines = raw ? raw.split("\n") : [];
+  } catch {
+    return empty;
+  }
+  const baseShort = base.replace(/^origin\//, "");
+  const now = Date.now();
+  const out = [];
+  let scanned = 0;
+  let truncated = false;
+  for (const line of lines) {
+    const parsed = parseRefLine(line);
+    if (!parsed) continue;
+    if (parsed.name === baseShort || parsed.name === "HEAD") continue;
+    if (scanned >= MAX_BRANCHES_SCANNED) {
+      truncated = true;
+      break;
+    }
+    scanned++;
+    let ahead = 0;
+    try {
+      const cnt = git(repoRoot, ["rev-list", "--count", `${base}..origin/${parsed.name}`]);
+      ahead = parseInt(cnt, 10) || 0;
+    } catch {
+      ahead = 0;
+    }
+    if (ahead <= 0) continue;
+    let filesChanged = 0;
+    try {
+      const diff = git(repoRoot, ["diff", "--name-only", `${base}...origin/${parsed.name}`]);
+      filesChanged = diff ? diff.split("\n").filter(Boolean).length : 0;
+    } catch {
+      filesChanged = 0;
+    }
+    const committedMs = parsed.committedAt ? Date.parse(parsed.committedAt) : NaN;
+    const ageHours = Number.isFinite(committedMs) ? Math.max(0, (now - committedMs) / 36e5) : 0;
+    out.push({
+      name: parsed.name,
+      ahead,
+      committedAt: parsed.committedAt,
+      ageHours,
+      filesChanged
+    });
+  }
+  const staleCount = out.filter((b) => b.ageHours >= staleHours).length;
+  return {
+    branches: out.slice(0, listingCap),
+    total: out.length,
+    staleCount,
+    truncated
+  };
+}
+function slugForMatch(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function findMatchingBranches(repoRoot, opts) {
+  const result = [];
+  const scan = scanUnmergedBranches(repoRoot, { listingCap: MAX_BRANCHES_SCANNED });
+  if (scan.branches.length === 0) return result;
+  const idToken = opts.id ? slugForMatch(opts.id) : "";
+  const shortId = idToken ? idToken.replace(/-/g, "").slice(0, 8) : "";
+  const titleSlug = opts.title ? slugForMatch(opts.title) : "";
+  const titleTokens = new Set(titleSlug.split("-").filter((t) => t.length >= 4));
+  for (const b of scan.branches) {
+    const branchSlug = slugForMatch(b.name);
+    const branchCompact = branchSlug.replace(/-/g, "");
+    let matched = false;
+    if (idToken && (branchSlug.includes(idToken) || shortId && branchCompact.includes(shortId))) {
+      matched = true;
+    } else if (titleTokens.size > 0) {
+      const branchTokens = new Set(branchSlug.split("-"));
+      let overlap = 0;
+      for (const t of titleTokens) if (branchTokens.has(t)) overlap++;
+      if (overlap >= 2) matched = true;
+    }
+    if (matched) {
+      result.push({ name: b.name, ahead: b.ahead, ageHours: b.ageHours });
+    }
+  }
+  return result;
+}
+export {
+  DEFAULT_LISTING_CAP,
+  findMatchingBranches,
+  scanUnmergedBranches,
+  slugForMatch
+};

package/dist/catchup-brief-DTETFZYW.js

@@ -0,0 +1,175 @@
+import {
+  lightweightSearch
+} from "./chunk-CZYJEUNA.js";
+import "./chunk-AB4PAQYK.js";
+import "./chunk-EM5WXY6H.js";
+import "./chunk-CHCA3ZM2.js";
+import "./chunk-OTVEIJUQ.js";
+import "./chunk-DQBHY3Q4.js";
+import "./chunk-Y25OJWOQ.js";
+import {
+  sessionScopeFilter,
+  strictSessionScopeFilter
+} from "./chunk-2ZXMXFGH.js";
+import "./chunk-E45SQG7C.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-4FVVJ7ME.js";
+import "./chunk-RAERYWCL.js";
+import "./chunk-HN3HGFBL.js";
+import "./chunk-YNORJIBH.js";
+import "./chunk-SSTLTIF3.js";
+import "./chunk-DVFHAY2J.js";
+import "./chunk-QRTJNSKU.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-GJS7CJRC.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-HH3MBGMJ.js";
+import "./chunk-HYZV25LY.js";
+import {
+  getClient
+} from "./chunk-TM2GZWIT.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-D3X64YSB.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-Z42MXYWW.js";
+import "./chunk-YTKVJJSU.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/catchup-brief.ts
+import { execSync } from "child_process";
+var HEADER = "## Catchup Brief\nHere's what happened while you were offline:";
+var DEFAULT_LOOKBACK_MS = 60 * 60 * 1e3;
+var MAX_BRIEF_CHARS = 2e3;
+var MAX_CHECKPOINT_CHARS = 500;
+var MAX_MESSAGE_CHARS = 100;
+function clipText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  if (maxChars <= 1) return "\u2026";
+  return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+}
+function clampSections(header, sections, maxChars) {
+  const bounded = [];
+  let remaining = Math.max(0, maxChars - header.length);
+  for (const section of sections) {
+    const separatorChars = 2;
+    if (remaining <= separatorChars) break;
+    remaining -= separatorChars;
+    if (section.length <= remaining) {
+      bounded.push(section);
+      remaining -= section.length;
+      continue;
+    }
+    const clipped = clipText(section, remaining);
+    if (clipped.trim().length > 0) bounded.push(clipped);
+    break;
+  }
+  return bounded;
+}
+async function buildCatchupBrief(agentId, projectName, cwd, sessionScope) {
+  const sections = [];
+  let lastTimestamp = new Date(Date.now() - DEFAULT_LOOKBACK_MS).toISOString();
+  try {
+    const checkpointMemories = await lightweightSearch(
+      "CONTEXT CHECKPOINT",
+      agentId,
+      { projectName, limit: 1 }
+    );
+    const checkpoint = checkpointMemories[0];
+    if (checkpoint?.timestamp) {
+      lastTimestamp = checkpoint.timestamp;
+    }
+    if (checkpoint?.raw_text) {
+      sections.push(
+        `### Last Checkpoint
+${clipText(checkpoint.raw_text, MAX_CHECKPOINT_CHARS)}`
+      );
+    }
+  } catch {
+  }
+  try {
+    const gitLog = execSync(
+      `git log --oneline --since=${JSON.stringify(lastTimestamp)} --format="%h %an: %s" | head -10`,
+      { cwd, timeout: 3e3, encoding: "utf-8" }
+    ).trim();
+    if (gitLog) {
+      sections.push(`### Git Activity Since You Left
+\`\`\`
+${gitLog}
+\`\`\``);
+    }
+  } catch {
+  }
+  try {
+    const client = getClient();
+    const taskScope = sessionScopeFilter(sessionScope);
+    const taskChanges = await client.execute({
+      sql: `SELECT title, status, priority FROM tasks
+            WHERE assigned_to = ? AND project_name = ?
+              AND updated_at > ? AND status IN ('open', 'in_progress')${taskScope.sql}
+            ORDER BY priority ASC, updated_at DESC LIMIT 5`,
+      args: [agentId, projectName, lastTimestamp, ...taskScope.args]
+    });
+    if (taskChanges.rows.length > 0) {
+      const taskLines = taskChanges.rows.map((row) => {
+        const record = row;
+        return `- [${String(record.priority).toUpperCase()}] ${String(record.title)} (${String(record.status)})`;
+      }).join("\n");
+      sections.push(`### Your Task Queue
+${taskLines}`);
+    }
+  } catch {
+  }
+  try {
+    const client = getClient();
+    const messageScope = strictSessionScopeFilter(sessionScope);
+    const messages = await client.execute({
+      sql: `SELECT from_agent, content, created_at FROM messages
+            WHERE target_agent = ? AND status = 'pending'${messageScope.sql}
+            ORDER BY created_at DESC LIMIT 3`,
+      args: [agentId, ...messageScope.args]
+    });
+    if (messages.rows.length > 0) {
+      const msgLines = messages.rows.map((row) => {
+        const record = row;
+        return `- From ${String(record.from_agent)}: ${clipText(String(record.content ?? ""), MAX_MESSAGE_CHARS)}`;
+      }).join("\n");
+      sections.push(`### Unread Messages
+${msgLines}`);
+    }
+  } catch {
+  }
+  try {
+    const { getPendingProspective, markSurfaced } = await import("./prospective-memory-JOKZL7QJ.js");
+    const due = await getPendingProspective(agentId, { projectName, limit: 5 });
+    if (due.length > 0) {
+      const now = Date.now();
+      const lines = due.map((item) => {
+        const overdue = item.dueDate != null && new Date(item.dueDate).getTime() < now;
+        const when = item.dueDate ? `due ${item.dueDate}${overdue ? " \u2014 OVERDUE" : ""}` : "someday";
+        const recur = item.recurrence !== "once" ? `, ${item.recurrence}` : "";
+        return `- [P${item.priority}] ${clipText(item.content, MAX_CHECKPOINT_CHARS)} (${when}${recur})`;
+      });
+      sections.push(`### Reminders Due (Prospective Memory)
+${lines.join("\n")}`);
+      try {
+        await markSurfaced(due.map((d) => d.id));
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return {
+    header: HEADER,
+    sections: clampSections(HEADER, sections, MAX_BRIEF_CHARS)
+  };
+}
+export {
+  buildCatchupBrief
+};