@askexenow/exe-os 0.9.280 → 0.9.281

package/dist/chunk-72UA2FB3.js

@@ -0,0 +1,181 @@
+import {
+  getClient
+} from "./chunk-WUKEXVOR.js";
+import {
+  loadConfig
+} from "./chunk-T3B5RK4H.js";
+
+// src/lib/reminders.ts
+import crypto from "crypto";
+async function getCloudConfig() {
+  try {
+    const config = await loadConfig();
+    if (config.cloud?.apiKey && config.cloud?.endpoint) {
+      return { apiKey: config.cloud.apiKey, endpoint: config.cloud.endpoint };
+    }
+  } catch {
+  }
+  return null;
+}
+function apiBaseUrl(cloud) {
+  try {
+    const url = new URL(cloud.endpoint);
+    if (url.hostname.startsWith("sync.")) {
+      url.hostname = url.hostname.replace(/^sync\./, "api.");
+      return url.origin;
+    }
+  } catch {
+  }
+  return "https://api.askexe.com";
+}
+async function cloudPushReminder(cloud, text, dueDate) {
+  try {
+    const base = apiBaseUrl(cloud);
+    await fetch(`${base}/v1/reminders`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text, due_date: dueDate })
+    });
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud push failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+async function cloudFetchReminders(cloud) {
+  try {
+    const base = apiBaseUrl(cloud);
+    const res = await fetch(`${base}/v1/reminders`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`
+      }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    if (!Array.isArray(data.items)) return [];
+    return data.items.map((r) => ({
+      id: r.id,
+      text: r.text,
+      createdAt: r.created_at,
+      dueDate: r.due_date,
+      completedAt: r.completed_at,
+      source: "cloud"
+    }));
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud fetch failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return [];
+  }
+}
+async function cloudDeleteReminder(cloud, id) {
+  try {
+    const base = apiBaseUrl(cloud);
+    await fetch(`${base}/v1/reminders/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`
+      }
+    });
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud delete failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+function dedup(local, cloud) {
+  const localKeys = /* @__PURE__ */ new Set();
+  for (const r of local) {
+    localKeys.add(`${r.text.trim().toLowerCase()}|${r.dueDate ?? ""}`);
+  }
+  const merged = local.map((r) => ({ ...r, source: "local" }));
+  for (const r of cloud) {
+    const key = `${r.text.trim().toLowerCase()}|${r.dueDate ?? ""}`;
+    if (localKeys.has(key)) {
+      const existing = merged.find(
+        (m) => m.text.trim().toLowerCase() === r.text.trim().toLowerCase() && (m.dueDate ?? "") === (r.dueDate ?? "")
+      );
+      if (existing) existing.source = "both";
+    } else {
+      merged.push({ ...r, source: "cloud" });
+    }
+  }
+  return merged;
+}
+async function createReminder(text, dueDate) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await client.execute({
+    sql: `INSERT INTO reminders (id, text, created_at, due_date) VALUES (?, ?, ?, ?)`,
+    args: [id, text, now, dueDate ?? null]
+  });
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    cloudPushReminder(cloud, text, dueDate ?? null).catch(() => {
+    });
+  }
+  return { id, text, createdAt: now, dueDate: dueDate ?? null, completedAt: null };
+}
+async function listReminders(includeCompleted = false) {
+  const client = getClient();
+  const sql = includeCompleted ? `SELECT id, text, created_at, due_date, completed_at FROM reminders ORDER BY due_date ASC NULLS LAST LIMIT 500` : `SELECT id, text, created_at, due_date, completed_at FROM reminders WHERE completed_at IS NULL ORDER BY due_date ASC NULLS LAST LIMIT 500`;
+  const result = await client.execute(sql);
+  const local = result.rows.map((row) => ({
+    id: String(row.id),
+    text: String(row.text),
+    createdAt: String(row.created_at),
+    dueDate: row.due_date ? String(row.due_date) : null,
+    completedAt: row.completed_at ? String(row.completed_at) : null
+  }));
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    const cloudReminders = await cloudFetchReminders(cloud);
+    return dedup(local, cloudReminders);
+  }
+  return local;
+}
+async function completeReminder(idOrText) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let result = await client.execute({
+    sql: `SELECT id, text FROM reminders WHERE id = ? AND completed_at IS NULL`,
+    args: [idOrText]
+  });
+  if (result.rows.length === 0) {
+    result = await client.execute({
+      sql: `SELECT id, text FROM reminders WHERE completed_at IS NULL AND text LIKE '%' || ? || '%' LIMIT 1`,
+      args: [idOrText]
+    });
+  }
+  if (result.rows.length === 0) return null;
+  const row = result.rows[0];
+  const id = String(row.id);
+  const text = String(row.text);
+  await client.execute({
+    sql: `UPDATE reminders SET completed_at = ? WHERE id = ?`,
+    args: [now, id]
+  });
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    cloudDeleteReminder(cloud, id).catch(() => {
+    });
+    cloudFetchReminders(cloud).then((cloudReminders) => {
+      for (const cr of cloudReminders) {
+        if (cr.text.trim().toLowerCase() === text.trim().toLowerCase()) {
+          cloudDeleteReminder(cloud, cr.id).catch(() => {
+          });
+        }
+      }
+    }).catch(() => {
+    });
+  }
+  return { id, text, createdAt: "", dueDate: null, completedAt: now };
+}
+
+export {
+  createReminder,
+  listReminders,
+  completeReminder
+};

package/dist/chunk-77DMFEOL.js

@@ -0,0 +1,30 @@
+import {
+  createReminder
+} from "./chunk-6TRSVY7L.js";
+
+// src/mcp/tools/create-reminder.ts
+import { z } from "zod";
+function registerCreateReminder(server) {
+  server.registerTool(
+    "create_reminder",
+    {
+      title: "Create Reminder",
+      description: "Set a reminder for the founder. Shown in the boot brief every session.",
+      inputSchema: {
+        text: z.string().describe("What to remind about"),
+        due_date: z.string().optional().describe("Optional due date \u2014 ISO date (2026-04-01) or null for persistent")
+      }
+    },
+    async ({ text, due_date }) => {
+      const reminder = await createReminder(text, due_date);
+      const dueStr = reminder.dueDate ? ` (due: ${reminder.dueDate})` : "";
+      return {
+        content: [{ type: "text", text: `Reminder set: "${reminder.text}"${dueStr}` }]
+      };
+    }
+  );
+}
+
+export {
+  registerCreateReminder
+};

package/dist/chunk-7COXVQ5W.js

@@ -0,0 +1,214 @@
+import {
+  sessionScopeFilter
+} from "./chunk-PWPJK7KB.js";
+
+// src/lib/git-task-sweep.ts
+import { execSync } from "child_process";
+var DEFAULT_COMMIT_LIMIT = 50;
+var DEFAULT_STALE_MINUTES = 10;
+var AUTO_ESCALATE_THRESHOLD = 0.6;
+var EXACT_UUID_SCORE = 1;
+var TITLE_KEYWORD_SCORE = 0.5;
+var FILE_PATH_SCORE = 0.3;
+var MIN_KEYWORD_OVERLAP = 3;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "as",
+  "be",
+  "was",
+  "are",
+  "this",
+  "that",
+  "not",
+  "no",
+  "if",
+  "so",
+  "do",
+  "up"
+]);
+function extractKeywords(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+}
+function matchScore(task, commitMessage, changedFiles) {
+  if (task.id.length >= 8 && commitMessage.includes(task.id)) {
+    return EXACT_UUID_SCORE;
+  }
+  let score = 0;
+  const titleWords = extractKeywords(task.title);
+  const commitWords = new Set(extractKeywords(commitMessage));
+  const overlap = titleWords.filter((w) => commitWords.has(w));
+  if (overlap.length >= MIN_KEYWORD_OVERLAP) {
+    score += TITLE_KEYWORD_SCORE;
+  }
+  if (task.context && changedFiles.length > 0) {
+    const contextLower = task.context.toLowerCase();
+    const hasFileMatch = changedFiles.some(
+      (f) => contextLower.includes(f.toLowerCase())
+    );
+    if (hasFileMatch) {
+      score += FILE_PATH_SCORE;
+    }
+  }
+  return score;
+}
+function getRecentCommits(limit = DEFAULT_COMMIT_LIMIT) {
+  try {
+    const SEPARATOR = "<<SEP>>";
+    const output = execSync(
+      `git log --format="%h${SEPARATOR}%s${SEPARATOR}%aI" --name-only -n ${limit} -z`,
+      { encoding: "utf8", timeout: 1e4 }
+    );
+    const entries = output.split("\0").filter(Boolean);
+    const commits = [];
+    let current = null;
+    for (const entry of entries) {
+      if (entry.includes(SEPARATOR)) {
+        const lines = entry.split("\n");
+        const headerLine = lines[0];
+        const parts = headerLine.split(SEPARATOR);
+        if (parts.length >= 3) {
+          if (current) commits.push(current);
+          current = {
+            hash: parts[0],
+            message: parts[1],
+            files: lines.slice(1).filter(Boolean),
+            date: new Date(parts[2])
+          };
+        }
+      } else if (current) {
+        const files = entry.split("\n").filter(Boolean);
+        current.files.push(...files);
+      }
+    }
+    if (current) commits.push(current);
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function isStale(updatedAt, staleMinutes) {
+  const updated = new Date(updatedAt).getTime();
+  const threshold = Date.now() - staleMinutes * 6e4;
+  return updated < threshold;
+}
+function findBestMatch(task, commits) {
+  let best = null;
+  for (const commit of commits) {
+    const score = matchScore(task, commit.message, commit.files);
+    if (score >= AUTO_ESCALATE_THRESHOLD && (!best || score > best.score)) {
+      best = { commit, score };
+    }
+  }
+  return best;
+}
+async function sweepTasks(projectName, options = {}) {
+  const commitLimit = options.commitLimit ?? DEFAULT_COMMIT_LIMIT;
+  const staleMinutes = options.staleMinutes ?? DEFAULT_STALE_MINUTES;
+  const dryRun = options.dryRun ?? false;
+  const result = { escalated: [], unchanged: 0, errors: [] };
+  const commits = getRecentCommits(commitLimit);
+  if (commits.length === 0) {
+    result.errors.push("No git commits found (not a git repo or empty history)");
+    return result;
+  }
+  let tasks;
+  try {
+    const { initStore } = await import("./lib/store.js");
+    await initStore();
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const conditions = ["status = 'in_progress'"];
+    const args = [];
+    if (projectName) {
+      conditions.push("project_name = ?");
+      args.push(projectName);
+    }
+    const swScope = sessionScopeFilter();
+    if (swScope.sql) {
+      conditions.push("(session_scope IS NULL OR session_scope = ?)");
+      args.push(...swScope.args);
+    }
+    const queryResult = await client.execute({
+      sql: `SELECT id, title, assigned_to, project_name, status, updated_at, context
+            FROM tasks WHERE ${conditions.join(" AND ")}
+            ORDER BY updated_at ASC`,
+      args
+    });
+    tasks = queryResult.rows.map((r) => ({
+      id: String(r.id),
+      title: String(r.title),
+      assignedTo: String(r.assigned_to),
+      projectName: String(r.project_name),
+      status: String(r.status),
+      updatedAt: String(r.updated_at),
+      context: r.context ? String(r.context) : void 0
+    }));
+  } catch (err) {
+    result.errors.push(`DB query failed: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  if (tasks.length === 0) {
+    return result;
+  }
+  for (const task of tasks) {
+    if (!isStale(task.updatedAt, staleMinutes)) {
+      result.unchanged++;
+      continue;
+    }
+    const match = findBestMatch(task, commits);
+    if (!match) {
+      result.unchanged++;
+      continue;
+    }
+    if (!dryRun) {
+      try {
+        const { updateTaskStatus } = await import("./tasks-crud-NV6JEWGL.js");
+        await updateTaskStatus({
+          taskId: task.id,
+          status: "needs_review",
+          result: `Auto-escalated by git-sweep: matching commit ${match.commit.hash} found (score: ${match.score.toFixed(2)})`
+        });
+      } catch (err) {
+        result.errors.push(
+          `Failed to escalate task ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
+      }
+    }
+    result.escalated.push({
+      taskId: task.id,
+      title: task.title,
+      matchedCommit: match.commit.hash,
+      score: match.score
+    });
+    process.stderr.write(
+      `[git-sweep] ${dryRun ? "WOULD escalate" : "Escalated"} task ${task.id} \u2192 commit ${match.commit.hash} (score: ${match.score.toFixed(2)})
+`
+    );
+  }
+  return result;
+}
+
+export {
+  extractKeywords,
+  matchScore,
+  getRecentCommits,
+  findBestMatch,
+  sweepTasks
+};

package/dist/chunk-7HLWBYH7.js

@@ -0,0 +1,60 @@
+// src/lib/mcp-health.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { homedir } from "os";
+var PID_PATH = path.join(homedir(), ".exe-os", "exed.pid");
+function isDaemonAlive() {
+  if (_isDaemonProcess) {
+    return { alive: true, pid: process.pid };
+  }
+  try {
+    if (!existsSync(PID_PATH)) {
+      const socketPath = process.env.EXE_DAEMON_SOCK ?? path.join(homedir(), ".exe-os", "exed.sock");
+      if (existsSync(socketPath)) return { alive: true, pid: null };
+      return { alive: false, pid: null };
+    }
+    const pid = parseInt(readFileSync(PID_PATH, "utf8").trim(), 10);
+    if (!Number.isFinite(pid) || pid <= 0) return { alive: false, pid: null };
+    process.kill(pid, 0);
+    return { alive: true, pid };
+  } catch {
+    return { alive: false, pid: null };
+  }
+}
+function isMcpHealthy(_timeoutMs = 2e3) {
+  if (_isDaemonProcess) return true;
+  const { alive } = isDaemonAlive();
+  if (!alive) return false;
+  const socketPath = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path.join(homedir(), ".exe-os", "exed.sock");
+  return existsSync(socketPath);
+}
+var _isDaemonProcess = false;
+function markAsDaemonProcess() {
+  _isDaemonProcess = true;
+}
+var EVENT_LOOP_DEGRADED_THRESHOLD_MS = 5e3;
+var _eventLoopLagMs = 0;
+var _eventLoopLagUpdatedAt = 0;
+function setEventLoopLagMs(lagMs) {
+  _eventLoopLagMs = lagMs;
+  _eventLoopLagUpdatedAt = Date.now();
+}
+function getEventLoopLagMs() {
+  return _eventLoopLagMs;
+}
+function getEventLoopLagUpdatedAt() {
+  return _eventLoopLagUpdatedAt;
+}
+function isEventLoopDegraded() {
+  return _eventLoopLagMs > EVENT_LOOP_DEGRADED_THRESHOLD_MS;
+}
+
+export {
+  isDaemonAlive,
+  isMcpHealthy,
+  markAsDaemonProcess,
+  setEventLoopLagMs,
+  getEventLoopLagMs,
+  getEventLoopLagUpdatedAt,
+  isEventLoopDegraded
+};

package/dist/chunk-ALSTZCWT.js

@@ -0,0 +1,204 @@
+import {
+  getClient
+} from "./chunk-WUKEXVOR.js";
+
+// src/lib/pipeline-router.ts
+import crypto from "crypto";
+async function sinkConversationStore(msg, agentResponse, agentName) {
+  try {
+    const client = getClient();
+    const id = crypto.randomUUID();
+    const mediaJson = msg.media ? JSON.stringify(msg.media) : null;
+    await client.execute({
+      sql: `INSERT INTO conversations
+            (id, platform, external_id, sender_id, sender_name, sender_phone, sender_email,
+             recipient_id, channel_id, thread_id, reply_to_id,
+             content_text, content_media, agent_response, agent_name,
+             timestamp, ingested_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        msg.platform,
+        msg.messageId,
+        msg.senderId,
+        msg.senderName ?? null,
+        msg.senderPhone ?? null,
+        msg.senderEmail ?? null,
+        msg.accountId ?? null,
+        msg.channelId,
+        msg.threadId ?? `${msg.platform}:${msg.channelId}`,
+        msg.replyTo?.messageId ?? null,
+        msg.text ?? null,
+        mediaJson,
+        agentResponse ?? null,
+        agentName ?? null,
+        msg.timestamp,
+        (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] conversation-store error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkMemory(msg, agentResponse, agentName) {
+  try {
+    const { embed } = await import("./lib/embedder.js");
+    const { writeMemory, flushBatch } = await import("./lib/store.js");
+    const direction = agentResponse ? "conversation" : "inbound";
+    const rawText = [
+      `[${msg.platform}] ${direction} from ${msg.senderName ?? msg.senderId}`,
+      msg.text ? `Message: ${msg.text}` : null,
+      agentResponse ? `Agent (${agentName ?? "unknown"}): ${agentResponse}` : null
+    ].filter(Boolean).join("\n");
+    const vector = await embed(rawText);
+    await writeMemory({
+      id: crypto.randomUUID(),
+      agent_id: agentName ?? "gateway",
+      agent_role: "gateway",
+      session_id: `gateway-${msg.platform}`,
+      timestamp: msg.timestamp,
+      tool_name: `gateway-${msg.platform}`,
+      project_name: "exe-os",
+      has_error: false,
+      raw_text: rawText,
+      vector,
+      importance: 4,
+      confidence: 0.8
+    });
+    await flushBatch();
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] memory-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkCRM(msg, agentResponse, agentName) {
+  try {
+    const { isCRMBridgeEnabled, pushConversationToCRM, pushInboundMessageToCRM } = await import("./crm-bridge-BVTB6LZK.js");
+    if (!isCRMBridgeEnabled()) return false;
+    if (agentResponse) {
+      await pushConversationToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        agentResponse,
+        agentName: agentName ?? "unknown",
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    } else {
+      await pushInboundMessageToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    }
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] crm-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkWiki(msg, agentResponse) {
+  try {
+    const { createWikiClient } = await import("./wiki-client-HETQ6XHM.js");
+    const client = await createWikiClient();
+    if (!client) return false;
+    const content = msg.text ?? "";
+    if (content.length < 50) return false;
+    const { chatInWorkspace } = await import("./wiki-client-HETQ6XHM.js");
+    const ingestText = [
+      `[${msg.platform}] Message from ${msg.senderName ?? msg.senderId} (${msg.timestamp}):`,
+      content,
+      agentResponse ? `
+Agent response: ${agentResponse}` : ""
+    ].join("\n");
+    await chatInWorkspace(client, "conversations", ingestText, "chat");
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] wiki-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkEntityExtraction(msg, agentResponse, agentName) {
+  try {
+    const { extractFromConversation } = await import("./conversation-entity-extractor-ZN3J4WGY.js");
+    const { storeExtraction } = await import("./graph-rag-HFBYZF3M.js");
+    if ((msg.text?.length ?? 0) < 20) return false;
+    if (msg.isHistorical) return false;
+    const extraction = await extractFromConversation(msg, agentResponse, agentName);
+    if (extraction.entities.length === 0) return false;
+    const client = getClient();
+    const memoryId = `conv:${msg.messageId}`;
+    await storeExtraction(client, extraction, memoryId, msg.timestamp);
+    import("./conversation-wiki-populator-CIWEI4FV.js").then(
+      ({ populateWikiFromExtraction }) => populateWikiFromExtraction(extraction, msg, agentResponse, agentName)
+    ).catch((err) => {
+      process.stderr.write(
+        `[pipeline] wiki-population error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] entity-extraction-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function ingest(msg, agentResponse, agentName) {
+  const errors = [];
+  const [conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted] = await Promise.all([
+    sinkConversationStore(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`conversation: ${e}`);
+      return false;
+    }),
+    sinkMemory(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`memory: ${e}`);
+      return false;
+    }),
+    sinkCRM(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`crm: ${e}`);
+      return false;
+    }),
+    sinkWiki(msg, agentResponse).catch((e) => {
+      errors.push(`wiki: ${e}`);
+      return false;
+    }),
+    sinkEntityExtraction(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`entity-extraction: ${e}`);
+      return false;
+    })
+  ]);
+  if (errors.length > 0) {
+    process.stderr.write(
+      `[pipeline] ${errors.length} sink error(s): ${errors.join("; ")}
+`
+    );
+  }
+  return { conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted, errors };
+}
+
+export {
+  ingest
+};