@askexenow/exe-os 0.9.286 → 0.9.288

package/dist/chunk-7M5ZHD4E.js

@@ -0,0 +1,214 @@
+import {
+  sessionScopeFilter
+} from "./chunk-5XOAYMSU.js";
+
+// src/lib/git-task-sweep.ts
+import { execSync } from "child_process";
+var DEFAULT_COMMIT_LIMIT = 50;
+var DEFAULT_STALE_MINUTES = 10;
+var AUTO_ESCALATE_THRESHOLD = 0.6;
+var EXACT_UUID_SCORE = 1;
+var TITLE_KEYWORD_SCORE = 0.5;
+var FILE_PATH_SCORE = 0.3;
+var MIN_KEYWORD_OVERLAP = 3;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "as",
+  "be",
+  "was",
+  "are",
+  "this",
+  "that",
+  "not",
+  "no",
+  "if",
+  "so",
+  "do",
+  "up"
+]);
+function extractKeywords(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+}
+function matchScore(task, commitMessage, changedFiles) {
+  if (task.id.length >= 8 && commitMessage.includes(task.id)) {
+    return EXACT_UUID_SCORE;
+  }
+  let score = 0;
+  const titleWords = extractKeywords(task.title);
+  const commitWords = new Set(extractKeywords(commitMessage));
+  const overlap = titleWords.filter((w) => commitWords.has(w));
+  if (overlap.length >= MIN_KEYWORD_OVERLAP) {
+    score += TITLE_KEYWORD_SCORE;
+  }
+  if (task.context && changedFiles.length > 0) {
+    const contextLower = task.context.toLowerCase();
+    const hasFileMatch = changedFiles.some(
+      (f) => contextLower.includes(f.toLowerCase())
+    );
+    if (hasFileMatch) {
+      score += FILE_PATH_SCORE;
+    }
+  }
+  return score;
+}
+function getRecentCommits(limit = DEFAULT_COMMIT_LIMIT) {
+  try {
+    const SEPARATOR = "<<SEP>>";
+    const output = execSync(
+      `git log --format="%h${SEPARATOR}%s${SEPARATOR}%aI" --name-only -n ${limit} -z`,
+      { encoding: "utf8", timeout: 1e4 }
+    );
+    const entries = output.split("\0").filter(Boolean);
+    const commits = [];
+    let current = null;
+    for (const entry of entries) {
+      if (entry.includes(SEPARATOR)) {
+        const lines = entry.split("\n");
+        const headerLine = lines[0];
+        const parts = headerLine.split(SEPARATOR);
+        if (parts.length >= 3) {
+          if (current) commits.push(current);
+          current = {
+            hash: parts[0],
+            message: parts[1],
+            files: lines.slice(1).filter(Boolean),
+            date: new Date(parts[2])
+          };
+        }
+      } else if (current) {
+        const files = entry.split("\n").filter(Boolean);
+        current.files.push(...files);
+      }
+    }
+    if (current) commits.push(current);
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function isStale(updatedAt, staleMinutes) {
+  const updated = new Date(updatedAt).getTime();
+  const threshold = Date.now() - staleMinutes * 6e4;
+  return updated < threshold;
+}
+function findBestMatch(task, commits) {
+  let best = null;
+  for (const commit of commits) {
+    const score = matchScore(task, commit.message, commit.files);
+    if (score >= AUTO_ESCALATE_THRESHOLD && (!best || score > best.score)) {
+      best = { commit, score };
+    }
+  }
+  return best;
+}
+async function sweepTasks(projectName, options = {}) {
+  const commitLimit = options.commitLimit ?? DEFAULT_COMMIT_LIMIT;
+  const staleMinutes = options.staleMinutes ?? DEFAULT_STALE_MINUTES;
+  const dryRun = options.dryRun ?? false;
+  const result = { escalated: [], unchanged: 0, errors: [] };
+  const commits = getRecentCommits(commitLimit);
+  if (commits.length === 0) {
+    result.errors.push("No git commits found (not a git repo or empty history)");
+    return result;
+  }
+  let tasks;
+  try {
+    const { initStore } = await import("./lib/store.js");
+    await initStore();
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const conditions = ["status = 'in_progress'"];
+    const args = [];
+    if (projectName) {
+      conditions.push("project_name = ?");
+      args.push(projectName);
+    }
+    const swScope = sessionScopeFilter();
+    if (swScope.sql) {
+      conditions.push("(session_scope IS NULL OR session_scope = ?)");
+      args.push(...swScope.args);
+    }
+    const queryResult = await client.execute({
+      sql: `SELECT id, title, assigned_to, project_name, status, updated_at, context
+            FROM tasks WHERE ${conditions.join(" AND ")}
+            ORDER BY updated_at ASC`,
+      args
+    });
+    tasks = queryResult.rows.map((r) => ({
+      id: String(r.id),
+      title: String(r.title),
+      assignedTo: String(r.assigned_to),
+      projectName: String(r.project_name),
+      status: String(r.status),
+      updatedAt: String(r.updated_at),
+      context: r.context ? String(r.context) : void 0
+    }));
+  } catch (err) {
+    result.errors.push(`DB query failed: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  if (tasks.length === 0) {
+    return result;
+  }
+  for (const task of tasks) {
+    if (!isStale(task.updatedAt, staleMinutes)) {
+      result.unchanged++;
+      continue;
+    }
+    const match = findBestMatch(task, commits);
+    if (!match) {
+      result.unchanged++;
+      continue;
+    }
+    if (!dryRun) {
+      try {
+        const { updateTaskStatus } = await import("./tasks-crud-J5TSLFQN.js");
+        await updateTaskStatus({
+          taskId: task.id,
+          status: "needs_review",
+          result: `Auto-escalated by git-sweep: matching commit ${match.commit.hash} found (score: ${match.score.toFixed(2)})`
+        });
+      } catch (err) {
+        result.errors.push(
+          `Failed to escalate task ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
+      }
+    }
+    result.escalated.push({
+      taskId: task.id,
+      title: task.title,
+      matchedCommit: match.commit.hash,
+      score: match.score
+    });
+    process.stderr.write(
+      `[git-sweep] ${dryRun ? "WOULD escalate" : "Escalated"} task ${task.id} \u2192 commit ${match.commit.hash} (score: ${match.score.toFixed(2)})
+`
+    );
+  }
+  return result;
+}
+
+export {
+  extractKeywords,
+  matchScore,
+  getRecentCommits,
+  findBestMatch,
+  sweepTasks
+};

package/dist/chunk-A3GC762G.js

@@ -0,0 +1,333 @@
+import {
+  executeAction,
+  substituteTemplate
+} from "./chunk-HMP6KB4V.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/chunk-ALTFDYI6.js

@@ -0,0 +1,97 @@
+import {
+  listBehaviors
+} from "./chunk-7G52QPUX.js";
+import {
+  loadConfigSync
+} from "./chunk-T3B5RK4H.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
+};

package/dist/chunk-AN25OIRX.js

@@ -0,0 +1,38 @@
+import {
+  listReminders
+} from "./chunk-OICU3UHF.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
+};