@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-SOZ7D77I.js

@@ -0,0 +1,204 @@
+import {
+  getClient
+} from "./chunk-V6LOEOXG.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-Q4O6EMTP.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-Q4O6EMTP.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-WC2RU6RS.js");
+    const { storeExtraction } = await import("./graph-rag-KECA5TE4.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-PDL2SUZJ.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
+};

package/dist/chunk-SVLSHDNL.js

@@ -0,0 +1,54 @@
+import {
+  processCRMEvent
+} from "./chunk-TVW7EDOJ.js";
+
+// src/gateway/adapters/crm-webhook.ts
+function parseTwentyWebhook(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  const eventName = p.eventName;
+  if (!eventName || typeof eventName !== "string") return null;
+  const dotIndex = eventName.indexOf(".");
+  if (dotIndex === -1) return null;
+  const objectType = eventName.slice(0, dotIndex);
+  const eventType = eventName.slice(dotIndex + 1);
+  if (!objectType || !eventType) return null;
+  const normalizedObjectType = objectType.charAt(0).toUpperCase() + objectType.slice(1);
+  const record = p.record ?? {};
+  if (typeof record !== "object") return null;
+  return {
+    eventType,
+    objectType: normalizedObjectType,
+    record
+  };
+}
+function createCRMWebhookHandler(options) {
+  return async (body) => {
+    const event = parseTwentyWebhook(body);
+    if (!event) {
+      console.warn(
+        "[crm-webhook] Malformed CRM webhook payload \u2014 skipping"
+      );
+      return;
+    }
+    console.log(
+      `[crm-webhook] ${event.objectType}.${event.eventType} received`
+    );
+    try {
+      const logs = await processCRMEvent(event, options?.executor, options?.triggers);
+      if (logs.length > 0 && options?.onFired) {
+        options.onFired(logs);
+      }
+    } catch (err) {
+      console.error(
+        "[crm-webhook] Error processing CRM event:",
+        err instanceof Error ? err.message : err
+      );
+    }
+  };
+}
+
+export {
+  parseTwentyWebhook,
+  createCRMWebhookHandler
+};

package/dist/chunk-SVUYBT5N.js

