@gitroll/tacitt-cli 0.6.12 → 0.6.14

package/dist/{src-CKQlTA2Z.mjs → src-CWMrGXJK.mjs}

@@ -1,17 +1,17 @@
-import { Gn as nativeField, Kn as nativeItems, Mn as walkNativeFields, Wn as nativeBoolean, Xn as retainedMainTextNodes, _r as declaredVersion, br as processingSite, dn as observeSource, fn as sourceSnapshotId, gr as ProcessingError, nr as defaultLimits, qn as nativeText, zn as parseNativeRecord } from "./locate-D-ZaHpI0.mjs";
-import { $r as nativeAdapterVersions, Oi as gitMetadataBudgetBytes, it as reviewInventory } from "./src-Do-qzuMn.mjs";
-import { a as isRecord, i as errorCode, n as checkDiscoveryAbort, o as unresolvedMetadata, r as discoveryBounds, t as DiscoveryWarnings } from "./model-DR9odhWP.mjs";
-import { c as previewLimits, d as checkOpenSource, f as checkSource, h as openSource, i as pageFits, l as previewSourceVersion, m as noSymlinks, p as fileSnapshot, r as previewHeapLimits, s as previewMessageSchema, u as createZstdFrameCheck } from "./run-DQ9xyKSt.mjs";
+import { $n as retainedMainTextNodes, Cr as processingSite, Fn as walkNativeFields, Hn as parseNativeRecord, Jn as nativeField, Xn as nativeText, Yn as nativeItems, ar as defaultLimits, br as declaredVersion, hn as sourceSnapshotId, mn as observeSource, qn as nativeBoolean, yr as ProcessingError } from "./locate-CP2t26j2.mjs";
+import { Hr as nativeAdapterVersions, it as reviewInventory, ji as gitMetadataBudgetBytes } from "./src-B3il9x5F.mjs";
+import { a as isRecord, i as errorCode, n as checkDiscoveryAbort, o as unresolvedMetadata, r as discoveryBounds, t as DiscoveryWarnings } from "./model-ChHuVKoB.mjs";
+import { c as previewLimits, d as checkOpenSource, f as checkSource, h as openSource, i as pageFits, l as previewSourceVersion, m as noSymlinks, p as fileSnapshot, r as previewHeapLimits, s as previewMessageSchema, u as createZstdFrameCheck } from "./run-CiJmV__5.mjs";
 import { a as titleHintLimits, n as titleHeapLimits, o as titleInputSchema, r as decodeTitleError, s as titleReplySchema } from "./heap-1FYhGds4.mjs";
 import { constants } from "node:fs";
-import { lstat, open, opendir, readFile, readdir, realpath, stat } from "node:fs/promises";
+import { access, constants as constants$1, lstat, open, opendir, readFile, readdir, realpath, stat } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep, win32 } from "node:path";
 import { PassThrough, Readable } from "node:stream";
 import { createHash, randomUUID } from "node:crypto";
 import { homedir, platform, tmpdir } from "node:os";
 import { pipeline } from "node:stream/promises";
-import { constants as constants$1, createZstdDecompress } from "node:zlib";
+import { constants as constants$2, createZstdDecompress } from "node:zlib";
 import { Worker } from "node:worker_threads";
 import { setFlagsFromString } from "node:v8";
 import { parse, quote } from "shell-quote";
