@askexenow/exe-os 0.9.279 → 0.9.280

package/dist/chunk-ZTS2KRU5.js

@@ -0,0 +1,333 @@
+import {
+  executeAction,
+  substituteTemplate
+} from "./chunk-ZM5WXR57.js";
+
+// src/automation/workflow-engine.ts
+import { randomUUID } from "crypto";
+var _definitions = /* @__PURE__ */ new Map();
+var _instances = /* @__PURE__ */ new Map();
+function createWorkflowDefinition(input) {
+  const def = {
+    id: randomUUID().slice(0, 12),
+    ...input,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  def.steps = def.steps.map((s, i) => ({ ...s, index: s.index || i + 1 }));
+  _definitions.set(def.id, def);
+  return def;
+}
+function getWorkflowDefinition(id) {
+  return _definitions.get(id);
+}
+function listWorkflowDefinitions() {
+  return [..._definitions.values()];
+}
+function buildTemplateContext(instance) {
+  const ctx = { ...instance.context };
+  const stepMap = {};
+  for (const sr of instance.step_results) {
+    stepMap[String(sr.step_index)] = {
+      status: sr.status,
+      result: sr.result,
+      error: sr.error
+    };
+  }
+  ctx.step = stepMap;
+  return ctx;
+}
+function resolveActionParams(action, context) {
+  const resolved = {};
+  for (const [key, val] of Object.entries(action.params)) {
+    resolved[key] = substituteTemplate(val, context);
+  }
+  return { ...action, params: resolved };
+}
+function startWorkflow(definitionId, context = {}) {
+  const def = _definitions.get(definitionId);
+  if (!def) throw new Error(`Workflow definition "${definitionId}" not found`);
+  const instance = {
+    id: randomUUID().slice(0, 12),
+    definition_id: definitionId,
+    status: "running",
+    current_step: 1,
+    step_results: [],
+    context,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  _instances.set(instance.id, instance);
+  return instance;
+}
+function getWorkflowInstance(id) {
+  return _instances.get(id);
+}
+function listWorkflowInstances(status) {
+  const all = [..._instances.values()];
+  return status ? all.filter((i) => i.status === status) : all;
+}
+async function advanceWorkflow(instanceId) {
+  const instance = _instances.get(instanceId);
+  if (!instance) throw new Error(`Workflow instance "${instanceId}" not found`);
+  if (instance.status !== "running") {
+    throw new Error(`Workflow "${instanceId}" is ${instance.status}, cannot advance`);
+  }
+  const def = _definitions.get(instance.definition_id);
+  if (!def) throw new Error(`Workflow definition "${instance.definition_id}" not found`);
+  const step = def.steps.find((s) => s.index === instance.current_step);
+  if (!step) {
+    instance.status = "completed";
+    instance.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    return instance;
+  }
+  const templateCtx = buildTemplateContext(instance);
+  const stepResult = {
+    step_index: step.index,
+    status: "success",
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  switch (step.type) {
+    case "execute_action": {
+      const action = step.action ?? buildActionFromConnector(step);
+      if (!action) {
+        stepResult.status = "failed";
+        stepResult.error = "No action defined for execute_action step";
+        break;
+      }
+      const resolvedAction = resolveActionParams(action, templateCtx);
+      const result = await executeAction(resolvedAction, templateCtx);
+      stepResult.status = result.success ? "success" : "failed";
+      stepResult.result = result;
+      stepResult.error = result.error;
+      if (!result.success) {
+        instance.status = "failed";
+      }
+      break;
+    }
+    case "wait_for_approval": {
+      const { createTask } = await import("./lib/tasks.js");
+      const { getCoordinatorName } = await import("./lib/employees.js");
+      const message = step.approval_message ? substituteTemplate(step.approval_message, templateCtx) : `Workflow "${def.name}" step ${step.index} ("${step.name}") requires approval.`;
+      const task = await createTask({
+        title: `[Workflow Approval] ${def.name}: ${step.name}`,
+        assignedTo: getCoordinatorName(),
+        assignedBy: "workflow-engine",
+        projectName: "exe-os",
+        priority: "p1",
+        context: `${message}
+
+**Workflow:** ${def.name} (${instance.id})
+**Step:** ${step.index} \u2014 ${step.name}
+
+To approve: call approve_workflow_step with instance_id="${instance.id}"
+To reject: call approve_workflow_step with instance_id="${instance.id}" approved=false`,
+        baseDir: process.cwd()
+      });
+      instance.approval_task_id = task.id;
+      instance.status = "waiting_approval";
+      stepResult.status = "pending_approval";
+      break;
+    }
+    case "conditional": {
+      if (!step.condition) {
+        stepResult.status = "failed";
+        stepResult.error = "No condition defined for conditional step";
+        break;
+      }
+      const resolvedExpr = substituteTemplate(step.condition.expression, templateCtx);
+      const conditionMet = evaluateSimpleExpression(resolvedExpr);
+      stepResult.result = { expression: resolvedExpr, met: conditionMet };
+      if (conditionMet && step.condition.then_step) {
+        instance.current_step = step.condition.then_step;
+        stepResult.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        instance.step_results.push(stepResult);
+        instance.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        return instance;
+      } else if (!conditionMet && step.condition.else_step) {
+        instance.current_step = step.condition.else_step;
+        stepResult.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        instance.step_results.push(stepResult);
+        instance.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        return instance;
+      }
+      break;
+    }
+  }
+  stepResult.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+  instance.step_results.push(stepResult);
+  if (instance.status === "running") {
+    const nextStep = def.steps.find((s) => s.index > step.index);
+    if (nextStep) {
+      instance.current_step = nextStep.index;
+    } else {
+      instance.status = "completed";
+    }
+  }
+  instance.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  return instance;
+}
+async function runWorkflow(instanceId) {
+  let instance = _instances.get(instanceId);
+  if (!instance) throw new Error(`Workflow instance "${instanceId}" not found`);
+  while (instance.status === "running") {
+    instance = await advanceWorkflow(instanceId);
+  }
+  return instance;
+}
+async function approveWorkflowStep(instanceId, approved = true) {
+  const instance = _instances.get(instanceId);
+  if (!instance) throw new Error(`Workflow instance "${instanceId}" not found`);
+  if (instance.status !== "waiting_approval") {
+    throw new Error(`Workflow "${instanceId}" is not waiting for approval (status: ${instance.status})`);
+  }
+  const pendingResult = instance.step_results.find(
+    (sr) => sr.step_index === instance.current_step && sr.status === "pending_approval"
+  );
+  if (pendingResult) {
+    pendingResult.status = approved ? "approved" : "failed";
+    pendingResult.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+    pendingResult.result = { approved };
+  }
+  if (!approved) {
+    instance.status = "cancelled";
+    instance.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    return instance;
+  }
+  const def = _definitions.get(instance.definition_id);
+  if (!def) throw new Error(`Workflow definition "${instance.definition_id}" not found`);
+  const currentStep = def.steps.find((s) => s.index === instance.current_step);
+  const nextStep = currentStep ? def.steps.find((s) => s.index > currentStep.index) : void 0;
+  if (nextStep) {
+    instance.current_step = nextStep.index;
+    instance.status = "running";
+  } else {
+    instance.status = "completed";
+  }
+  instance.approval_task_id = void 0;
+  instance.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  if (instance.status === "running") {
+    return runWorkflow(instanceId);
+  }
+  return instance;
+}
+function buildActionFromConnector(step) {
+  if (!step.connector || !step.operation) return null;
+  const params = {};
+  if (step.payload) {
+    for (const [k, v] of Object.entries(step.payload)) {
+      params[k] = String(v);
+    }
+  }
+  params._connector = step.connector;
+  params._operation = step.operation;
+  return {
+    type: "mcp_tool",
+    params
+  };
+}
+function evaluateSimpleExpression(expr) {
+  const operators = ["==", "!=", ">=", "<=", ">", "<"];
+  for (const op of operators) {
+    const idx = expr.indexOf(op);
+    if (idx === -1) continue;
+    const left = expr.slice(0, idx).trim();
+    const right = expr.slice(idx + op.length).trim();
+    switch (op) {
+      case "==":
+        return left === right;
+      case "!=":
+        return left !== right;
+      case ">":
+        return Number(left) > Number(right);
+      case "<":
+        return Number(left) < Number(right);
+      case ">=":
+        return Number(left) >= Number(right);
+      case "<=":
+        return Number(left) <= Number(right);
+    }
+  }
+  return expr.trim() !== "" && expr.trim() !== "false" && expr.trim() !== "0";
+}
+async function persistWorkflows() {
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    for (const def of _definitions.values()) {
+      await client.execute({
+        sql: `INSERT OR REPLACE INTO workflow_definitions (id, name, description, steps, trigger_event, created_at)
+              VALUES (?, ?, ?, ?, ?, ?)`,
+        args: [def.id, def.name, def.description ?? null, JSON.stringify(def.steps), def.trigger_event ?? null, def.created_at]
+      });
+    }
+    for (const inst of _instances.values()) {
+      await client.execute({
+        sql: `INSERT OR REPLACE INTO workflow_instances
+              (id, definition_id, status, current_step, step_results, context, approval_task_id, created_at, updated_at)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          inst.id,
+          inst.definition_id,
+          inst.status,
+          inst.current_step,
+          JSON.stringify(inst.step_results),
+          JSON.stringify(inst.context),
+          inst.approval_task_id ?? null,
+          inst.created_at,
+          inst.updated_at
+        ]
+      });
+    }
+  } catch (e) {
+    process.stderr.write(`[workflow-engine] persist failed: ${e instanceof Error ? e.message : String(e)}
+`);
+  }
+}
+async function loadWorkflows() {
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const defs = await client.execute("SELECT * FROM workflow_definitions");
+    for (const row of defs.rows) {
+      const def = {
+        id: String(row.id),
+        name: String(row.name),
+        description: String(row.description),
+        steps: JSON.parse(String(row.steps)),
+        trigger_event: String(row.trigger_event),
+        created_at: String(row.created_at)
+      };
+      _definitions.set(def.id, def);
+    }
+    const insts = await client.execute("SELECT * FROM workflow_instances WHERE status NOT IN ('completed', 'cancelled')");
+    for (const row of insts.rows) {
+      const inst = {
+        id: String(row.id),
+        definition_id: String(row.definition_id),
+        status: String(row.status),
+        current_step: Number(row.current_step),
+        step_results: JSON.parse(String(row.step_results)),
+        context: JSON.parse(String(row.context)),
+        approval_task_id: row.approval_task_id ? String(row.approval_task_id) : void 0,
+        created_at: String(row.created_at),
+        updated_at: String(row.updated_at)
+      };
+      _instances.set(inst.id, inst);
+    }
+  } catch {
+  }
+}
+
+export {
+  createWorkflowDefinition,
+  getWorkflowDefinition,
+  listWorkflowDefinitions,
+  startWorkflow,
+  getWorkflowInstance,
+  listWorkflowInstances,
+  advanceWorkflow,
+  runWorkflow,
+  approveWorkflowStep,
+  persistWorkflows,
+  loadWorkflows
+};

package/dist/co-activation-PLLVFEDK.js

@@ -0,0 +1,73 @@
+import {
+  getClient
+} from "./chunk-ZJP3ZONM.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-K26DLCUP.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/co-activation.ts
+async function recordCoActivations(entityIds) {
+  if (entityIds.length < 2) return;
+  const unique = [...new Set(entityIds)].slice(0, 20);
+  const client = getClient();
+  const pairs = [];
+  for (let i = 0; i < unique.length; i++) {
+    for (let j = i + 1; j < unique.length; j++) {
+      const idI = unique[i];
+      const idJ = unique[j];
+      const pair = idI < idJ ? [idI, idJ] : [idJ, idI];
+      pairs.push(pair);
+    }
+  }
+  for (const [a, b] of pairs) {
+    await client.execute({
+      sql: `INSERT INTO co_activations (entity_a_id, entity_b_id, count, last_activated_at)
+            VALUES (?, ?, 1, datetime('now'))
+            ON CONFLICT (entity_a_id, entity_b_id)
+            DO UPDATE SET count = count + 1, last_activated_at = datetime('now')`,
+      args: [a, b]
+    });
+  }
+}
+async function getHotPairs(limit = 20) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT entity_a_id, entity_b_id, count, last_activated_at
+          FROM co_activations
+          ORDER BY count DESC
+          LIMIT ?`,
+    args: [limit]
+  });
+  return result.rows.map((r) => ({
+    entity_a_id: String(r.entity_a_id),
+    entity_b_id: String(r.entity_b_id),
+    count: Number(r.count),
+    last_activated_at: String(r.last_activated_at)
+  }));
+}
+async function getCoActivationNeighbors(entityId, limit = 20) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT entity_a_id, entity_b_id, count, last_activated_at
+          FROM co_activations
+          WHERE entity_a_id = ? OR entity_b_id = ?
+          ORDER BY count DESC
+          LIMIT ?`,
+    args: [entityId, entityId, limit]
+  });
+  return result.rows.map((r) => ({
+    entity_a_id: String(r.entity_a_id),
+    entity_b_id: String(r.entity_b_id),
+    count: Number(r.count),
+    last_activated_at: String(r.last_activated_at)
+  }));
+}
+export {
+  getCoActivationNeighbors,
+  getHotPairs,
+  recordCoActivations
+};

package/dist/co-occurrence-OIK6WLXN.js

@@ -0,0 +1,94 @@
+import {
+  entityId,
+  normalizeEntityName
+} from "./chunk-I7GRBEFS.js";
+import "./chunk-I7AW4237.js";
+import "./chunk-GUMRIUI5.js";
+import {
+  getClient
+} from "./chunk-ZJP3ZONM.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-K26DLCUP.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/co-occurrence.ts
+var SPECIFICITY = {
+  file: 5,
+  function: 4,
+  error: 3,
+  tool: 2,
+  agent: 1,
+  project: 0
+};
+function getSpecificity(type) {
+  return SPECIFICITY[type] ?? 1;
+}
+function coOccurrenceId(entityId1, entityId2) {
+  const sorted = [entityId1, entityId2].sort();
+  return `cooccur:${sorted[0]}:${sorted[1]}`;
+}
+async function actualEntityId(name, type, fallbackId) {
+  try {
+    const result = await getClient().execute({
+      sql: "SELECT id FROM entities WHERE LOWER(name) = LOWER(?) AND type = ? LIMIT 1",
+      args: [name, type]
+    });
+    return result.rows[0]?.id ? String(result.rows[0].id) : fallbackId;
+  } catch {
+    return fallbackId;
+  }
+}
+async function createCoOccurrenceEdges(entities, _memoryId) {
+  if (entities.length < 2) return 0;
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = entities.filter((e) => {
+    const key = `${e.type.toLowerCase()}:${normalizeEntityName(e.name)}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const sorted = deduped.sort((a, b) => getSpecificity(b.type) - getSpecificity(a.type));
+  const MAX_PAIRS = 10;
+  const pairs = [];
+  for (let i = 0; i < sorted.length && pairs.length < MAX_PAIRS; i++) {
+    for (let j = i + 1; j < sorted.length && pairs.length < MAX_PAIRS; j++) {
+      pairs.push([sorted[i], sorted[j]]);
+    }
+  }
+  let created = 0;
+  for (const [a, b] of pairs) {
+    const aName = normalizeEntityName(a.name);
+    const bName = normalizeEntityName(b.name);
+    const aType = a.type.toLowerCase();
+    const bType = b.type.toLowerCase();
+    const aId = await actualEntityId(aName, aType, entityId(aName, aType));
+    const bId = await actualEntityId(bName, bType, entityId(bName, bType));
+    if (aId === bId) continue;
+    const relId = coOccurrenceId(aId, bId);
+    const sortedIds = [aId, bId].sort();
+    const sourceId = sortedIds[0];
+    const targetId = sortedIds[1];
+    try {
+      await client.execute({
+        sql: `INSERT INTO relationships (id, source_entity_id, target_entity_id, type, weight, timestamp, properties)
+              VALUES (?, ?, ?, 'co_occurs_with', 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, now, now]
+      });
+      created++;
+    } catch {
+    }
+  }
+  return created;
+}
+export {
+  createCoOccurrenceEdges
+};

package/dist/co-occurrence-QB4MQSY7.js

@@ -0,0 +1,94 @@
+import {
+  entityId,
+  normalizeEntityName
+} from "./chunk-KBNMVPDE.js";
+import "./chunk-GUMRIUI5.js";
+import "./chunk-I7AW4237.js";
+import {
+  getClient
+} from "./chunk-ZJP3ZONM.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-K26DLCUP.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/co-occurrence.ts
+var SPECIFICITY = {
+  file: 5,
+  function: 4,
+  error: 3,
+  tool: 2,
+  agent: 1,
+  project: 0
+};
+function getSpecificity(type) {
+  return SPECIFICITY[type] ?? 1;
+}
+function coOccurrenceId(entityId1, entityId2) {
+  const sorted = [entityId1, entityId2].sort();
+  return `cooccur:${sorted[0]}:${sorted[1]}`;
+}
+async function actualEntityId(name, type, fallbackId) {
+  try {
+    const result = await getClient().execute({
+      sql: "SELECT id FROM entities WHERE LOWER(name) = LOWER(?) AND type = ? LIMIT 1",
+      args: [name, type]
+    });
+    return result.rows[0]?.id ? String(result.rows[0].id) : fallbackId;
+  } catch {
+    return fallbackId;
+  }
+}
+async function createCoOccurrenceEdges(entities, _memoryId) {
+  if (entities.length < 2) return 0;
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = entities.filter((e) => {
+    const key = `${e.type.toLowerCase()}:${normalizeEntityName(e.name)}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const sorted = deduped.sort((a, b) => getSpecificity(b.type) - getSpecificity(a.type));
+  const MAX_PAIRS = 10;
+  const pairs = [];
+  for (let i = 0; i < sorted.length && pairs.length < MAX_PAIRS; i++) {
+    for (let j = i + 1; j < sorted.length && pairs.length < MAX_PAIRS; j++) {
+      pairs.push([sorted[i], sorted[j]]);
+    }
+  }
+  let created = 0;
+  for (const [a, b] of pairs) {
+    const aName = normalizeEntityName(a.name);
+    const bName = normalizeEntityName(b.name);
+    const aType = a.type.toLowerCase();
+    const bType = b.type.toLowerCase();
+    const aId = await actualEntityId(aName, aType, entityId(aName, aType));
+    const bId = await actualEntityId(bName, bType, entityId(bName, bType));
+    if (aId === bId) continue;
+    const relId = coOccurrenceId(aId, bId);
+    const sortedIds = [aId, bId].sort();
+    const sourceId = sortedIds[0];
+    const targetId = sortedIds[1];
+    try {
+      await client.execute({
+        sql: `INSERT INTO relationships (id, source_entity_id, target_entity_id, type, weight, timestamp, properties)
+              VALUES (?, ?, ?, 'co_occurs_with', 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, now, now]
+      });
+      created++;
+    } catch {
+    }
+  }
+  return created;
+}
+export {
+  createCoOccurrenceEdges
+};

package/dist/code-context-index-CG4P2JZI.js

@@ -0,0 +1,30 @@
+import {
+  analyzeBlastRadius,
+  buildCodeContextIndex,
+  buildCodeContextIndexWithEmbeddings,
+  getCodeContextIndexPath,
+  getCodeContextStats,
+  loadOrBuildCodeContextIndex,
+  searchCodeContext,
+  searchCodeContextSemantic,
+  traceCodeSymbol
+} from "./chunk-5BUPCYCN.js";
+import "./chunk-I7AW4237.js";
+import "./chunk-KZ57MNYJ.js";
+import "./chunk-QQ7LYLRH.js";
+import "./chunk-3XX3CDKF.js";
+import "./chunk-7L2EV3XX.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  analyzeBlastRadius,
+  buildCodeContextIndex,
+  buildCodeContextIndexWithEmbeddings,
+  getCodeContextIndexPath,
+  getCodeContextStats,
+  loadOrBuildCodeContextIndex,
+  searchCodeContext,
+  searchCodeContextSemantic,
+  traceCodeSymbol
+};