oreshnik-cli 0.1.3 → 0.1.4

package/dist/cli.js

@@ -2212,6 +2212,208 @@ var init_helpers = __esm({
   }
 });
 
+// src/core/task-distributor.service.ts
+var task_distributor_service_exports = {};
+__export(task_distributor_service_exports, {
+  TaskDistributor: () => TaskDistributor,
+  createTaskDistributor: () => createTaskDistributor
+});
+function createTaskDistributor() {
+  return new TaskDistributor();
+}
+var TaskDistributor;
+var init_task_distributor_service = __esm({
+  "src/core/task-distributor.service.ts"() {
+    "use strict";
+    init_esm_shims();
+    TaskDistributor = class {
+      /**
+       * Distribute tasks equitably among operators, considering:
+       * 1. Explicit assignments ('asignar a Jean', 'para Manuel')
+       * 2. Zone conflict avoidance (same zone → same operator)
+       * 3. Current workload balance
+       * 4. Dependency ordering (dependency owner gets priority)
+       */
+      distribute(newTasks, existingBoard, zoneMap, portfolio) {
+        const operators = this.getOperators(portfolio, existingBoard);
+        if (operators.length === 0) {
+          return newTasks.map((t) => ({
+            taskId: t.taskId,
+            assignedOwner: "architect",
+            reason: "no operators defined"
+          }));
+        }
+        const workload = /* @__PURE__ */ new Map();
+        for (const op of operators) {
+          workload.set(op, existingBoard.tasks.filter((t) => t.owner === op && t.status !== "done").length);
+        }
+        const zoneOwner = /* @__PURE__ */ new Map();
+        for (const [pattern, entry] of Object.entries(zoneMap)) {
+          if (entry.owner && entry.owner !== "shared" && entry.owner !== "none") {
+            zoneOwner.set(pattern, entry.owner);
+          }
+        }
+        const operatorZones = /* @__PURE__ */ new Map();
+        for (const task of existingBoard.tasks) {
+          if (task.status === "done") continue;
+          for (const zone of task.zone || []) {
+            if (!operatorZones.has(task.owner)) operatorZones.set(task.owner, /* @__PURE__ */ new Set());
+            operatorZones.get(task.owner).add(zone);
+          }
+        }
+        const results = [];
+        const newlyAssigned = /* @__PURE__ */ new Map();
+        for (const task of newTasks) {
+          const explicit = this.detectExplicitOwner(task.taskTitle, operators);
+          if (explicit) {
+            workload.set(explicit, (workload.get(explicit) || 0) + 1);
+            results.push({ taskId: task.taskId, assignedOwner: explicit, reason: `explicit assignment in title` });
+            continue;
+          }
+          let bestOperator = operators[0];
+          let bestScore = Infinity;
+          for (const op of operators) {
+            let score = (workload.get(op) || 0) + (newlyAssigned.get(op) || 0);
+            const opZones = operatorZones.get(op);
+            if (opZones && task.zones.length > 0) {
+              const sharedZoneCount = task.zones.filter((z2) => opZones.has(z2)).length;
+              if (sharedZoneCount === 0) score += 2;
+              else score -= sharedZoneCount;
+            }
+            for (const depId of task.dependsOn) {
+              const depTask = existingBoard.tasks.find((t) => t.id === depId);
+              if (depTask && depTask.owner === op) {
+                score -= 1;
+              }
+            }
+            if (score < bestScore) {
+              bestScore = score;
+              bestOperator = op;
+            }
+          }
+          newlyAssigned.set(bestOperator, (newlyAssigned.get(bestOperator) || 0) + 1);
+          let blockingBy;
+          let blockingReason;
+          for (const depId of task.dependsOn) {
+            const depTask = existingBoard.tasks.find((t) => t.id === depId);
+            if (depTask && depTask.status !== "done" && depTask.owner !== bestOperator) {
+              blockingBy = depTask.owner;
+              blockingReason = `depends on ${depId} (${depTask.status}, owned by ${depTask.owner})`;
+              break;
+            }
+          }
+          results.push({
+            taskId: task.taskId,
+            assignedOwner: bestOperator,
+            reason: `workload=${bestScore}, zone affinity, equitable distribution`,
+            blockingBy,
+            blockingReason
+          });
+        }
+        return results;
+      }
+      /**
+       * Detect explicit operator assignment in task title
+       * Examples: "asignar a Jean", "esto es para Manuel", "Jean debe hacer"
+       */
+      detectExplicitOwner(title, operators) {
+        const lower = title.toLowerCase();
+        const patterns = [
+          /asignar\s+a\s+(\w+)/i,
+          /para\s+(\w+)\b/i,
+          /(\w+)\s+debe\s+hacer/i,
+          /(\w+)\s+se\s+encarga/i,
+          /owner[:\s]+(\w+)/i,
+          /@(\w+)/i
+        ];
+        for (const pattern of patterns) {
+          const match = lower.match(pattern);
+          if (match) {
+            const name = match[1].toLowerCase();
+            const found = operators.find((op) => op.toLowerCase() === name);
+            if (found) return found;
+            const partial = operators.find((op) => op.toLowerCase().includes(name) || name.includes(op.toLowerCase()));
+            if (partial) return partial;
+          }
+        }
+        return null;
+      }
+      /**
+       * Get operators from portfolio and existing task-board
+       */
+      getOperators(portfolio, board) {
+        const operators = /* @__PURE__ */ new Set();
+        for (const project of portfolio.projects) {
+          for (const op of project.operators) {
+            operators.add(op);
+          }
+        }
+        for (const task of board.tasks) {
+          if (task.owner && !task.owner.includes("+")) {
+            operators.add(task.owner);
+          }
+        }
+        const seen = /* @__PURE__ */ new Set();
+        const result = [];
+        for (const op of operators) {
+          const key = op.toLowerCase();
+          if (!seen.has(key)) {
+            seen.add(key);
+            result.push(op);
+          }
+        }
+        return result;
+      }
+      /**
+       * Rebalance: if one operator finishes faster, move pending tasks from overloaded to underloaded.
+       * Respects explicit assignments (stays with original owner) and zone conflicts.
+       * Returns a list of suggested reassignments. Does NOT mutate the board.
+       */
+      rebalance(board, zoneMap, maxImbalance = 3) {
+        const operators = this.getOperators({ projects: [] }, board);
+        if (operators.length <= 1) return [];
+        const workload = /* @__PURE__ */ new Map();
+        const pendingTasks = /* @__PURE__ */ new Map();
+        for (const op of operators) {
+          const pts = board.tasks.filter((t) => t.owner === op && t.status !== "done");
+          workload.set(op, pts.length);
+          pendingTasks.set(op, pts);
+        }
+        const sorted = [...operators].sort((a, b) => (workload.get(b) || 0) - (workload.get(a) || 0));
+        const mostLoaded = sorted[0];
+        const leastLoaded = sorted[sorted.length - 1];
+        const maxLoad = workload.get(mostLoaded) || 0;
+        const minLoad = workload.get(leastLoaded) || 0;
+        if (maxLoad - minLoad <= maxImbalance) return [];
+        const reassignments = [];
+        const excess = maxLoad - Math.ceil((maxLoad + minLoad) / 2);
+        const candidates = pendingTasks.get(mostLoaded) || [];
+        let moved = 0;
+        for (const task of candidates) {
+          if (moved >= excess) break;
+          if (this.isExplicitAssignment(task.title, operators)) continue;
+          const taskZones = task.zone || [];
+          const otherTasks = pendingTasks.get(leastLoaded) || [];
+          const zoneConflict = taskZones.some((z2) => otherTasks.some((ot) => (ot.zone || []).includes(z2)));
+          if (zoneConflict) continue;
+          reassignments.push({
+            taskId: task.id,
+            from: mostLoaded,
+            to: leastLoaded,
+            reason: `rebalance: ${mostLoaded}=${maxLoad} \u2192 ${leastLoaded}=${minLoad} (diff=${maxLoad - minLoad} > ${maxImbalance})`
+          });
+          moved++;
+        }
+        return reassignments;
+      }
+      isExplicitAssignment(title, operators) {
+        const detected = this.detectExplicitOwner(title, operators);
+        return detected !== null && detected !== void 0;
+      }
+    };
+  }
+});
+
 // src/core/injection.service.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 import { isAbsolute as isAbsolute3, join as join6, resolve as resolve3 } from "path";
