@askexenow/exe-os 0.9.292 → 0.9.293

package/dist/chunk-MJ2MCLZH.js

@@ -0,0 +1,402 @@
+import {
+  entityId,
+  normalizeEntityName
+} from "./chunk-6OAAN25C.js";
+import {
+  getClient
+} from "./chunk-IDJCLLJF.js";
+
+// src/lib/memory-graph-extractor.ts
+function relationshipId(sourceId, targetId, relType) {
+  return `rel:${sourceId}:${relType}:${targetId}`;
+}
+var FILE_EXT_PATTERN = /(?:^|\s|['"`(])([a-zA-Z0-9_./-]+\.(?:ts|js|tsx|jsx|json|md|py|rs|go|toml|yaml|yml|css|html|sql|sh|bash|zsh|env|conf|cfg|xml|csv|lock))\b/g;
+var PATH_PATTERN = /(?:^|\s|['"`(])((?:src|lib|bin|dist|tests?|__tests__|node_modules|\.?\w+)\/[a-zA-Z0-9_./-]+)/g;
+function extractFilePaths(text) {
+  const paths = /* @__PURE__ */ new Set();
+  let match;
+  FILE_EXT_PATTERN.lastIndex = 0;
+  while ((match = FILE_EXT_PATTERN.exec(text)) !== null) {
+    const p = match[1].trim();
+    if (p.length >= 3 && p.length <= 200 && !p.startsWith("http")) {
+      paths.add(p);
+    }
+  }
+  PATH_PATTERN.lastIndex = 0;
+  while ((match = PATH_PATTERN.exec(text)) !== null) {
+    const p = match[1].trim();
+    if (p.length >= 5 && p.length <= 200 && !p.startsWith("http") && p.includes("/")) {
+      paths.add(p);
+    }
+  }
+  return Array.from(paths).slice(0, 20);
+}
+var ERROR_PATTERNS = [
+  /\b(Error|TypeError|ReferenceError|SyntaxError|RangeError):\s*(.{10,80})/g,
+  /\b(ERR_[A-Z_]+)/g,
+  /\b(ENOENT|EACCES|EPERM|ECONNREFUSED|ETIMEDOUT|SQLITE_BUSY)\b/g,
+  /\bfailed\s+(?:to\s+)?(\w+(?:\s+\w+){0,3})/gi
+];
+function extractErrors(text) {
+  const errors = /* @__PURE__ */ new Set();
+  for (const pattern of ERROR_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const err = (match[1] ?? match[0]).trim();
+      if (err.length >= 3 && err.length <= 100) {
+        errors.add(err);
+      }
+    }
+    if (errors.size >= 5) break;
+  }
+  return Array.from(errors).slice(0, 5);
+}
+var CONCEPT_PATTERNS = [
+  // Exe OS architecture
+  [/\b(?:GraphRAG|graph[\s-]?rag)\b/gi, "GraphRAG"],
+  [/\b(?:cloud[\s-]?sync|cloud backup)\b/gi, "cloud-sync"],
+  [/\b(?:three[\s-]?layer cognition|3[\s-]?layer cognition|cognition layers?)\b/gi, "three-layer-cognition"],
+  [/\b(?:working[\s-]?memory|runtime[\s-]?scratchpad)\b/gi, "working-memory"],
+  [/\b(?:checkpoint[\s/]?resume|crash[\s-]?recovery)\b/gi, "checkpoint-resume"],
+  [/\b(?:fan[\s-]?out[\s/]?fan[\s-]?in|barrier[\s-]?primitive)\b/gi, "fan-out-fan-in"],
+  [/\b(?:entity[\s-]?extraction|entity[\s-]?resolution)\b/gi, "entity-extraction"],
+  [/\b(?:alias[\s-]?resolution|entity[\s-]?aliases?)\b/gi, "alias-resolution"],
+  [/\b(?:daemon[\s-]?orchestration|daemon[\s-]?tick)\b/gi, "daemon-orchestration"],
+  [/\b(?:capacity[\s-]?monitor|context[\s-]?capacity)\b/gi, "capacity-monitor"],
+  [/\b(?:idle[\s-]?nudge|idle[\s-]?detection)\b/gi, "idle-nudge"],
+  [/\b(?:session[\s-]?scoping|session[\s-]?isolation)\b/gi, "session-scoping"],
+  [/\b(?:task[\s-]?enforcement|task[\s-]?lifecycle)\b/gi, "task-lifecycle"],
+  [/\b(?:intercom|tmux[\s-]?send[\s-]?keys)\b/gi, "intercom"],
+  [/\b(?:memory[\s-]?sovereignty|E2EE|local[\s-]?first)\b/gi, "memory-sovereignty"],
+  [/\b(?:MCP[\s-]?server|MCP[\s-]?tool|model[\s-]?context[\s-]?protocol)\b/gi, "MCP"],
+  [/\b(?:domain[\s-]?shard|shard[\s-]?manager)\b/gi, "domain-sharding"],
+  [/\b(?:co[\s-]?occurrence[\s-]?edge|co[\s-]?occurrence)\b/gi, "co-occurrence"],
+  [/\b(?:stack[\s-]?update|stack[\s-]?manifest)\b/gi, "stack-update"],
+  [/\b(?:license[\s-]?validation|license[\s-]?check)\b/gi, "licensing"],
+  // Infrastructure
+  [/\b(?:white[\s-]?label|agency[\s-]?mode)\b/gi, "white-label"],
+  [/\b(?:AGPL|AGPL[\s-]?3)\b/g, "AGPL-license"],
+  [/\b(?:SQLCipher)\b/g, "SQLCipher"],
+  [/\b(?:pgvector)\b/g, "pgvector"],
+  [/\b(?:Cloudflare[\s-]?Workers?)\b/gi, "cloudflare-workers"]
+];
+function extractConcepts(text) {
+  const concepts = /* @__PURE__ */ new Set();
+  for (const [pattern, canonical] of CONCEPT_PATTERNS) {
+    pattern.lastIndex = 0;
+    if (pattern.test(text)) {
+      concepts.add(canonical);
+    }
+    if (concepts.size >= 10) break;
+  }
+  return Array.from(concepts);
+}
+var IDENTIFIER_PATTERN = /\b([a-z][a-zA-Z0-9]{3,30}[A-Z][a-zA-Z0-9]{0,30}|[A-Z][a-zA-Z0-9]{2,30})\b/g;
+var COMMON_WORDS = /* @__PURE__ */ new Set([
+  "Error",
+  "String",
+  "Number",
+  "Boolean",
+  "Object",
+  "Array",
+  "Promise",
+  "Buffer",
+  "Event",
+  "Date",
+  "Math",
+  "JSON",
+  "RegExp",
+  "Symbol",
+  "NULL",
+  "TRUE",
+  "FALSE",
+  "undefined",
+  "NaN",
+  "This",
+  "That",
+  "Each",
+  "Some",
+  "Every",
+  "Many"
+]);
+function extractIdentifiers(text) {
+  const counts = /* @__PURE__ */ new Map();
+  IDENTIFIER_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = IDENTIFIER_PATTERN.exec(text)) !== null) {
+    const id = match[1];
+    if (!COMMON_WORDS.has(id) && id.length >= 4) {
+      counts.set(id, (counts.get(id) ?? 0) + 1);
+    }
+  }
+  return Array.from(counts.entries()).filter(([, count]) => count >= 2).map(([name]) => name).slice(0, 10);
+}
+function parseListLine(text, label) {
+  const re = new RegExp(`^${label}:\\s*(.+)$`, "im");
+  const match = text.match(re);
+  if (!match?.[1]) return [];
+  return match[1].split(",").map((part) => part.trim()).filter((part) => part.length >= 2 && part.length <= 180).slice(0, 30);
+}
+function parseScalarLine(text, label) {
+  const re = new RegExp(`^${label}:\\s*(.+)$`, "im");
+  const match = text.match(re);
+  return match?.[1]?.trim() ?? null;
+}
+function parseDecisionLines(text) {
+  const decisions = [];
+  const block = text.match(/^Decisions:\s*\n([\s\S]*?)(?:\n\n|^Patterns:|^Promoted behaviors:|$)/im)?.[1];
+  if (!block) return decisions;
+  for (const line of block.split("\n")) {
+    const decision = line.replace(/^\s*[-*]\s*/, "").trim();
+    if (decision.length >= 8 && decision.length <= 180) {
+      decisions.push(decision);
+    }
+    if (decisions.length >= 12) break;
+  }
+  return decisions;
+}
+function appendSessionSnapshotGraph(memoryText, agentId, projectName, entities, relationships) {
+  if (!/^SESSION SNAPSHOT\b/m.test(memoryText)) return;
+  const sessionId = parseScalarLine(memoryText, "Snapshot ID") ?? "snapshot-cli";
+  const snapshotProject = parseScalarLine(memoryText, "Project") ?? projectName;
+  const keyEntities = parseListLine(memoryText, "Key entities");
+  const files = parseListLine(memoryText, "Files changed");
+  const decisions = parseDecisionLines(memoryText);
+  entities.push({ name: sessionId, type: "session" });
+  relationships.push({
+    source: agentId,
+    sourceType: "agent",
+    target: sessionId,
+    targetType: "session",
+    type: "captured_snapshot"
+  });
+  if (snapshotProject && snapshotProject !== "unknown") {
+    entities.push({ name: snapshotProject, type: "project" });
+    relationships.push({
+      source: sessionId,
+      sourceType: "session",
+      target: snapshotProject,
+      targetType: "project",
+      type: "snapshot_of"
+    });
+  }
+  for (const entity of keyEntities) {
+    entities.push({ name: entity, type: "concept" });
+    relationships.push({
+      source: sessionId,
+      sourceType: "session",
+      target: entity,
+      targetType: "concept",
+      type: "mentions"
+    });
+  }
+  for (const file of files) {
+    entities.push({ name: file, type: "file" });
+    relationships.push({
+      source: sessionId,
+      sourceType: "session",
+      target: file,
+      targetType: "file",
+      type: "touched_file"
+    });
+  }
+  for (const decision of decisions) {
+    entities.push({ name: decision, type: "decision" });
+    relationships.push({
+      source: sessionId,
+      sourceType: "session",
+      target: decision,
+      targetType: "decision",
+      type: "recorded_decision"
+    });
+    if (snapshotProject && snapshotProject !== "unknown") {
+      relationships.push({
+        source: decision,
+        sourceType: "decision",
+        target: snapshotProject,
+        targetType: "project",
+        type: "decision_for"
+      });
+    }
+  }
+}
+function extractMemoryGraph(memoryText, agentId, projectName, toolName) {
+  const entities = [];
+  const relationships = [];
+  entities.push({ name: agentId, type: "agent" });
+  if (projectName && projectName !== "unknown") {
+    entities.push({ name: projectName, type: "project" });
+    relationships.push({
+      source: agentId,
+      sourceType: "agent",
+      target: projectName,
+      targetType: "project",
+      type: "works_on"
+    });
+  }
+  if (toolName && toolName !== "manual" && toolName !== "unknown") {
+    entities.push({ name: toolName, type: "tool" });
+    relationships.push({
+      source: agentId,
+      sourceType: "agent",
+      target: toolName,
+      targetType: "tool",
+      type: "used_tool"
+    });
+  }
+  const filePaths = extractFilePaths(memoryText);
+  for (const fp of filePaths) {
+    entities.push({ name: fp, type: "file" });
+    relationships.push({
+      source: agentId,
+      sourceType: "agent",
+      target: fp,
+      targetType: "file",
+      type: "modified"
+    });
+    if (projectName && projectName !== "unknown") {
+      relationships.push({
+        source: fp,
+        sourceType: "file",
+        target: projectName,
+        targetType: "project",
+        type: "belongs_to"
+      });
+    }
+  }
+  const errors = extractErrors(memoryText);
+  for (const err of errors) {
+    entities.push({ name: err, type: "error" });
+    relationships.push({
+      source: agentId,
+      sourceType: "agent",
+      target: err,
+      targetType: "error",
+      type: "encountered"
+    });
+  }
+  const identifiers = extractIdentifiers(memoryText);
+  for (const id of identifiers) {
+    entities.push({ name: id, type: "function" });
+    if (filePaths.length > 0) {
+      relationships.push({
+        source: filePaths[0],
+        sourceType: "file",
+        target: id,
+        targetType: "function",
+        type: "contains"
+      });
+    }
+  }
+  const concepts = extractConcepts(memoryText);
+  for (const concept of concepts) {
+    entities.push({ name: concept, type: "concept" });
+    if (projectName && projectName !== "unknown") {
+      relationships.push({
+        source: concept,
+        sourceType: "concept",
+        target: projectName,
+        targetType: "project",
+        type: "related_to"
+      });
+    }
+  }
+  appendSessionSnapshotGraph(memoryText, agentId, projectName, entities, relationships);
+  return { entities, relationships };
+}
+async function resolveEntityAlias(client, name, originalId) {
+  try {
+    const normalized = normalizeEntityName(name);
+    const result = await client.execute({
+      sql: "SELECT canonical_entity_id FROM entity_aliases WHERE alias = ?",
+      args: [normalized]
+    });
+    if (result.rows.length > 0) {
+      return String(result.rows[0].canonical_entity_id);
+    }
+  } catch {
+  }
+  return originalId;
+}
+async function upsertMemoryGraph(result, memoryId) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const actualEntityIds = /* @__PURE__ */ new Map();
+  for (const e of result.entities) {
+    const normalizedName = normalizeEntityName(e.name);
+    const normalizedType = e.type.toLowerCase();
+    const rawId = entityId(normalizedName, normalizedType);
+    const id = await resolveEntityAlias(client, e.name, rawId);
+    await client.execute({
+      sql: `INSERT INTO entities (id, name, type, first_seen, last_seen, properties)
+            VALUES (?, ?, ?, ?, ?, '{}')
+            ON CONFLICT(name, type) DO UPDATE SET last_seen = ?`,
+      args: [id, normalizedName, normalizedType, now, now, now]
+    });
+    const actual = await client.execute({
+      sql: "SELECT id FROM entities WHERE LOWER(name) = LOWER(?) AND type = ? LIMIT 1",
+      args: [normalizedName, normalizedType]
+    });
+    const actualId = actual.rows[0]?.id ? String(actual.rows[0].id) : id;
+    actualEntityIds.set(`${normalizedType}:${normalizedName}`, actualId);
+    await client.execute({
+      sql: `INSERT OR IGNORE INTO entity_memories (entity_id, memory_id)
+            VALUES (?, ?)`,
+      args: [actualId, memoryId]
+    });
+  }
+  try {
+    const { createCoOccurrenceEdges } = await import("./co-occurrence-VKJWYROE.js");
+    await createCoOccurrenceEdges(result.entities, memoryId);
+  } catch {
+  }
+  for (const r of result.relationships) {
+    const sourceType = r.sourceType.toLowerCase();
+    const targetType = r.targetType.toLowerCase();
+    const sourceName = normalizeEntityName(r.source);
+    const targetName = normalizeEntityName(r.target);
+    const sourceId = actualEntityIds.get(`${sourceType}:${sourceName}`) ?? entityId(sourceName, sourceType);
+    const targetId = actualEntityIds.get(`${targetType}:${targetName}`) ?? entityId(targetName, targetType);
+    if (sourceId === targetId) continue;
+    const relId = relationshipId(sourceId, targetId, r.type);
+    await client.execute({
+      sql: `INSERT INTO relationships (id, source_entity_id, target_entity_id, type, weight, timestamp, properties)
+            VALUES (?, ?, ?, ?, 1.0, ?, '{}')
+            ON CONFLICT(source_entity_id, target_entity_id, type) DO UPDATE SET
+              weight = MIN(weight + 0.1, 10.0),
+              timestamp = ?`,
+      args: [relId, sourceId, targetId, r.type, now, now]
+    });
+  }
+}
+async function extractGraphForBatch(batch) {
+  for (const row of batch) {
+    try {
+      const graphResult = extractMemoryGraph(
+        row.raw_text,
+        row.agent_id,
+        row.project_name,
+        row.tool_name
+      );
+      if (graphResult.entities.length > 0) {
+        await upsertMemoryGraph(graphResult, row.id);
+      }
+      try {
+        const client = getClient();
+        await client.execute({
+          sql: `UPDATE memories SET graph_extracted = 1 WHERE id = ?`,
+          args: [row.id]
+        });
+      } catch {
+      }
+    } catch {
+    }
+  }
+}
+
+export {
+  extractMemoryGraph,
+  upsertMemoryGraph,
+  extractGraphForBatch
+};

