@cassiomc1/forgeloop 1.13.0 → 1.14.0

package/src/core/test-intelligence/inventory.js

@@ -0,0 +1,73 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+
+const TEST_DIRECTORIES = Object.freeze(["test", "tests", "spec", "specs"]);
+const TEST_FILE_PATTERN = /\.(?:test|spec)\.(?:c|cpp|go|java|js|jsx|mjs|py|rb|rs|ts|tsx)$/i;
+
+async function filesUnder(root, relative = "") {
+  const current = path.join(root, relative);
+  let entries = [];
+  try { entries = await readdir(current, { withFileTypes: true }); } catch { return []; }
+  const result = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const child = path.join(relative, entry.name);
+    if (entry.isDirectory()) result.push(...await filesUnder(root, child));
+    else if (entry.isFile() && TEST_FILE_PATTERN.test(entry.name)) result.push(child);
+  }
+  return result;
+}
+
+function stableId(framework, file, suite, name) {
+  return `test-${createHash("sha256").update(JSON.stringify({ framework, file, suite, name })).digest("hex").slice(0, 24)}`;
+}
+
+function frameworkFor(source) {
+  if (/node:test/.test(source)) return "node:test";
+  if (/vitest/.test(source)) return "vitest";
+  if (/jest/.test(source)) return "jest";
+  if (/pytest|unittest/.test(source)) return "python";
+  return "unknown";
+}
+
+function collectUnits(source) {
+  const units = [];
+  const matcher = /\b(test|it)\s*\(\s*(["'`])([^"'`]+)\2/g;
+  let match;
+  while ((match = matcher.exec(source))) units.push({ name: match[3].trim(), line: source.slice(0, match.index).split("\n").length });
+  return units;
+}
+
+function signals(file, name) {
+  const text = `${file} ${name}`.toLowerCase();
+  return {
+    requiredBehavior: /contract|acceptance|required|lifecycle|protocol/.test(text),
+    security: /security|auth|secret|permission|credential|csp|injection/.test(text),
+    publicApi: /api|compat|public|cli|protocol/.test(text),
+    criticalPath: /critical|transaction|lock|concurr|race|recovery/.test(text),
+    integration: /integration|e2e|browser|provider|package|release/.test(text),
+    migration: /migration|schema|upgrade|downgrade/.test(text),
+    release: /package|release|publish|smoke/.test(text),
+    platformSpecific: /windows|win32|macos|darwin|linux|platform|native/.test(text),
+  };
+}
+
+export async function inventoryTests(projectRoot = process.cwd()) {
+  const files = [];
+  for (const directory of TEST_DIRECTORIES) files.push(...await filesUnder(projectRoot, directory));
+  const tests = [];
+  for (const relativeFile of [...new Set(files)].sort()) {
+    const source = await readFile(path.join(projectRoot, relativeFile), "utf8");
+    const framework = frameworkFor(source);
+    for (const unit of collectUnits(source)) {
+      const file = relativeFile.replaceAll(path.sep, "/");
+      tests.push({
+        testId: stableId(framework, file, "", unit.name), file, framework, suite: "", name: unit.name,
+        line: unit.line, sourceSummary: `${file}:${unit.line} ${unit.name}`.slice(0, 500),
+        targets: [file], runtimeMs: null, uniqueBranches: null, signals: signals(file, unit.name),
+      });
+    }
+  }
+  tests.sort((a, b) => a.testId.localeCompare(b.testId));
+  return { schemaVersion: 1, source: "DETERMINISTIC", tests };
+}

package/src/core/test-intelligence/prune.js

@@ -0,0 +1,90 @@
+import { readTestUtility } from "./service.js";
+import { cp, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const PROTECTED_CLASSES = new Set([
+  "KEEP_REQUIRED", "KEEP_RISK_GUARD", "KEEP_UNIQUE", "KEEP_AUTHORITY_BOUNDARY",
+  "KEEP_RECOVERY_INVARIANT", "KEEP_RELEASE_SMOKE", "KEEP_MIGRATION_COMPATIBILITY",
+  "KEEP_PLATFORM_BEHAVIOR",
+]);
+
+function planFor(test) {
+  if (test.protected || PROTECTED_CLASSES.has(test.classification)) return { action: "KEEP", reason: "PROTECTED_TEST" };
+  if (test.classification === "REDUNDANT_CANDIDATE" && test.recommendation === "PROBE_REMOVAL") return { action: "PROBE_REMOVAL", reason: "SEMANTIC_AND_DETERMINISTIC_EVIDENCE_REQUIRED" };
+  if (test.classification === "KEEP_DOCUMENTATION_VALUE") return { action: "KEEP", reason: "DOCUMENTATION_VALUE" };
+  return { action: "BLOCKED", reason: "INSUFFICIENT_PROVENANCE" };
+}
+
+export async function buildPrunePlan({ target, packageRoot, taskId } = {}) {
+  const utility = await readTestUtility({ target, packageRoot, taskId });
+  const items = utility.value.tests.map((test) => ({ testId: test.testId, file: test.file, name: test.name, ...planFor(test) }));
+  return { schemaVersion: 1, taskId, semanticStatus: utility.value.semanticStatus, items, deletionAuthority: false };
+}
+
+export async function runPruneProbe({ target, packageRoot, taskId, testId } = {}) {
+  const plan = await buildPrunePlan({ target, packageRoot, taskId });
+  const item = plan.items.find((candidate) => candidate.testId === testId);
+  if (!item) {
+    const error = new Error(`Unknown test ID: ${testId}`); error.code = "E_TEST_ID_UNKNOWN"; throw error;
+  }
+  if (item.action !== "PROBE_REMOVAL") {
+    const error = new Error(`Test prune probe blocked for ${testId}: ${item.reason}`);
+    error.code = "E_TEST_PRUNE_BLOCKED";
+    throw error;
+  }
+  const temporaryRoot = await mkdtemp(path.join(os.tmpdir(), "forgeloop-prune-probe-"));
+  try {
+    await cp(target, temporaryRoot, {
+      recursive: true,
+      dereference: false,
+      filter(source) {
+        const relative = path.relative(target, source);
+        return relative !== ".forgeloop" && relative !== ".git" && !relative.startsWith(`${path.sep}.forgeloop${path.sep}`) && !relative.startsWith(`${path.sep}.git${path.sep}`) && relative !== "node_modules";
+      },
+    });
+    const dependencies = path.join(target, "node_modules");
+    try { await symlink(dependencies, path.join(temporaryRoot, "node_modules"), "junction"); } catch { /* dependencies are optional for static probes */ }
+    if (item.file.endsWith(".mjs") || item.file.endsWith(".js")) {
+      const candidatePath = path.join(temporaryRoot, item.file);
+      const source = await readFile(candidatePath, "utf8");
+      const escapedName = item.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const pattern = new RegExp(`\\b(test|it)\\s*\\(\\s*([\\"'])${escapedName}\\2`);
+      if (!pattern.test(source)) {
+        return { status: "INCONCLUSIVE", reason: "TEST_UNIT_NOT_LOCATED", testId, liveWorktreeModified: false, temporaryWorkspaceCleaned: true };
+      }
+      const disabled = source.replace(pattern, (_, keyword, quote) => `${keyword}.skip(${quote}${item.name}${quote}`);
+      await writeFile(candidatePath, disabled, "utf8");
+      const result = await execFileAsync(process.execPath, ["--test", item.file], {
+        cwd: temporaryRoot,
+        timeout: 120_000,
+        maxBuffer: 2_000_000,
+        windowsHide: true,
+      });
+      return {
+        status: "INCONCLUSIVE",
+        reason: "COVERAGE_OR_MUTATION_EVIDENCE_UNAVAILABLE",
+        testId,
+        affectedTestExitCode: 0,
+        affectedTestOutput: `${result.stdout ?? ""}${result.stderr ?? ""}`.slice(-8_000),
+        liveWorktreeModified: false,
+        temporaryWorkspaceCleaned: true,
+      };
+    }
+    return { status: "INCONCLUSIVE", reason: "FRAMEWORK_PROBE_UNSUPPORTED", testId, liveWorktreeModified: false, temporaryWorkspaceCleaned: true };
+  } catch (error) {
+    return {
+      status: "BLOCKED",
+      reason: error.code === "ETIMEDOUT" ? "AFFECTED_TEST_TIMEOUT" : "AFFECTED_TEST_FAILED",
+      testId,
+      error: error.message,
+      liveWorktreeModified: false,
+      temporaryWorkspaceCleaned: true,
+    };
+  } finally {
+    await rm(temporaryRoot, { recursive: true, force: true });
+  }
+}

package/src/core/test-intelligence/semantic-state.js

@@ -0,0 +1,15 @@
+export const TEST_UTILITY_BATCH_SIZE = 8;
+
+export function batchTests(tests = [], size = TEST_UTILITY_BATCH_SIZE) {
+  const batches = [];
+  for (let index = 0; index < tests.length; index += size) batches.push(tests.slice(index, index + size));
+  return batches;
+}
+
+export function buildTestSemanticState(tests = []) {
+  return {
+    tests: tests.map(({ testId, file, framework, suite, name, line, sourceSummary, targets, runtimeMs, uniqueBranches, signals }) => ({
+      testId, file, framework, suite, name, line, sourceSummary, targets, runtimeMs, uniqueBranches, signals,
+    })),
+  };
+}

package/src/core/test-intelligence/service.js

@@ -0,0 +1,40 @@
+import { taskArtifactPath } from "../task-paths.js";
+import { writeJsonArtifact, readJsonArtifact } from "../artifacts.js";
+import { withTaskMutation } from "../task-command.js";
+import { inventoryTests } from "./inventory.js";
+import { buildTestUtilityArtifact } from "./utility.js";
+import { canonicalFingerprint } from "../artifacts.js";
+import { readWorkState } from "../work-state.js";
+import { buildTestUtilityQuestionSet } from "../decision/question-registry.js";
+import { ensureSemanticDecision } from "../decision/service.js";
+import { batchTests, buildTestSemanticState } from "./semantic-state.js";
+
+export async function runTestInventory({ projectRoot = process.cwd() } = {}) { return inventoryTests(projectRoot); }
+
+export async function runTestUtility({ target, packageRoot, taskId, provider = null } = {}) {
+  const inventory = await inventoryTests(target);
+  const semanticDecisions = [];
+  const state = await readWorkState(target, { packageRoot, taskId });
+  for (const [index, batch] of batchTests(inventory.tests).entries()) {
+    const questionSet = buildTestUtilityQuestionSet(batch);
+    semanticDecisions.push(await ensureSemanticDecision({
+      target, packageRoot, taskId, provider,
+      decisionId: `test-utility-${index}-${canonicalFingerprint(batch.map((test) => test.testId)).slice(0, 16)}`,
+      request: {
+        decisionKind: "TEST_UTILITY", questionSetId: questionSet.id, questionSet,
+        state: { lifecycle: state, ...buildTestSemanticState(batch) },
+        candidateIds: batch.map((test) => test.testId),
+        candidateSetFingerprint: canonicalFingerprint(batch.map((test) => test.testId)),
+      },
+    }));
+  }
+  return withTaskMutation(target, { taskId, packageRoot }, "test-utility", async (ctx) => {
+    const artifact = buildTestUtilityArtifact({ taskId: ctx.taskId, inventory, semanticDecisions: semanticDecisions.map((decision) => decision.artifact) });
+    const written = await writeJsonArtifact(target, taskArtifactPath(ctx.taskId, "testUtility"), artifact, "test-utility", packageRoot, { taskId: ctx.taskId, operation: "test-utility" });
+    return { path: written.path, artifact, inventory };
+  });
+}
+
+export async function readTestUtility({ target, packageRoot, taskId } = {}) {
+  return readJsonArtifact(target, taskArtifactPath(taskId, "testUtility"), "test-utility", packageRoot);
+}

package/src/core/test-intelligence/utility.js

@@ -0,0 +1,50 @@
+import { canonicalFingerprint } from "../artifacts.js";
+
+function classify(test, judgment = null, confidence = 1) {
+  const signal = test.signals ?? {};
+  if (signal.requiredBehavior) return { classification: "KEEP_REQUIRED", recommendation: "KEEP", protected: true };
+  if (signal.security) return { classification: "KEEP_RISK_GUARD", recommendation: "KEEP", protected: true };
+  if (signal.criticalPath) return { classification: "KEEP_RECOVERY_INVARIANT", recommendation: "KEEP", protected: true };
+  if (signal.migration) return { classification: "KEEP_MIGRATION_COMPATIBILITY", recommendation: "KEEP", protected: true };
+  if (signal.publicApi) return { classification: "KEEP_UNIQUE", recommendation: "KEEP", protected: true };
+  if (signal.release) return { classification: "KEEP_RELEASE_SMOKE", recommendation: "KEEP", protected: true };
+  if (signal.platformSpecific) return { classification: "KEEP_PLATFORM_BEHAVIOR", recommendation: "KEEP", protected: true };
+  if (signal.integration) return { classification: "KEEP_INTEGRATION_GUARD", recommendation: "KEEP", protected: true };
+  if (!judgment || confidence < 0.75) return { classification: "UNKNOWN", recommendation: "BLOCKED", protected: false };
+  if (judgment.protocol_invariant) return { classification: "KEEP_RECOVERY_INVARIANT", recommendation: "KEEP", protected: true };
+  if (judgment.semantic_duplicate) {
+    return {
+      classification: "REDUNDANT_CANDIDATE",
+      recommendation: judgment.requires_system_two_review ? "BLOCKED" : "PROBE_REMOVAL",
+      protected: false,
+    };
+  }
+  if (judgment.likely_obsolete) return { classification: "OBSOLETE_CANDIDATE", recommendation: "BLOCKED", protected: false };
+  if (judgment.likely_flaky_low_signal) return { classification: "FLAKY_LOW_SIGNAL", recommendation: "BLOCKED", protected: false };
+  if (judgment.expensive_relative_to_signal) return { classification: "EXPENSIVE_LOW_SIGNAL", recommendation: "BLOCKED", protected: false };
+  if (judgment.documentation_value) return { classification: "KEEP_DOCUMENTATION_VALUE", recommendation: "KEEP", protected: false };
+  if (judgment.integration_value) return { classification: "KEEP_INTEGRATION_GUARD", recommendation: "KEEP", protected: true };
+  if (judgment.has_unique_semantic_intent) return { classification: "KEEP_UNIQUE", recommendation: "KEEP", protected: false };
+  return { classification: "UNKNOWN", recommendation: "BLOCKED", protected: false };
+}
+
+export function buildTestUtilityArtifact({ taskId, inventory, semanticStatus = "NOT_REQUESTED", semanticDecision = null, semanticDecisions = [] } = {}) {
+  const decisions = semanticDecisions.length > 0 ? semanticDecisions : (semanticDecision ? [semanticDecision] : []);
+  const byTest = new Map(decisions.flatMap((decision) => Object.entries(decision.decision?.tests ?? {}).map(([testId, judgment]) => [testId, {
+    judgment, confidence: Math.min(...Object.keys(judgment).map((key) => decision.confidence?.[`test_${(decision.decision.candidateIds ?? []).indexOf(testId)}_${key}`] ?? 0)),
+  }])));
+  return {
+    schemaVersion: 1,
+    protocolVersion: 1,
+    taskId,
+    generatedAt: new Date().toISOString(),
+    inventoryFingerprint: canonicalFingerprint(inventory),
+    semanticStatus: decisions.length > 0 ? "PROVIDER_REPORTED" : semanticStatus,
+    ...(decisions.length > 0 ? {
+      ...(decisions.length === 1 ? { decisionId: decisions[0].decisionId, semanticDecisionFingerprint: canonicalFingerprint(decisions[0]) } : {}),
+      decisionIds: decisions.map((decision) => decision.decisionId),
+      semanticDecisionFingerprints: decisions.map((decision) => canonicalFingerprint(decision)),
+    } : {}),
+    tests: (inventory?.tests ?? []).map((test) => ({ ...test, ...classify(test, byTest.get(test.testId)?.judgment, byTest.get(test.testId)?.confidence ?? 0) })),
+  };
+}

package/src/core/trace.js

@@ -51,6 +51,7 @@ const EVENT_CATEGORY_MAP = Object.freeze({
   TASK_RECOVERY_RECORDED: "recovery",
   TASK_RECOVERY_RESUMED: "recovery",
   OPERATOR_RECOVERY_RECORDED: "recovery",
+  TASK_ABANDONED: "recovery",
   LEGACY_RECOVERY_MIGRATION_RECORDED: "recovery",
   GATE_SATISFIED: "policy",
   COMPLETION_VALIDATED: "completion",
@@ -82,6 +83,13 @@ const LIFECYCLE_TRANSITIONS = Object.freeze([
   "COMPLETION_REJECTED",
 ]);
 
+const STATIC_EVENT_SUMMARIES = Object.freeze({
+  TASK_RECOVERY_RESUMED: "Task resumed after recovery",
+  OPERATOR_RECOVERY_RECORDED: "Operator recovery recorded",
+  TASK_ABANDONED: "Task explicitly abandoned",
+  LEGACY_RECOVERY_MIGRATION_RECORDED: "Legacy recovery migration recorded",
+});
+
 export function eventCategory(eventType) {
   return EVENT_CATEGORY_MAP[eventType] ?? "integrity";
 }
@@ -93,6 +101,8 @@ export function timestampQuality(event) {
 
 function eventSummary(event) {
   const d = event.details ?? {};
+  const staticSummary = STATIC_EVENT_SUMMARIES[event.event];
+  if (staticSummary) return staticSummary;
   switch (event.event) {
     case "TASK_RECEIVED":
       return `Task received${d.taskId ? ` (${d.taskId})` : ""}`;
@@ -132,12 +142,6 @@ function eventSummary(event) {
       return "Continuity checkpoint recorded";
     case "TASK_RECOVERY_RECORDED":
       return `Task recovery recorded (${d.classification ?? "unknown"})`;
-    case "TASK_RECOVERY_RESUMED":
-      return "Task resumed after recovery";
-    case "OPERATOR_RECOVERY_RECORDED":
-      return "Operator recovery recorded";
-    case "LEGACY_RECOVERY_MIGRATION_RECORDED":
-      return "Legacy recovery migration recorded";
     case "COMPLETION_VALIDATED":
       return "Completion validated";
     case "COMPLETION_REJECTED":
@@ -451,7 +455,7 @@ export async function buildTaskTrace({ target, packageRoot, taskId = null, event
   const evidence = [...evidenceSources.values()].sort((a, b) => a.ref.localeCompare(b.ref));
 
   const recovery = taskEvents
-    .filter((event) => ["TASK_RECOVERY_RECORDED", "TASK_RECOVERY_RESUMED", "OPERATOR_RECOVERY_RECORDED", "LEGACY_RECOVERY_MIGRATION_RECORDED"].includes(event.event))
+    .filter((event) => ["TASK_RECOVERY_RECORDED", "TASK_RECOVERY_RESUMED", "OPERATOR_RECOVERY_RECORDED", "TASK_ABANDONED", "LEGACY_RECOVERY_MIGRATION_RECORDED"].includes(event.event))
     .map((event) => ({ sequence: event.seq, at: event.at, type: event.event, details: event.details ?? {} }));
 
   const completionEvents = taskEvents.filter((event) => ["COMPLETION_VALIDATED", "COMPLETION_REJECTED"].includes(event.event));

package/src/core/transaction.js

@@ -142,6 +142,7 @@ export async function withTaskTransaction({
       target,
       transactionId,
       taskId,
+      operation,
       lock,
       async readText(relativePath) {
         await assertSafePath(target, relativePath);