pi-one-ui 0.1.1

package/extensions/shell/runtime.ts

@@ -0,0 +1,915 @@
+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" };
+  }
+}