@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-JJNXFW7M.js

@@ -0,0 +1,330 @@
+import {
+  employeeSessionName,
+  isEmployeeAlive,
+  resolveExeSession,
+  sendIntercom,
+  strictSessionScopeFilter
+} from "./chunk-UBMGUX6T.js";
+import {
+  parseMessage,
+  serializeMessage
+} from "./chunk-4JERP7NT.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-CTFKTUYN.js";
+import {
+  getClient
+} from "./chunk-UJOSFVWG.js";
+
+// src/lib/messaging.ts
+import crypto from "crypto";
+function generateUlid() {
+  const timestamp = Date.now().toString(36).padStart(10, "0");
+  const random = crypto.randomBytes(10).toString("hex").slice(0, 16);
+  return (timestamp + random).toUpperCase();
+}
+function rowToMessage(row) {
+  return {
+    id: row.id,
+    fromAgent: row.from_agent,
+    fromDevice: row.from_device,
+    targetAgent: row.target_agent,
+    targetProject: row.target_project ?? null,
+    targetDevice: row.target_device,
+    sessionScope: row.session_scope ?? null,
+    content: row.content,
+    priority: row.priority ?? "normal",
+    status: row.status ?? "pending",
+    serverSeq: row.server_seq != null ? Number(row.server_seq) : null,
+    retryCount: Number(row.retry_count ?? 0),
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at ?? null,
+    processedAt: row.processed_at ?? null,
+    failedAt: row.failed_at ?? null,
+    failureReason: row.failure_reason ?? null
+  };
+}
+var MAX_RETRIES = 10;
+async function sendMessage(input) {
+  const client = getClient();
+  const id = generateUlid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const targetDevice = input.targetDevice ?? "local";
+  const sessionScope = input.sessionScope === void 0 ? resolveExeSession() : input.sessionScope;
+  await client.execute({
+    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, session_scope, content, priority, status, founder_id, created_at)
+          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`,
+    args: [
+      id,
+      input.fromAgent,
+      input.targetAgent,
+      input.targetProject ?? null,
+      targetDevice,
+      sessionScope,
+      input.content,
+      input.priority ?? "normal",
+      input.founderId ?? null,
+      now
+    ]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.sent",
+    source: "messaging.sendMessage",
+    agentId: input.fromAgent,
+    payload: { targetAgent: input.targetAgent, priority: input.priority ?? "normal", targetDevice },
+    sessionScope: sessionScope ?? null
+  });
+  try {
+    if (targetDevice !== "local") {
+      await deliverCrossMachineMessage(id, targetDevice);
+    } else {
+      await deliverLocalMessage(id);
+    }
+  } catch {
+  }
+  const sentScope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE id = ?${sentScope.sql}`,
+    args: [id, ...sentScope.args]
+  });
+  return rowToMessage(result.rows[0]);
+}
+var _wsClientSend = null;
+function setWsClientSend(fn) {
+  _wsClientSend = fn;
+}
+async function deliverCrossMachineMessage(messageId, targetDevice) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  if (!_wsClientSend) {
+    return false;
+  }
+  const payload = JSON.stringify({
+    id: msg.id,
+    fromAgent: msg.fromAgent,
+    targetAgent: msg.targetAgent,
+    targetProject: msg.targetProject,
+    sessionScope: msg.sessionScope,
+    content: msg.content,
+    priority: msg.priority,
+    createdAt: msg.createdAt
+  });
+  const sent = _wsClientSend(targetDevice, payload);
+  if (sent) {
+    await client.execute({
+      sql: "UPDATE messages SET status = 'synced' WHERE id = ?",
+      args: [messageId]
+    });
+    return true;
+  }
+  return false;
+}
+async function deliverLocalMessage(messageId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  const targetAgent = msg.targetAgent;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      throw new Error("No coordinator session found");
+    }
+    process.stderr.write(`[messaging] ENTER deliverLocal: target=${targetAgent} exeSession=${exeSession}
+`);
+    const { isCoordinatorName: isCoord } = await import("./lib/employees.js");
+    const isCOO = isCoord(targetAgent);
+    process.stderr.write(`[messaging] COO check: targetAgent="${targetAgent}" isCOO=${isCOO}
+`);
+    const sessionName = isCOO ? exeSession : employeeSessionName(targetAgent, exeSession);
+    process.stderr.write(`[messaging] delivery attempt: target=${targetAgent} session=${sessionName} isCOO=${isCOO}
+`);
+    if (!isCOO && !isEmployeeAlive(sessionName)) {
+      throw new Error("Session not running \u2014 message stays queued");
+    }
+    const intercomResult = sendIntercom(sessionName, { force: true });
+    process.stderr.write(`[messaging] intercom result for ${sessionName}: ${intercomResult}
+`);
+    await client.execute({
+      sql: "UPDATE messages SET status = 'delivered', delivered_at = ? WHERE id = ?",
+      args: [now, messageId]
+    });
+    recordOrchestrationEventBestEffort({
+      eventType: "message.delivered",
+      source: "messaging.deliverLocalMessage",
+      agentId: msg.targetAgent,
+      payload: { fromAgent: msg.fromAgent, priority: msg.priority }
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[messaging] delivery failed for message ${messageId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    const newRetryCount = msg.retryCount + 1;
+    if (newRetryCount >= MAX_RETRIES) {
+      await markFailed(messageId, "session unavailable after 10 retries", msg.sessionScope);
+    } else {
+      await client.execute({
+        sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
+        args: [newRetryCount, messageId]
+      });
+    }
+    return false;
+  }
+}
+async function getPendingMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markRead(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'read'
+          WHERE id = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.read",
+    source: "messaging.markRead",
+    payload: { messageId }
+  });
+}
+async function markAcknowledged(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'acknowledged', processed_at = ?
+          WHERE id = ? AND status = 'read'${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function markProcessed(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'processed', processed_at = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function getMessageStatus(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT status FROM messages WHERE id = ?${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  return result.rows[0]?.status ?? null;
+}
+async function getUnacknowledgedMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered', 'read')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function getReadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status = 'read'${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markFailed(messageId, reason, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId, ...scope.args]
+  });
+}
+async function getFailedMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE status = 'failed'${scope.sql} ORDER BY created_at DESC`,
+    args: [...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function retryPendingMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE status = 'pending' AND retry_count < ?${scope.sql}
+          ORDER BY id`,
+    args: [MAX_RETRIES, ...scope.args]
+  });
+  let delivered = 0;
+  for (const row of result.rows) {
+    const msg = rowToMessage(row);
+    try {
+      const success = await deliverLocalMessage(msg.id);
+      if (success) delivered++;
+    } catch {
+    }
+  }
+  return delivered;
+}
+async function sendTypedMessage(envelope, targetAgent, opts) {
+  return sendMessage({
+    fromAgent: envelope.from,
+    targetAgent,
+    targetProject: opts?.targetProject,
+    targetDevice: opts?.targetDevice,
+    content: serializeMessage(envelope),
+    priority: opts?.priority,
+    sessionScope: opts?.sessionScope
+  });
+}
+function parseIncomingMessage(content) {
+  return parseMessage(content);
+}
+
+export {
+  sendMessage,
+  setWsClientSend,
+  deliverLocalMessage,
+  getPendingMessages,
+  markRead,
+  markAcknowledged,
+  markProcessed,
+  getMessageStatus,
+  getUnacknowledgedMessages,
+  getReadMessages,
+  markFailed,
+  getFailedMessages,
+  retryPendingMessages,
+  sendTypedMessage,
+  parseIncomingMessage
+};

