forgemap 0.7.0-dev.117-ac8b2c6 → 0.7.0-dev.118-ba83f2c

package/dist/bin/forgemap.mjs

@@ -256,11 +256,15 @@ async function safeStat(path) {
 * marker and never descends into a repo, which keeps submodules and nested
 * checkouts out without a special case for either.
 *
-* `segments` is the namespace accumulated below the forge dir; the repo takes
-* the last one, so a repo needs at least two.
+* `segments` is the path accumulated below the forge dir; the repo takes the
+* last one and the namespace the rest, so a repo needs at least two.
+*
+* The cap counts those segments inclusive of the repo's own — a namespace at
+* exactly MAX_NAMESPACE_DEPTH must still have its repo visited, or the
+* resolver would accept a path the scanner can never find.
 */
 async function walk(ctx, dirPath, segments) {
-	if (segments.length >= 10) {
+	if (segments.length > 10) {
 		ctx.hints.push({
 			path: dirPath,
 			reason: "too-deep"
@@ -803,8 +807,11 @@ var gitlabAdapter = {
 	* GRAPHQL_CHUNK projects, and each miss — `null` could mean gone *or*
 	* renamed — costs a single REST call to tell the two apart.
 	*
-	* Every input in a batch belongs to one forge (the importer groups by
-	* server dir), so the host is taken from the first.
+	* A batch may span several configured GitLab forges, so the inputs are
+	* grouped by host before they are chunked: one server must never be asked
+	* about another's projects. Where the same full path exists on both — a
+	* public mirror of an internal project — the wrong server would otherwise
+	* answer `exists` for a project this one does not have.
 	*/
 	async checkRemotes(inputs) {
 		if (inputs.length === 0) return [];
@@ -812,10 +819,16 @@ var gitlabAdapter = {
 			state: "unknown",
 			reason: "glab not installed"
 		}));
-		const forge = inputs[0].forge;
 		const results = Array.from({ length: inputs.length }, () => null);
-		for (let start = 0; start < inputs.length; start += GRAPHQL_CHUNK) {
-			const chunk = inputs.slice(start, start + GRAPHQL_CHUNK);
+		const byHost = /* @__PURE__ */ new Map();
+		inputs.forEach((input, index) => {
+			const indices = byHost.get(input.forge.host);
+			if (indices) indices.push(index);
+			else byHost.set(input.forge.host, [index]);
+		});
+		for (const indices of byHost.values()) for (let start = 0; start < indices.length; start += GRAPHQL_CHUNK) {
+			const slice = indices.slice(start, start + GRAPHQL_CHUNK);
+			const chunk = slice.map((index) => inputs[index]);
 			const res = await execCapture("glab", [
 				"api",
 				"graphql",
@@ -823,7 +836,7 @@ var gitlabAdapter = {
 				`query=${buildQuery(chunk)}`
 			], {
 				timeoutMs: GLAB_TIMEOUT_MS,
-				env: glabEnv(forge)
+				env: glabEnv(chunk[0].forge)
 			});
 			let data = null;
 			try {
@@ -835,7 +848,7 @@ var gitlabAdapter = {
 			for (let i = 0; i < chunk.length; i++) {
 				const node = data?.[`r${i}`];
 				const canonical = node?.fullPath ? splitFullPath(node.fullPath) : null;
-				if (canonical) results[start + i] = {
+				if (canonical) results[slice[i]] = {
 					state: "exists",
 					canonical
 				};
@@ -1203,16 +1216,31 @@ function remoteBlocker(state) {
 	if (state === "exists" || state === "moved") return null;
 	return state === "gone" ? "remote no longer exists" : "remote unreachable";
 }
-/** Check each candidate's remote, grouped by forge so GitHub can batch. */
+/**
+* Check each candidate's remote, grouped by forge **type and host** so an
+* adapter can batch.
+*
+* The host is half the key, not a detail: two configured forges of one type —
+* gitlab.com beside a self-hosted instance — are two different servers, and a
+* batch spanning both would ask one of them about the other's projects. Where
+* the same path exists on each (a public mirror of an internal project), that
+* answers `exists` for the wrong server, and `remoteBlocker` reads `exists` as
+* "safe to delete".
+*/
 async function classifyRemotes(candidates) {
-	const byType = /* @__PURE__ */ new Map();
+	const groups = /* @__PURE__ */ new Map();
 	for (const c of candidates) {
-		const list = byType.get(c.repo.forge.type);
-		if (list) list.push(c);
-		else byType.set(c.repo.forge.type, [c]);
+		const { type, host } = c.repo.forge;
+		const key = `${type}\0${host}`;
+		const group = groups.get(key);
+		if (group) group.items.push(c);
+		else groups.set(key, {
+			type,
+			items: [c]
+		});
 	}
 	const results = /* @__PURE__ */ new Map();
-	await Promise.all(Array.from(byType, async ([type, items]) => {
+	await Promise.all(Array.from(groups.values(), async ({ type, items }) => {
 		const inputs = items.map((c) => ({
 			forge: c.repo.forge,
 			owner: c.owner,
@@ -2533,7 +2561,7 @@ async function readEntries(path) {
 * reason `import` looks at directories a scan would simply skip.
 */
 async function discoverBelow(serverDir, dirPath, segments, found) {
-	if (segments.length >= 10) return;
+	if (segments.length > 10) return;
 	const entries = await readEntries(dirPath);
 	const isLeaf = entries === null || entries.dirs.length === 0;
 	if (segments.length >= 2 && (entries?.isRepo || isLeaf)) {
@@ -3215,7 +3243,7 @@ var infoCommand = defineCommand({
 	async run({ args }) {
 		const binary = resolveBinary(process.argv[1]);
 		const info = {
-			version: "0.7.0-dev.117-ac8b2c6",
+			version: "0.7.0-dev.118-ba83f2c",
 			build: detectBuild(binary.resolved),
 			binary,
 			node: process.version,
@@ -4415,7 +4443,7 @@ var completionCommand = defineCommand({
 runMain(defineCommand({
 	meta: {
 		name: "forgemap",
-		version: "0.7.0-dev.117-ac8b2c6",
+		version: "0.7.0-dev.118-ba83f2c",
 		description: "Manage a local repo layout of the form <root>/<forge.dir>/<owner>/<repo>"
 	},
 	subCommands: {