@ipul-labs/forge 1.16.7 → 1.17.0

package/server/forge/core/configStore.js

@@ -1,229 +0,0 @@
-/**
- * Forge persistent config.
- *
- * Storage contract
- * ────────────────
- * A single JSON blob on disk (default: ~/.forge/config.json). Loaded once at
- * process start into an in-memory cache so route handlers read synchronously.
- * Writes are atomic (tmp-file + rename) and serialized to avoid interleaving.
- *
- * Swap to Redis or another backend by re-exporting a different instance from
- * this module — callers import `get()` / `patch()` and don't know the source.
- */
-
-import fsSync from "node:fs";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-/** @typedef {{ id: string, label: string, projectType?: "auto" | "node" | "go" }} ForgeRepo */
-
-/**
- * @typedef {{ baseUrl: string, token: string }} GitLabConnection
- * @typedef {{ token: string }} GitHubConnection
- * @typedef {{ token: string }} AzureDevOpsConnection
- *
- * @typedef {{
- *   repos: ForgeRepo[],
- *   defaults: {
- *     model: string | null,
- *     agent: string | null,
- *     autoPushOnValidatePass: boolean,
- *     refineRepoAccess: boolean,
- *     promptRules: string,
- *   },
- *   connections: {
- *     gitlab: GitLabConnection,
- *     github: GitHubConnection,
- *     azuredevops: AzureDevOpsConnection,
- *   }
- * }} ForgeConfig
- */
-
-const BUILTIN_BASE_URLS = {
-	gitlab: "https://gitlab.com/api/v4",
-	github: "https://api.github.com",
-};
-
-/** @type {ForgeConfig} */
-const DEFAULT_CONFIG = {
-	repos: [],
-	defaults: {
-		model: null,
-		agent: null,
-		autoPushOnValidatePass: false,
-		// When true (default), Refine gets Read/Glob/Grep access to a local
-		// clone of the primary repo. Off → lighter "file tree in prompt" flow.
-		// The FORGE_REFINE_REPO_ACCESS env var, when set, overrides this.
-		refineRepoAccess: true,
-		// Free-form rules injected into every analysis and refine prompt.
-		// Lets the user steer the model without touching code.
-		promptRules: "",
-		// Test-deploy URL surfaced next to "Approve & Create MR" when the
-		// branch pipeline is green. Plain URL (e.g. "https://test.example.com")
-		// for a shared env; supports "{branch}" / "{slug}" placeholders when
-		// moving to ephemeral per-branch deploys.
-		testDeployUrlTemplate: "",
-	},
-	connections: {
-		gitlab: { baseUrl: BUILTIN_BASE_URLS.gitlab, token: "" },
-		github: { token: "" },
-		azuredevops: { token: "" },
-	},
-};
-
-function configPath() {
-	return process.env.FORGE_CONFIG_PATH ?? path.join(os.homedir(), ".forge", "config.json");
-}
-
-/**
- * Synchronous load — called once at startup so the rest of the routes can
- * read config without awaiting. If the file is missing we return defaults;
- * if it's malformed we warn and return defaults (don't crash the server over
- * a bad config).
- */
-function loadSync() {
-	const p = configPath();
-	try {
-		const raw = fsSync.readFileSync(p, "utf8");
-		const parsed = JSON.parse(raw);
-		return mergeDeep(DEFAULT_CONFIG, parsed);
-	} catch (err) {
-		if (err.code === "ENOENT") return structuredClone(DEFAULT_CONFIG);
-		console.warn(`[forge] config file at ${p} is unreadable (${err.message}); using defaults`);
-		return structuredClone(DEFAULT_CONFIG);
-	}
-}
-
-/** @type {ForgeConfig} */
-let cache = loadSync();
-
-/** Serializes writes so two concurrent PUTs can't interleave. */
-let inFlight = Promise.resolve();
-
-async function writeToDisk(cfg) {
-	const p = configPath();
-	await fs.mkdir(path.dirname(p), { recursive: true });
-	const tmp = `${p}.${process.pid}.${Date.now()}.tmp`;
-	await fs.writeFile(tmp, JSON.stringify(cfg, null, 2), "utf8");
-	// 0600 — owner read/write only. Belt-and-suspenders for when tokens land here.
-	await fs.chmod(tmp, 0o600);
-	await fs.rename(tmp, p);
-}
-
-function mergeDeep(base, patch) {
-	const out = Array.isArray(base) ? [...base] : { ...base };
-	for (const [k, v] of Object.entries(patch)) {
-		const bv = base?.[k];
-		if (
-			v !== null &&
-			typeof v === "object" &&
-			!Array.isArray(v) &&
-			bv !== null &&
-			typeof bv === "object" &&
-			!Array.isArray(bv)
-		) {
-			out[k] = mergeDeep(bv, v);
-		} else {
-			out[k] = v;
-		}
-	}
-	return out;
-}
-
-/** Returns the current cached config. Synchronous. */
-export function get() {
-	return cache;
-}
-
-/**
- * Deep-merges `patch` into the current config, persists, and updates the
- * cache. Arrays are replaced (not merged) so callers send the whole repos
- * list when editing it.
- */
-export function patch(delta) {
-	inFlight = inFlight.then(async () => {
-		const next = mergeDeep(cache, delta);
-		await writeToDisk(next);
-		cache = next;
-		return next;
-	});
-	return inFlight;
-}
-
-/** Escape hatch for tests / explicit reload from disk. */
-export function reload() {
-	cache = loadSync();
-	return cache;
-}
-
-/**
- * Resolves the primary project identifier.
- * Priority: persisted config repos[0] → FORGE_REPOS first entry → FORGE_GITLAB_PROJECT.
- */
-export function getPrimaryProject() {
-	const repos = cache.repos;
-	if (repos.length > 0) return repos[0].id;
-	const raw = process.env.FORGE_REPOS ?? process.env.FORGE_GITLAB_PROJECT ?? "";
-	return raw.split(",")[0]?.trim() || null;
-}
-
-const ENV_TOKEN_KEYS = {
-	gitlab: "GITLAB_TOKEN",
-	github: "GITHUB_TOKEN",
-	azuredevops: "AZURE_DEVOPS_TOKEN",
-};
-
-/**
- * Resolved provider connection: config value wins, env var fills gaps, builtin
- * URL is the last fallback. Providers call this instead of reading process.env.
- *
- * @param {"gitlab"|"github"|"azuredevops"} provider
- * @returns {{ baseUrl?: string, token: string }}
- */
-export function getConnection(provider) {
-	const fromCfg = cache.connections?.[provider] ?? {};
-	const envToken = process.env[ENV_TOKEN_KEYS[provider]] ?? "";
-	const baseUrl = fromCfg.baseUrl || BUILTIN_BASE_URLS[provider];
-	return {
-		...(baseUrl ? { baseUrl } : {}),
-		token: fromCfg.token || envToken,
-	};
-}
-
-function maskToken(t) {
-	if (!t) return "";
-	if (t.length <= 4) return "••••";
-	return `••••${t.slice(-4)}`;
-}
-
-/**
- * Safe view for the API — raw tokens are replaced with a short hint and a
- * boolean so the UI can render state without ever seeing a secret.
- */
-export function getPublic() {
-	const cfg = cache;
-	const conn = cfg.connections ?? {};
-	return {
-		repos: cfg.repos,
-		defaults: cfg.defaults,
-		connections: {
-			gitlab: {
-				baseUrl: conn.gitlab?.baseUrl ?? BUILTIN_BASE_URLS.gitlab,
-				hasToken: Boolean(conn.gitlab?.token || process.env.GITLAB_TOKEN),
-				tokenHint: maskToken(conn.gitlab?.token || process.env.GITLAB_TOKEN || ""),
-				tokenSource: conn.gitlab?.token ? "config" : process.env.GITLAB_TOKEN ? "env" : "none",
-			},
-			github: {
-				hasToken: Boolean(conn.github?.token || process.env.GITHUB_TOKEN),
-				tokenHint: maskToken(conn.github?.token || process.env.GITHUB_TOKEN || ""),
-				tokenSource: conn.github?.token ? "config" : process.env.GITHUB_TOKEN ? "env" : "none",
-			},
-			azuredevops: {
-				hasToken: Boolean(conn.azuredevops?.token || process.env.AZURE_DEVOPS_TOKEN),
-				tokenHint: maskToken(conn.azuredevops?.token || process.env.AZURE_DEVOPS_TOKEN || ""),
-				tokenSource: conn.azuredevops?.token ? "config" : process.env.AZURE_DEVOPS_TOKEN ? "env" : "none",
-			},
-		},
-	};
-}

