@ipul-labs/forge 1.16.7 → 1.17.0

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

@@ -1,84 +0,0 @@
-/**
- * Auto-attribution: figure out which configured repo a proposed change
- * actually belongs to.
- *
- * Uses the SCM provider's `getFileContent` as a cheap remote existence check
- * — no clone needed. We only fall back to the model's `c.repo` for `create`
- * actions where the file doesn't yet exist anywhere. The result: only repos
- * that actually own at least one change end up in the validation plan, and
- * we never clone a repo that won't be validated.
- */
-
-import { createProvider } from "../providers/index.js";
-
-async function existsRemote(provider, file) {
-	try {
-		await provider.getFileContent(file);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Convenience wrapper: returns a flat list of changes with their `repo`
- * field rewritten to the auto-detected target. Used by callers (ForgeAgent's
- * apply/commit/deploy paths) that want a corrected change list rather than
- * the per-repo grouping the validator needs.
- *
- * @returns {Promise<{ changes: object[], unattributed: object[] }>}
- */
-export async function reattributeChanges(changes, candidates) {
-	const { byRepo, unattributed } = await attributeChanges(changes, candidates);
-	const out = [];
-	for (const [repo, list] of byRepo) {
-		for (const c of list) out.push({ ...c, repo });
-	}
-	return { changes: out, unattributed };
-}
-
-/**
- * @returns {Promise<{ byRepo: Map<string, object[]>, unattributed: object[] }>}
- */
-export async function attributeChanges(changes, candidates, emit = () => {}) {
-	const providers = new Map();
-	for (const repo of candidates) {
-		try {
-			providers.set(repo, createProvider(repo));
-		} catch (err) {
-			emit({ type: "log", message: `Couldn't build provider for ${repo}: ${err?.message ?? err}` });
-		}
-	}
-
-	const byRepo = new Map();
-	const unattributed = [];
-
-	for (const c of changes ?? []) {
-		let target = null;
-
-		if (c.action === "modify" || c.action === "delete") {
-			emit({ type: "log", message: `Locating ${c.file}…` });
-			for (const [repo, provider] of providers) {
-				if (await existsRemote(provider, c.file)) {
-					target = repo;
-					emit({ type: "log", message: `  → ${repo}` });
-					break;
-				}
-			}
-		} else if (c.action === "create") {
-			// New file — no remote evidence to consult. Honour the model's
-			// attribution if it points to a real candidate.
-			if (c.repo && candidates.includes(c.repo)) target = c.repo;
-		}
-
-		if (target) {
-			const list = byRepo.get(target) ?? [];
-			list.push(c);
-			byRepo.set(target, list);
-		} else {
-			unattributed.push(c);
-		}
-	}
-
-	return { byRepo, unattributed };
-}

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

@@ -1,105 +0,0 @@
-/**
- * Cache + clone management for the validator's per-repo workspaces.
- *
- *   ensureClone(repo, branchName, emit)
- *     - Lazily clones into ~/.forge/cache/<repo>/ (or FORGE_VALIDATE_CACHE).
- *     - Always fetch + reset to origin/main, then check out a stable per-issue
- *       branch so validation runs are deterministic and old overlays can't
- *       linger across runs.
- *     - GitLab-only for v1; GitHub / Azure DevOps raise a clear error.
- *     - Emits clone-step progress / log / step_result events.
- */
-
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-import { getConnection } from "../configStore.js";
-import { runCmd } from "./cmd.js";
-import { exists } from "./fs.js";
-
-const CACHE_ROOT = process.env.FORGE_VALIDATE_CACHE
-	?? path.join(os.homedir(), ".forge", "cache");
-
-function sanitizeRepo(repo) {
-	return repo.replace(/[^a-zA-Z0-9_./-]/g, "_");
-}
-
-function gitlabCloneUrl(project) {
-	return `https://gitlab.com/${project}.git`;
-}
-
-function gitEnvWithToken() {
-	const { token } = getConnection("gitlab");
-	if (!token) {
-		throw new Error("GitLab token is required to clone the repo for validation. Set it in Settings → Connections or via GITLAB_TOKEN env var.");
-	}
-	return {
-		GIT_ASKPASS: "echo",
-		GIT_TERMINAL_PROMPT: "0",
-		GIT_CONFIG_COUNT: "2",
-		GIT_CONFIG_KEY_0: "credential.helper",
-		GIT_CONFIG_VALUE_0: "",
-		GIT_CONFIG_KEY_1: "http.extraHeader",
-		GIT_CONFIG_VALUE_1: `Authorization: Bearer ${token}`,
-	};
-}
-
-function resolveCloneUrl(repoInput) {
-	// Repos may arrive prefixed — "github:owner/name", "azuredevops:org/proj/repo".
-	// v1 only supports GitLab; tell the caller clearly when it's something else.
-	const colon = repoInput.indexOf(":");
-	if (colon > 0) {
-		const prefix = repoInput.slice(0, colon).toLowerCase();
-		if (prefix === "gitlab") return gitlabCloneUrl(repoInput.slice(colon + 1));
-		if (prefix === "github" || prefix === "azuredevops" || prefix === "azure") {
-			throw new Error(`Validation for ${prefix} repos isn't implemented yet — GitLab only for now.`);
-		}
-	}
-	return gitlabCloneUrl(repoInput);
-}
-
-export async function ensureClone(repo, branchName, emit) {
-	const dir = path.join(CACHE_ROOT, sanitizeRepo(repo));
-	const hasRepo = await exists(path.join(dir, ".git"));
-
-	emit({ type: "progress", step: "clone", status: "running" });
-	emit({ type: "log", step: "clone", message: hasRepo ? `Reusing clone at ${dir}` : `Cloning ${repo} → ${dir}` });
-
-	const gitEnv = gitEnvWithToken();
-	if (!hasRepo) {
-		await fs.mkdir(dir, { recursive: true });
-		const clone = await runCmd(
-			"git", ["clone", "--depth=1", resolveCloneUrl(repo), dir],
-			{ env: { ...process.env, ...gitEnv } },
-			(l) => emit({ type: "log", step: "clone", message: l }),
-		);
-		if (clone.code !== 0) throw new Error(`git clone failed (code ${clone.code})`);
-	}
-
-	const fetch = await runCmd(
-		"git", ["fetch", "--depth=1", "origin", "main"],
-		{ cwd: dir, env: { ...process.env, ...gitEnv } },
-		(l) => emit({ type: "log", step: "clone", message: l }),
-	);
-	if (fetch.code !== 0) throw new Error(`git fetch failed (code ${fetch.code})`);
-
-	// Two-step reset+clean before the branch switch so any lingering overlay
-	// from a prior run is wiped — `git checkout -B` alone refuses if dirty.
-	// `clean -fd` preserves node_modules because it's .gitignored.
-	emit({ type: "log", step: "clone", message: `Resetting workspace to origin/main` });
-	const reset = await runCmd("git", ["reset", "--hard", "origin/main"], { cwd: dir });
-	if (reset.code !== 0) throw new Error(`git reset failed (code ${reset.code})`);
-	await runCmd("git", ["clean", "-fd"], { cwd: dir });
-
-	emit({ type: "log", step: "clone", message: `Checking out workspace branch ${branchName}` });
-	const checkout = await runCmd(
-		"git", ["checkout", "-B", branchName],
-		{ cwd: dir },
-		(l) => emit({ type: "log", step: "clone", message: l }),
-	);
-	if (checkout.code !== 0) throw new Error(`git checkout ${branchName} failed (code ${checkout.code})`);
-
-	emit({ type: "step_result", step: "clone", passed: true });
-	return dir;
-}

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

@@ -1,98 +0,0 @@
-/**
- * Low-level child-process helpers shared by every runner.
- *
- *   runCmd      — spawn → resolve with { code, output, error }; line-buffers
- *                 stdout+stderr through `onLine` for live streaming.
- *   runStep     — runCmd + emits the standard progress / step_result events
- *                 the SSE consumer expects, returning a `{ passed, ... }` row.
- *
- * Children inherit a forced no-colour CI environment so eslint/tsc/jest/vitest
- * don't spam ANSI into the SSE stream.
- */
-
-import { spawn } from "node:child_process";
-
-export const MAX_TAIL_LINES = 60;
-
-// CSI (colour, cursor moves), OSC (titles), and simple ESC[ sequences.
-// eslint-disable-next-line no-control-regex
-const ANSI_RX = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[@-Z\\-_]/g;
-
-export function stripAnsi(s) {
-	return s.replace(ANSI_RX, "");
-}
-
-export function runCmd(cmd, args, opts = {}, onLine) {
-	return new Promise((resolve) => {
-		const env = {
-			...process.env,
-			...(opts.env ?? {}),
-			FORCE_COLOR: "0",
-			NO_COLOR: "1",
-			CI: "1",
-			TERM: "dumb",
-		};
-		const proc = spawn(cmd, args, { ...opts, env, stdio: ["ignore", "pipe", "pipe"] });
-		const lines = [];
-		let outBuf = "";
-		let errBuf = "";
-
-		const flush = (buf, sink) => {
-			let i;
-			while ((i = buf.indexOf("\n")) !== -1) {
-				const line = stripAnsi(buf.slice(0, i)).replace(/\r$/, "");
-				lines.push(line);
-				sink(line);
-				buf = buf.slice(i + 1);
-			}
-			return buf;
-		};
-
-		proc.stdout.on("data", (d) => {
-			outBuf += d.toString();
-			outBuf = flush(outBuf, (l) => onLine?.(l));
-		});
-		proc.stderr.on("data", (d) => {
-			errBuf += d.toString();
-			errBuf = flush(errBuf, (l) => onLine?.(l));
-		});
-		proc.on("error", (err) => {
-			resolve({ code: -1, output: lines.join("\n"), error: err.message });
-		});
-		proc.on("close", (code) => {
-			if (outBuf) {
-				const line = stripAnsi(outBuf).replace(/\r$/, "");
-				lines.push(line);
-				onLine?.(line);
-			}
-			if (errBuf) {
-				const line = stripAnsi(errBuf).replace(/\r$/, "");
-				lines.push(line);
-				onLine?.(line);
-			}
-			resolve({ code: code ?? -1, output: lines.join("\n"), error: null });
-		});
-	});
-}
-
-export async function runStep(dir, stepName, cmd, args, emit) {
-	emit({ type: "progress", step: stepName, status: "running" });
-	const start = Date.now();
-	const result = await runCmd(
-		cmd, args,
-		{ cwd: dir },
-		(l) => emit({ type: "log", step: stepName, message: l }),
-	);
-	const durationMs = Date.now() - start;
-	const tail = result.output.split("\n").slice(-MAX_TAIL_LINES).join("\n");
-	const passed = result.code === 0;
-	emit({
-		type: "step_result",
-		step: stepName,
-		passed,
-		exitCode: result.code,
-		durationMs,
-		tail,
-	});
-	return { passed, exitCode: result.code, durationMs, tail };
-}

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

@@ -1,52 +0,0 @@
-/**
- * Overlay proposed changes onto the cloned working tree, and read formatter
- * rewrites back into the analysis so committed text matches what was validated.
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-
-export async function overlayChanges(dir, changes, emit) {
-	emit({ type: "progress", step: "overlay", status: "running" });
-	const realBase = await fs.realpath(dir);
-	for (const c of changes) {
-		const full = path.resolve(dir, c.file);
-		if (!full.startsWith(realBase + path.sep) && full !== realBase) {
-			throw new Error(`Refusing to write outside clone dir: ${c.file}`);
-		}
-		if (c.action === "delete") {
-			await fs.rm(full, { force: true });
-			emit({ type: "log", step: "overlay", message: `- ${c.file}` });
-		} else {
-			await fs.mkdir(path.dirname(full), { recursive: true });
-			await fs.writeFile(full, c.proposed);
-			emit({ type: "log", step: "overlay", message: `+ ${c.file} (${c.action})` });
-		}
-	}
-	emit({ type: "step_result", step: "overlay", passed: true });
-}
-
-/**
- * After a formatter step (npm run format, go fmt …), re-read the overlayed
- * files. If the formatter rewrote any of them, mutate `c.proposed` in place
- * and emit a `changes_formatted` event so the frontend can sync.
- */
-export async function readbackFormatted(dir, changes, emit) {
-	const updated = [];
-	for (const c of changes) {
-		if (c.action === "delete") continue;
-		try {
-			const after = await fs.readFile(path.join(dir, c.file), "utf8");
-			if (after !== c.proposed) {
-				c.proposed = after;
-				updated.push({ file: c.file, proposed: after });
-			}
-		} catch {
-			// File may have been removed or renamed by the formatter
-			// (uncommon for prettier/eslint --fix); skip silently.
-		}
-	}
-	if (updated.length) {
-		emit({ type: "changes_formatted", files: updated });
-	}
-}

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

@@ -1,87 +0,0 @@
-/**
- * Per-repo project-type resolution.
- *
- * Resolution order (strongest → weakest signal):
- *   1. configStore — the user's explicit choice in Settings → Repositories.
- *      Honoured verbatim when not "auto".
- *   2. Changeset extensions — what the user is actually editing. Safe to
- *      trust as the primary signal because auto-attribution upstream
- *      guarantees that only repos that actually own a change ever reach
- *      this resolver. A polyglot repo with a root `package.json` and a
- *      nested Go module still classifies as Go when the changeset is `.go`.
- *   3. Root marker — `go.mod` / `package.json` at the repo root.
- *   4. Shallow tree scan — last resort, walks one level to find a nested
- *      marker (monorepo layouts).
- *   5. Fallback — Node.
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import * as configStore from "../configStore.js";
-import { exists } from "./fs.js";
-
-export const SUPPORTED_TYPES = ["node", "go"];
-
-const GO_EXTS = new Set([".go"]);
-const NODE_EXTS = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]);
-
-function detectFromChanges(changes) {
-	let go = 0;
-	let node = 0;
-	for (const c of changes ?? []) {
-		const ext = path.extname(c.file ?? "").toLowerCase();
-		if (GO_EXTS.has(ext)) go++;
-		else if (NODE_EXTS.has(ext)) node++;
-	}
-	if (go > 0 && node === 0) return "go";
-	if (node > 0 && go === 0) return "node";
-	return null;
-}
-
-async function detectFromRoot(dir) {
-	const hasGo = await exists(path.join(dir, "go.mod"));
-	const hasNode = await exists(path.join(dir, "package.json"));
-	if (hasGo && !hasNode) return "go";
-	if (hasNode && !hasGo) return "node";
-	if (hasGo && hasNode) return "go"; // both at root — prefer the more specific toolchain.
-	return null;
-}
-
-async function detectFromShallowScan(dir) {
-	let hasGo = false;
-	let hasNode = false;
-	try {
-		const entries = await fs.readdir(dir, { withFileTypes: true });
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "vendor") continue;
-			const sub = path.join(dir, entry.name);
-			if (!hasGo && (await exists(path.join(sub, "go.mod")))) hasGo = true;
-			if (!hasNode && (await exists(path.join(sub, "package.json")))) hasNode = true;
-			if (hasGo && hasNode) break;
-		}
-	} catch {
-		// readdir failed — fall through with whatever we already have.
-	}
-	if (hasGo && !hasNode) return "go";
-	if (hasNode && !hasGo) return "node";
-	if (hasGo) return "go";
-	return null;
-}
-
-export async function resolveProjectType(repoId, dir, changes) {
-	const repos = configStore.get().repos ?? [];
-	const cfg = repos.find((r) => r.id === repoId);
-	const configured = cfg?.projectType;
-	if (configured && configured !== "auto") return configured;
-
-	// Auto-attribution already filtered out misattributed changes upstream,
-	// so the changeset here genuinely reflects this repo's diff. Trust it.
-	return (
-		detectFromChanges(changes)
-		?? (await detectFromRoot(dir))
-		?? (await detectFromShallowScan(dir))
-		?? "node"
-	);
-}

package/server/forge/core/validator/runners/go.js

@@ -1,107 +0,0 @@
-/**
- * Go runner: emits Go-canonical step names so the UI shows what's actually
- * being run instead of forcing Node-isms onto the toolchain.
- *
- *   fmt   → go fmt ./...        (rewrites .go files; readback feeds the diff)
- *   vet   → go vet ./...        (replaced by golangci-lint when installed)
- *   build → go build ./...      (compile + type check)
- *   test  → go test -race -count=1 ./...
- *
- * Module location: `go` commands need to run inside the directory containing
- * the relevant go.mod. Monorepos commonly nest the module under e.g.
- * `services/api/go.mod`, so we walk up from a changed .go file (and shallow-
- * scan the clone) to find it. Multi-module repos with several go.mod files
- * are out of scope for v1 — we use whichever module the changeset hits first.
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { runCmd, runStep } from "../cmd.js";
-import { exists } from "../fs.js";
-import { readbackFormatted } from "../overlay.js";
-
-// Public step contract for the orchestrator → frontend handshake.
-export const STEP_ORDER = ["clone", "install", "overlay", "fmt", "vet", "build", "test"];
-export const FIXABLE_STEPS = ["vet", "build", "test"];
-
-async function which(bin) {
-	const r = await runCmd("which", [bin]);
-	return r.code === 0;
-}
-
-async function findGoModDir(cloneDir, changes) {
-	// Walk up from the first changed .go file looking for the nearest go.mod.
-	const goChange = (changes ?? []).find((c) => path.extname(c.file ?? "").toLowerCase() === ".go");
-	if (goChange) {
-		let cur = path.dirname(path.join(cloneDir, goChange.file));
-		while (cur.startsWith(cloneDir)) {
-			if (await exists(path.join(cur, "go.mod"))) return cur;
-			const parent = path.dirname(cur);
-			if (parent === cur) break;
-			cur = parent;
-		}
-	}
-
-	if (await exists(path.join(cloneDir, "go.mod"))) return cloneDir;
-
-	// Shallow scan for monorepos with no .go changes (e.g. an MR that only
-	// touches a config file but the module is in a subdir).
-	try {
-		const entries = await fs.readdir(cloneDir, { withFileTypes: true });
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "vendor") continue;
-			const sub = path.join(cloneDir, entry.name);
-			if (await exists(path.join(sub, "go.mod"))) return sub;
-		}
-	} catch {
-		// fall through
-	}
-	return null;
-}
-
-async function ensureInstalled(goDir, emit) {
-	emit({ type: "progress", step: "install", status: "running" });
-	emit({ type: "log", step: "install", message: "Running go mod download…" });
-	const r = await runCmd(
-		"go", ["mod", "download"],
-		{ cwd: goDir },
-		(l) => emit({ type: "log", step: "install", message: l }),
-	);
-	if (r.code !== 0) throw new Error(`go mod download failed (code ${r.code})`);
-	emit({ type: "step_result", step: "install", passed: true });
-}
-
-export async function runGoRepo(cloneDir, changes, emit) {
-	const goDir = await findGoModDir(cloneDir, changes);
-	if (!goDir) {
-		throw new Error("Couldn't locate a go.mod in the clone — repo doesn't look like a Go module.");
-	}
-	const rel = path.relative(cloneDir, goDir) || ".";
-	if (rel !== ".") emit({ type: "log", step: "overlay", message: `Go module rooted at ${rel}` });
-
-	await ensureInstalled(goDir, emit);
-
-	const results = {};
-
-	results.fmt = await runStep(goDir, "fmt", "go", ["fmt", "./..."], emit);
-	if (results.fmt.passed) await readbackFormatted(cloneDir, changes, emit);
-
-	// `go vet` is the baseline. If the repo (or developer) has golangci-lint
-	// installed, prefer it — it covers gofmt, vet, staticcheck, errcheck, and
-	// more in a single pass and is the de-facto community standard.
-	if (await which("golangci-lint")) {
-		results.vet = await runStep(goDir, "vet", "golangci-lint", ["run", "./..."], emit);
-	} else {
-		results.vet = await runStep(goDir, "vet", "go", ["vet", "./..."], emit);
-	}
-
-	results.build = await runStep(goDir, "build", "go", ["build", "./..."], emit);
-
-	// -race catches data races; -count=1 disables the test cache so we always
-	// re-execute against the overlayed source. Both are standard Go CI practice.
-	results.test = await runStep(goDir, "test", "go", ["test", "-race", "-count=1", "./..."], emit);
-
-	return results;
-}

package/server/forge/core/validator/runners/node.js

@@ -1,84 +0,0 @@
-/**
- * Node runner: `npm ci` (lockfile-hash cached) followed by the standard
- * format / lint / typecheck / test scripts. Missing scripts are skipped, not
- * failed. The formatter step is read back so its rewrites flow into the
- * proposal the user commits.
- */
-
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { runCmd, runStep } from "../cmd.js";
-import { exists } from "../fs.js";
-import { readbackFormatted } from "../overlay.js";
-import { runTddPrecheckNode } from "../tdd.js";
-
-const SCRIPTS = ["format", "lint", "typecheck", "test"];
-
-// Public step contract for the orchestrator → frontend handshake. `tdd_precheck`
-// sits before `test`; it only actually runs (and appears in the UI) when the
-// proposal bundles new test files with impl changes — see runTddPrecheckNode.
-export const STEP_ORDER = ["clone", "install", "overlay", "format", "lint", "typecheck", "tdd_precheck", "test"];
-export const FIXABLE_STEPS = ["lint", "typecheck", "test"];
-
-async function readPackageScripts(dir) {
-	try {
-		const raw = await fs.readFile(path.join(dir, "package.json"), "utf8");
-		return JSON.parse(raw).scripts ?? {};
-	} catch {
-		return {};
-	}
-}
-
-async function ensureInstalled(dir, emit) {
-	const lockPath = path.join(dir, "package-lock.json");
-	if (!(await exists(lockPath))) return; // not an npm-managed project — omit the row entirely.
-
-	const hashPath = path.join(dir, "node_modules", ".forge-lock-hash");
-	const lockContent = await fs.readFile(lockPath);
-	const lockHash = crypto.createHash("sha256").update(lockContent).digest("hex");
-
-	if (await exists(hashPath)) {
-		const stored = (await fs.readFile(hashPath, "utf8")).trim();
-		if (stored === lockHash) return; // node_modules already matches; nothing to install.
-	}
-
-	emit({ type: "progress", step: "install", status: "running" });
-	emit({ type: "log", step: "install", message: "Running npm ci (first run for this lockfile may take a minute)…" });
-	const install = await runCmd(
-		"npm", ["ci", "--prefer-offline", "--no-audit", "--no-fund"],
-		{ cwd: dir },
-		(l) => emit({ type: "log", step: "install", message: l }),
-	);
-	if (install.code !== 0) {
-		throw new Error(`npm ci failed (code ${install.code})`);
-	}
-	await fs.mkdir(path.dirname(hashPath), { recursive: true });
-	await fs.writeFile(hashPath, lockHash);
-	emit({ type: "step_result", step: "install", passed: true });
-}
-
-export async function runNodeRepo(dir, changes, emit) {
-	await ensureInstalled(dir, emit);
-
-	const scripts = await readPackageScripts(dir);
-	const results = {};
-	// Only run (and thus only render) scripts the project actually defines —
-	// missing scripts are omitted from the UI rather than shown as "skipped".
-	for (const s of SCRIPTS) {
-		if (!scripts[s]) continue;
-		// TDD precheck runs only when the `test` script exists, a new test file
-		// is part of the proposal, and there's impl code to revert. It records
-		// its own step_result under `tdd_precheck`.
-		if (s === "test") {
-			const precheck = await runTddPrecheckNode(dir, changes, emit);
-			if (precheck) results.tdd_precheck = precheck;
-		}
-		results[s] = await runStep(dir, s, "npm", ["run", "--silent", s], emit);
-		if (s === "format" && results[s].passed) {
-			await readbackFormatted(dir, changes, emit);
-		}
-	}
-	return results;
-}