@@ -2228,6 +2430,7 @@ var init_injection_service = __esm({
     init_helpers();
     init_git_service();
     init_state_manager();
+    init_task_distributor_service();
     InjectionService = class {
       constructor(root) {
         this.root = root;
@@ -3804,6 +4007,29 @@ async function preflightCommand(options) {
     operator = OperatorIdSchema.parse(operator);
   }
   header("ORESHNIK PREFLIGHT", (/* @__PURE__ */ new Date()).toISOString());
+  try {
+    const { execSync } = await import("child_process");
+    const installed = execSync("npm list -g oreshnik-cli --depth=0 --json 2>nul", { encoding: "utf8", timeout: 1e4 });
+    const latest = execSync("npm view oreshnik-cli version 2>nul", { encoding: "utf8", timeout: 1e4 });
+    if (installed && latest) {
+      const installedMatch = installed.match(/"oreshnik-cli":\s*\{[^}]*"version":\s*"([^"]+)"/);
+      const installedVer = installedMatch?.[1];
+      const latestVer = latest.trim();
+      if (installedVer && latestVer && installedVer !== latestVer) {
+        console.log(`  [UPDATE] oreshnik-cli ${installedVer} \u2192 ${latestVer}`);
+        try {
+          execSync("npm install -g oreshnik-cli@alpha", { encoding: "utf8", timeout: 6e4, stdio: "inherit" });
+          console.log(`  [OK] Updated to ${latestVer}. Restarting...`);
+          const { spawnSync: spawnSync4 } = await import("child_process");
+          spawnSync4(process.argv[0], process.argv.slice(1), { stdio: "inherit", shell: true });
+          process.exit(0);
+        } catch {
+          console.log("  [WARN] Update failed. Continuing with current version.");
+        }
+      }
+    }
+  } catch {
+  }
   const blockers = [];
   const warnings = [];
   const okChecks = [];
@@ -4079,6 +4305,28 @@ async function preflightCommand(options) {
             if (poolReadyTasks.length > 5) console.log(`  ... and ${poolReadyTasks.length - 5} more`);
             console.log("");
           }
+          if (poolTasks.length > 3 && operatorTasks.length < 3) {
+            try {
+              const { createTaskDistributor: createTaskDistributor3 } = await Promise.resolve().then(() => (init_task_distributor_service(), task_distributor_service_exports));
+              const distributor = createTaskDistributor3();
+              const zoneMapForRebalance = {};
+              const zonePath = join11(ROOT2, "docs", "07_handoffs", "zone-map.json");
+              if (existsSync10(zonePath)) {
+                const raw = JSON.parse(readFileSync10(zonePath, "utf8").replace(/^\uFEFF/, ""));
+                for (const [k, v] of Object.entries(raw.zones || {})) zoneMapForRebalance[k] = v;
+              }
+              const rebalances = distributor.rebalance(board, zoneMapForRebalance);
+              if (rebalances.length > 0) {
+                console.log(`  [REBALANCE] Load imbalance detected:`);
+                for (const r of rebalances) {
+                  console.log(`    ${r.from} \u2192 ${r.to}: ${r.taskId.slice(0, 50)}`);
+                }
+                console.log(`  Run: oreshnik inject --rebalance to apply`);
+                console.log("");
+              }
+            } catch {
+            }
+          }
           const otherActiveTasks = board.tasks.filter(
             (t) => t.owner.toLowerCase() !== operator.toLowerCase() && !(t.owner.toLowerCase() === "architect" && operator.toLowerCase() === "manuel") && (t.status === "active" || t.status === "ready")
           );