@evo-dev/core 0.0.1-alpha.3 → 0.0.1-alpha.5

package/src/evolution/processor/process.ts

@@ -0,0 +1,235 @@
+import { mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { resolveEvoDevPaths } from "../../config/paths.ts";
+import { createStableId, isFileExistsError, normalizeTimestamp } from "../../utils/index.ts";
+import { analyzeEvolutionRun } from "../evidence/analysis.ts";
+import type {
+  EvolutionProcessInput,
+  EvolutionProcessResult,
+  EvolutionTriggerStatus,
+} from "../schema.ts";
+import { sanitizeText } from "../shared.ts";
+import {
+  groupTriggersByRun,
+  listEvolutionTriggers,
+  listSegmentEvolutionTriggers,
+  updateSegmentTriggers,
+  updateTriggers,
+} from "../triggers/index.ts";
+import {
+  activateEvolutionDistillationBatch,
+  createEvolutionDistillationBatch,
+} from "./distillation.ts";
+
+const PROCESS_LOCK_STALE_MS = 5 * 60 * 1000;
+
+export async function processEvolutionTriggers(
+  input: EvolutionProcessInput,
+): Promise<EvolutionProcessResult> {
+  const now = normalizeTimestamp(input.now);
+  const limit = input.limit ?? 20;
+  const dryRun = input.dryRun === true;
+  const warnings: string[] = [];
+  const lock = dryRun ? null : await acquireEvolutionProcessLock(input.homeDir, now);
+  if (!dryRun && lock === null) {
+    warnings.push("Evolution trigger processor is already running; this pass was skipped.");
+    return {
+      processed: 0,
+      consumed: 0,
+      skipped: 0,
+      failed: 0,
+      pending: 0,
+      triggerIds: [],
+      batchIds: [],
+      warnings,
+      dryRun,
+    };
+  }
+
+  try {
+    const pendingSegments = (
+      await listSegmentEvolutionTriggers({
+        homeDir: input.homeDir,
+        projectKey: input.projectKey,
+        runId: input.runId,
+        status: "pending",
+      })
+    ).slice(0, limit);
+    const remainingLimit = Math.max(0, limit - pendingSegments.length);
+    const pending =
+      remainingLimit === 0
+        ? []
+        : (
+            await listEvolutionTriggers({
+              homeDir: input.homeDir,
+              projectKey: input.projectKey,
+              runId: input.runId,
+              status: "pending",
+            })
+          ).slice(0, remainingLimit);
+    const grouped = groupTriggersByRun(pending);
+    const result: EvolutionProcessResult = {
+      processed: 0,
+      consumed: 0,
+      skipped: 0,
+      failed: 0,
+      pending: 0,
+      triggerIds: [
+        ...pendingSegments.map((trigger) => trigger.id),
+        ...pending.map((trigger) => trigger.id),
+      ],
+      batchIds: [],
+      warnings,
+      dryRun,
+    };
+
+    for (const trigger of pendingSegments) {
+      result.processed += 1;
+      if (dryRun) {
+        result.pending += 1;
+        continue;
+      }
+      await updateSegmentTriggers(input.homeDir, [trigger], {
+        status: "processing",
+        updatedAt: now,
+        attempts: (current) => current.attempts + 1,
+      });
+      try {
+        result.consumed += 1;
+        await updateSegmentTriggers(input.homeDir, [trigger], {
+          status: "consumed",
+          updatedAt: now,
+          processedBatchId: createStableId("segment-evidence", [trigger.id]),
+          lastError: null,
+        });
+      } catch (error) {
+        result.failed += 1;
+        const message = sanitizeText(error instanceof Error ? error.message : String(error));
+        warnings.push(message);
+        await updateSegmentTriggers(input.homeDir, [trigger], {
+          status: "failed",
+          updatedAt: now,
+          lastError: message,
+        });
+      }
+    }
+
+    for (const triggers of grouped) {
+      result.processed += triggers.length;
+      if (dryRun) {
+        result.pending += triggers.length;
+        continue;
+      }
+      await updateTriggers(input.homeDir, triggers, {
+        status: "processing",
+        updatedAt: now,
+        attempts: (trigger) => trigger.attempts + 1,
+      });
+
+      try {
+        const first = triggers[0];
+        if (first === undefined) continue;
+        const analysis = await analyzeEvolutionRun({
+          homeDir: input.homeDir,
+          projectKey: first.projectKey,
+          runId: first.runId,
+          now,
+        });
+        warnings.push(...analysis.warnings);
+        const missingTrace = triggers.some(
+          (trigger) =>
+            trigger.eventId !== null &&
+            !analysis.evidenceWindow.events.some((event) => event.hookEventId === trigger.eventId),
+        );
+        if (missingTrace) {
+          result.pending += triggers.length;
+          await updateTriggers(input.homeDir, triggers, {
+            status: "pending",
+            updatedAt: now,
+            lastError: "waiting-for-trace",
+          });
+          continue;
+        }
+        if (!analysis.evidenceWindow.triggerPolicy.distillRecommended) {
+          result.skipped += triggers.length;
+          await updateTriggers(input.homeDir, triggers, {
+            status: "skipped",
+            updatedAt: now,
+            lastError: "no-distillation-signal",
+          });
+          continue;
+        }
+
+        const batch = createEvolutionDistillationBatch({
+          evidenceWindow: analysis.evidenceWindow,
+          warnings: analysis.warnings,
+          now,
+        });
+        await activateEvolutionDistillationBatch({
+          homeDir: input.homeDir,
+          batch,
+          overwrite: true,
+        });
+        result.consumed += triggers.length;
+        result.batchIds.push(batch.id);
+        await updateTriggers(input.homeDir, triggers, {
+          status: "consumed",
+          updatedAt: now,
+          processedBatchId: batch.id,
+          lastError: null,
+        });
+      } catch (error) {
+        result.failed += triggers.length;
+        const message = sanitizeText(error instanceof Error ? error.message : String(error));
+        warnings.push(message);
+        await updateTriggers(input.homeDir, triggers, {
+          status: "failed",
+          updatedAt: now,
+          lastError: message,
+        });
+      }
+    }
+
+    return result;
+  } finally {
+    if (lock !== null) await releaseEvolutionProcessLock(lock);
+  }
+}
+
+async function acquireEvolutionProcessLock(
+  homeDir: string,
+  now: string,
+): Promise<{ path: string } | null> {
+  const paths = resolveEvoDevPaths(homeDir);
+  const lockPath = join(paths.stateDir, "evolution", ".process.lock");
+  await mkdir(dirname(lockPath), { recursive: true });
+  try {
+    await writeFile(
+      lockPath,
+      `${JSON.stringify(
+        {
+          schemaVersion: 1,
+          kind: "evolution-process-lock",
+          createdAt: now,
+          pid: process.pid,
+        },
+        null,
+        2,
+      )}\n`,
+      { encoding: "utf8", flag: "wx" },
+    );
+    return { path: lockPath };
+  } catch (error) {
+    if (!isFileExistsError(error)) throw error;
+    const current = await stat(lockPath).catch(() => null);
+    if (current !== null && Date.now() - current.mtimeMs > PROCESS_LOCK_STALE_MS) {
+      await rm(lockPath, { force: true });
+      return acquireEvolutionProcessLock(homeDir, now);
+    }
+    return null;
+  }
+}
+
+async function releaseEvolutionProcessLock(lock: { path: string }): Promise<void> {
+  await rm(lock.path, { force: true });
+}