@askexenow/exe-os 0.8.1 → 0.8.2

package/dist/lib/task-router.js

@@ -1,128 +0,0 @@
-// src/lib/task-router.ts
-import { randomUUID } from "crypto";
-var DEFAULT_BLOOM_CONFIG = {
-  complexityToTier: {
-    routine: "junior",
-    standard: "standard",
-    complex: "senior",
-    critical: "specialist"
-  },
-  tierRules: {
-    junior: {
-      eligible: ["tom"],
-      reviewRequired: false,
-      manualOnly: false
-    },
-    standard: {
-      eligible: ["tom"],
-      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) => e.name !== "exe");
-  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,
-  createAssignmentMemory,
-  formatAssignmentOutput,
-  resolveBloomRouting,
-  routeTask,
-  scoreEmployee
-};