package/server/forge/core/configStore.test.js

@@ -1,89 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// We test getPrimaryProject and getConnection which resolve from
-// cache (configStore state) → env vars → defaults.
-
-import { getPrimaryProject, getConnection, get, reload } from "./configStore.js";
-
-describe("getPrimaryProject", () => {
-	const originalEnv = { ...process.env };
-
-	afterEach(() => {
-		process.env = { ...originalEnv };
-	});
-
-	it("returns first config repo when config has repos", () => {
-		const cfg = get();
-		// If the test env has repos in config, this tests the real path.
-		// Otherwise we test the env fallback paths below.
-		if (cfg.repos.length > 0) {
-			expect(getPrimaryProject()).toBe(cfg.repos[0].id);
-		}
-	});
-
-	it("falls back to FORGE_REPOS first entry", () => {
-		// Temporarily clear config repos by checking current state
-		const cfg = get();
-		if (cfg.repos.length === 0) {
-			process.env.FORGE_REPOS = "group/web-app,group/api";
-			expect(getPrimaryProject()).toBe("group/web-app");
-		}
-	});
-
-	it("falls back to FORGE_GITLAB_PROJECT when FORGE_REPOS is unset", () => {
-		const cfg = get();
-		if (cfg.repos.length === 0) {
-			delete process.env.FORGE_REPOS;
-			process.env.FORGE_GITLAB_PROJECT = "legacy/project";
-			expect(getPrimaryProject()).toBe("legacy/project");
-		}
-	});
-
-	it("returns null when nothing is configured", () => {
-		const cfg = get();
-		if (cfg.repos.length === 0) {
-			delete process.env.FORGE_REPOS;
-			delete process.env.FORGE_GITLAB_PROJECT;
-			expect(getPrimaryProject()).toBeNull();
-		}
-	});
-
-	it("trims whitespace from FORGE_REPOS entries", () => {
-		const cfg = get();
-		if (cfg.repos.length === 0) {
-			process.env.FORGE_REPOS = "  group/web-app , group/api ";
-			expect(getPrimaryProject()).toBe("group/web-app");
-		}
-	});
-});
-
-describe("getConnection", () => {
-	const originalEnv = { ...process.env };
-
-	afterEach(() => {
-		process.env = { ...originalEnv };
-	});
-
-	it("returns token from env when config has none", () => {
-		process.env.GITLAB_TOKEN = "test-token-123";
-		const conn = getConnection("gitlab");
-		// Config token takes precedence, so if config has one we get that.
-		// Either way, we should get a non-empty token.
-		expect(conn.token).toBeTruthy();
-	});
-
-	it("returns a baseUrl for gitlab", () => {
-		const conn = getConnection("gitlab");
-		expect(conn.baseUrl).toContain("gitlab.com");
-	});
-
-	it("returns empty token when nothing is configured", () => {
-		delete process.env.GITLAB_TOKEN;
-		const cfg = get();
-		// Only test if config also has no token
-		if (!cfg.connections?.gitlab?.token) {
-			const conn = getConnection("gitlab");
-			expect(conn.token).toBe("");
-		}
-	});
-});