@@ -4215,7 +4215,8 @@ function seedEnvironment(input) {
 	return env;
 }
 function gitCommands(env, limits, signal, budget) {
-	return async (args, directory = tmpdir(), allowMissing = false) => {
+	/** Runs one command within the limits; settles with its exit status and output. */
+	const run = async (args, directory) => {
 		checkSeedAbort(signal);
 		if (budget.remaining < 1) throw new ProcessingError("PROCESSING_LIMIT");
 		return await new Promise((resolve, reject) => {
@@ -4239,15 +4240,158 @@ function gitCommands(env, limits, signal, budget) {
 				budget.remaining -= bytes;
 				if (signal.aborted) return reject(new ProcessingError("PROCESSING_CANCELED"));
 				if (budget.remaining < 0 || bytes > limits.maxCommandBytes || error?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || error?.killed) return reject(new ProcessingError("PROCESSING_LIMIT"));
-				if (error !== null && !(allowMissing && error.code === 1)) return reject(new ProcessingError("PROCESSING_FAILED"));
-				try {
-					resolve(new TextDecoder("utf-8", { fatal: true }).decode(stdout));
-				} catch {
-					reject(new ProcessingError("PROCESSING_FAILED"));
-				}
+				resolve({
+					error,
+					stdout,
+					stderr
+				});
 			});
 		});
 	};
+	const failed = (args, code) => new ProcessingError("PROCESSING_FAILED", gitExitSite(args[0], code));
+	const command = async (args, directory = tmpdir(), allowMissing = false) => {
+		const { error, stdout } = await run(args, directory);
+		if (error !== null && !(allowMissing && error.code === 1)) throw failed(args, error.code);
+		try {
+			return new TextDecoder("utf-8", { fatal: true }).decode(stdout);
+		} catch {
+			throw new ProcessingError("PROCESSING_FAILED");
+		}
+	};
+	/**
+	* True only when `cat-file -e` reports a well-formed object ID absent without any error
+	* (exit 1, empty stderr) with lazy fetching off, and the object store proves it absent.
+	* Git also answers exit 1 for an unreadable object directory, so an unproven absence
+	* fails closed instead of skipping the ref.
+	*/
+	const objectMissing = async (objectId, directory) => {
+		if (!objectIdPattern.test(objectId) || env["GIT_NO_LAZY_FETCH"] !== "1") throw new ProcessingError("PROCESSING_FAILED");
+		const args = [
+			"cat-file",
+			"-e",
+			"--end-of-options",
+			objectId
+		];
+		const { error, stderr } = await run(args, directory);
+		if (error === null) return false;
+		if (error.code !== 1 || stderr.byteLength !== 0) throw failed(args, error.code);
+		if (!await provablyAbsent(resolve(directory, (await command([
+			"rev-parse",
+			"--git-path",
+			"objects"
+		], directory)).trimEnd()), objectId)) throw failed(args, error.code);
+		return true;
+	};
+	return Object.assign(command, { objectMissing });
+}
+/**
+* The local object store cannot hold `objectId`: no alternates, its loose path is reached
+* and absent (ENOENT, so every directory on the way is searchable), and every pack file
+* is readable, so Git's own pack lookup was complete.
+*/
+async function provablyAbsent(objects, objectId) {
+	const absent = async (path) => {
+		try {
+			await lstat(path);
+			return false;
+		} catch (error) {
+			return errorCode(error) === "ENOENT";
+		}
+	};
+	if (!await absent(join(objects, "info", "alternates"))) return false;
+	if (!await absent(join(objects, objectId.slice(0, 2), objectId.slice(2)))) return false;
+	let packs;
+	try {
+		packs = await readdir(join(objects, "pack"));
+	} catch (error) {
+		return errorCode(error) === "ENOENT";
+	}
+	try {
+		for (const pack of packs) await access(join(objects, "pack", pack), constants$1.R_OK);
+	} catch {
+		return false;
+	}
+	return true;
+}
+/** A full SHA-1 or SHA-256 object ID as `for-each-ref` and `rev-parse` print it. */
+const objectIdPattern = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u;
+const gitSiteCommands = /* @__PURE__ */ new Set([
+	"show-ref",
+	"log",
+	"config",
+	"for-each-ref",
+	"rev-parse",
+	"cat-file"
+]);
+/** Only fixed, known command names and process exit statuses may reach safe diagnostics. */
+function gitExitSite(command, code) {
+	if (!gitSiteCommands.has(command ?? "") || typeof code !== "number" || !Number.isInteger(code) || code < 1 || code > 255) return {};
+	return { site: `git-${command}-exit-${code}` };
+}
+//#endregion
+//#region packages/harnesses/src/export/git/refs.ts
+/** `show-ref` or `log` exited 128, as a ref to a missing object makes them. */
+function missingObjectExit(error) {
+	return error instanceof ProcessingError && error.code === "PROCESSING_FAILED" && /^git-(?:show-ref|log)-exit-128$/u.test(error.site ?? "");
+}
+/**
+* `show-ref --head`, or, when it exits 128 or `enumerate` is set, every ref with a present
+* tip (ADR 2026-11-15-skip-missing-object-refs). A 128 exit that no missing tip explains
+* still fails closed.
+*/
+async function readRefs(command, directory, enumerate = false) {
+	if (enumerate) return await enumerateRefs(command, directory);
+	try {
+		return {
+			text: await command(["show-ref", "--head"], directory, true),
+			skipped: []
+		};
+	} catch (error) {
+		if (!missingObjectExit(error)) throw error;
+		const refs = await enumerateRefs(command, directory);
+		if (!refs.skipped.length) throw error;
+		return refs;
+	}
+}
+/** Every author reachable from the refs that were not skipped, HEAD included. */
+async function readAuthors(command, directory, refs) {
+	return await command([
+		"log",
+		...refs.skipped.map((name) => `--exclude=${name}`),
+		"--all",
+		"--no-mailmap",
+		"--no-show-signature",
+		"--format=%an",
+		"-z"
+	], directory);
+}
+/** `for-each-ref` lists a ref whose object is missing; `cat-file -e` decides each tip. */
+async function enumerateRefs(command, directory) {
+	const head = await command([
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		"HEAD"
+	], directory, true);
+	const listed = await command(["for-each-ref", "--format=%(objectname) %(refname)"], directory);
+	const lines = [...head ? [`${head.trimEnd()} HEAD`] : [], ...listed.split("\n")];
+	if (lines.pop() !== "") throw new ProcessingError("PROCESSING_FAILED");
+	const refs = lines.map((line) => {
+		const space = line.indexOf(" ");
+		const id = line.slice(0, space);
+		const name = line.slice(space + 1);
+		if (space < 0 || !objectIdPattern.test(id) || !name) throw new ProcessingError("PROCESSING_FAILED");
+		return {
+			id,
+			name
+		};
+	});
+	const missing = /* @__PURE__ */ new Map();
+	for (const { id } of refs) if (!missing.has(id)) missing.set(id, await command.objectMissing(id, directory));
+	return {
+		text: refs.filter(({ id }) => !missing.get(id)).map(({ id, name }) => `${id} ${name}\n`).join(""),
+		skipped: refs.filter(({ id }) => missing.get(id)).map(({ name }) => name)
+	};
 }
 //#endregion
 //#region packages/harnesses/src/git/config.ts
