@askexenow/exe-os 0.9.286 → 0.9.288

package/dist/chunk-BJTBA4XS.js

@@ -0,0 +1,290 @@
+import {
+  storeBehavior
+} from "./chunk-CTJQX44O.js";
+import {
+  getClient
+} from "./chunk-XVDWHYIK.js";
+import {
+  loadConfig
+} from "./chunk-CEKZ77KA.js";
+
+// src/lib/skill-learning.ts
+import crypto from "crypto";
+var DEFAULT_SKILL_THRESHOLD = 3;
+async function extractTrajectory(taskId, agentId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT tool_name, raw_text
+          FROM memories
+          WHERE task_id = ? AND agent_id = ?
+          ORDER BY timestamp ASC`,
+    args: [taskId, agentId]
+  });
+  if (result.rows.length === 0) return [];
+  const rawTools = result.rows.map((r) => {
+    const toolName = String(r.tool_name);
+    if (toolName === "Bash") {
+      const text = String(r.raw_text);
+      const cmdMatch = text.match(/(?:command|Command).*?[:\s]+"?(\w+)/);
+      return cmdMatch ? `Bash:${cmdMatch[1]}` : "Bash";
+    }
+    return toolName;
+  });
+  const signature = [];
+  for (const tool of rawTools) {
+    if (signature.length === 0 || signature[signature.length - 1] !== tool) {
+      signature.push(tool);
+    }
+  }
+  return signature;
+}
+function hashSignature(signature) {
+  return crypto.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+}
+async function storeTrajectory(opts) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const signatureHash = hashSignature(opts.signature);
+  await client.execute({
+    sql: `INSERT INTO trajectories (id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      opts.taskId,
+      opts.agentId,
+      opts.projectName,
+      opts.taskTitle,
+      JSON.stringify(opts.signature),
+      signatureHash,
+      opts.signature.length,
+      now
+    ]
+  });
+  return id;
+}
+async function findSimilarTrajectories(signature, threshold = DEFAULT_SKILL_THRESHOLD) {
+  const client = getClient();
+  const hash = hashSignature(signature);
+  const result = await client.execute({
+    sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
+          FROM trajectories
+          WHERE signature_hash = ?
+          ORDER BY created_at DESC
+          LIMIT 20`,
+    args: [hash]
+  });
+  const mapRow = (r) => ({
+    id: String(r.id),
+    taskId: String(r.task_id),
+    agentId: String(r.agent_id),
+    projectName: String(r.project_name),
+    taskTitle: String(r.task_title),
+    signature: JSON.parse(String(r.signature)),
+    signatureHash: String(r.signature_hash),
+    toolCount: Number(r.tool_count),
+    skillId: r.skill_id ? String(r.skill_id) : null,
+    createdAt: String(r.created_at)
+  });
+  const matches = result.rows.map(mapRow);
+  if (matches.length >= threshold) return matches;
+  const nearResult = await client.execute({
+    sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
+          FROM trajectories
+          WHERE tool_count BETWEEN ? AND ?
+            AND signature_hash != ?
+          ORDER BY created_at DESC
+          LIMIT 50`,
+    args: [
+      Math.max(1, signature.length - 3),
+      signature.length + 3,
+      hash
+    ]
+  });
+  for (const r of nearResult.rows) {
+    const candidateSig = JSON.parse(String(r.signature));
+    if (editDistance(signature, candidateSig) <= 2) {
+      matches.push(mapRow(r));
+    }
+  }
+  return matches;
+}
+async function captureTrajectory(opts) {
+  const signature = await extractTrajectory(opts.taskId, opts.agentId);
+  if (signature.length < 3) {
+    return { trajectoryId: "", similarCount: 0, similar: [] };
+  }
+  const trajectoryId = await storeTrajectory({
+    taskId: opts.taskId,
+    agentId: opts.agentId,
+    projectName: opts.projectName,
+    taskTitle: opts.taskTitle,
+    signature
+  });
+  const similar = await findSimilarTrajectories(
+    signature,
+    opts.skillThreshold ?? DEFAULT_SKILL_THRESHOLD
+  );
+  return { trajectoryId, similarCount: similar.length, similar };
+}
+function buildExtractionPrompt(trajectories) {
+  const items = trajectories.map((t, i) => {
+    const sig = t.signature.join(" \u2192 ");
+    return `Task ${i + 1}: "${t.taskTitle}" (${t.agentId}, ${t.projectName}) \u2014 ${t.toolCount} tool calls
+Signature: ${sig}`;
+  }).join("\n\n");
+  return `You are analyzing ${trajectories.length} completed tasks that followed similar procedures:
+
+${items}
+
+Extract the reusable procedure. Format your response EXACTLY like this:
+
+SKILL: {name \u2014 short, descriptive}
+TRIGGER: {when to use this \u2014 one sentence}
+STEPS:
+1. ...
+2. ...
+PITFALLS: {common mistakes to avoid}
+
+Be specific and actionable. Include tool names, file patterns, and concrete commands where applicable.`;
+}
+async function extractSkill(trajectories, model) {
+  if (trajectories.length === 0) return null;
+  const config = await loadConfig();
+  const skillModel = model ?? config.skillModel;
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const prompt = buildExtractionPrompt(trajectories);
+  const response = await client.messages.create({
+    model: skillModel,
+    max_tokens: 500,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const textBlock = response.content.find((b) => b.type === "text");
+  const skillText = textBlock?.text;
+  if (!skillText) return null;
+  const agentId = trajectories[0].agentId;
+  const projectName = trajectories[0].projectName;
+  const skillId = await storeBehavior({
+    agentId,
+    content: skillText,
+    domain: "skill",
+    projectName
+  });
+  const dbClient = getClient();
+  for (const t of trajectories) {
+    await dbClient.execute({
+      sql: "UPDATE trajectories SET skill_id = ? WHERE id = ?",
+      args: [skillId, t.id]
+    });
+  }
+  process.stderr.write(
+    `[skill-learning] Skill extracted from ${trajectories.length} trajectories \u2192 behavior ${skillId}
+`
+  );
+  return skillId;
+}
+async function captureAndLearn(opts) {
+  try {
+    const config = await loadConfig();
+    if (!config.skillLearning) return;
+    const { trajectoryId, similarCount, similar } = await captureTrajectory({
+      ...opts,
+      skillThreshold: config.skillThreshold
+    });
+    if (!trajectoryId) return;
+    if (similarCount >= config.skillThreshold) {
+      const unprocessed = similar.filter((t) => !t.skillId);
+      if (unprocessed.length >= config.skillThreshold) {
+        extractSkill(unprocessed, config.skillModel).catch((err) => {
+          process.stderr.write(
+            `[skill-learning] Extraction failed: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        });
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[skill-learning] captureAndLearn failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function sweepTrajectories(threshold, model) {
+  const config = await loadConfig();
+  if (!config.skillLearning) return { clustersProcessed: 0, skillsExtracted: 0 };
+  const t = threshold ?? config.skillThreshold;
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT signature_hash, COUNT(*) as cnt
+          FROM trajectories
+          WHERE skill_id IS NULL
+          GROUP BY signature_hash
+          HAVING cnt >= ?
+          ORDER BY cnt DESC
+          LIMIT 10`,
+    args: [t]
+  });
+  let clustersProcessed = 0;
+  let skillsExtracted = 0;
+  for (const row of result.rows) {
+    const hash = String(row.signature_hash);
+    const trajResult = await client.execute({
+      sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at
+            FROM trajectories
+            WHERE signature_hash = ? AND skill_id IS NULL
+            ORDER BY created_at DESC
+            LIMIT 10`,
+      args: [hash]
+    });
+    const trajectories = trajResult.rows.map((r) => ({
+      id: String(r.id),
+      taskId: String(r.task_id),
+      agentId: String(r.agent_id),
+      projectName: String(r.project_name),
+      taskTitle: String(r.task_title),
+      signature: JSON.parse(String(r.signature)),
+      signatureHash: String(r.signature_hash),
+      toolCount: Number(r.tool_count),
+      skillId: null,
+      createdAt: String(r.created_at)
+    }));
+    if (trajectories.length >= t) {
+      clustersProcessed++;
+      const skillId = await extractSkill(trajectories, model ?? config.skillModel);
+      if (skillId) skillsExtracted++;
+    }
+  }
+  return { clustersProcessed, skillsExtracted };
+}
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+
+export {
+  extractTrajectory,
+  hashSignature,
+  storeTrajectory,
+  findSimilarTrajectories,
+  captureTrajectory,
+  extractSkill,
+  captureAndLearn,
+  sweepTrajectories,
+  editDistance
+};

package/dist/chunk-BQBPNRUW.js

@@ -0,0 +1,231 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-DYICAAAM.js";
+import {
+  atomicWriteJsonSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/session-registry.ts
+import { readFileSync, mkdirSync, existsSync, openSync, closeSync, writeSync, unlinkSync, constants } from "fs";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var REGISTRY_PATH = path.join(os.homedir(), ".exe-os", "session-registry.json");
+var REGISTRY_LOCK_PATH = `${REGISTRY_PATH}.lock`;
+var REGISTRY_CACHE_TTL_MS = 100;
+var registryCache = null;
+function acquireRegistryLock() {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const data = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  const deadline = Date.now() + 250;
+  while (Date.now() < deadline) {
+    try {
+      const fd = openSync(REGISTRY_LOCK_PATH, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+      writeSync(fd, data);
+      closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      try {
+        const lock = JSON.parse(readFileSync(REGISTRY_LOCK_PATH, "utf8"));
+        if (Date.now() - Number(lock.timestamp ?? 0) > 3e4) unlinkSync(REGISTRY_LOCK_PATH);
+      } catch {
+        try {
+          unlinkSync(REGISTRY_LOCK_PATH);
+        } catch {
+        }
+      }
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+  }
+  return false;
+}
+function releaseRegistryLock() {
+  try {
+    unlinkSync(REGISTRY_LOCK_PATH);
+  } catch {
+  }
+}
+function readSessionsUncached() {
+  try {
+    const raw = readFileSync(REGISTRY_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function writeSessions(sessions) {
+  atomicWriteJsonSync(REGISTRY_PATH, sessions);
+  registryCache = { at: Date.now(), sessions };
+}
+function registerSession(entry) {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const _locked = acquireRegistryLock();
+  try {
+    const sessions = readSessionsUncached();
+    const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
+    if (idx >= 0) {
+      sessions[idx] = entry;
+    } else {
+      sessions.push(entry);
+    }
+    writeSessions(sessions);
+  } finally {
+    if (_locked) releaseRegistryLock();
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "registry.registered",
+    source: "session-registry.registerSession",
+    agentId: entry.agentId,
+    sessionScope: entry.parentExe,
+    tmuxSession: entry.windowName,
+    payload: { hasProjectDir: Boolean(entry.projectDir) }
+  });
+}
+function refreshSessionProject(windowName, projectDir) {
+  if (!acquireRegistryLock()) return;
+  try {
+    const sessions = readSessionsUncached();
+    const entry = sessions.find((s) => s.windowName === windowName);
+    if (!entry || entry.projectDir === projectDir) return;
+    entry.projectDir = projectDir;
+    writeSessions(sessions);
+  } catch {
+  } finally {
+    releaseRegistryLock();
+  }
+}
+function listSessions() {
+  const now = Date.now();
+  if (registryCache && now - registryCache.at < REGISTRY_CACHE_TTL_MS) {
+    return registryCache.sessions;
+  }
+  const sessions = readSessionsUncached();
+  registryCache = { at: now, sessions };
+  return sessions;
+}
+function pruneStaleSessions() {
+  if (!acquireRegistryLock()) return 0;
+  const sessions = readSessionsUncached();
+  if (sessions.length === 0) {
+    releaseRegistryLock();
+    return 0;
+  }
+  let liveSessions = [];
+  try {
+    liveSessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim().split("\n").filter(Boolean);
+  } catch {
+    releaseRegistryLock();
+    return 0;
+  }
+  const liveSet = new Set(liveSessions);
+  const alive = sessions.filter((s) => liveSet.has(s.windowName));
+  const staleSessions = sessions.filter((s) => !liveSet.has(s.windowName));
+  if (staleSessions.length > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_tmux",
+      source: "session-registry.pruneStaleSessions",
+      severity: "warn",
+      attempt: staleSessions.length,
+      payload: {
+        count: staleSessions.length,
+        examples: staleSessions.slice(0, 5).map((s) => s.windowName)
+      }
+    });
+  }
+  const pruned = sessions.length - alive.length;
+  if (pruned > 0) {
+    writeSessions(alive);
+  }
+  releaseRegistryLock();
+  return pruned;
+}
+function checkSessionRegistryConsistency(liveSessionsOverride) {
+  const sessions = listSessions();
+  const result = { missingTmux: 0, missingRegistry: 0 };
+  let liveSessions = liveSessionsOverride;
+  if (!liveSessions) {
+    try {
+      liveSessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim().split("\n").filter(Boolean);
+    } catch {
+      return result;
+    }
+  }
+  const liveSet = new Set(liveSessions);
+  const registeredSet = new Set(sessions.map((s) => s.windowName));
+  const missingTmuxExamples = [];
+  const missingRegistryExamples = [];
+  for (const entry of sessions) {
+    if (liveSet.has(entry.windowName)) continue;
+    result.missingTmux++;
+    if (missingTmuxExamples.length < 5) missingTmuxExamples.push(entry.windowName);
+  }
+  for (const live of liveSessions) {
+    if (registeredSet.has(live)) continue;
+    if (!looksLikeExeOsSession(live)) continue;
+    result.missingRegistry++;
+    if (missingRegistryExamples.length < 5) missingRegistryExamples.push(live);
+  }
+  if (result.missingTmux > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_tmux",
+      source: "session-registry.checkSessionRegistryConsistency",
+      severity: "warn",
+      attempt: result.missingTmux,
+      payload: {
+        count: result.missingTmux,
+        examples: missingTmuxExamples
+      }
+    });
+  }
+  if (result.missingRegistry > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_entry",
+      source: "session-registry.checkSessionRegistryConsistency",
+      severity: "warn",
+      attempt: result.missingRegistry,
+      payload: {
+        count: result.missingRegistry,
+        examples: missingRegistryExamples
+      }
+    });
+  }
+  return result;
+}
+function looksLikeExeOsSession(sessionName) {
+  const coordName = getCoordinatorNameCached();
+  const escaped = coordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const coordPattern = new RegExp(`^${escaped}\\d*$`);
+  const employeePattern = new RegExp(`-${escaped}\\d*$`);
+  return coordPattern.test(sessionName) || employeePattern.test(sessionName);
+}
+function getCoordinatorNameCached() {
+  try {
+    const rosterPath = path.join(os.homedir(), ".exe-os", "exe-employees.json");
+    if (existsSync(rosterPath)) {
+      const roster = JSON.parse(readFileSync(rosterPath, "utf8"));
+      const coo = roster.find((e) => (e.role ?? "").toUpperCase() === "COO");
+      if (coo?.name) return coo.name;
+    }
+  } catch {
+  }
+  return "exe";
+}
+
+export {
+  registerSession,
+  refreshSessionProject,
+  listSessions,
+  pruneStaleSessions,
+  checkSessionRegistryConsistency
+};

package/dist/chunk-BQD4XYWX.js

@@ -0,0 +1,159 @@
+import {
+  EMBEDDING_DIM
+} from "./chunk-FXU7JOXK.js";
+
+// src/lib/tool-capability-index.ts
+var ALWAYS_ON = /* @__PURE__ */ new Set([
+  "mcp_ping",
+  "memory",
+  "task",
+  "message",
+  "identity",
+  "diagnostics",
+  "session"
+]);
+function categoryForToolName(toolName, categoryMap) {
+  const normalized = toolName.replace(/[_-]/g, "").toLowerCase();
+  for (const [registerFn, cat] of Object.entries(categoryMap)) {
+    const fnNormalized = registerFn.replace(/^register/, "").toLowerCase();
+    if (fnNormalized === normalized) return cat;
+  }
+  return "unknown";
+}
+function extractParamNames(inputSchema) {
+  if (!inputSchema || typeof inputSchema !== "object") return "";
+  return Object.keys(inputSchema).join(", ");
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+function keywordScore(query, tool) {
+  const words = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  if (words.length === 0) return 0;
+  const searchText = `${tool.name} ${tool.description} ${tool.category} ${tool.paramSummary}`.toLowerCase();
+  let matches = 0;
+  for (const word of words) {
+    if (searchText.includes(word)) matches++;
+  }
+  return matches / words.length;
+}
+var ToolCapabilityIndex = class {
+  capabilities = [];
+  initialized = false;
+  /**
+   * Build the index by intercepting registerAllTools via a fake McpServer.
+   *
+   * @param registerFn - function that registers tools on a server (e.g. registerAllTools)
+   * @param categoryMap - optional map of registerFnName → category (from tool-gates TOOL_CATEGORIES)
+   */
+  async buildIndex(registerFn, categoryMap, directEmbedFn) {
+    const captured = [];
+    const fakeServer = {
+      registerTool(name, config, _handler) {
+        captured.push({
+          name,
+          description: config.description ?? "",
+          inputSchema: config.inputSchema ?? {}
+        });
+      }
+    };
+    registerFn(fakeServer);
+    const capabilityDocs = [];
+    for (const tool of captured) {
+      const paramSummary = extractParamNames(tool.inputSchema);
+      const category = categoryMap ? categoryForToolName(tool.name, categoryMap) : "unknown";
+      const doc = `${tool.name}: ${tool.description}. Parameters: ${paramSummary}`;
+      capabilityDocs.push({ name: tool.name, description: tool.description, category, paramSummary, doc });
+    }
+    let vectors = capabilityDocs.map(() => null);
+    try {
+      if (directEmbedFn) {
+        const allVectors = await directEmbedFn(capabilityDocs.map((c) => c.doc));
+        vectors = allVectors.map((v) => v.length === EMBEDDING_DIM ? v : null);
+      } else {
+        const { embed } = await import("./lib/embedder.js");
+        const test = await embed("test");
+        if (test.length === EMBEDDING_DIM) {
+          for (let i = 0; i < capabilityDocs.length; i++) {
+            try {
+              vectors[i] = await embed(capabilityDocs[i].doc);
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    const capabilities = capabilityDocs.map((c, i) => ({
+      name: c.name,
+      description: c.description,
+      category: c.category,
+      vector: vectors[i] ?? null,
+      paramSummary: c.paramSummary
+    }));
+    this.capabilities = capabilities;
+    this.initialized = true;
+    process.stderr.write(
+      `[tool-capability-index] Indexed ${capabilities.length} tools (${capabilities.filter((c) => c.vector).length} with vectors)
+`
+    );
+  }
+  /**
+   * Semantic search for tools matching a natural-language query.
+   * Returns tools sorted by relevance, with always-on tools boosted.
+   */
+  async search(query, limit = 20) {
+    if (!this.initialized || this.capabilities.length === 0) return [];
+    let queryVector = null;
+    try {
+      const { embed } = await import("./lib/embedder.js");
+      queryVector = await embed(query);
+    } catch {
+    }
+    const scored = [];
+    for (const tool of this.capabilities) {
+      let relevance;
+      if (queryVector && tool.vector) {
+        const vecScore = cosineSimilarity(queryVector, tool.vector);
+        const kwScore = keywordScore(query, tool);
+        relevance = vecScore * 0.8 + kwScore * 0.2;
+      } else {
+        relevance = keywordScore(query, tool);
+      }
+      if (ALWAYS_ON.has(tool.name)) {
+        relevance = Math.max(relevance, 0.5);
+      }
+      scored.push({ ...tool, relevance });
+    }
+    scored.sort((a, b) => b.relevance - a.relevance);
+    return scored.slice(0, limit);
+  }
+  /** Whether the index has been built. */
+  isReady() {
+    return this.initialized;
+  }
+  /** Total number of indexed tools. */
+  get toolCount() {
+    return this.capabilities.length;
+  }
+};
+var _instance = null;
+function getToolCapabilityIndex() {
+  if (!_instance) {
+    _instance = new ToolCapabilityIndex();
+  }
+  return _instance;
+}
+
+export {
+  ToolCapabilityIndex,
+  getToolCapabilityIndex
+};