@ipul-labs/forge 1.13.0

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

@@ -0,0 +1,105 @@
+/**
+ * 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

@@ -0,0 +1,166 @@
+/**
+ * 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 { 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 env = process.env.FORGE_GITLAB_PROJECT;
+	return env ? [env] : [];
+}
+
+/**
+ * @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;
+	}
+}