@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-5QTWQKNF.js

@@ -0,0 +1,137 @@
+import {
+  init_employees,
+  isCoordinatorRole
+} from "./chunk-RUG3N6P4.js";
+
+// src/lib/task-router.ts
+init_employees();
+import { randomUUID } from "crypto";
+var DEFAULT_BLOOM_CONFIG = {
+  complexityToTier: {
+    routine: "junior",
+    standard: "standard",
+    complex: "senior",
+    critical: "specialist"
+  },
+  tierRules: {
+    junior: {
+      eligible: [],
+      // resolved dynamically from roster (Principal Engineer role)
+      reviewRequired: false,
+      manualOnly: false
+    },
+    standard: {
+      eligible: [],
+      // resolved dynamically from roster (Principal Engineer role)
+      reviewRequired: false,
+      manualOnly: false
+    },
+    senior: {
+      eligible: [],
+      // any specialist, but review required
+      reviewRequired: true,
+      manualOnly: false
+    },
+    specialist: {
+      eligible: [],
+      reviewRequired: true,
+      manualOnly: true
+    }
+  }
+};
+function resolveBloomRouting(complexity, config = DEFAULT_BLOOM_CONFIG) {
+  const tier = config.complexityToTier[complexity];
+  const rule = config.tierRules[tier];
+  return {
+    tier,
+    reviewRequired: rule.reviewRequired,
+    manualOnly: rule.manualOnly,
+    eligible: rule.eligible
+  };
+}
+async function scoreEmployee(taskVector, agentId, searchFn) {
+  const results = await searchFn(taskVector, agentId, { limit: 5 });
+  if (results.length === 0) {
+    return { agentId, score: 0 };
+  }
+  const distances = results.map((r) => r["_distance"]).filter((d) => typeof d === "number");
+  if (distances.length > 0) {
+    const avgDistance = distances.reduce((sum, d) => sum + d, 0) / distances.length;
+    return { agentId, score: 1 / (1 + avgDistance) };
+  }
+  return { agentId, score: results.length / 5 };
+}
+async function routeTask(taskDescription, employees, embedFn, searchFn, options) {
+  let specialists = employees.filter((e) => !isCoordinatorRole(e.role));
+  if (specialists.length === 0) {
+    throw new Error(
+      "No specialist employees available. Create one with /exe-new-employee."
+    );
+  }
+  let bloomRouting;
+  if (options?.complexity) {
+    bloomRouting = resolveBloomRouting(options.complexity, options.bloomConfig);
+    if (bloomRouting.manualOnly) {
+      throw new Error(
+        `Task complexity "${options.complexity}" requires manual assignment (tier: ${bloomRouting.tier}).`
+      );
+    }
+    if (bloomRouting.eligible.length > 0) {
+      const eligible = new Set(bloomRouting.eligible);
+      const filtered = specialists.filter((e) => eligible.has(e.name));
+      if (filtered.length > 0) {
+        specialists = filtered;
+      }
+    }
+  }
+  const taskVector = await embedFn(taskDescription);
+  const scored = await Promise.all(
+    specialists.map(async (emp) => {
+      const { score } = await scoreEmployee(taskVector, emp.name, searchFn);
+      return { employee: emp, score };
+    })
+  );
+  scored.sort((a, b) => b.score - a.score);
+  return { ...scored[0], bloomRouting };
+}
+function createAssignmentMemory(taskDescription, assignedTo, assignedBy) {
+  return {
+    id: randomUUID(),
+    agent_id: assignedTo.name,
+    agent_role: assignedTo.role,
+    session_id: `assign-${Date.now()}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool_name: "assignment",
+    project_name: "",
+    has_error: false,
+    raw_text: `Task assigned by ${assignedBy}: ${taskDescription}`,
+    vector: null
+    // Will be backfilled
+  };
+}
+function formatAssignmentOutput(employee, task, score, mode, bloomRouting) {
+  const modeLabel = mode === "auto" ? "auto-routed" : "direct";
+  const percent = Math.round(score * 100);
+  const lines = [
+    `Assigned to ${employee.name} (${employee.role})`,
+    `Mode: ${modeLabel}`,
+    `Relevance: ${percent}%`,
+    `Task: ${task}`
+  ];
+  if (bloomRouting) {
+    lines.push(`Complexity tier: ${bloomRouting.tier}`);
+    if (bloomRouting.reviewRequired) {
+      lines.push(`Review: required`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  DEFAULT_BLOOM_CONFIG,
+  resolveBloomRouting,
+  scoreEmployee,
+  routeTask,
+  createAssignmentMemory,
+  formatAssignmentOutput
+};

package/dist/chunk-6A7P74QV.js

@@ -0,0 +1,53 @@
+// src/lib/cache-warmth.ts
+import os from "os";
+import path from "path";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var CACHE_DIR = path.join(
+  process.env.EXE_OS_DIR ?? path.join(os.homedir(), ".exe-os"),
+  "session-cache"
+);
+function getStatePath(sessionKey) {
+  return path.join(CACHE_DIR, `cache-warmth-${sessionKey}.json`);
+}
+function recordApiCall(sessionKey, agentId, sessionUuid) {
+  try {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    const state = {
+      lastApiCallAt: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId,
+      sessionUuid
+    };
+    writeFileSync(getStatePath(sessionKey), JSON.stringify(state));
+  } catch {
+  }
+}
+function isCacheCold(sessionKey) {
+  const statePath = getStatePath(sessionKey);
+  if (!existsSync(statePath)) {
+    return { cold: true, idleMs: Number.POSITIVE_INFINITY };
+  }
+  try {
+    const state = JSON.parse(readFileSync(statePath, "utf-8"));
+    const lastApiCallAt = new Date(state.lastApiCallAt).getTime();
+    if (!Number.isFinite(lastApiCallAt)) {
+      return { cold: true, idleMs: Number.POSITIVE_INFINITY };
+    }
+    const idleMs = Date.now() - lastApiCallAt;
+    return { cold: idleMs > CACHE_TTL_MS, idleMs };
+  } catch {
+    return { cold: true, idleMs: Number.POSITIVE_INFINITY };
+  }
+}
+function clearCacheState(sessionKey) {
+  try {
+    unlinkSync(getStatePath(sessionKey));
+  } catch {
+  }
+}
+
+export {
+  recordApiCall,
+  isCacheCold,
+  clearCacheState
+};

package/dist/chunk-6BFIFI5F.js

@@ -0,0 +1,45 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/mcp-prefix.ts
+function isExeMcpTool(toolName) {
+  if (!toolName) return false;
+  return MCP_TOOL_PREFIXES.some((p) => toolName.startsWith(p));
+}
+function stripExeMcpPrefix(toolName) {
+  for (const p of MCP_TOOL_PREFIXES) {
+    if (toolName.startsWith(p)) return toolName.slice(p.length);
+  }
+  return toolName;
+}
+function expandDualPrefixTools(shortNames) {
+  const out = [];
+  for (const name of shortNames) {
+    for (const prefix of MCP_TOOL_PREFIXES) {
+      out.push(prefix + name);
+    }
+  }
+  return out;
+}
+var MCP_PRIMARY_KEY, MCP_LEGACY_KEY, MCP_TOOL_PREFIXES;
+var init_mcp_prefix = __esm({
+  "src/lib/mcp-prefix.ts"() {
+    "use strict";
+    MCP_PRIMARY_KEY = "exe-os";
+    MCP_LEGACY_KEY = "exe-mem";
+    MCP_TOOL_PREFIXES = [
+      `mcp__${MCP_PRIMARY_KEY}__`,
+      `mcp__${MCP_LEGACY_KEY}__`
+    ];
+  }
+});
+
+export {
+  MCP_PRIMARY_KEY,
+  MCP_LEGACY_KEY,
+  isExeMcpTool,
+  stripExeMcpPrefix,
+  expandDualPrefixTools,
+  init_mcp_prefix
+};

package/dist/chunk-6KFICEAT.js

@@ -0,0 +1,20 @@
+// src/lib/ws-auth.ts
+import crypto from "crypto";
+var WS_AUTH_HKDF_INFO = "exe-os-ws-auth-v1";
+var ORG_ID_HKDF_INFO = "exe-os-org-id-v1";
+function deriveWsAuthToken(masterKey) {
+  return Buffer.from(crypto.hkdfSync("sha256", masterKey, "", WS_AUTH_HKDF_INFO, 32));
+}
+function deriveOrgId(masterKey) {
+  const raw = Buffer.from(crypto.hkdfSync("sha256", masterKey, "", ORG_ID_HKDF_INFO, 32));
+  return crypto.createHash("sha256").update(raw).digest("hex").slice(0, 32);
+}
+function hashAuthToken(token) {
+  return crypto.createHash("sha256").update(token).digest("hex");
+}
+
+export {
+  deriveWsAuthToken,
+  deriveOrgId,
+  hashAuthToken
+};

package/dist/chunk-6LKDJ5WX.js

@@ -0,0 +1,317 @@
+// src/lib/graph-query.ts
+async function getEntityByName(client, name, type) {
+  const sql = type ? `SELECT * FROM entities WHERE LOWER(name) = LOWER(?) AND type = ? LIMIT 1` : `SELECT * FROM entities WHERE LOWER(name) = LOWER(?) LIMIT 1`;
+  const args = type ? [name, type] : [name];
+  const result = await client.execute({ sql, args });
+  if (result.rows.length === 0) return null;
+  const row = result.rows[0];
+  return {
+    id: String(row.id),
+    name: String(row.name),
+    type: String(row.type),
+    firstSeen: String(row.first_seen),
+    lastSeen: String(row.last_seen),
+    properties: JSON.parse(String(row.properties ?? "{}"))
+  };
+}
+async function searchEntities(client, query, limit = 10) {
+  const result = await client.execute({
+    sql: `SELECT * FROM entities WHERE LOWER(name) LIKE ? ORDER BY last_seen DESC LIMIT ?`,
+    args: [`%${query.toLowerCase()}%`, limit]
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    name: String(row.name),
+    type: String(row.type),
+    firstSeen: String(row.first_seen),
+    lastSeen: String(row.last_seen),
+    properties: JSON.parse(String(row.properties ?? "{}"))
+  }));
+}
+async function getRelationships(client, entityId, options) {
+  const direction = options?.direction ?? "both";
+  let sql;
+  const args = [];
+  if (direction === "outgoing") {
+    sql = `SELECT r.*, s.name as source_name, t.name as target_name
+           FROM relationships r
+           JOIN entities s ON r.source_entity_id = s.id
+           JOIN entities t ON r.target_entity_id = t.id
+           WHERE r.source_entity_id = ?`;
+    args.push(entityId);
+  } else if (direction === "incoming") {
+    sql = `SELECT r.*, s.name as source_name, t.name as target_name
+           FROM relationships r
+           JOIN entities s ON r.source_entity_id = s.id
+           JOIN entities t ON r.target_entity_id = t.id
+           WHERE r.target_entity_id = ?`;
+    args.push(entityId);
+  } else {
+    sql = `SELECT r.*, s.name as source_name, t.name as target_name
+           FROM relationships r
+           JOIN entities s ON r.source_entity_id = s.id
+           JOIN entities t ON r.target_entity_id = t.id
+           WHERE r.source_entity_id = ? OR r.target_entity_id = ?`;
+    args.push(entityId, entityId);
+  }
+  if (options?.type) {
+    sql += ` AND r.type = ?`;
+    args.push(options.type);
+  }
+  sql += ` ORDER BY r.weight DESC, r.timestamp DESC`;
+  const result = await client.execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    sourceEntityId: String(row.source_entity_id),
+    targetEntityId: String(row.target_entity_id),
+    type: String(row.type),
+    weight: Number(row.weight),
+    timestamp: String(row.timestamp),
+    properties: JSON.parse(String(row.properties ?? "{}")),
+    confidence: Number(row.confidence ?? 1),
+    confidenceLabel: String(row.confidence_label ?? "extracted"),
+    sourceName: String(row.source_name),
+    targetName: String(row.target_name)
+  }));
+}
+async function traverseChain(client, startEntityId, relationshipType, maxDepth = 3) {
+  const result = await client.execute({
+    sql: `WITH RECURSIVE chain(entity_id, depth, rel_type) AS (
+            SELECT ?, 0, ''
+            UNION ALL
+            SELECT r.target_entity_id, c.depth + 1, r.type
+            FROM chain c
+            JOIN relationships r ON r.source_entity_id = c.entity_id
+            WHERE r.type = ? AND c.depth < ?
+          )
+          SELECT DISTINCT e.*, chain.depth, chain.rel_type
+          FROM chain
+          JOIN entities e ON e.id = chain.entity_id
+          ORDER BY chain.depth ASC`,
+    args: [startEntityId, relationshipType, maxDepth]
+  });
+  return result.rows.map((row) => ({
+    entity: {
+      id: String(row.id),
+      name: String(row.name),
+      type: String(row.type),
+      firstSeen: String(row.first_seen),
+      lastSeen: String(row.last_seen),
+      properties: JSON.parse(String(row.properties ?? "{}"))
+    },
+    depth: Number(row.depth),
+    relationship: String(row.rel_type)
+  }));
+}
+async function getEntityNeighbors(client, entityId, maxHops = 2) {
+  const result = await client.execute({
+    sql: `WITH RECURSIVE neighborhood(entity_id, depth, rel_type, rel_confidence) AS (
+            SELECT ?, 0, '', 1.0
+            UNION ALL
+            SELECT CASE
+              WHEN r.source_entity_id = n.entity_id THEN r.target_entity_id
+              ELSE r.source_entity_id
+            END, n.depth + 1, r.type, COALESCE(r.confidence, 1.0)
+            FROM neighborhood n
+            JOIN relationships r ON r.source_entity_id = n.entity_id
+                                 OR r.target_entity_id = n.entity_id
+            WHERE n.depth < ?
+          )
+          SELECT DISTINCT e.*, MIN(neighborhood.depth) as depth,
+                 neighborhood.rel_type, neighborhood.rel_confidence
+          FROM neighborhood
+          JOIN entities e ON e.id = neighborhood.entity_id
+          GROUP BY e.id
+          ORDER BY depth ASC, e.last_seen DESC
+          LIMIT 50`,
+    args: [entityId, maxHops]
+  });
+  return result.rows.map((row) => ({
+    entity: {
+      id: String(row.id),
+      name: String(row.name),
+      type: String(row.type),
+      firstSeen: String(row.first_seen),
+      lastSeen: String(row.last_seen),
+      properties: JSON.parse(String(row.properties ?? "{}"))
+    },
+    depth: Number(row.depth),
+    relType: String(row.rel_type ?? ""),
+    relConfidence: Number(row.rel_confidence ?? 1)
+  }));
+}
+async function getGraphStats(client) {
+  const entityCount = await client.execute("SELECT COUNT(*) as cnt FROM entities");
+  const relCount = await client.execute("SELECT COUNT(*) as cnt FROM relationships");
+  const typeResult = await client.execute(
+    "SELECT type, COUNT(*) as cnt FROM entities GROUP BY type ORDER BY cnt DESC"
+  );
+  const types = {};
+  for (const row of typeResult.rows) {
+    types[String(row.type)] = Number(row.cnt);
+  }
+  return {
+    entities: Number(entityCount.rows[0]?.cnt ?? 0),
+    relationships: Number(relCount.rows[0]?.cnt ?? 0),
+    types
+  };
+}
+async function getEntityTimeline(client, entityId, since) {
+  const args = [entityId, entityId];
+  let sinceClause = "";
+  if (since) {
+    sinceClause = " AND r.timestamp >= ?";
+    args.push(since.toISOString());
+  }
+  const result = await client.execute({
+    sql: `SELECT r.*, s.name as source_name, t.name as target_name
+          FROM relationships r
+          JOIN entities s ON r.source_entity_id = s.id
+          JOIN entities t ON r.target_entity_id = t.id
+          WHERE (r.source_entity_id = ? OR r.target_entity_id = ?)${sinceClause}
+          ORDER BY r.timestamp DESC`,
+    args
+  });
+  return result.rows.map((row) => ({
+    relationship: {
+      id: String(row.id),
+      sourceEntityId: String(row.source_entity_id),
+      targetEntityId: String(row.target_entity_id),
+      type: String(row.type),
+      weight: Number(row.weight),
+      timestamp: String(row.timestamp),
+      properties: JSON.parse(String(row.properties ?? "{}")),
+      sourceName: String(row.source_name),
+      targetName: String(row.target_name)
+    },
+    timestamp: String(row.timestamp)
+  }));
+}
+async function getRelationshipFrequency(client, entityId, options) {
+  const granularity = options?.granularity ?? "day";
+  const args = [entityId, entityId];
+  let typeClause = "";
+  if (options?.type) {
+    typeClause = " AND r.type = ?";
+    args.push(options.type);
+  }
+  let bucketExpr;
+  switch (granularity) {
+    case "week":
+      bucketExpr = `strftime('%Y', r.timestamp) || '-W' || strftime('%W', r.timestamp)`;
+      break;
+    case "month":
+      bucketExpr = `strftime('%Y-%m', r.timestamp)`;
+      break;
+    default:
+      bucketExpr = `strftime('%Y-%m-%d', r.timestamp)`;
+  }
+  const result = await client.execute({
+    sql: `SELECT ${bucketExpr} as bucket, COUNT(*) as cnt, r.type as rel_type
+          FROM relationships r
+          WHERE (r.source_entity_id = ? OR r.target_entity_id = ?)${typeClause}
+          GROUP BY bucket${options?.type ? "" : ", r.type"}
+          ORDER BY bucket DESC`,
+    args
+  });
+  return result.rows.map((row) => ({
+    bucket: String(row.bucket),
+    count: Number(row.cnt),
+    relationshipType: options?.type ? options.type : String(row.rel_type)
+  }));
+}
+async function getConversationPartners(client, contactEntityId, since) {
+  const args = [contactEntityId, contactEntityId];
+  let sinceClause = "";
+  if (since) {
+    sinceClause = " AND r.timestamp >= ?";
+    args.push(since.toISOString());
+  }
+  const result = await client.execute({
+    sql: `SELECT
+            CASE
+              WHEN r.source_entity_id = ? THEN r.target_entity_id
+              ELSE r.source_entity_id
+            END as partner_id,
+            COUNT(*) as interaction_count,
+            MAX(r.timestamp) as last_interaction
+          FROM relationships r
+          WHERE (r.source_entity_id = ? OR r.target_entity_id = ?)${sinceClause}
+          GROUP BY partner_id
+          ORDER BY interaction_count DESC`,
+    args: [contactEntityId, ...args]
+  });
+  const partners = [];
+  for (const row of result.rows) {
+    const partnerId = String(row.partner_id);
+    const entityResult = await client.execute({
+      sql: "SELECT * FROM entities WHERE id = ?",
+      args: [partnerId]
+    });
+    if (entityResult.rows.length === 0) continue;
+    const e = entityResult.rows[0];
+    partners.push({
+      agentEntity: {
+        id: String(e.id),
+        name: String(e.name),
+        type: String(e.type),
+        firstSeen: String(e.first_seen),
+        lastSeen: String(e.last_seen),
+        properties: JSON.parse(String(e.properties ?? "{}"))
+      },
+      interactionCount: Number(row.interaction_count),
+      lastInteraction: String(row.last_interaction)
+    });
+  }
+  return partners;
+}
+async function getHotEntities(client, since, limit = 10) {
+  const sinceISO = since.toISOString();
+  const result = await client.execute({
+    sql: `SELECT entity_id, COUNT(*) as rel_count
+          FROM (
+            SELECT source_entity_id as entity_id FROM relationships WHERE timestamp >= ?
+            UNION ALL
+            SELECT target_entity_id as entity_id FROM relationships WHERE timestamp >= ?
+          )
+          GROUP BY entity_id
+          ORDER BY rel_count DESC
+          LIMIT ?`,
+    args: [sinceISO, sinceISO, limit]
+  });
+  const hotEntities = [];
+  for (const row of result.rows) {
+    const eid = String(row.entity_id);
+    const entityResult = await client.execute({
+      sql: "SELECT * FROM entities WHERE id = ?",
+      args: [eid]
+    });
+    if (entityResult.rows.length === 0) continue;
+    const e = entityResult.rows[0];
+    hotEntities.push({
+      entity: {
+        id: String(e.id),
+        name: String(e.name),
+        type: String(e.type),
+        firstSeen: String(e.first_seen),
+        lastSeen: String(e.last_seen),
+        properties: JSON.parse(String(e.properties ?? "{}"))
+      },
+      newRelationships: Number(row.rel_count)
+    });
+  }
+  return hotEntities;
+}
+
+export {
+  getEntityByName,
+  searchEntities,
+  getRelationships,
+  traverseChain,
+  getEntityNeighbors,
+  getGraphStats,
+  getEntityTimeline,
+  getRelationshipFrequency,
+  getConversationPartners,
+  getHotEntities
+};