@ipul-labs/forge 1.16.8 → 1.17.0

package/server/forge/core/validator/tdd.js

@@ -1,105 +0,0 @@
-/**
- * TDD precheck: when a proposal adds *new* test files alongside impl changes,
- * run just those tests with the impl reverted. If they pass, the tests don't
- * actually exercise the new behavior — that's the gap we surface.
- *
- * Only fires when all three hold:
- *   - at least one new test file (action === "create" on a test path)
- *   - at least one non-test change (impl)
- *   - the project has a `test` script
- *
- * The precheck reverts impl files via git (or `rm` for untracked creates),
- * runs vitest scoped to the new test paths, then re-overlays impl so the
- * downstream `test` step sees the full proposal.
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { runCmd } from "./cmd.js";
-
-const TEST_FILE_RE_NODE = /\.(test|spec)\.[cm]?[jt]sx?$/;
-
-export function isNodeTestFile(filePath) {
-	return TEST_FILE_RE_NODE.test(filePath);
-}
-
-export function partitionChangesNode(changes) {
-	const impl = [];
-	const newTests = [];
-	for (const c of changes ?? []) {
-		if (isNodeTestFile(c.file)) {
-			if (c.action === "create") newTests.push(c);
-		} else {
-			impl.push(c);
-		}
-	}
-	return { impl, newTests };
-}
-
-async function revertImplOverlay(dir, impl) {
-	for (const c of impl) {
-		const full = path.join(dir, c.file);
-		if (c.action === "create") {
-			await fs.rm(full, { force: true });
-		} else {
-			// modify or delete — restore the pre-overlay content from HEAD.
-			await runCmd("git", ["checkout", "--", c.file], { cwd: dir });
-		}
-	}
-}
-
-async function reapplyImplOverlay(dir, impl) {
-	for (const c of impl) {
-		const full = path.join(dir, c.file);
-		if (c.action === "delete") {
-			await fs.rm(full, { force: true });
-		} else {
-			await fs.mkdir(path.dirname(full), { recursive: true });
-			await fs.writeFile(full, c.proposed);
-		}
-	}
-}
-
-/**
- * @returns {Promise<null|{passed: boolean, exitCode: number}>} null when skipped.
- */
-export async function runTddPrecheckNode(dir, changes, emit) {
-	const { impl, newTests } = partitionChangesNode(changes);
-	if (newTests.length === 0 || impl.length === 0) return null;
-
-	const testPaths = newTests.map((c) => c.file);
-	emit({ type: "progress", step: "tdd_precheck", status: "running" });
-	emit({
-		type: "log",
-		step: "tdd_precheck",
-		message: `Verifying ${newTests.length} new test file(s) fail without impl: ${testPaths.join(", ")}`,
-	});
-
-	await revertImplOverlay(dir, impl);
-	const start = Date.now();
-	const res = await runCmd(
-		"npx", ["vitest", "--run", "--reporter=default", ...testPaths],
-		{ cwd: dir },
-		(l) => emit({ type: "log", step: "tdd_precheck", message: l }),
-	);
-	await reapplyImplOverlay(dir, impl);
-
-	// TDD contract: without the impl, the new tests must fail (non-zero exit).
-	// Exit 0 means either the tests passed without the impl — they don't
-	// exercise the new behavior — or vitest found nothing to run.
-	const precheckPassed = res.code !== 0;
-	const tail = res.output.split("\n").slice(-60).join("\n");
-	emit({
-		type: "step_result",
-		step: "tdd_precheck",
-		passed: precheckPassed,
-		exitCode: res.code,
-		durationMs: Date.now() - start,
-		tail,
-		message: precheckPassed
-			? `${newTests.length} new test(s) failed without implementation (good TDD).`
-			: `${newTests.length} new test(s) passed without the implementation change — they may not actually test the fix.`,
-	});
-	return { passed: precheckPassed, exitCode: res.code };
-}

package/server/forge/core/validator.js