package/dist/chunk-MX63V4YD.js

@@ -0,0 +1,38 @@
+import {
+  listReminders
+} from "./chunk-XWVCURC2.js";
+
+// src/mcp/tools/list-reminders.ts
+import { z } from "zod";
+function registerListReminders(server) {
+  server.registerTool(
+    "list_reminders",
+    {
+      title: "List Reminders",
+      description: "List active reminders. Pass include_completed=true to see all.",
+      inputSchema: {
+        include_completed: z.boolean().optional().default(false).describe("Include completed reminders")
+      }
+    },
+    async ({ include_completed }) => {
+      const reminders = await listReminders(include_completed);
+      if (reminders.length === 0) {
+        return {
+          content: [{ type: "text", text: "No active reminders." }]
+        };
+      }
+      const lines = reminders.map((r) => {
+        const due = r.dueDate ? ` (due: ${r.dueDate})` : "";
+        const done = r.completedAt ? " [DONE]" : "";
+        return `\u2022 ${r.text}${due}${done}  [id: ${r.id.slice(0, 8)}]`;
+      });
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+export {
+  registerListReminders
+};

package/dist/chunk-N7TWCWY5.js

@@ -0,0 +1,128 @@
+// src/lib/tool-telemetry.ts
+var _toolCalls = /* @__PURE__ */ new Map();
+var _sessionStartedAt = Date.now();
+var _flushTimer = null;
+function recordCall(toolName, action, isError) {
+  let record = _toolCalls.get(toolName);
+  if (!record) {
+    record = { count: 0, actions: /* @__PURE__ */ new Map(), lastCalledAt: 0, errors: 0 };
+    _toolCalls.set(toolName, record);
+  }
+  record.count++;
+  record.lastCalledAt = Date.now();
+  if (isError) record.errors++;
+  if (action) {
+    record.actions.set(action, (record.actions.get(action) ?? 0) + 1);
+  }
+}
+function wrapServerWithTelemetry(server) {
+  const originalRegisterTool = server.registerTool.bind(server);
+  server.registerTool = (name, config, handler) => {
+    const wrappedHandler = async (input, extra) => {
+      const action = input.action;
+      try {
+        const result = await handler(input, extra);
+        const isError = result?.isError === true;
+        recordCall(name, action, isError);
+        return result;
+      } catch (err) {
+        recordCall(name, action, true);
+        throw err;
+      }
+    };
+    return originalRegisterTool(name, config, wrappedHandler);
+  };
+  return server;
+}
+function getToolUsageStats() {
+  let totalCalls = 0;
+  let totalErrors = 0;
+  const tools = {};
+  for (const [name, record] of _toolCalls) {
+    totalCalls += record.count;
+    totalErrors += record.errors;
+    const entry = {
+      calls: record.count,
+      errors: record.errors,
+      lastCalledAt: new Date(record.lastCalledAt).toISOString()
+    };
+    if (record.actions.size > 0) {
+      entry.actions = Object.fromEntries(record.actions);
+    }
+    tools[name] = entry;
+  }
+  return {
+    sessionStartedAt: new Date(_sessionStartedAt).toISOString(),
+    uptimeMs: Date.now() - _sessionStartedAt,
+    totalCalls,
+    totalErrors,
+    tools
+  };
+}
+function resetToolUsageStats() {
+  _toolCalls.clear();
+  _sessionStartedAt = Date.now();
+}
+var FLUSH_INTERVAL_MS = 5 * 60 * 1e3;
+var _lastFlushedAt = 0;
+async function flushToMemory() {
+  const stats = getToolUsageStats();
+  if (stats.totalCalls === 0) return;
+  if (stats.totalCalls === _lastFlushedAt) return;
+  try {
+    const { getClient, isInitialized } = await import("./lib/database.js");
+    if (!isInitialized()) return;
+    const client = getClient();
+    const toolSummary = Object.entries(stats.tools).sort((a, b) => b[1].calls - a[1].calls).map(([name, t]) => {
+      const actionStr = t.actions ? ` (${Object.entries(t.actions).sort((a, b) => b[1] - a[1]).map(([a, c]) => `${a}:${c}`).join(", ")})` : "";
+      return `${name}: ${t.calls} calls${t.errors > 0 ? ` (${t.errors} errors)` : ""}${actionStr}`;
+    }).join("\n");
+    const raw_text = `Tool usage since ${stats.sessionStartedAt} (${Math.round(stats.uptimeMs / 6e4)}min):
+Total: ${stats.totalCalls} calls, ${stats.totalErrors} errors
+
+${toolSummary}`;
+    await client.execute({
+      sql: `INSERT INTO memories (id, agent_id, raw_text, memory_type, project_name, importance, created_at, updated_at, session_scope)
+            VALUES (?, 'system', ?, 'telemetry', 'exe-os', 2, datetime('now'), datetime('now'), NULL)`,
+      args: [
+        `telemetry-tools-${Date.now()}`,
+        raw_text
+      ]
+    });
+    _lastFlushedAt = stats.totalCalls;
+  } catch {
+  }
+}
+function startToolTelemetryFlush() {
+  if (_flushTimer) return;
+  _sessionStartedAt = Date.now();
+  _flushTimer = setInterval(() => void flushToMemory(), FLUSH_INTERVAL_MS);
+  _flushTimer.unref();
+}
+async function stopToolTelemetryFlush() {
+  if (_flushTimer) {
+    clearInterval(_flushTimer);
+    _flushTimer = null;
+  }
+  await flushToMemory();
+}
+function getToolUsageSummary() {
+  const summary = {};
+  for (const [tool, record] of _toolCalls) {
+    summary[tool] = {
+      count: record.count,
+      errors: record.errors,
+      actions: Object.fromEntries(record.actions)
+    };
+  }
+  return summary;
+}
+
+export {
+  wrapServerWithTelemetry,
+  getToolUsageStats,
+  resetToolUsageStats,
+  startToolTelemetryFlush,
+  stopToolTelemetryFlush,
+  getToolUsageSummary
+};