package/dist/chunk-JKGAJAM7.js

@@ -0,0 +1,214 @@
+import {
+  sessionScopeFilter
+} from "./chunk-UBMGUX6T.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-CLAYZZ4O.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-JQ6TLNIV.js

@@ -0,0 +1,133 @@
+import {
+  checkPermission
+} from "./chunk-PRKVT4KN.js";
+
+// src/runtime/zod-to-schema.ts
+function zodToJsonSchema(schema) {
+  if ("toJSONSchema" in schema && typeof schema.toJSONSchema === "function") {
+    return schema.toJSONSchema();
+  }
+  const def = schema._def;
+  if (!def) {
+    return { type: "object", properties: {} };
+  }
+  return extractSchema(def);
+}
+function extractSchema(def) {
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodObject": {
+      const shape = def.shape;
+      const properties = {};
+      const required = [];
+      if (shape) {
+        const resolved = typeof shape === "function" ? shape() : shape;
+        for (const [key, value] of Object.entries(resolved)) {
+          const fieldDef = value._def ?? value;
+          const isOptional = fieldDef.typeName === "ZodOptional";
+          if (isOptional) {
+            properties[key] = extractSchema(
+              fieldDef.innerType?._def ?? {}
+            );
+          } else {
+            properties[key] = extractSchema(fieldDef);
+            required.push(key);
+          }
+        }
+      }
+      const result = { type: "object", properties };
+      if (required.length > 0) result.required = required;
+      return result;
+    }
+    case "ZodString":
+      return { type: "string", ...def.description ? { description: String(def.description) } : {} };
+    case "ZodNumber":
+      return { type: "number", ...def.description ? { description: String(def.description) } : {} };
+    case "ZodBoolean":
+      return { type: "boolean", ...def.description ? { description: String(def.description) } : {} };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: extractSchema(
+          def.type?._def ?? {}
+        )
+      };
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    case "ZodOptional":
+      return extractSchema(
+        def.innerType?._def ?? {}
+      );
+    case "ZodDefault":
+      return extractSchema(
+        def.innerType?._def ?? {}
+      );
+    default:
+      return { type: "string" };
+  }
+}
+
+// src/runtime/tool-registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  /** Register a tool */
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /** Look up a tool by name */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /** List all registered tools */
+  list() {
+    return [...this.tools.values()];
+  }
+  /** List tool names */
+  names() {
+    return [...this.tools.keys()];
+  }
+  /** Convert all tools to LLM-ready NormalizedTool format */
+  toNormalizedTools() {
+    return this.list().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: zodToJsonSchema(tool.inputSchema)
+    }));
+  }
+  /** Get only tools allowed by the given permission set */
+  listAllowed(permissions) {
+    return this.list().filter(
+      (tool) => checkPermission(tool.name, permissions).allowed
+    );
+  }
+  /** Convert allowed tools to NormalizedTool format */
+  toAllowedNormalizedTools(permissions) {
+    return this.listAllowed(permissions).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: zodToJsonSchema(tool.inputSchema)
+    }));
+  }
+};
+function partitionTools(blocks, registry) {
+  const concurrent = [];
+  const sequential = [];
+  let hitWrite = false;
+  for (const block of blocks) {
+    if (block.type !== "tool_use") continue;
+    const tool = registry.get(block.name);
+    if (!hitWrite && tool?.isReadOnly) {
+      concurrent.push(block);
+    } else {
+      hitWrite = true;
+      sequential.push(block);
+    }
+  }
+  return { concurrent, sequential };
+}
+
+export {
+  zodToJsonSchema,
+  ToolRegistry,
+  partitionTools
+};