@selesai/code 0.9.14 → 0.10.0

package/dist/extensions/pi-zentui/extensions/zentui/runtime.ts

@@ -0,0 +1,841 @@
+import { execFile } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const VERSION_TIMEOUT_MS = 2500;
+
+export type RuntimeMetadata = {
+	name: string;
+	symbol: string;
+	style: string;
+};
+
+export type RuntimeInfo = Pick<RuntimeMetadata, "name" | "symbol" | "style"> & {
+	version?: string;
+};
+
+export type RuntimeReadResult = { kind: "ok"; runtime?: RuntimeInfo } | { kind: "error" };
+
+type RuntimeCacheEntry = {
+	fingerprint: string;
+	runtime: RuntimeInfo | undefined;
+};
+
+const RUNTIME_CACHE_MAX = 32;
+const runtimeInfoCache = new Map<string, RuntimeCacheEntry>();
+
+export function clearRuntimeInfoCache(): void {
+	runtimeInfoCache.clear();
+}
+
+function topLevelFingerprint(entries: readonly string[]): string {
+	return entries.slice().sort().join("\0");
+}
+
+function cacheRuntimeInfo(
+	cwd: string,
+	fingerprint: string,
+	runtime: RuntimeInfo | undefined,
+): void {
+	// Drop prior fingerprints for the same cwd so stale marker sets do not linger.
+	for (const key of runtimeInfoCache.keys()) {
+		if (key === cwd || key.startsWith(`${cwd}\0`)) runtimeInfoCache.delete(key);
+	}
+	const key = `${cwd}\0${fingerprint}`;
+	runtimeInfoCache.set(key, { fingerprint, runtime });
+	while (runtimeInfoCache.size > RUNTIME_CACHE_MAX) {
+		const oldest = runtimeInfoCache.keys().next().value;
+		if (oldest === undefined) break;
+		runtimeInfoCache.delete(oldest);
+	}
+}
+
+type RuntimeEnvironment = Record<string, string | undefined>;
+
+type DetectionSpec = {
+	extensions?: readonly string[];
+	files?: readonly string[];
+	folders?: readonly string[];
+	env?: (env: RuntimeEnvironment) => boolean;
+	excludedFiles?: readonly string[];
+};
+
+type VersionCommand = {
+	command: string;
+	args?: readonly string[];
+	pattern?: RegExp;
+};
+
+type RuntimeDef = RuntimeMetadata & {
+	priority: number;
+	detect: DetectionSpec;
+	version: (cwd: string) => Promise<string | undefined>;
+};
+
+// --- Detection utilities ---
+
+function hasAnyFile(cwd: string, names: readonly string[]): boolean {
+	return names.some((name) => existsSync(join(cwd, name)));
+}
+
+function hasAnyFolder(cwd: string, names: readonly string[]): boolean {
+	return names.some((name) => {
+		try {
+			return statSync(join(cwd, name)).isDirectory();
+		} catch {
+			return false;
+		}
+	});
+}
+
+function entryExtensions(entry: string): string[] {
+	const baseName = entry.split(/[\\/]/).pop() ?? entry;
+	if (!baseName || baseName.startsWith(".")) return [];
+
+	const firstDot = baseName.indexOf(".");
+	if (firstDot === -1) return [];
+
+	const extensions = [baseName.slice(firstDot + 1)];
+	const lastDot = baseName.lastIndexOf(".");
+	if (lastDot !== firstDot) extensions.push(baseName.slice(lastDot + 1));
+	return extensions;
+}
+
+function hasAnyExtension(entries: readonly string[], extensions: readonly string[]): boolean {
+	const extensionSet = new Set(extensions);
+	return entries.some((entry) =>
+		entryExtensions(entry).some((extension) => extensionSet.has(extension)),
+	);
+}
+
+function matchesDetection(
+	cwd: string,
+	entries: string[],
+	spec: DetectionSpec,
+	env: RuntimeEnvironment,
+): boolean {
+	if (spec.excludedFiles && hasAnyFile(cwd, spec.excludedFiles)) return false;
+	return Boolean(
+		(spec.files && hasAnyFile(cwd, spec.files)) ||
+			(spec.folders && hasAnyFolder(cwd, spec.folders)) ||
+			(spec.extensions && hasAnyExtension(entries, spec.extensions)) ||
+			spec.env?.(env),
+	);
+}
+
+// --- Version utilities ---
+
+async function runVersion(
+	command: string,
+	args: readonly string[] = [],
+	cwd?: string,
+): Promise<string | undefined> {
+	try {
+		const { stdout, stderr } = await execFileAsync(command, [...args], {
+			cwd,
+			timeout: VERSION_TIMEOUT_MS,
+		});
+		const text =
+			`${typeof stdout === "string" ? stdout : String(stdout)}\n${typeof stderr === "string" ? stderr : String(stderr)}`.trim();
+		return text || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function prefixVersion(version: string | undefined): string | undefined {
+	if (!version) return undefined;
+	return version.startsWith("v") ? version : `v${version}`;
+}
+
+function extractVersion(output: string | undefined, pattern?: RegExp): string | undefined {
+	if (!output) return undefined;
+	const match = output.match(
+		pattern ?? /(?:version\s*)?v?([0-9]+(?:\.[0-9A-Za-z][0-9A-Za-z.+_-]*)*)/i,
+	);
+	return prefixVersion(match?.[1]);
+}
+
+function versionFromCommands(
+	commands: readonly VersionCommand[],
+): () => Promise<string | undefined> {
+	return async () => {
+		for (const { command, args = [], pattern } of commands) {
+			const version = extractVersion(await runVersion(command, args), pattern);
+			if (version) return version;
+		}
+		return undefined;
+	};
+}
+
+function noVersion(): Promise<undefined> {
+	return Promise.resolve(undefined);
+}
+
+// --- Priority levels ---
+// 10 = build-system runtimes (checked first to avoid language false-positives)
+// 50 = common runtimes (bun, deno, node, python, etc.)
+// 100 = default (everything else, checked in definition order)
+
+const PRIORITY_BUILD_SYSTEM = 10;
+const PRIORITY_COMMON = 50;
+const PRIORITY_DEFAULT = 100;
+
+// --- Runtime definitions ---
+
+const runtimes: RuntimeDef[] = [
+	{
+		name: "xmake",
+		symbol: "",
+		style: "bold green",
+		priority: PRIORITY_BUILD_SYSTEM,
+		detect: { files: ["xmake.lua"] },
+		version: versionFromCommands([{ command: "xmake", args: ["--version"] }]),
+	},
+	{
+		name: "maven",
+		symbol: "",
+		style: "bold bright-cyan",
+		priority: PRIORITY_BUILD_SYSTEM,
+		detect: { files: ["pom.xml"] },
+		version: versionFromCommands([
+			{ command: "mvn", args: ["--version"], pattern: /Apache Maven\s+([0-9][^\s]*)/i },
+		]),
+	},
+	{
+		name: "gradle",
+		symbol: "",
+		style: "bold bright-cyan",
+		priority: PRIORITY_BUILD_SYSTEM,
+		detect: { files: ["build.gradle", "build.gradle.kts"], folders: ["gradle"] },
+		version: versionFromCommands([
+			{ command: "gradle", args: ["--version"], pattern: /Gradle\s+([0-9][^\s]*)/i },
+		]),
+	},
+	{
+		name: "bun",
+		symbol: "",
+		style: "bold red",
+		priority: PRIORITY_COMMON,
+		detect: { files: ["bun.lock", "bun.lockb"] },
+		version: async () => prefixVersion(await runVersion("bun", ["--version"])),
+	},
+	{
+		name: "deno",
+		symbol: "",
+		style: "green bold",
+		priority: PRIORITY_COMMON,
+		detect: { files: ["deno.json", "deno.jsonc", "deno.lock"] },
+		version: async () =>
+			extractVersion(await runVersion("deno", ["--version"]), /deno\s+([0-9][^\s]*)/i),
+	},
+	{
+		name: "lua",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_COMMON,
+		detect: {
+			extensions: ["lua"],
+			files: [
+				"stylua.toml",
+				".stylua.toml",
+				".luarc.json",
+				".luarc.jsonc",
+				"init.lua",
+				".lua-version",
+			],
+			folders: ["lua"],
+			excludedFiles: ["xmake.lua"],
+		},
+		version: async () => {
+			const lua = await runVersion("lua", ["-v"]);
+			const luaMatch = lua?.match(/Lua\s+([0-9][^\s]*)/i);
+			if (luaMatch?.[1]) return prefixVersion(luaMatch[1]);
+			const luajit = await runVersion("luajit", ["-v"]);
+			const luajitMatch = luajit?.match(/LuaJIT\s+([0-9][^\s]*)/i);
+			return prefixVersion(luajitMatch?.[1]);
+		},
+	},
+	{
+		name: "nodejs",
+		symbol: "",
+		style: "bold green",
+		priority: PRIORITY_COMMON,
+		detect: {
+			files: ["package.json", ".node-version", ".nvmrc"],
+			excludedFiles: ["bunfig.toml", "bun.lock", "bun.lockb"],
+		},
+		version: async () => prefixVersion(await runVersion("node", ["--version"])),
+	},
+	{
+		name: "python",
+		symbol: "",
+		style: "yellow bold",
+		priority: PRIORITY_COMMON,
+		detect: {
+			files: [
+				"requirements.txt",
+				".python-version",
+				"pyproject.toml",
+				"Pipfile",
+				"setup.py",
+				"setup.cfg",
+			],
+		},
+		version: async () => {
+			const python3 = await runVersion("python3", ["--version"]);
+			const python3Match = python3?.match(/Python\s+([0-9][^\s]*)/i);
+			if (python3Match?.[1]) return prefixVersion(python3Match[1]);
+			const python = await runVersion("python", ["--version"]);
+			const pythonMatch = python?.match(/Python\s+([0-9][^\s]*)/i);
+			return prefixVersion(pythonMatch?.[1]);
+		},
+	},
+	{
+		name: "golang",
+		symbol: "",
+		style: "bold cyan",
+		priority: PRIORITY_COMMON,
+		detect: { files: ["go.mod"] },
+		version: async () =>
+			extractVersion(await runVersion("go", ["version"]), /go version go([0-9][^\s]*)/i),
+	},
+	{
+		name: "rust",
+		symbol: "󱘗",
+		style: "bold red",
+		priority: PRIORITY_COMMON,
+		detect: { files: ["Cargo.toml"] },
+		version: async () =>
+			extractVersion(await runVersion("rustc", ["--version"]), /rustc\s+([0-9][^\s]*)/i),
+	},
+	{
+		name: "java",
+		symbol: "",
+		style: "red dimmed",
+		priority: PRIORITY_COMMON,
+		detect: { files: [".java-version"] },
+		version: async () => {
+			const output = await runVersion("java", ["-version"]);
+			const quoted = output?.match(/"([0-9][^"]*)"/);
+			if (quoted?.[1]) return prefixVersion(quoted[1]);
+			const plain = output?.match(/version\s+([0-9][^\s]*)/i);
+			return prefixVersion(plain?.[1]);
+		},
+	},
+	{
+		name: "ruby",
+		symbol: "",
+		style: "bold red",
+		priority: PRIORITY_COMMON,
+		detect: { files: ["Gemfile", ".ruby-version"] },
+		version: async () =>
+			extractVersion(await runVersion("ruby", ["--version"]), /ruby\s+([0-9][^\s]*)/i),
+	},
+	{
+		name: "php",
+		symbol: "",
+		style: "147 bold",
+		priority: PRIORITY_COMMON,
+		detect: { files: ["composer.json"] },
+		version: async () =>
+			extractVersion(await runVersion("php", ["--version"]), /PHP\s+([0-9][^\s]*)/i),
+	},
+	{
+		name: "buf",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { files: ["buf.yaml", "buf.gen.yaml", "buf.work.yaml"] },
+		version: versionFromCommands([{ command: "buf", args: ["--version"] }]),
+	},
+	{
+		name: "cmake",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { files: ["CMakeLists.txt", "CMakeCache.txt"] },
+		version: versionFromCommands([{ command: "cmake", args: ["--version"] }]),
+	},
+	{
+		name: "cpp",
+		symbol: "",
+		style: "bold 149",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["cpp", "cc", "cxx", "c++", "hpp", "hh", "hxx", "h++", "tcc"] },
+		version: versionFromCommands([
+			{ command: "c++", args: ["--version"] },
+			{ command: "g++", args: ["--version"] },
+			{ command: "clang++", args: ["--version"] },
+		]),
+	},
+	{
+		name: "c",
+		symbol: "",
+		style: "bold 149",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["c", "h"] },
+		version: versionFromCommands([
+			{ command: "cc", args: ["--version"] },
+			{ command: "gcc", args: ["--version"] },
+			{ command: "clang", args: ["--version"] },
+		]),
+	},
+	{
+		name: "cobol",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["cbl", "cob", "CBL", "COB"] },
+		version: versionFromCommands([{ command: "cobc", args: ["--version"] }]),
+	},
+	{
+		name: "conda",
+		symbol: "",
+		style: "bold green",
+		priority: PRIORITY_DEFAULT,
+		detect: { env: (env) => Boolean(env.CONDA_DEFAULT_ENV?.trim()) && !env.PIXI_ENVIRONMENT_NAME },
+		version: noVersion,
+	},
+	{
+		name: "crystal",
+		symbol: "",
+		style: "bold red",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["cr"], files: ["shard.yml"] },
+		version: versionFromCommands([{ command: "crystal", args: ["--version"] }]),
+	},
+	{
+		name: "dart",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: ["dart"],
+			files: ["pubspec.yaml", "pubspec.yml", "pubspec.lock"],
+			folders: [".dart_tool"],
+		},
+		version: versionFromCommands([{ command: "dart", args: ["--version"] }]),
+	},
+	{
+		name: "dotnet",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: ["csproj", "fsproj", "xproj"],
+			files: [
+				"global.json",
+				"project.json",
+				"Directory.Build.props",
+				"Directory.Build.targets",
+				"Packages.props",
+			],
+		},
+		version: versionFromCommands([{ command: "dotnet", args: ["--version"] }]),
+	},
+	{
+		name: "elixir",
+		symbol: "",
+		style: "bold purple",
+		priority: PRIORITY_DEFAULT,
+		detect: { files: ["mix.exs"] },
+		version: versionFromCommands([
+			{ command: "elixir", args: ["--version"], pattern: /Elixir\s+([0-9][^\s]*)/i },
+		]),
+	},
+	{
+		name: "elm",
+		symbol: "",
+		style: "cyan bold",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: ["elm"],
+			files: ["elm.json", "elm-package.json", ".elm-version"],
+			folders: ["elm-stuff"],
+		},
+		version: versionFromCommands([{ command: "elm", args: ["--version"] }]),
+	},
+	{
+		name: "erlang",
+		symbol: "",
+		style: "bold red",
+		priority: PRIORITY_DEFAULT,
+		detect: { files: ["rebar.config", "erlang.mk"] },
+		version: versionFromCommands([{ command: "erl", args: ["-version"] }]),
+	},
+	{
+		name: "fennel",
+		symbol: "",
+		style: "bold green",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["fnl"] },
+		version: versionFromCommands([{ command: "fennel", args: ["--version"] }]),
+	},
+	{
+		name: "fortran",
+		symbol: "",
+		style: "bold purple",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: [
+				"f",
+				"F",
+				"for",
+				"FOR",
+				"ftn",
+				"FTN",
+				"f77",
+				"F77",
+				"f90",
+				"F90",
+				"f95",
+				"F95",
+				"f03",
+				"F03",
+				"f08",
+				"F08",
+				"f18",
+				"F18",
+			],
+			files: ["fpm.toml"],
+		},
+		version: versionFromCommands([
+			{ command: "gfortran", args: ["--version"] },
+			{ command: "flang", args: ["--version"] },
+			{ command: "flang-new", args: ["--version"] },
+		]),
+	},
+	{
+		name: "gleam",
+		symbol: "",
+		style: "bold #FFAFF3",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["gleam"], files: ["gleam.toml"] },
+		version: versionFromCommands([{ command: "gleam", args: ["--version"] }]),
+	},
+	{
+		name: "guix_shell",
+		symbol: "",
+		style: "yellow bold",
+		priority: PRIORITY_DEFAULT,
+		detect: { env: (env) => Boolean(env.GUIX_ENVIRONMENT?.trim()) },
+		version: noVersion,
+	},
+	{
+		name: "haskell",
+		symbol: "",
+		style: "bold purple",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["hs", "cabal", "hs-boot"], files: ["stack.yaml", "cabal.project"] },
+		version: versionFromCommands([{ command: "ghc", args: ["--numeric-version"] }]),
+	},
+	{
+		name: "haxe",
+		symbol: "",
+		style: "bold fg:202",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: ["hx", "hxml"],
+			files: ["haxelib.json", "hxformat.json", ".haxerc"],
+			folders: [".haxelib", "haxe_libraries"],
+		},
+		version: versionFromCommands([{ command: "haxe", args: ["--version"] }]),
+	},
+	{
+		name: "helm",
+		symbol: "",
+		style: "bold white",
+		priority: PRIORITY_DEFAULT,
+		detect: { files: ["helmfile.yaml", "Chart.yaml"] },
+		version: versionFromCommands([{ command: "helm", args: ["version", "--short"] }]),
+	},
+	{
+		name: "julia",
+		symbol: "",
+		style: "bold purple",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["jl"], files: ["Project.toml", "Manifest.toml"] },
+		version: versionFromCommands([{ command: "julia", args: ["--version"] }]),
+	},
+	{
+		name: "kotlin",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["kt", "kts"] },
+		version: versionFromCommands([{ command: "kotlin", args: ["-version"] }]),
+	},
+	{
+		name: "meson",
+		symbol: "󰔷",
+		style: "blue bold",
+		priority: PRIORITY_DEFAULT,
+		detect: { env: (env) => env.MESON_DEVENV === "1" && Boolean(env.MESON_PROJECT_NAME?.trim()) },
+		version: noVersion,
+	},
+	{
+		name: "mojo",
+		symbol: "󰈸",
+		style: "bold 208",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["mojo", "🔥"] },
+		version: versionFromCommands([{ command: "mojo", args: ["--version"] }]),
+	},
+	{
+		name: "nim",
+		symbol: "",
+		style: "bold yellow",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["nim", "nims", "nimble"], files: ["nim.cfg"] },
+		version: versionFromCommands([{ command: "nim", args: ["--version"] }]),
+	},
+	{
+		name: "nix_shell",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { env: (env) => env.IN_NIX_SHELL === "pure" || env.IN_NIX_SHELL === "impure" },
+		version: noVersion,
+	},
+	{
+		name: "ocaml",
+		symbol: "",
+		style: "bold yellow",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: ["opam", "ml", "mli", "re", "rei"],
+			files: ["dune", "dune-project", "jbuild", "jbuild-ignore", ".merlin"],
+			folders: ["_opam", "esy.lock"],
+		},
+		version: versionFromCommands([{ command: "ocaml", args: ["-version"] }]),
+	},
+	{
+		name: "odin",
+		symbol: "󰟢",
+		style: "bold bright-blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["odin"] },
+		version: versionFromCommands([{ command: "odin", args: ["version"] }]),
+	},
+	{
+		name: "opa",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["rego"] },
+		version: versionFromCommands([{ command: "opa", args: ["version"] }]),
+	},
+	{
+		name: "perl",
+		symbol: "",
+		style: "bold 149",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: ["pl", "pm", "pod"],
+			files: [
+				"Makefile.PL",
+				"Build.PL",
+				"cpanfile",
+				"cpanfile.snapshot",
+				"META.json",
+				"META.yml",
+				".perl-version",
+			],
+		},
+		version: versionFromCommands([{ command: "perl", args: ["--version"] }]),
+	},
+	{
+		name: "pixi",
+		symbol: "󰏗",
+		style: "yellow bold",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			files: ["pixi.toml", "pixi.lock"],
+			env: (env) => Boolean(env.PIXI_ENVIRONMENT_NAME?.trim()),
+		},
+		version: versionFromCommands([{ command: "pixi", args: ["--version"] }]),
+	},
+	{
+		name: "pulumi",
+		symbol: "",
+		style: "bold 5",
+		priority: PRIORITY_DEFAULT,
+		detect: { files: ["Pulumi.yaml", "Pulumi.yml"] },
+		version: versionFromCommands([{ command: "pulumi", args: ["version"] }]),
+	},
+	{
+		name: "purescript",
+		symbol: "",
+		style: "bold white",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["purs"], files: ["spago.dhall", "spago.yaml", "spago.lock"] },
+		version: versionFromCommands([{ command: "purs", args: ["--version"] }]),
+	},
+	{
+		name: "raku",
+		symbol: "󱖊",
+		style: "bold 149",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["p6", "pm6", "pod6", "raku", "rakumod"], files: ["META6.json"] },
+		version: versionFromCommands([{ command: "raku", args: ["--version"] }]),
+	},
+	{
+		name: "red",
+		symbol: "󱍼",
+		style: "red bold",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["red", "reds"] },
+		version: versionFromCommands([{ command: "red", args: ["--version"] }]),
+	},
+	{
+		name: "rlang",
+		symbol: "󰟔",
+		style: "blue bold",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: ["R", "Rd", "Rmd", "Rproj", "Rsx"],
+			files: ["DESCRIPTION"],
+			folders: [".Rproj.user"],
+		},
+		version: versionFromCommands([{ command: "R", args: ["--version"] }]),
+	},
+	{
+		name: "scala",
+		symbol: "",
+		style: "red dimmed",
+		priority: PRIORITY_DEFAULT,
+		detect: {
+			extensions: ["sbt", "scala"],
+			files: [".scalaenv", ".sbtenv", "build.sbt"],
+			folders: [".metals"],
+		},
+		version: versionFromCommands([{ command: "scala", args: ["-version"] }]),
+	},
+	{
+		name: "solidity",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["sol"] },
+		version: versionFromCommands([{ command: "solc", args: ["--version"] }]),
+	},
+	{
+		name: "spack",
+		symbol: "",
+		style: "bold blue",
+		priority: PRIORITY_DEFAULT,
+		detect: { env: (env) => Boolean(env.SPACK_ENV?.trim()) },
+		version: noVersion,
+	},
+	{
+		name: "swift",
+		symbol: "",
+		style: "bold 202",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["swift"], files: ["Package.swift"] },
+		version: versionFromCommands([
+			{ command: "swift", args: ["--version"], pattern: /Swift version\s+([0-9][^\s]*)/i },
+		]),
+	},
+	{
+		name: "terraform",
+		symbol: "",
+		style: "bold 105",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["tf", "tfplan", "tfstate"], folders: [".terraform"] },
+		version: versionFromCommands([
+			{ command: "terraform", args: ["version"] },
+			{ command: "tofu", args: ["version"] },
+		]),
+	},
+	{
+		name: "typst",
+		symbol: "",
+		style: "bold #0093A7",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["typ"], files: ["template.typ"] },
+		version: versionFromCommands([{ command: "typst", args: ["--version"] }]),
+	},
+	{
+		name: "vagrant",
+		symbol: "",
+		style: "cyan bold",
+		priority: PRIORITY_DEFAULT,
+		detect: { files: ["Vagrantfile"] },
+		version: versionFromCommands([{ command: "vagrant", args: ["--version"] }]),
+	},
+	{
+		name: "vlang",
+		symbol: "",
+		style: "blue bold",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["v"], files: ["v.mod", "vpkg.json", ".vpkg-lock.json"] },
+		version: versionFromCommands([{ command: "v", args: ["version"] }]),
+	},
+	{
+		name: "zig",
+		symbol: "",
+		style: "bold yellow",
+		priority: PRIORITY_DEFAULT,
+		detect: { extensions: ["zig"], files: ["build.zig"] },
+		version: versionFromCommands([{ command: "zig", args: ["version"] }]),
+	},
+];
+
+// Sort once at module load — stable sort preserves definition order within same priority
+const sortedRuntimes = [...runtimes].sort((a, b) => a.priority - b.priority);
+
+export const runtimeMetadata: RuntimeMetadata[] = runtimes.map(({ name, symbol, style }) => ({
+	name,
+	symbol,
+	style,
+}));
+
+export function detectRuntime(
+	cwd: string,
+	entries: string[],
+	env: RuntimeEnvironment = process.env,
+): RuntimeDef | undefined {
+	for (const runtime of sortedRuntimes) {
+		if (matchesDetection(cwd, entries, runtime.detect, env)) return runtime;
+	}
+	return undefined;
+}
+
+export async function readRuntimeInfo(cwd: string): Promise<RuntimeReadResult> {
+	let entries: string[];
+	try {
+		entries = readdirSync(cwd);
+	} catch {
+		// readdir failure is treated as a transient error so last-good can be kept.
+		return { kind: "error" };
+	}
+
+	const fingerprint = topLevelFingerprint(entries);
+	const cacheKey = `${cwd}\0${fingerprint}`;
+	const cached = runtimeInfoCache.get(cacheKey);
+	if (cached && cached.fingerprint === fingerprint) {
+		return { kind: "ok", runtime: cached.runtime };
+	}
+
+	try {
+		const runtime = detectRuntime(cwd, entries);
+		if (!runtime) {
+			cacheRuntimeInfo(cwd, fingerprint, undefined);
+			return { kind: "ok", runtime: undefined };
+		}
+		const info: RuntimeInfo = {
+			name: runtime.name,
+			symbol: runtime.symbol,
+			style: runtime.style,
+			version: await runtime.version(cwd),
+		};
+		cacheRuntimeInfo(cwd, fingerprint, info);
+		return { kind: "ok", runtime: info };
+	} catch {
+		return { kind: "error" };
+	}
+}