@@ -1,167 +0,0 @@
-/**
- * server/forge/core/validator.js
- *
- * Pre-flight runner. Auto-attributes each proposed change to the repo whose
- * working tree actually contains that file, then runs the right toolchain
- * (Node npm scripts vs Go go-tool commands) on each repo with at least one
- * attributed change.
- *
- * Composition:
- *
- *   validator/cmd.js          — child-process + step-event helpers
- *   validator/clone.js        — cache + git clone management
- *   validator/attribute.js    — file-existence-based repo auto-detection
- *   validator/overlay.js      — overlay changes + readback after format
- *   validator/projectType.js  — per-repo type resolution (config + auto-detect)
- *   validator/runners/node.js — npm ci + format/lint/typecheck/test
- *   validator/runners/go.js   — go mod + go fmt/vet/build/test
- *
- * Scope (v1):
- *   - Validates only repos that actually own at least one change (1, both, or
- *     none — never a phantom block from a misrouted attribution).
- *   - GitLab HTTPS clone using GITLAB_TOKEN. GitHub / Azure DevOps raise a
- *     clear "not supported yet" error.
- *   - Step names per runner: format/lint/typecheck/test (Node) or
- *     fmt/vet/build/test (Go). Missing scripts (Node) are silently skipped.
- */
-
-import { branchNameFor } from "./branchName.js";
-import * as configStore from "./configStore.js";
-import { attributeChanges } from "./validator/attribute.js";
-import { ensureClone } from "./validator/clone.js";
-import { overlayChanges } from "./validator/overlay.js";
-import { resolveProjectType } from "./validator/projectType.js";
-import * as goRunner from "./validator/runners/go.js";
-import * as nodeRunner from "./validator/runners/node.js";
-
-const RUNNERS = {
-	go: { run: goRunner.runGoRepo, stepOrder: goRunner.STEP_ORDER, fixableSteps: goRunner.FIXABLE_STEPS },
-	node: { run: nodeRunner.runNodeRepo, stepOrder: nodeRunner.STEP_ORDER, fixableSteps: nodeRunner.FIXABLE_STEPS },
-};
-
-async function validateRepo(repo, changes, branchName, emit) {
-	// Stamp every downstream event with the current repo so the frontend can
-	// route progress/log/step_result rows into the right per-repo block.
-	const repoEmit = (e) => emit({ ...e, repo });
-
-	const fileList = changes.map((c) => c.file).join(", ");
-	repoEmit({
-		type: "log",
-		message: `Validating ${changes.length} change(s) for ${repo} on ${branchName} — ${fileList}`,
-	});
-
-	// Idempotent — the candidate-clone phase already populated the cache, so
-	// this is essentially a fetch/reset that completes quickly and gives the
-	// UI its `clone` step events.
-	const dir = await ensureClone(repo, branchName, repoEmit);
-
-	const projectType = await resolveProjectType(repo, dir, changes);
-	const runner = RUNNERS[projectType] ?? RUNNERS.node;
-
-	// Send the runner's step contract up front so the UI can render rows in
-	// the runner's natural order (e.g. fmt/vet/build/test for Go) and gate
-	// the "Fix with AI" button on the right step keys.
-	repoEmit({
-		type: "repo_started",
-		projectType,
-		stepOrder: runner.stepOrder,
-		fixableSteps: runner.fixableSteps,
-	});
-
-	await overlayChanges(dir, changes, repoEmit);
-
-	const results = await runner.run(dir, changes, repoEmit);
-
-	const allPassed = Object.values(results).every((r) => r.passed);
-	repoEmit({
-		type: "repo_result",
-		projectType,
-		allPassed,
-		checkedAt: new Date().toISOString(),
-	});
-	return { repo, branchName, projectType, results, allPassed };
-}
-
-function resolveCandidates(analysis) {
-	const fromAnalysis = analysis.repos ?? [];
-	if (fromAnalysis.length) return fromAnalysis;
-	const fromChange = analysis.changes?.[0]?.repo;
-	if (fromChange) return [fromChange];
-	const primary = configStore.getPrimaryProject();
-	return primary ? [primary] : [];
-}
-
-/**
- * @param {{ changes: Array<{repo?: string, file: string, action: string, proposed: string}>, repos?: string[], issue?: { iid: number } }} analysis
- * @param {(event: object) => void} onEvent
- */
-export async function validate(analysis, onEvent) {
-	const emit = onEvent ?? (() => {});
-
-	try {
-		const candidates = resolveCandidates(analysis);
-		if (!candidates.length) throw new Error("No repos to validate against.");
-
-		const branchName = analysis.issue?.iid
-			? branchNameFor(analysis.issue.iid, analysis)
-			: "forge/workspace";
-
-		// Step 1: attribute each change by querying the SCM API for file
-		// existence. No clones yet — we only clone repos we'll actually
-		// validate. The model's `c.repo` is advisory; we trust the API.
-		const { byRepo, unattributed } = await attributeChanges(analysis.changes, candidates, emit);
-		if (unattributed.length) {
-			for (const c of unattributed) {
-				emit({
-					type: "log",
-					message: `Dropping ${c.file} (${c.action}): not found in ${candidates.join(" or ")}.`,
-				});
-			}
-		}
-		if (!byRepo.size) {
-			throw new Error(
-				`No proposed changes match files in ${candidates.join(" or ")}. ` +
-				`The file paths in the proposal don't exist in those repos — likely a wrong path.`,
-			);
-		}
-
-		// Step 3: order chosen repos by the analysis's repos[] (primary first).
-		const ordered = candidates.filter((r) => byRepo.has(r));
-
-		emit({
-			type: "log",
-			message: `Plan: ${ordered.length} repo(s): ${ordered.map((r) => `${r} (${byRepo.get(r).length} change${byRepo.get(r).length === 1 ? "" : "s"})`).join(", ")}`,
-		});
-
-		const perRepo = [];
-		for (const repo of ordered) {
-			perRepo.push(await validateRepo(repo, byRepo.get(repo), branchName, emit));
-		}
-
-		const allPassed = perRepo.length > 0 && perRepo.every((r) => r.allPassed);
-		const repoLabel = perRepo.length === 1
-			? perRepo[0].repo
-			: perRepo.map((r) => r.repo).join(", ");
-		// Single-repo runs keep the original flat `results` shape; multi-repo
-		// runs nest by repo so older single-repo consumers still see something
-		// sensible at `results.<step>` for their own repo.
-		const results = perRepo.length === 1
-			? perRepo[0].results
-			: Object.fromEntries(perRepo.map((r) => [r.repo, r.results]));
-
-		emit({
-			type: "result",
-			data: {
-				repo: repoLabel,
-				branchName,
-				results,
-				allPassed,
-				checkedAt: new Date().toISOString(),
-			},
-		});
-		return { repo: repoLabel, branchName, results, allPassed, perRepo };
-	} catch (err) {
-		emit({ type: "error", message: err?.message ?? "Validation failed" });
-		throw err;
-	}
-}