@askexenow/exe-os 0.9.265 → 0.9.266

package/dist/chunk-QKMFMJTU.js

@@ -0,0 +1,171 @@
+import {
+  writeMemoryViaDaemon
+} from "./chunk-Q3GLQDZI.js";
+
+// src/lib/auto-checkpoint.ts
+var FILE_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;
+var DECISION_RE = /\b(decision:|decided:|we decided|founder directive|captured in .*architecture|source of truth)\b/i;
+function asString(value, fallback = "") {
+  if (value == null) return fallback;
+  return String(value);
+}
+function compactLine(text, max = 220) {
+  return text.replace(/\s+/g, " ").trim().slice(0, max);
+}
+function topEntries(counts, limit) {
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([name, count]) => `${name}(${count})`);
+}
+function buildAutoCheckpoint(input) {
+  const maxSamples = input.maxSamples ?? 8;
+  const projectCounts = /* @__PURE__ */ new Map();
+  const toolCounts = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Set();
+  const errors = [];
+  const samples = [];
+  const decisionTexts = [];
+  for (const row of input.memories) {
+    const tool = asString(row.tool_name, "unknown");
+    const project = asString(row.project_name, input.projectName || "unknown");
+    const raw = asString(row.raw_text);
+    const hasError = row.has_error === 1 || row.has_error === true;
+    toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+    projectCounts.set(project, (projectCounts.get(project) ?? 0) + 1);
+    if (hasError && errors.length < 5) errors.push(compactLine(raw, 180));
+    if (samples.length < maxSamples && raw.length > 30) {
+      samples.push(`[${tool}] ${compactLine(raw)}`);
+    }
+    if (DECISION_RE.test(raw) && decisionTexts.length < 5) {
+      decisionTexts.push(`AUTO DECISION CANDIDATE [${input.agentId}]: ${compactLine(raw, 500)}`);
+    }
+    for (const match of raw.matchAll(FILE_RE)) {
+      if (match[1]) files.add(match[1]);
+      if (files.size >= 20) break;
+    }
+  }
+  const taskLines = (input.tasks ?? []).slice(0, 10).map((task) => {
+    const status = asString(task.status, "unknown");
+    const priority = asString(task.priority, "?").toUpperCase();
+    const title = asString(task.title, "untitled");
+    const taskFile = asString(task.task_file);
+    return `- [${status}/${priority}] ${title}${taskFile ? ` (${taskFile})` : ""}`;
+  });
+  const parts = [
+    `CONTEXT CHECKPOINT [auto:${input.reason}]`,
+    `Agent: ${input.agentId} (${input.agentRole})`,
+    `Session: ${input.sessionId}`,
+    `Project: ${input.projectName}`,
+    `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Recent Activity",
+    `- Memories scanned: ${input.memories.length}`,
+    `- Projects: ${topEntries(projectCounts, 5).join(", ") || input.projectName}`,
+    `- Tools: ${topEntries(toolCounts, 8).join(", ") || "none"}`
+  ];
+  if (taskLines.length > 0) {
+    parts.push("", "## Open / Active Tasks", ...taskLines);
+  }
+  if (files.size > 0) {
+    parts.push("", "## Files Mentioned", ...[...files].slice(0, 20).map((f) => `- ${f}`));
+  }
+  if (samples.length > 0) {
+    parts.push("", "## Important Recent Traces", ...samples.map((s) => `- ${s}`));
+  }
+  if (errors.length > 0) {
+    parts.push("", "## Errors / Risks", ...errors.map((e) => `- ${e}`));
+  }
+  if (decisionTexts.length > 0) {
+    parts.push("", "## Decision Candidates", ...decisionTexts.map((d) => `- ${d.replace(/^AUTO DECISION CANDIDATE \\[[^\\]]+\\]: /, "")}`));
+  }
+  return {
+    checkpointText: parts.join("\n"),
+    decisionTexts
+  };
+}
+
+// src/lib/checkpoint-orchestrator.ts
+function toolNameForReason(reason) {
+  switch (reason) {
+    case "periodic":
+      return "auto-summary";
+    case "session-end":
+      return "SessionEnd";
+    case "pre-compact":
+      return "pre-compact-hook";
+    case "capacity-signal":
+      return "auto-checkpoint";
+  }
+}
+function importanceForReason(reason, override) {
+  if (override !== void 0) return override;
+  switch (reason) {
+    case "periodic":
+      return 7;
+    case "session-end":
+    case "pre-compact":
+    case "capacity-signal":
+      return 8;
+  }
+}
+function buildContinuityCheckpoint(input) {
+  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+    agentId: input.agentId,
+    agentRole: input.agentRole,
+    sessionId: input.sessionId,
+    projectName: input.projectName,
+    reason: input.reason,
+    memories: input.memories ?? [],
+    tasks: input.tasks ?? [],
+    maxSamples: input.maxSamples
+  });
+  const extra = input.extraSections?.filter((section) => section.trim().length > 0) ?? [];
+  return {
+    checkpointText: extra.length > 0 ? `${checkpointText}
+
+${extra.join("\n\n")}` : checkpointText,
+    decisionTexts
+  };
+}
+async function writeContinuityCheckpoint(input) {
+  const result = buildContinuityCheckpoint(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await writeMemoryViaDaemon({
+    raw_text: result.checkpointText,
+    agent_id: input.agentId,
+    agent_role: input.agentRole,
+    session_id: input.sessionId,
+    tool_name: toolNameForReason(input.reason),
+    project_name: input.projectName,
+    timestamp: now,
+    importance: importanceForReason(input.reason, input.importance),
+    task_id: input.taskId,
+    memory_type: "checkpoint"
+  });
+  const decisionLimit = input.reason === "periodic" ? 3 : 5;
+  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
+    await writeMemoryViaDaemon({
+      raw_text: decisionText,
+      agent_id: input.agentId,
+      agent_role: input.agentRole,
+      session_id: input.sessionId,
+      tool_name: "auto-decision",
+      project_name: input.projectName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 8,
+      memory_type: "decision"
+    });
+  }
+  return result;
+}
+async function checkpointActiveTask(input) {
+  const { writeCheckpoint } = await import("./lib/tasks.js");
+  await writeCheckpoint({
+    taskId: input.taskId,
+    step: input.step ?? "pre-compaction-checkpoint",
+    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`
+  });
+}
+
+export {
+  writeContinuityCheckpoint,
+  checkpointActiveTask
+};