@askexenow/exe-os 0.9.294 → 0.9.296

package/dist/chunk-OTPRHBTO.js

@@ -0,0 +1,33 @@
+import {
+  completeReminder
+} from "./chunk-MEP7OUVZ.js";
+
+// src/mcp/tools/complete-reminder.ts
+import { z } from "zod";
+function registerCompleteReminder(server) {
+  server.registerTool(
+    "complete_reminder",
+    {
+      title: "Complete Reminder",
+      description: "Mark a reminder as done. Accepts UUID or text substring.",
+      inputSchema: {
+        reminder_id: z.string().describe("Reminder UUID or text substring to match")
+      }
+    },
+    async ({ reminder_id }) => {
+      const reminder = await completeReminder(reminder_id);
+      if (!reminder) {
+        return {
+          content: [{ type: "text", text: `No active reminder matching "${reminder_id}".` }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Reminder completed: "${reminder.text}"` }]
+      };
+    }
+  );
+}
+
+export {
+  registerCompleteReminder
+};

package/dist/chunk-P6MUA4QU.js

@@ -0,0 +1,157 @@
+import {
+  clean,
+  stableId
+} from "./chunk-465PQFTH.js";
+
+// src/lib/reflection-checkpoints.ts
+function parsePayload(payload) {
+  if (!payload) return {};
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return {};
+  }
+}
+function semanticArray(event, key) {
+  const payload = parsePayload(event.payload);
+  const semantic = payload.semantic;
+  const value = semantic?.[key];
+  return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function buildReflectionCheckpoint(events) {
+  if (!events.length) return null;
+  const sorted = [...events].sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  const goals = /* @__PURE__ */ new Set();
+  const successes = [];
+  const failures = [];
+  const risks = [];
+  const nextActions = [];
+  const decisions = [];
+  for (const event of sorted) {
+    for (const goal of semanticArray(event, "goals")) goals.add(goal);
+    for (const item of semanticArray(event, "successSignals")) successes.push(item);
+    for (const item of semanticArray(event, "failureSignals")) failures.push(item);
+    for (const item of semanticArray(event, "nextActions")) nextActions.push(item);
+    for (const item of semanticArray(event, "decisions")) decisions.push(item);
+    if (event.impact === "negative" || event.outcome === "failure_signal" || event.event_type === "problem" || event.event_type === "error") {
+      failures.push(event.outcome || event.intention || event.event_type);
+    }
+    if (event.outcome === "risk_signal") risks.push(event.intention || event.outcome);
+    if (event.impact === "positive" || event.outcome === "success_signal" || event.event_type === "milestone") {
+      successes.push(event.outcome || event.intention || event.event_type);
+    }
+  }
+  const uniqueGoals = [...goals].slice(0, 6);
+  const uniqueSuccesses = [...new Set(successes.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueFailures = [...new Set(failures.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueRisks = [...new Set(risks.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueNext = [...new Set(nextActions.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueDecisions = [...new Set(decisions.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const learnings = [
+    uniqueSuccesses.length ? `Working: ${uniqueSuccesses.slice(0, 3).join("; ")}` : "Working: no strong success signal yet",
+    uniqueFailures.length ? `Improve: ${uniqueFailures.slice(0, 3).join("; ")}` : "Improve: no strong failure signal in this window",
+    uniqueDecisions.length ? `Decision context: ${uniqueDecisions.slice(0, 2).join("; ")}` : "Decision context: no explicit decision signal"
+  ];
+  const summary = clean([
+    `Window ${first.occurred_at} \u2192 ${last.occurred_at}`,
+    `${sorted.length} events`,
+    uniqueGoals.length ? `goals: ${uniqueGoals.join("; ")}` : "goals: inferred from event trajectory",
+    uniqueSuccesses.length ? `successes: ${uniqueSuccesses.slice(0, 2).join("; ")}` : "successes: none explicit",
+    uniqueFailures.length ? `failures: ${uniqueFailures.slice(0, 2).join("; ")}` : "failures: none explicit"
+  ].join(". "), 1200);
+  return {
+    id: stableId("reflection", first.project_name ?? "", first.session_id ?? "", first.occurred_at, last.occurred_at, sorted.length),
+    projectName: first.project_name ?? null,
+    sessionId: first.session_id ?? null,
+    windowStartAt: first.occurred_at,
+    windowEndAt: last.occurred_at,
+    eventCount: sorted.length,
+    goalCount: uniqueGoals.length,
+    successCount: uniqueSuccesses.length,
+    failureCount: uniqueFailures.length,
+    riskCount: uniqueRisks.length,
+    summary,
+    learnings,
+    nextActions: uniqueNext.length ? uniqueNext : ["Continue from latest successful event and resolve highest-impact failure/risk first."],
+    evidenceEventIds: sorted.slice(-25).map((e) => e.id),
+    confidence: Math.min(0.95, 0.5 + Math.min(sorted.length, 100) / 250 + uniqueGoals.length * 0.03)
+  };
+}
+async function resolveClient(client) {
+  if (client) return client;
+  const { getClient } = await import("./lib/database.js");
+  return getClient();
+}
+async function insertReflectionCheckpoint(checkpoint, client) {
+  const db = await resolveClient(client);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `INSERT INTO agent_reflection_checkpoints
+      (id, project_name, session_id, window_start_at, window_end_at, event_count, goal_count,
+       success_count, failure_count, risk_count, summary, learnings, next_actions, evidence_event_ids,
+       confidence, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET summary = excluded.summary, learnings = excluded.learnings,
+        next_actions = excluded.next_actions, confidence = excluded.confidence`,
+    args: [
+      checkpoint.id,
+      checkpoint.projectName,
+      checkpoint.sessionId,
+      checkpoint.windowStartAt,
+      checkpoint.windowEndAt,
+      checkpoint.eventCount,
+      checkpoint.goalCount,
+      checkpoint.successCount,
+      checkpoint.failureCount,
+      checkpoint.riskCount,
+      checkpoint.summary,
+      JSON.stringify(checkpoint.learnings),
+      JSON.stringify(checkpoint.nextActions),
+      JSON.stringify(checkpoint.evidenceEventIds),
+      checkpoint.confidence,
+      now
+    ]
+  });
+}
+async function generateReflectionCheckpoints(opts = {}) {
+  const db = await resolveClient(opts.client);
+  const windowSize = opts.windowSize ?? 100;
+  const minEvents = opts.minEvents ?? 20;
+  const limit = opts.limit ?? 5e3;
+  const where = opts.projectName ? "WHERE project_name = ?" : "";
+  const args = opts.projectName ? [opts.projectName] : [];
+  const result = await db.execute({
+    sql: `SELECT id, event_type, occurred_at, actor_agent_id, project_name, session_id, intention, outcome, impact, evidence_memory_id, payload
+          FROM agent_events ${where}
+          ORDER BY project_name, session_id, occurred_at, sequence_index
+          LIMIT ?`,
+    args: [...args, limit]
+  });
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const event = row;
+    const key = `${event.project_name ?? ""}::${event.session_id ?? ""}`;
+    const bucket = groups.get(key) ?? [];
+    bucket.push(event);
+    groups.set(key, bucket);
+  }
+  let inserted = 0;
+  for (const events of groups.values()) {
+    for (let i = 0; i < events.length; i += windowSize) {
+      const window = events.slice(i, i + windowSize);
+      if (window.length < minEvents) continue;
+      const checkpoint = buildReflectionCheckpoint(window);
+      if (!checkpoint) continue;
+      await insertReflectionCheckpoint(checkpoint, db);
+      inserted++;
+    }
+  }
+  return inserted;
+}
+
+export {
+  buildReflectionCheckpoint,
+  generateReflectionCheckpoints
+};