stim 1.0.0 → 1.2.0

package/dist/worktree-C79xx_kM.mjs

@@ -0,0 +1,543 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { g as loadConfig, u as getConfigDir } from "./config-CMtIaTk9.mjs";
+import { accessSync, chmodSync, constants, lstatSync, mkdirSync, mkdtempSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { chmodSync as chmodSync$1, existsSync as existsSync$1, lstatSync as lstatSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, utimesSync } from "fs";
+import { dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
+import { tmpdir } from "node:os";
+//#region src/temporary.ts
+function existingPath(path) {
+	const missing = [];
+	let current = resolve(path);
+	while (!lstatSync(current, { throwIfNoEntry: false })) {
+		missing.unshift(basename(current));
+		current = dirname(current);
+	}
+	const existing = realpathSync(current);
+	return {
+		existing,
+		resolved: join(existing, ...missing)
+	};
+}
+function filesystemDevice(path) {
+	return statSync(existingPath(path).existing).dev;
+}
+function outsideWorkingTree(path) {
+	let current = path;
+	while (true) {
+		if (lstatSync(join(current, ".git"), { throwIfNoEntry: false })) return false;
+		const parent = dirname(current);
+		if (parent === current) return true;
+		current = parent;
+	}
+}
+function temporaryRoot(near) {
+	const reference = existingPath(near);
+	const insideReference = (path) => {
+		const rel = relative(reference.resolved, path);
+		return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+	};
+	const override = process.env.STIM_TMPDIR ?? loadConfig()?.tempDir;
+	if (override !== void 0) {
+		if (typeof override !== "string" || !isAbsolute(override)) throw new Error("STIM_TMPDIR / tempDir must be an absolute directory path.");
+		const { existing, resolved } = existingPath(override);
+		if (!statSync(existing).isDirectory() || !outsideWorkingTree(existing)) throw new Error(`Temporary directory ${override} must be outside Git working trees.`);
+		if (insideReference(resolved)) throw new Error(`Temporary directory ${override} must not be inside ${near}.`);
+		accessSync(existing, constants.W_OK);
+		return resolved;
+	}
+	const { existing } = reference;
+	const device = statSync(existing).dev;
+	const candidates = [tmpdir()];
+	let current = existing === reference.resolved || !statSync(existing).isDirectory() ? dirname(existing) : existing;
+	while (statSync(current).dev === device) {
+		candidates.push(current);
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	for (const candidate of candidates) try {
+		const path = realpathSync(candidate);
+		if (statSync(path).dev !== device || insideReference(path) || !outsideWorkingTree(path)) continue;
+		accessSync(path, constants.W_OK);
+		return path;
+	} catch {}
+	throw new Error(`No writable temporary directory on the filesystem containing ${near}. Set STIM_TMPDIR or tempDir in ${join(getConfigDir(), "config.json")} to a directory outside Git working trees.`);
+}
+function makeTemporaryDirectory(near, prefix) {
+	const root = temporaryRoot(near);
+	mkdirSync(root, {
+		recursive: true,
+		mode: 448
+	});
+	return mkdtempSync(join(root, prefix));
+}
+function removeTemporaryEntry(path) {
+	const stat = lstatSync(path, { throwIfNoEntry: false });
+	if (stat?.isDirectory()) {
+		chmodSync(path, stat.mode | 448);
+		for (const entry of readdirSync(path, { withFileTypes: true })) if (entry.isDirectory()) removeTemporaryEntry(join(path, entry.name));
+	}
+	rmSync(path, {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/worktree.ts
+const CARRY_SKIP_BASENAMES = /* @__PURE__ */ new Set([
+	".DerivedData",
+	".DS_Store",
+	".idea"
+]);
+function isCarrySkipped(rel) {
+	return /(^|\/)android\/build\/generated\/autolinking(\/|$)/.test(rel) || String(rel).split("/").some((seg) => CARRY_SKIP_BASENAMES.has(seg));
+}
+function gitCommonDir(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-common-dir"
+	]);
+	return out ? out.trim() : null;
+}
+function isMainWorkingTree(path) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		path,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-dir",
+		"--git-common-dir"
+	]);
+	if (!out) return false;
+	const [gitDir, commonDir] = out.trim().split("\n").map((line) => line.trim());
+	return Boolean(gitDir) && gitDir === commonDir;
+}
+function repoRoot(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"rev-parse",
+		"--show-toplevel"
+	]);
+	return out ? out.trim() : null;
+}
+function warmWorktreePaths(cwd) {
+	const currentRoot = repoRoot(cwd);
+	if (!currentRoot) throw new Error("Not a git repository.");
+	const target = realpathSync$1(currentRoot);
+	if (isMainWorkingTree(target)) throw new Error("Run stim worktree warm from a linked worktree, not the source checkout.");
+	const entries = listWorktrees(target);
+	const current = entries.find((entry) => canonicalPath(entry.path) === target);
+	const main = entries.find((entry) => isMainWorkingTree(entry.path));
+	if (!current || !main) throw new Error("Could not identify the linked worktree and its source checkout.");
+	const root = realpathSync$1(main.path);
+	const sourceRoot = repoRoot(root);
+	const sourceCommon = gitCommonDir(root);
+	const targetCommon = gitCommonDir(target);
+	if (root === target || !sourceRoot || realpathSync$1(sourceRoot) !== root || !sourceCommon || !targetCommon || realpathSync$1(sourceCommon) !== realpathSync$1(targetCommon)) throw new Error("Could not verify that the source checkout belongs to this linked worktree.");
+	return {
+		root,
+		target,
+		common: realpathSync$1(targetCommon)
+	};
+}
+function matchesInclude(path, patterns) {
+	for (const pattern of patterns || []) {
+		const rooted = pattern.startsWith("/");
+		const escaped = (rooted ? pattern.slice(1) : pattern).replace(/[.+^${}()|[\]\\?]/g, "\\$&").replace(/\*\*\//g, "::GLOBSTAR::").replace(/\*/g, "[^/]+").replace(/::GLOBSTAR::/g, "(?:.*/)?").replace(/\\\?/g, "[^/]");
+		if (new RegExp(`${rooted ? "^" : "(^|/)"}${escaped}$`).test(path)) return true;
+	}
+	return false;
+}
+function readWorktreeExclude(root) {
+	return readPatternFile(join$1(root, ".worktreeexclude"));
+}
+function readPatternFile(p) {
+	if (!existsSync$1(p)) return null;
+	return readFileSync$1(p, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+}
+function canonicalPath(path) {
+	try {
+		return realpathSync$1(path);
+	} catch {
+		return resolve$1(path);
+	}
+}
+function nestedWorktreePaths(root) {
+	const source = canonicalPath(root);
+	const paths = /* @__PURE__ */ new Set();
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		root,
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	if (out === null) throw new Error("Could not list Git worktrees. Refusing to carry ignored files.");
+	for (const entry of parseWorktrees(out)) {
+		const rel = relative$1(source, canonicalPath(entry.path));
+		if (!rel || rel === ".." || rel.startsWith(`..${sep$1}`) || isAbsolute$1(rel)) continue;
+		paths.add(rel.split(sep$1).join("/"));
+	}
+	return [...paths];
+}
+function overlapsNestedWorktree(rel, nestedPaths) {
+	const path = String(rel).replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+	return nestedPaths.some((nested) => path === nested || path.startsWith(`${nested}/`) || nested.startsWith(`${path}/`));
+}
+function listTrackedPaths(dir) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"ls-files",
+		"-z"
+	]);
+	if (out === null) return null;
+	return out.split("\0").filter(Boolean);
+}
+function trackedGuard(dir) {
+	const paths = listTrackedPaths(dir);
+	if (paths === null) return {
+		known: false,
+		covers: () => false
+	};
+	const entries = new Set(paths);
+	const covered = new Set(paths);
+	for (const p of paths) for (let i = p.indexOf("/"); i !== -1; i = p.indexOf("/", i + 1)) covered.add(p.slice(0, i));
+	return {
+		known: true,
+		covers: (rel) => {
+			if (covered.has(rel)) return true;
+			for (let i = rel.indexOf("/"); i !== -1; i = rel.indexOf("/", i + 1)) if (entries.has(rel.slice(0, i))) return true;
+			return false;
+		}
+	};
+}
+function listGitignoredEntries(root) {
+	const args = [
+		"-C",
+		root,
+		"ls-files",
+		"--others",
+		"--ignored",
+		"--exclude-standard",
+		"--directory",
+		"--no-empty-directory",
+		"-z"
+	];
+	const out = getExecutor().runFile("git", args);
+	if (!out) return [];
+	return out.split("\0").filter(Boolean).map((e) => e.endsWith("/") ? e.slice(0, -1) : e);
+}
+function listCarryableIgnoredEntries(root, patterns) {
+	const nested = nestedWorktreePaths(root);
+	return listGitignoredEntries(root).filter((rel) => !isCarrySkipped(rel) && !overlapsNestedWorktree(rel, nested) && !matchesInclude(rel, patterns));
+}
+function missingDestinationReason(target, rel) {
+	const parts = rel.split("/");
+	for (let i = 1; i < parts.length; i++) {
+		const parent = parts.slice(0, i).join("/");
+		const stat = lstatSync$1(join$1(target, parent), { throwIfNoEntry: false });
+		if (stat?.isSymbolicLink()) return `symlink ancestor: ${parent}`;
+		if (stat && !stat.isDirectory()) return `non-directory ancestor: ${parent}`;
+	}
+	return lstatSync$1(join$1(target, rel), { throwIfNoEntry: false }) ? "exists" : null;
+}
+function removeCopiedExclusions(path, rel) {
+	const entries = readdirSync$1(path, { withFileTypes: true });
+	const excluded = entries.filter((entry) => isCarrySkipped(`${rel}/${entry.name}`));
+	if (excluded.length > 0) {
+		const stat = lstatSync$1(path);
+		chmodSync$1(path, stat.mode | 448);
+		try {
+			for (const entry of excluded) removeTemporaryEntry(join$1(path, entry.name));
+		} finally {
+			utimesSync(path, stat.atime, stat.mtime);
+			chmodSync$1(path, stat.mode);
+		}
+	}
+	for (const entry of entries) {
+		const child = `${rel}/${entry.name}`;
+		if (entry.isDirectory() && !isCarrySkipped(child)) removeCopiedExclusions(join$1(path, entry.name), child);
+	}
+}
+function cloneIgnoredEntries({ root, target, patterns }) {
+	const copied = [];
+	const skipped = [];
+	const failed = [];
+	let cloned = true;
+	const guard = trackedGuard(target);
+	if (!guard.known) throw new Error("Could not list the destination's tracked files.");
+	const nested = nestedWorktreePaths(target);
+	for (const rel of listCarryableIgnoredEntries(root, patterns)) {
+		const from = join$1(root, rel);
+		const to = join$1(target, rel);
+		try {
+			const reason = guard.covers(rel) ? "tracked" : overlapsNestedWorktree(rel, nested) ? "nested worktree" : missingDestinationReason(target, rel);
+			if (reason) {
+				skipped.push({
+					file: rel,
+					reason
+				});
+				continue;
+			}
+			mkdirSync$1(dirname$1(to), { recursive: true });
+			try {
+				getExecutor().runFile("cp", [
+					"-Rc",
+					from,
+					to
+				]);
+			} catch {
+				removeTemporaryEntry(to);
+				getExecutor().runFile("cp", [
+					"-R",
+					from,
+					to
+				]);
+				cloned = false;
+			}
+			if (lstatSync$1(to).isDirectory()) removeCopiedExclusions(to, rel);
+			copied.push(rel);
+		} catch (e) {
+			failed.push({
+				file: rel,
+				error: String(e?.message || e)
+			});
+		}
+	}
+	return {
+		copied,
+		skipped,
+		failed,
+		cloned
+	};
+}
+function podsOutOfSync(target, copiedEntries, { read = readFileSync$1 } = {}) {
+	const problems = [];
+	for (const rel of copiedEntries || []) {
+		if (rel !== "Pods" && !rel.endsWith("/Pods")) continue;
+		const iosDir = rel === "Pods" ? "" : rel.slice(0, -5);
+		const manifest = join$1(target, rel, "Manifest.lock");
+		const podfileLock = join$1(target, iosDir, "Podfile.lock");
+		if (!existsSync$1(manifest)) continue;
+		if (!existsSync$1(podfileLock)) {
+			problems.push({
+				dir: iosDir || ".",
+				reason: "missing"
+			});
+			continue;
+		}
+		try {
+			if (read(manifest, "utf-8") !== read(podfileLock, "utf-8")) problems.push({
+				dir: iosDir || ".",
+				reason: "mismatch"
+			});
+		} catch {}
+	}
+	return problems;
+}
+const LOCKFILE_NAMES = [
+	"package-lock.json",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"bun.lock",
+	"bun.lockb"
+];
+function depsOutOfSync(root, target, copiedEntries, { read = readFileSync$1 } = {}) {
+	const problems = [];
+	for (const rel of copiedEntries || []) {
+		if (rel !== "node_modules" && !rel.endsWith("/node_modules")) continue;
+		const dir = rel === "node_modules" ? "" : rel.slice(0, -13);
+		for (const name of LOCKFILE_NAMES) {
+			const source = join$1(root, dir, name);
+			const branch = join$1(target, dir, name);
+			if (!existsSync$1(source) || !existsSync$1(branch)) continue;
+			try {
+				if (read(source, "utf-8") !== read(branch, "utf-8")) problems.push({
+					dir: dir || ".",
+					lockfile: name
+				});
+			} catch {}
+			break;
+		}
+	}
+	return problems;
+}
+const FINGERPRINT_INPUT_FILES = [
+	"app.json",
+	"app.config.ts",
+	"app.config.js",
+	"app.config.mjs",
+	"package.json"
+];
+function dirtyFingerprintFiles(root) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		root,
+		"status",
+		"--porcelain",
+		"--",
+		...FINGERPRINT_INPUT_FILES
+	]);
+	if (out === null || out.trim() === "") return [];
+	return out.split("\n").map((line) => normalizePorcelainLine(line.trimEnd())).filter((line) => line !== "").map((line) => line.slice(3).trim()).filter((path) => path !== "");
+}
+function hasUncommittedWork(dir) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"status",
+		"--porcelain"
+	]);
+	if (out === null) return null;
+	return out.trim().length > 0;
+}
+function dirtyPaths(dir, { limit = 10 } = {}) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"status",
+		"--porcelain"
+	]);
+	if (out === null) return [];
+	return out.split("\n").map((l) => normalizePorcelainLine(l.trimEnd())).filter(Boolean).slice(0, limit);
+}
+function normalizePorcelainLine(line) {
+	if (line === "" || line[2] === " ") return line;
+	return ` ${line}`;
+}
+function restoreFile(dir, file) {
+	return getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"checkout",
+		"--",
+		file
+	]) !== null;
+}
+function isPodInstallChurn(paths) {
+	if (!paths || paths.length === 0) return false;
+	return paths.every((line) => /(?:^|\/)(?:Podfile\.lock|project\.pbxproj)$/.test(line.slice(3).trim()));
+}
+const SAFE_BRANCH_NAME = /^[A-Za-z0-9._/-]+$/;
+function unpushedCommits(dir) {
+	const exec = getExecutor();
+	const branch = exec.runFileQuiet("git", [
+		"-C",
+		dir,
+		"symbolic-ref",
+		"--quiet",
+		"--short",
+		"HEAD"
+	]);
+	const own = branch === null ? "" : branch.trim();
+	const protection = own && SAFE_BRANCH_NAME.test(own) ? [
+		"--remotes",
+		`--exclude=${own}`,
+		"--branches"
+	] : ["--remotes"];
+	if (!own && exec.runFileQuiet("git", [
+		"-C",
+		dir,
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]) === "HEAD") protection.push("--branches");
+	const out = exec.runFileQuiet("git", [
+		"-C",
+		dir,
+		"log",
+		"--oneline",
+		"HEAD",
+		"--not",
+		...protection
+	]);
+	if (out === null) return null;
+	return out.split("\n").map((l) => l.trim()).filter(Boolean);
+}
+function hasRemote(dir) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"remote"
+	]);
+	return Boolean(out && out.trim().length > 0);
+}
+function branchExists(cwd, branch) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		`refs/heads/${branch}`
+	]);
+	return Boolean(out);
+}
+function resolveFullRef(cwd, ref) {
+	try {
+		const out = getExecutor().runFile("git", [
+			"-C",
+			cwd,
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			"--end-of-options",
+			`${ref}^{commit}`
+		]);
+		return out && out.trim() ? out.trim() : null;
+	} catch {
+		return null;
+	}
+}
+function removeWorktree(path, { force = false } = {}) {
+	const args = [
+		"-C",
+		path,
+		"worktree",
+		"remove",
+		...force ? ["--force"] : [],
+		"--",
+		path
+	];
+	getExecutor().runFile("git", args);
+}
+function deleteBranch(cwd, branch, expectedSha) {
+	if (!SAFE_BRANCH_NAME.test(branch) || branch.startsWith("-")) throw new Error(`Refusing branch ${JSON.stringify(branch)}: it is not a safe local branch name.`);
+	getExecutor().runFile("git", [
+		"-C",
+		cwd,
+		"update-ref",
+		"-d",
+		`refs/heads/${branch}`,
+		expectedSha
+	]);
+}
+function parseWorktrees(out) {
+	const entries = [];
+	let current = {};
+	for (const line of out.split("\n")) if (line.startsWith("worktree ")) {
+		if (current.path) entries.push(current);
+		current = { path: line.slice(9) };
+	} else if (line.startsWith("branch ")) current.branch = line.slice(7).replace("refs/heads/", "");
+	else if (line === "prunable" || line.startsWith("prunable ")) current.prunable = true;
+	if (current.path) entries.push(current);
+	return entries;
+}
+function listWorktrees(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	return out ? parseWorktrees(out) : [];
+}
+//#endregion
+export { removeTemporaryEntry as C, makeTemporaryDirectory as S, resolveFullRef as _, dirtyFingerprintFiles as a, warmWorktreePaths as b, hasRemote as c, isPodInstallChurn as d, listWorktrees as f, repoRoot as g, removeWorktree as h, depsOutOfSync as i, hasUncommittedWork as l, readWorktreeExclude as m, cloneIgnoredEntries as n, dirtyPaths as o, podsOutOfSync as p, deleteBranch as r, gitCommonDir as s, branchExists as t, isMainWorkingTree as u, restoreFile as v, temporaryRoot as w, filesystemDevice as x, unpushedCommits as y };