@@ -4363,14 +4507,14 @@ async function selectedRepositories(roots, limits, signal, budget) {
 }
 //#endregion
 //#region packages/harnesses/src/export/git/state.ts
-/** Pin local shallow boundaries as evidence limits without requiring unfetched history. */
-async function localHistoryState(repository, refs, budget, signal) {
+/** Pin refs, local shallow boundaries and the skipped-ref count without requiring unfetched history. */
+async function localHistoryState(repository, refs, budget, signal, skipped = 0) {
 	checkSeedAbort(signal);
 	const shared = await gitText(join(repository.gitDirectory, "commondir"), 16384, budget);
 	const common = shared === null ? repository.gitDirectory : resolve(repository.gitDirectory, shared.trim());
 	const shallow = await gitText(join(common, "shallow"), budget.remaining, budget);
 	checkSeedAbort(signal);
-	return createHash("sha256").update(`${Buffer.byteLength(refs)}:`).update(refs).update(shallow === null ? "absent" : `present:${shallow}`).digest("hex");
+	return createHash("sha256").update(`${Buffer.byteLength(refs)}:`).update(refs).update(shallow === null ? "absent" : `present:${shallow}`).update(skipped ? `skipped:${skipped}` : "").digest("hex");
 }
 //#endregion
 //#region packages/harnesses/src/export/git/index.ts
@@ -4411,19 +4555,24 @@ function createGitNameSeedProvider(options = {}) {
 				checkSeedAbort(signal);
 				const scoped = await readNameConfig(command, repository.directory, limits, budget, signal);
 				collect(scoped.names);
-				const before = await localHistoryState(repository, await command(["show-ref", "--head"], repository.directory, true), budget, signal);
-				const authors = await command([
-					"log",
-					"--all",
-					"--no-mailmap",
-					"--no-show-signature",
-					"--format=%an",
-					"-z"
-				], repository.directory);
-				if (before !== await localHistoryState(repository, await command(["show-ref", "--head"], repository.directory, true), budget, signal)) throw new ProcessingError("PROCESSING_FAILED");
+				let refs = await readRefs(command, repository.directory);
+				let authors;
+				try {
+					authors = await readAuthors(command, repository.directory, refs);
+				} catch (error) {
+					if (refs.skipped.length || !missingObjectExit(error)) throw error;
+					refs = await readRefs(command, repository.directory, true);
+					if (!refs.skipped.length) throw error;
+					authors = await readAuthors(command, repository.directory, refs);
+				}
+				const enumerate = refs.skipped.length > 0;
+				const before = await localHistoryState(repository, refs.text, budget, signal, refs.skipped.length);
+				const afterRefs = await readRefs(command, repository.directory, enumerate);
+				if (before !== await localHistoryState(repository, afterRefs.text, budget, signal, afterRefs.skipped.length)) throw new ProcessingError("PROCESSING_FAILED");
 				originals.set(repository.directory, {
 					history: before,
-					config: scoped.fingerprint
+					config: scoped.fingerprint,
+					enumerate
 				});
 				collect(authors.split("\0"));
 				snapshots.push(Object.freeze({
@@ -4436,9 +4585,10 @@ function createGitNameSeedProvider(options = {}) {
 				}));
 			}
 			for (const repository of repositories) {
-				const history = await localHistoryState(repository, await command(["show-ref", "--head"], repository.directory, true), budget, signal);
-				const scoped = await readNameConfig(command, repository.directory, limits, budget, signal);
 				const original = originals.get(repository.directory);
+				const refs = await readRefs(command, repository.directory, original?.enumerate);
+				const history = await localHistoryState(repository, refs.text, budget, signal, refs.skipped.length);
+				const scoped = await readNameConfig(command, repository.directory, limits, budget, signal);
 				if (original?.history !== history || original.config !== scoped.fingerprint) throw new ProcessingError("PROCESSING_FAILED");
 			}
 			if (config.fingerprint !== (await readNameConfig(command, void 0, limits, budget, signal, true)).fingerprint) throw new ProcessingError("PROCESSING_FAILED");
@@ -4682,7 +4832,7 @@ async function metadataStream(part, harness, options) {
 	});
 	const decoded = part.representation === "jsonl.zst" ? createZstdDecompress({
 		chunkSize: Math.min(discoveryBounds.chunkBytes, headLimit),
-		params: { [constants$1.ZSTD_d_windowLogMax]: previewLimits.zstdWindowLogMax }
+		params: { [constants$2.ZSTD_d_windowLogMax]: previewLimits.zstdWindowLogMax }
 	}) : new PassThrough({ highWaterMark: chunkBytes });
 	let streamError;
 	const cancellation = new AbortController();