@@ -0,0 +1,262 @@
+// src/lib/agentic-ontology.ts
+import { createHash } from "crypto";
+function stableId(...parts) {
+  return createHash("sha256").update(parts.map((p) => String(p ?? "")).join("::")).digest("hex").slice(0, 32);
+}
+function clean(text, max = 240) {
+  return text.replace(/\u0000/g, "").replace(/```[\s\S]*?```/g, " ").replace(/\s+/g, " ").trim().slice(0, max);
+}
+function inferOntologyEventType(row) {
+  const lower = row.raw_text.toLowerCase();
+  if (row.has_error) return "error";
+  if (/\b(done|complete|completed|fixed|resolved|shipped|deployed|pushed|published)\b/.test(lower)) return "milestone";
+  if (/\b(blocked|failed|error|bug|regression|broken)\b/.test(lower)) return "problem";
+  if (/\b(decided|decision|adr|we chose|approved|rejected)\b/.test(lower)) return "decision";
+  if (/\b(goal|need to|we need|want to|trying to|objective)\b/.test(lower)) return "goal_signal";
+  if (["Bash", "Read", "Edit", "Write", "Grep", "Glob"].includes(row.tool_name)) return "tool_action";
+  if (row.tool_name.startsWith("memory_card")) return "memory_card";
+  return "memory_observation";
+}
+function inferIntention(row) {
+  if (row.intent) return clean(row.intent, 220);
+  const text = clean(row.raw_text, 1e3);
+  const patterns = [
+    /(?:we need to|need to|let'?s|i want to|we should|goal is to|objective is to|trying to)\s+([^.!?\n]{8,220})/i,
+    /(?:so that|in order to)\s+([^.!?\n]{8,220})/i,
+    /(?:task|plan):\s*([^.!?\n]{8,220})/i
+  ];
+  for (const p of patterns) {
+    const m = text.match(p);
+    if (m?.[1]) return clean(m[1], 220);
+  }
+  if (["Bash", "Read", "Edit", "Write", "Grep", "Glob"].includes(row.tool_name)) {
+    return `${row.tool_name} during ${row.project_name}`;
+  }
+  return null;
+}
+function inferOutcome(row) {
+  if (row.outcome) return clean(row.outcome, 220);
+  if (row.has_error) return "error";
+  const lower = row.raw_text.toLowerCase();
+  if (/\b(done|complete|completed|fixed|resolved|shipped|deployed|pushed|published|passed)\b/.test(lower)) return "success_signal";
+  if (/\b(blocked|failed|error|regression|broken|not working|could not)\b/.test(lower)) return "failure_signal";
+  if (/\b(warning|risk|concern|caveat)\b/.test(lower)) return "risk_signal";
+  return null;
+}
+function extractGoalCandidates(row) {
+  const text = clean(row.raw_text, 1600);
+  const patterns = [
+    /(?:we need to|need to|i want to|we should|goal is to|objective is to|trying to|let'?s)\s+([^.!?\n]{12,220})/gi,
+    /(?:success means|success criteria|so that)\s+([^.!?\n]{12,220})/gi
+  ];
+  const out = [];
+  for (const pattern of patterns) {
+    for (const m of text.matchAll(pattern)) {
+      const candidate = clean(m[1] ?? "", 220);
+      if (candidate.length >= 12 && !out.some((x) => x.toLowerCase() === candidate.toLowerCase())) out.push(candidate);
+      if (out.length >= 3) return out;
+    }
+  }
+  return out;
+}
+function uniq(values, max = 6) {
+  const out = [];
+  for (const value of values.map((v) => clean(v, 220)).filter(Boolean)) {
+    if (!out.some((x) => x.toLowerCase() === value.toLowerCase())) out.push(value);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+function extractMatches(text, patterns, max = 5) {
+  const out = [];
+  for (const pattern of patterns) {
+    for (const match of text.matchAll(pattern)) {
+      const value = match[1] ?? match[0];
+      if (value) out.push(value);
+      if (out.length >= max) return uniq(out, max);
+    }
+  }
+  return uniq(out, max);
+}
+function inferSemanticLabel(row) {
+  const text = clean(row.raw_text, 2400);
+  const eventType = inferOntologyEventType(row);
+  const intention = inferIntention(row);
+  const outcome = inferOutcome(row);
+  const goals = extractGoalCandidates(row);
+  const milestones = extractMatches(text, [
+    /\b(?:completed|finished|fixed|resolved|shipped|deployed|published|pushed|passed)\b([^.!?\n]{0,180})/gi,
+    /(?:milestone|done):\s*([^.!?\n]{8,220})/gi
+  ]);
+  const problems = extractMatches(text, [
+    /\b(?:blocked by|failed because|bug|regression|broken|not working|error)\b([^.!?\n]{0,180})/gi,
+    /(?:problem|issue|risk):\s*([^.!?\n]{8,220})/gi
+  ]);
+  const decisions = extractMatches(text, [
+    /(?:decided|decision|adr|we chose|approved|rejected)\s+([^.!?\n]{8,220})/gi
+  ]);
+  const temporalAnchors = extractMatches(text, [
+    /\b(\d{4}-\d{2}-\d{2}(?:[T ][0-9:.+-Z]+)?)\b/g,
+    /\b(today|yesterday|tomorrow|this week|next week|last week|morning|afternoon|tonight)\b/gi
+  ], 8);
+  const nextActions = extractMatches(text, [
+    /(?:next|todo|follow[- ]?up|remaining|need to)\s*:?\s*([^.!?\n]{8,220})/gi
+  ]);
+  const actors = uniq([
+    row.agent_id,
+    ...extractMatches(text, [/\b(?:agent|employee|owner|assignee)[:= ]+([a-zA-Z][a-zA-Z0-9_-]{1,40})/gi], 5)
+  ], 6);
+  const successSignals = milestones.length ? milestones : outcome === "success_signal" ? [clean(text, 180)] : [];
+  const failureSignals = problems.length ? problems : outcome === "failure_signal" || row.has_error ? [clean(text, 180)] : [];
+  const impact = successSignals.length && failureSignals.length ? "mixed" : failureSignals.length ? "negative" : successSignals.length ? "positive" : "neutral";
+  const signalCount = goals.length + milestones.length + problems.length + decisions.length + nextActions.length;
+  return {
+    labeler: "deterministic",
+    schemaVersion: 1,
+    eventType,
+    intention,
+    outcome,
+    impact,
+    confidence: Math.min(0.95, 0.45 + signalCount * 0.08 + (intention ? 0.1 : 0) + (outcome ? 0.1 : 0)),
+    goals,
+    milestones,
+    problems,
+    decisions,
+    actors,
+    temporalAnchors,
+    successSignals,
+    failureSignals,
+    nextActions,
+    summary: clean(text, 280)
+  };
+}
+function ontologyPayload(row) {
+  const semantic = inferSemanticLabel(row);
+  return {
+    tool_name: row.tool_name,
+    memory_version: row.version ?? null,
+    domain: row.domain ?? null,
+    trajectory: row.trajectory ? safeJson(row.trajectory) : null,
+    semantic
+  };
+}
+function safeJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value.slice(0, 1e3);
+  }
+}
+async function resolveClient(client) {
+  if (client) return client;
+  const { getClient } = await import("./lib/database.js");
+  return getClient();
+}
+async function insertOntologyForMemory(row, client) {
+  const db = await resolveClient(client);
+  const occurredAt = row.timestamp;
+  const sequence = Number(row.version ?? 0) || Math.floor(new Date(occurredAt).getTime() / 1e3);
+  const eventType = inferOntologyEventType(row);
+  const intention = inferIntention(row);
+  const outcome = inferOutcome(row);
+  const eventId = stableId("event", row.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `INSERT INTO agent_sessions (id, agent_id, project_name, started_at, last_event_at, event_count, properties)
+          VALUES (?, ?, ?, ?, ?, 1, ?)
+          ON CONFLICT(id) DO UPDATE SET last_event_at = MAX(last_event_at, excluded.last_event_at),
+            event_count = event_count + 1`,
+    args: [row.session_id, row.agent_id, row.project_name, occurredAt, occurredAt, JSON.stringify({ agent_role: row.agent_role })]
+  });
+  await db.execute({
+    sql: `INSERT OR IGNORE INTO agent_events
+          (id, event_type, occurred_at, sequence_index, actor_agent_id, agent_role, project_name,
+           session_id, task_id, goal_id, parent_event_id, intention, outcome, evidence_memory_id,
+           impact, payload, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      eventId,
+      eventType,
+      occurredAt,
+      sequence,
+      row.agent_id,
+      row.agent_role,
+      row.project_name,
+      row.session_id,
+      row.task_id ?? null,
+      intention,
+      outcome,
+      row.id,
+      row.has_error ? "negative" : outcome === "success_signal" ? "positive" : "neutral",
+      JSON.stringify(ontologyPayload(row)),
+      now
+    ]
+  });
+  const semantic = inferSemanticLabel(row);
+  await db.execute({
+    sql: `INSERT INTO agent_semantic_labels
+          (id, source_memory_id, event_id, labeler, schema_version, confidence, labels, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET confidence = excluded.confidence,
+            labels = excluded.labels, updated_at = excluded.updated_at`,
+    args: [
+      stableId("semantic", row.id, semantic.labeler, semantic.schemaVersion),
+      row.id,
+      eventId,
+      semantic.labeler,
+      semantic.schemaVersion,
+      semantic.confidence,
+      JSON.stringify(semantic),
+      now,
+      now
+    ]
+  });
+  for (const statement of extractGoalCandidates(row)) {
+    const goalId = stableId("goal", row.project_name, statement.toLowerCase());
+    await db.execute({
+      sql: `INSERT INTO agent_goals
+            (id, statement, owner_agent_id, project_name, status, priority, success_criteria,
+             parent_goal_id, due_at, achieved_at, supersedes_id, created_at, updated_at, source_memory_id)
+            VALUES (?, ?, ?, ?, 'open', 5, NULL, NULL, NULL, NULL, NULL, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET updated_at = excluded.updated_at`,
+      args: [goalId, statement, row.agent_id, row.project_name, now, now, row.id]
+    });
+    await db.execute({
+      sql: `INSERT OR IGNORE INTO agent_goal_links
+            (id, goal_id, link_type, target_id, target_type, created_at)
+            VALUES (?, ?, 'evidence', ?, 'memory', ?)`,
+      args: [stableId("goal_link", goalId, row.id, "memory"), goalId, row.id, now]
+    });
+    await db.execute({
+      sql: `INSERT OR IGNORE INTO agent_goal_links
+            (id, goal_id, link_type, target_id, target_type, created_at)
+            VALUES (?, ?, 'event', ?, 'event', ?)`,
+      args: [stableId("goal_link", goalId, eventId, "event"), goalId, eventId, now]
+    });
+  }
+}
+async function insertOntologyForBatch(rows, client) {
+  const db = await resolveClient(client);
+  let count = 0;
+  for (const row of rows) {
+    try {
+      await insertOntologyForMemory(row, db);
+      count++;
+    } catch {
+    }
+  }
+  return count;
+}
+
+export {
+  stableId,
+  clean,
+  inferOntologyEventType,
+  inferIntention,
+  inferOutcome,
+  extractGoalCandidates,
+  inferSemanticLabel,
+  ontologyPayload,
+  insertOntologyForMemory,
+  insertOntologyForBatch
+};