package/server/forge/core/jobs.js

@@ -1,180 +0,0 @@
-/**
- * server/forge/core/jobs.js
- *
- * Unified in-memory job store with event buffering + multi-subscriber replay.
- *
- * Why this exists: SSE endpoints like refine / ci-fix / validate / analyze
- * run a long task and stream events to one EventSource. If the browser
- * reloads or React re-mounts the component, that stream dies. Before this
- * module, the job also died — its state was deleted the moment the stream
- * was consumed, so there was nothing to reconnect to.
- *
- * With this store:
- *   1. `createJob(type, runner)` starts the runner immediately in the
- *      background and buffers every event it emits.
- *   2. `subscribe(id, handler)` replays the buffer synchronously, then wires
- *      the handler to future events until the job is terminal.
- *   3. A reconnecting client gets the full history on reconnect and then
- *      live events — identical to if it had been watching all along.
- *
- * Process-restart survival is out of scope for v1 (Map is in-memory only).
- */
-
-const TTL_MS = 10 * 60 * 1000;
-const SWEEP_INTERVAL_MS = 60 * 1000;
-
-const jobs = new Map();
-let sweeper = null;
-
-function ensureSweeper() {
-	if (sweeper) return;
-	sweeper = setInterval(() => {
-		const now = Date.now();
-		for (const [id, job] of jobs) {
-			if (job.expiresAt && job.expiresAt <= now && job.subscribers.size === 0) {
-				jobs.delete(id);
-			}
-		}
-	}, SWEEP_INTERVAL_MS);
-	sweeper.unref?.();
-}
-
-function newId(prefix) {
-	return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-
-/**
- * Create and start a job. `runner` is an async function that receives
- * `(send, signal)` — any value it returns is captured as `doneResult`.
- * A terminal `done`, `error`, or `cancelled` event is emitted automatically
- * when runner settles; runners must not emit those themselves.
- *
- * The `signal` is an `AbortSignal` that fires when a client calls `cancelJob`.
- * Runners should forward it to any subprocess / fetch / SDK call that
- * supports AbortSignal so the underlying work actually stops (and API/CLI
- * costs aren't incurred for work the user no longer wants).
- */
-export function createJob(type, runner, { idPrefix = type } = {}) {
-	ensureSweeper();
-	const id = newId(idPrefix);
-	const controller = new AbortController();
-	const job = {
-		id,
-		type,
-		status: "running",
-		events: [],
-		doneResult: undefined,
-		error: null,
-		createdAt: Date.now(),
-		finishedAt: null,
-		expiresAt: null,
-		subscribers: new Set(),
-		controller,
-	};
-	jobs.set(id, job);
-
-	const send = (event) => {
-		job.events.push(event);
-		for (const sub of job.subscribers) {
-			try { sub(event); } catch { /* subscriber errors don't break fanout */ }
-		}
-	};
-
-	(async () => {
-		try {
-			const result = await runner(send, controller.signal);
-			if (job.status === "cancelled") return;
-			job.doneResult = result ?? null;
-			job.status = "done";
-			send({ type: "done" });
-		} catch (e) {
-			if (job.status === "cancelled") return;
-			// If the runner threw because of our own abort, prefer the cancelled
-			// terminal over a misleading error event.
-			if (controller.signal.aborted) {
-				job.status = "cancelled";
-				send({ type: "cancelled" });
-				return;
-			}
-			job.status = "error";
-			job.error = e?.message ?? String(e);
-			send({ type: "error", message: job.error });
-		} finally {
-			job.finishedAt = Date.now();
-			job.expiresAt = job.finishedAt + TTL_MS;
-		}
-	})();
-
-	return id;
-}
-
-/**
- * Cancel a running job. Aborts the signal, emits a terminal `cancelled`
- * event, and marks the job non-running. No-op if the job is already
- * terminal or doesn't exist — returns whether a cancel was actually issued.
- */
-export function cancelJob(id) {
-	const job = jobs.get(id);
-	if (!job) return false;
-	if (job.status !== "running") return false;
-	job.status = "cancelled";
-	try {
-		job.controller.abort();
-	} catch { /* ignore */ }
-	// Emit the terminal *before* the runner's catch block runs, so reconnecting
-	// clients always see a cancellation event in the buffer.
-	job.events.push({ type: "cancelled" });
-	for (const sub of job.subscribers) {
-		try { sub({ type: "cancelled" }); } catch { /* ignore */ }
-	}
-	job.finishedAt = Date.now();
-	job.expiresAt = job.finishedAt + TTL_MS;
-	return true;
-}
-
-export function getJob(id) {
-	return jobs.get(id) ?? null;
-}
-
-/**
- * Replay buffered events to `handler`, then subscribe for live events until
- * the job reaches terminal state. Returns an `unsubscribe` function, or
- * `null` if the job doesn't exist.
- *
- * The terminal `done`/`error` event is part of the buffered replay — callers
- * that want to end the response on terminal should check for it inside
- * their handler.
- */
-export function subscribe(id, handler) {
-	const job = jobs.get(id);
-	if (!job) return null;
-
-	for (const e of job.events) {
-		try { handler(e); } catch { /* ignore */ }
-	}
-
-	if (job.status !== "running") {
-		return () => {};
-	}
-
-	job.subscribers.add(handler);
-	return () => { job.subscribers.delete(handler); };
-}
-
-/**
- * Public status snapshot — safe to send to clients. Excludes the event
- * buffer (potentially large) and subscribers (not serialisable).
- */
-export function snapshot(id) {
-	const job = jobs.get(id);
-	if (!job) return null;
-	return {
-		id: job.id,
-		type: job.type,
-		status: job.status,
-		createdAt: job.createdAt,
-		finishedAt: job.finishedAt,
-		error: job.error,
-		eventCount: job.events.length,
-	};
-}

package/server/forge/core/k8s.js

@@ -1,54 +0,0 @@
-import * as k8s from "@kubernetes/client-node";
-
-let kc = new k8s.KubeConfig();
-
-function loadConfig() {
-	kc = new k8s.KubeConfig();
-	const token = process.env.K8S_CLUSTER_TOKEN;
-	const server = process.env.K8S_CLUSTER_SERVER;
-
-	if (token && server) {
-		kc.loadFromOptions({
-			clusters: [{ name: "cluster", server, skipTLSVerify: process.env.K8S_SKIP_TLS_VERIFY === "true" }],
-			users: [{ name: "admin", token }],
-			contexts: [{ name: "default", cluster: "cluster", user: "admin" }],
-			currentContext: "default",
-		});
-	} else {
-		kc.loadFromDefault();
-	}
-}
-
-loadConfig();
-
-function getAppsApi() {
-	return kc.makeApiClient(k8s.AppsV1Api);
-}
-
-function formatDeployment(dep) {
-	const containers = dep.spec?.template?.spec?.containers || [];
-	const status = dep.status || {};
-	return {
-		name: dep.metadata?.name,
-		namespace: dep.metadata?.namespace,
-		image: containers[0]?.image || "unknown",
-		replicas: {
-			desired: dep.spec?.replicas || 0,
-			ready: status.readyReplicas || 0,
-			available: status.availableReplicas || 0,
-			unavailable: status.unavailableReplicas || 0,
-			updated: status.updatedReplicas || 0,
-		},
-		conditions: (status.conditions || []).map((c) => ({
-			type: c.type,
-			status: c.status,
-			message: c.message,
-		})),
-	};
-}
-
-export async function listDeployments(namespace) {
-	const api = getAppsApi();
-	const res = await api.listNamespacedDeployment({ namespace });
-	return (res.items || []).map(formatDeployment);
-}

package/server/forge/core/localRepo.js

@@ -1,153 +0,0 @@
-/**
- * server/forge/core/localRepo.js
- *
- * Shared helpers for maintaining a shallow working clone of a repo under
- * ~/.forge/cache/<repo>/ and overlaying proposed file changes onto it.
- *
- * Used by:
- *   - validator.js → run lint/typecheck/test against the overlaid tree
- *   - ForgeAgent.refineIssue → give the refine model real Read/Glob/Grep access
- *     against the current state of the working tree (FORGE_REFINE_REPO_ACCESS)
- *
- * Scope matches validator v1: GitLab HTTPS clones only. GitHub / Azure DevOps
- * raise a clear "not supported yet" error so the caller can fall back cleanly.
- */
-
-import { spawn } from "child_process";
-import fs from "fs/promises";
-import os from "os";
-import path from "path";
-
-import { getConnection } from "./configStore.js";
-
-const CACHE_ROOT = process.env.FORGE_VALIDATE_CACHE
-	?? path.join(os.homedir(), ".forge", "cache");
-
-function runGit(args, opts = {}, onLog) {
-	return new Promise((resolve) => {
-		const proc = spawn("git", args, {
-			...opts,
-			env: { ...process.env, ...(opts.env ?? {}), FORCE_COLOR: "0", NO_COLOR: "1", TERM: "dumb" },
-			stdio: ["ignore", "pipe", "pipe"],
-		});
-		const lines = [];
-		const collect = (buf) => {
-			for (const raw of buf.toString().split("\n")) {
-				const line = raw.replace(/\r$/, "");
-				if (!line) continue;
-				lines.push(line);
-				onLog?.(line);
-			}
-		};
-		proc.stdout.on("data", collect);
-		proc.stderr.on("data", collect);
-		proc.on("error", (err) => resolve({ code: -1, output: lines.join("\n"), error: err.message }));
-		proc.on("close", (code) => resolve({ code: code ?? -1, output: lines.join("\n"), error: null }));
-	});
-}
-
-async function exists(p) {
-	try { await fs.access(p); return true; } catch { return false; }
-}
-
-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 locally. 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) {
-	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(`Local clone for ${prefix} repos isn't supported yet — GitLab only.`);
-		}
-	}
-	return gitlabCloneUrl(repoInput);
-}
-
-export function cachePathFor(repo) {
-	return path.join(CACHE_ROOT, sanitizeRepo(repo));
-}
-
-/**
- * Ensures the repo is cloned and reset to a clean branch at origin/main.
- * Reuses any existing clone under ~/.forge/cache/<repo>/.
- *
- * @param {string} repo        Repo id (may carry a "gitlab:" prefix)
- * @param {string} branchName  Workspace branch to check out
- * @param {(msg: string) => void} [onLog]
- * @returns {Promise<string>}  Absolute path to the working tree
- */
-export async function ensureWorkingTree(repo, branchName, onLog) {
-	const dir = cachePathFor(repo);
-	const hasRepo = await exists(path.join(dir, ".git"));
-	const log = (m) => onLog?.(m);
-
-	const gitEnv = gitEnvWithToken();
-	const envOpts = { env: { ...process.env, ...gitEnv } };
-	if (!hasRepo) {
-		log(`Cloning ${repo} → ${dir}`);
-		await fs.mkdir(dir, { recursive: true });
-		const clone = await runGit(["clone", "--depth=1", resolveCloneUrl(repo), dir], envOpts, onLog);
-		if (clone.code !== 0) throw new Error(`git clone failed (code ${clone.code})`);
-	} else {
-		log(`Reusing clone at ${dir}`);
-	}
-
-	const fetch = await runGit(["fetch", "--depth=1", "origin", "main"], { cwd: dir, ...envOpts }, onLog);
-	if (fetch.code !== 0) throw new Error(`git fetch failed (code ${fetch.code})`);
-
-	const reset = await runGit(["reset", "--hard", "origin/main"], { cwd: dir }, onLog);
-	if (reset.code !== 0) throw new Error(`git reset failed (code ${reset.code})`);
-	await runGit(["clean", "-fd"], { cwd: dir }, onLog);
-
-	const checkout = await runGit(["checkout", "-B", branchName], { cwd: dir }, onLog);
-	if (checkout.code !== 0) throw new Error(`git checkout ${branchName} failed (code ${checkout.code})`);
-
-	return dir;
-}
-
-/**
- * Writes proposed file contents into the working tree (or deletes files for
- * action="delete"). Refuses paths that escape the clone directory.
- *
- * @param {string} dir
- * @param {Array<{file: string, action: 'create'|'modify'|'delete', proposed?: string}>} changes
- * @param {(msg: string) => void} [onLog]
- */
-export async function overlayChanges(dir, changes, onLog) {
-	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 });
-			onLog?.(`- ${c.file}`);
-		} else {
-			await fs.mkdir(path.dirname(full), { recursive: true });
-			await fs.writeFile(full, c.proposed ?? "");
-			onLog?.(`+ ${c.file} (${c.action})`);
-		}
-	}
-}