nemoris 0.1.0

package/src/runtime/task-router.js

@@ -0,0 +1,140 @@
+function normalizeText(value) {
+  return String(value || "")
+    .toLowerCase()
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalizeRule(ruleId, rule = {}) {
+  return {
+    id: ruleId,
+    description: rule.description || null,
+    targetLane: rule.targetLane || null,
+    routeMode: rule.routeMode || "primary",
+    matchKeywords: rule.matchKeywords || [],
+    matchTaskTypes: rule.matchTaskTypes || [],
+    matchOutputTargets: rule.matchOutputTargets || [],
+    matchDeliveryProfiles: rule.matchDeliveryProfiles || [],
+    requirePingback: rule.requirePingback ?? null,
+    notifyOnDone: rule.notifyOnDone ?? null,
+    requireTools: rule.requireTools || [],
+    priority: Number(rule.priority ?? 0)
+  };
+}
+
+function ruleMatches(rule, context) {
+  if (!rule.targetLane) {
+    return { matches: false, reasons: [] };
+  }
+
+  const reasons = [];
+  const haystack = normalizeText([
+    context.objective,
+    context.jobId,
+    context.taskType,
+    ...(context.artifactRefs || [])
+  ].join(" "));
+
+  if (rule.matchTaskTypes.length) {
+    if (!rule.matchTaskTypes.includes(context.taskType)) {
+      return { matches: false, reasons: [] };
+    }
+    reasons.push(`taskType:${context.taskType}`);
+  }
+
+  if (rule.matchOutputTargets.length) {
+    if (!rule.matchOutputTargets.includes(context.outputTarget)) {
+      return { matches: false, reasons: [] };
+    }
+    reasons.push(`outputTarget:${context.outputTarget}`);
+  }
+
+  if (rule.matchDeliveryProfiles.length) {
+    if (!rule.matchDeliveryProfiles.includes(context.deliveryProfile)) {
+      return { matches: false, reasons: [] };
+    }
+    reasons.push(`deliveryProfile:${context.deliveryProfile}`);
+  }
+
+  if (rule.requirePingback !== null) {
+    if (Boolean(context.requiresPingback) !== Boolean(rule.requirePingback)) {
+      return { matches: false, reasons: [] };
+    }
+    reasons.push(`requiresPingback:${Boolean(context.requiresPingback)}`);
+  }
+
+  if (rule.notifyOnDone !== null) {
+    if (Boolean(context.notifyOnDone) !== Boolean(rule.notifyOnDone)) {
+      return { matches: false, reasons: [] };
+    }
+    reasons.push(`notifyOnDone:${Boolean(context.notifyOnDone)}`);
+  }
+
+  if (rule.requireTools.length) {
+    const toolSet = new Set((context.allowedTools || []).map((tool) => String(tool)));
+    const missingTools = rule.requireTools.filter((tool) => !toolSet.has(tool));
+    if (missingTools.length) {
+      return { matches: false, reasons: [] };
+    }
+    reasons.push(`tools:${rule.requireTools.join(",")}`);
+  }
+
+  if (rule.matchKeywords.length) {
+    const matchedKeywords = rule.matchKeywords.filter((keyword) => haystack.includes(normalizeText(keyword)));
+    if (!matchedKeywords.length) {
+      return { matches: false, reasons: [] };
+    }
+    reasons.push(`keywords:${matchedKeywords.join(",")}`);
+  }
+
+  return {
+    matches: reasons.length > 0 || (!rule.matchTaskTypes.length && !rule.requireTools.length && !rule.matchKeywords.length),
+    reasons
+  };
+}
+
+export class TaskRouter {
+  constructor(config = {}) {
+    this.defaults = {
+      enabled: config.defaults?.enabled ?? true,
+      defaultRouteMode: config.defaults?.defaultRouteMode || "primary"
+    };
+    this.rules = Object.entries(config.rules || {})
+      .map(([ruleId, rule]) => normalizeRule(ruleId, rule))
+      .sort((a, b) => b.priority - a.priority);
+  }
+
+  choose(context) {
+    const baseLane = context.requestedLane || context.agentPrimaryLane || null;
+    const baseRouteMode = context.requestedRouteMode || this.defaults.defaultRouteMode;
+
+    if (!this.defaults.enabled) {
+      return {
+        selectedLane: baseLane,
+        routeMode: baseRouteMode,
+        matchedRule: null,
+        reasons: ["task-router-disabled"]
+      };
+    }
+
+    for (const rule of this.rules) {
+      const result = ruleMatches(rule, context);
+      if (result.matches) {
+        return {
+          selectedLane: rule.targetLane,
+          routeMode: rule.routeMode || baseRouteMode,
+          matchedRule: rule.id,
+          reasons: result.reasons,
+          description: rule.description
+        };
+      }
+    }
+
+    return {
+      selectedLane: baseLane,
+      routeMode: baseRouteMode,
+      matchedRule: null,
+      reasons: ["no-route-override"]
+    };
+  }
+}