@askexenow/exe-os 0.9.264 → 0.9.266

package/dist/chunk-XURCA5VD.js

@@ -0,0 +1,297 @@
+import {
+  getClient
+} from "./chunk-RHZ2CRJU.js";
+
+// src/lib/memory-graph-extractor.ts
+function entityId(type, name) {
+  return `mem:${type}:${name.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}`;
+}
+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 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"
+      });
+    }
+  }
+  return { entities, relationships };
+}
+async function resolveEntityAlias(client, name, originalId) {
+  try {
+    const normalized = name.toLowerCase().trim();
+    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();
+  for (const e of result.entities) {
+    const rawId = entityId(e.type, e.name);
+    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, e.name, e.type, now, now, now]
+    });
+    await client.execute({
+      sql: `INSERT OR IGNORE INTO entity_memories (entity_id, memory_id)
+            VALUES (?, ?)`,
+      args: [id, memoryId]
+    });
+  }
+  try {
+    const { createCoOccurrenceEdges } = await import("./co-occurrence-G7RRJ3DB.js");
+    await createCoOccurrenceEdges(result.entities, memoryId);
+  } catch {
+  }
+  for (const r of result.relationships) {
+    const sourceId = entityId(r.sourceType, r.source);
+    const targetId = entityId(r.targetType, r.target);
+    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-Y55VFZJB.js

@@ -0,0 +1,50 @@
+import {
+  sendMessage
+} from "./chunk-GIJUXLK5.js";
+import {
+  getActiveAgent
+} from "./chunk-BH2ST7KK.js";
+
+// src/mcp/tools/send-message.ts
+import { z } from "zod";
+function registerSendMessage(server) {
+  server.registerTool(
+    "send_message",
+    {
+      title: "Send Message",
+      description: "Send a structured message to another agent. Messages are queued and delivered via intercom. NOTE: messages are fire-and-forget \u2014 do NOT use for actionable work dispatch. Use create_task instead to assign work to employees.",
+      inputSchema: {
+        target_agent: z.string().describe("Recipient agent name"),
+        content: z.string().describe("Message content"),
+        target_project: z.string().optional().describe("Project context (optional)"),
+        priority: z.enum(["normal", "urgent"]).default("normal").describe("Message priority (default: normal)"),
+        target_device: z.string().optional().describe("Target device ID for cross-machine delivery (default: local)")
+      }
+    },
+    async ({ target_agent, content, target_project, priority, target_device }) => {
+      const { agentId } = getActiveAgent();
+      const msg = await sendMessage({
+        fromAgent: agentId,
+        targetAgent: target_agent,
+        targetProject: target_project,
+        targetDevice: target_device,
+        content,
+        priority
+      });
+      const statusText = msg.status === "delivered" ? "delivered" : msg.status === "failed" ? `failed: ${msg.failureReason}` : "queued (pending delivery)";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Message sent to ${target_agent}: ${statusText}
+ID: ${msg.id}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerSendMessage
+};

package/dist/chunk-YIH2YMWP.js

@@ -0,0 +1,76 @@
+import {
+  fastDbInit
+} from "./chunk-WXHAMPK4.js";
+import {
+  sessionScopeFilter
+} from "./chunk-P2QTTEYP.js";
+import {
+  formatStatusAll,
+  formatStatusDeep,
+  getEmployeeStatuses,
+  inTmux
+} from "./chunk-CX6GL3ZJ.js";
+import {
+  getClient,
+  isCoordinatorRole,
+  loadEmployees
+} from "./chunk-RHZ2CRJU.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-status.ts
+async function status(targetEmployee) {
+  if (!inTmux()) {
+    return "Not in a tmux session. Start tmux first: tmux new-session -s work";
+  }
+  const employees = await loadEmployees();
+  const names = employees.filter((e) => !isCoordinatorRole(e.role)).map((e) => e.name);
+  const roles = new Map(employees.map((e) => [e.name, e.role ?? ""]));
+  await fastDbInit();
+  const client = getClient();
+  const taskMap = /* @__PURE__ */ new Map();
+  try {
+    const esScope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT assigned_to, title, priority FROM tasks
+            WHERE status = 'in_progress'${esScope.sql}
+            ORDER BY priority ASC, created_at ASC`,
+      args: [...esScope.args]
+    });
+    for (const row of result.rows) {
+      const assignee = String(row.assigned_to);
+      if (!taskMap.has(assignee)) {
+        taskMap.set(assignee, {
+          title: String(row.title),
+          priority: String(row.priority)
+        });
+      }
+    }
+  } catch {
+  }
+  if (targetEmployee) {
+    if (!names.includes(targetEmployee)) {
+      return `Employee "${targetEmployee}" not found. Available: ${names.join(", ")}`;
+    }
+    const statuses2 = getEmployeeStatuses([targetEmployee]);
+    const s = statuses2[0];
+    return formatStatusDeep(s, taskMap.get(targetEmployee), roles.get(targetEmployee) ?? "");
+  }
+  const statuses = getEmployeeStatuses(names);
+  return formatStatusAll(statuses, taskMap, roles);
+}
+if (isMainModule(import.meta.url)) {
+  const target = process.argv[2];
+  status(target).then((output) => {
+    process.stdout.write(output + "\n");
+  }).catch((err) => {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+
+export {
+  status
+};

package/dist/chunk-YZMCCT73.js

@@ -0,0 +1,97 @@
+import {
+  listBehaviors
+} from "./chunk-32QR5EHE.js";
+import {
+  loadConfigSync
+} from "./chunk-VXIMSRTO.js";
+
+// src/lib/behaviors-export.ts
+import os from "os";
+import path from "path";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+var BEHAVIORS_EXPORT_DIR = path.join(
+  os.homedir(),
+  ".exe-os",
+  "behaviors-export"
+);
+var STALE_EXPORT_AGE_MS = 60 * 60 * 1e3;
+var DEFAULT_BEHAVIOR_LIMIT = 30;
+function getBehaviorLimit() {
+  try {
+    const cfg = loadConfigSync();
+    return cfg.behaviorExportLimit ?? DEFAULT_BEHAVIOR_LIMIT;
+  } catch {
+    return DEFAULT_BEHAVIOR_LIMIT;
+  }
+}
+function sweepStaleBehaviorExports(now = Date.now()) {
+  if (!existsSync(BEHAVIORS_EXPORT_DIR)) return;
+  let entries;
+  try {
+    entries = readdirSync(BEHAVIORS_EXPORT_DIR);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const filePath = path.join(BEHAVIORS_EXPORT_DIR, entry);
+    try {
+      const stat = statSync(filePath);
+      if (now - stat.mtimeMs > STALE_EXPORT_AGE_MS) {
+        unlinkSync(filePath);
+      }
+    } catch {
+    }
+  }
+}
+function renderBehaviorLine(row) {
+  const tag = row.domain ? `[${row.domain}] ` : "";
+  const scope = row.project_name ? ` (${row.project_name})` : "";
+  return `- ${tag}${row.content}${scope}`;
+}
+function renderBehaviorExport(behaviors) {
+  if (behaviors.length === 0) {
+    return "";
+  }
+  const lines = behaviors.map(renderBehaviorLine);
+  return [
+    "<system-reminder>",
+    "## Your Behavioral Memory",
+    "Validated patterns and corrections for this session. Follow them.",
+    "Sourced from exe-os Layer 2 (Expertise). Changes apply on next spawn.",
+    "",
+    ...lines,
+    "</system-reminder>",
+    ""
+  ].join("\n");
+}
+function exportFilePath(agentId, projectName, sessionKey) {
+  if (!sessionKey) {
+    return path.join(BEHAVIORS_EXPORT_DIR, `${agentId}.md`);
+  }
+  const safeProject = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path.join(
+    BEHAVIORS_EXPORT_DIR,
+    `${agentId}-${safeProject}-${sessionKey}.md`
+  );
+}
+async function exportBehaviorsForAgent(agentId, projectName, sessionKey) {
+  mkdirSync(BEHAVIORS_EXPORT_DIR, { recursive: true });
+  sweepStaleBehaviorExports();
+  const behaviors = await listBehaviors(agentId, projectName, getBehaviorLimit());
+  if (behaviors.length === 0) return null;
+  const body = renderBehaviorExport(behaviors);
+  const target = exportFilePath(agentId, projectName, sessionKey);
+  writeFileSync(target, body, "utf-8");
+  return target;
+}
+
+export {
+  exportBehaviorsForAgent
+};