forgemap 0.4.1-dev.79-818a2fa → 0.4.1-dev.80-662a8e8

package/dist/bin/forgemap.mjs

@@ -5,7 +5,7 @@ import { access, mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile }
 import { colors, formatTree } from "consola/utils";
 import { dirname, isAbsolute, join, resolve } from "pathe";
 import { homedir } from "node:os";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { loadConfig } from "c12";
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
@@ -93,7 +93,30 @@ var DEFAULT_CONFIG$1 = {
 async function loadForgeMapConfig(options = {}) {
 	const envConfig = process.env.FORGEMAP_CONFIG;
 	const startDir = options.cwd ?? process.cwd();
-	const explicit = options.configFile ?? envConfig ?? findConfigUp(startDir) ?? findGlobalConfig();
+	let explicit;
+	let source;
+	if (options.configFile) {
+		explicit = options.configFile;
+		source = "flag";
+	} else if (envConfig) {
+		explicit = envConfig;
+		source = "env";
+	} else {
+		const walkedUp = findConfigUp(startDir);
+		if (walkedUp) {
+			explicit = walkedUp;
+			source = "walk-up";
+		} else {
+			const global = findGlobalConfig();
+			if (global) {
+				explicit = global;
+				source = "global";
+			} else {
+				explicit = void 0;
+				source = "default";
+			}
+		}
+	}
 	const cwd = explicit ? dirname(explicit) : startDir;
 	const { config, configFile } = await loadConfig({
 		name: "forgemap",
@@ -103,14 +126,17 @@ async function loadForgeMapConfig(options = {}) {
 		globalRc: false,
 		dotenv: false
 	});
+	const merged = {
+		root: config.root ?? DEFAULT_CONFIG$1.root,
+		defaultForge: config.defaultForge ?? DEFAULT_CONFIG$1.defaultForge,
+		forges: config.forges && Object.keys(config.forges).length > 0 ? config.forges : DEFAULT_CONFIG$1.forges
+	};
+	const resolvedFile = source === "default" ? void 0 : configFile || void 0;
 	return {
-		config: {
-			root: config.root ?? DEFAULT_CONFIG$1.root,
-			defaultForge: config.defaultForge ?? DEFAULT_CONFIG$1.defaultForge,
-			forges: config.forges && Object.keys(config.forges).length > 0 ? config.forges : DEFAULT_CONFIG$1.forges
-		},
-		configFile: configFile || void 0,
-		cwd
+		config: merged,
+		configFile: resolvedFile,
+		cwd,
+		source: resolvedFile ? source : "default"
 	};
 }
 //#endregion
@@ -2243,6 +2269,170 @@ var importCommand = defineCommand({
 	}
 });
 //#endregion
+//#region src/commands/info.ts
+/** Resolve the real executed file behind any shim or symlink. */
+function resolveBinary(entry) {
+	if (!entry) return {
+		invoked: null,
+		resolved: null
+	};
+	try {
+		return {
+			invoked: entry,
+			resolved: realpathSync(entry)
+		};
+	} catch {
+		return {
+			invoked: entry,
+			resolved: entry
+		};
+	}
+}
+/** Walk up from `start` to the nearest package.json, returning its dir + name. */
+function findPackageRoot(start) {
+	let dir = resolve(start);
+	for (;;) {
+		const pkgPath = join(dir, "package.json");
+		if (existsSync(pkgPath)) try {
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+			return {
+				dir,
+				name: pkg.name
+			};
+		} catch {
+			return {
+				dir,
+				name: void 0
+			};
+		}
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/**
+* Distinguish a linked/dev build from an installed release: the resolved binary
+* lives inside a git work tree whose package.json is named `forgemap`. An
+* installed package has the same package.json but no `.git` beside it. When the
+* binary or a `forgemap` package.json cannot be located, report `unknown`
+* rather than guessing.
+*/
+function detectBuild(resolved) {
+	if (!resolved) return {
+		kind: "unknown",
+		packageRoot: null,
+		reason: "binary path could not be resolved"
+	};
+	const pkg = findPackageRoot(dirname(resolved));
+	if (!pkg) return {
+		kind: "unknown",
+		packageRoot: null,
+		reason: "no package.json found above the binary"
+	};
+	if (pkg.name !== "forgemap") return {
+		kind: "unknown",
+		packageRoot: pkg.dir,
+		reason: `nearest package.json is "${pkg.name ?? "unnamed"}", not forgemap`
+	};
+	const inGitTree = existsSync(join(pkg.dir, ".git"));
+	return {
+		kind: inGitTree ? "linked" : "release",
+		packageRoot: pkg.dir,
+		reason: inGitTree ? "runs from a git work tree named forgemap" : "installed forgemap package (no git work tree beside it)"
+	};
+}
+async function gatherConfig(configFile) {
+	try {
+		const loaded = await loadForgeMapConfig({ configFile });
+		const configDir = loaded.configFile ? dirname(loaded.configFile) : loaded.cwd;
+		return {
+			source: loaded.source,
+			file: loaded.configFile ?? null,
+			root: resolveRoot(loaded.config.root, configDir),
+			forges: Object.entries(loaded.config.forges).map(([name, forge]) => ({
+				name,
+				type: forge.type,
+				dir: forge.dir
+			})),
+			error: null
+		};
+	} catch (error) {
+		return {
+			source: "error",
+			file: null,
+			root: null,
+			forges: [],
+			error: error.message
+		};
+	}
+}
+var SOURCE_LABELS = {
+	flag: "--config flag",
+	env: "FORGEMAP_CONFIG env",
+	"walk-up": "walk-up from cwd",
+	global: "global ($XDG_CONFIG_HOME/forgemap)",
+	default: "built-in defaults (no config file found)",
+	error: "failed to load"
+};
+var BUILD_LABELS = {
+	linked: "linked / dev build",
+	release: "installed release",
+	unknown: "unknown"
+};
+function row(label, value) {
+	return `  ${colors.dim(label.padEnd(9))} ${value}\n`;
+}
+function renderPretty(info) {
+	let out = `${colors.bold("forgemap")} ${colors.cyan(`v${info.version}`)} ${colors.dim(`(${BUILD_LABELS[info.build.kind]})`)}\n`;
+	out += row("build", colors.dim(info.build.reason));
+	out += row("binary", info.binary.resolved ?? colors.dim("unknown"));
+	if (info.binary.invoked && info.binary.invoked !== info.binary.resolved) out += row("", colors.dim(`via ${info.binary.invoked}`));
+	out += row("node", info.node);
+	out += `\n${colors.bold("config")}\n`;
+	out += row("source", SOURCE_LABELS[info.config.source]);
+	if (info.config.error) out += row("error", colors.red(info.config.error));
+	else {
+		out += row("file", info.config.file ?? colors.dim("none"));
+		out += row("root", info.config.root ?? colors.dim("unknown"));
+	}
+	out += `\n${colors.bold("forges")}\n`;
+	if (info.config.forges.length === 0) out += `  ${colors.dim("none")}\n`;
+	else for (const forge of info.config.forges) out += `  ${colors.cyan(forge.name.padEnd(12))} ${forge.type} ${colors.dim("→")} ${forge.dir}\n`;
+	return out;
+}
+var infoCommand = defineCommand({
+	meta: {
+		name: "info",
+		description: "Describe this installation: version, binary path, node, and resolved config"
+	},
+	args: {
+		json: {
+			type: "boolean",
+			description: "Emit a machine-readable JSON report",
+			default: false
+		},
+		config: {
+			type: "string",
+			description: "Path to forgemap.config.ts (overrides walk-up discovery)"
+		}
+	},
+	async run({ args }) {
+		const binary = resolveBinary(process.argv[1]);
+		const info = {
+			version: "0.4.1-dev.80-662a8e8",
+			build: detectBuild(binary.resolved),
+			binary,
+			node: process.version,
+			config: await gatherConfig(args.config)
+		};
+		if (args.json) {
+			process.stdout.write(`${JSON.stringify(info, null, 2)}\n`);
+			return;
+		}
+		process.stdout.write(renderPretty(info));
+	}
+});
+//#endregion
 //#region src/repos/match.ts
 /**
 * The one Fuse configuration every fuzzy lookup shares — `search`, `pick`
@@ -3141,6 +3331,7 @@ function severitySymbol(severity) {
 runMain(defineCommand({
 	meta: {
 		name: "forgemap",
+		version: "0.4.1-dev.80-662a8e8",
 		description: "Manage a local repo layout of the form <root>/<forge.dir>/<owner>/<repo>"
 	},
 	subCommands: {
@@ -3191,6 +3382,7 @@ runMain(defineCommand({
 				if (!loaded.configFile) consola.warn("No forgemap.config.ts found — using built-in defaults. Run `forgemap config init` to materialize one.");
 			}
 		}),
+		info: infoCommand,
 		completion: completionCommand,
 		"shell-init": shellInitCommand,
 		config: configCommand