novahiz 0.1.0

package/install/install.mjs

@@ -0,0 +1,466 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  copyFileWithBackup,
+  copyInto,
+  loadManifest,
+  mergeBackups,
+  mergeCreated,
+  nodeVersionOk,
+  novahizHome,
+  opencodeConfigDir,
+  parseArgs,
+  readJson,
+  repoRoot,
+  saveManifest,
+  skillNamesIn,
+  writeJson
+} from "./lib.mjs";
+import { createPrompt } from "./prompt.mjs";
+
+const CORE_ITEMS = [
+  "src",
+  "catalog",
+  "bin",
+  "install",
+  "mcp",
+  "adapters",
+  "skills",
+  "bundled-skills",
+  "docs",
+  "package.json",
+  "tsconfig.json",
+  "LICENSE",
+  "README.md",
+  "NOTICE.md",
+  "novahiz.config.example.json"
+];
+
+function defaultConfig(skillsDir) {
+  return {
+    dbPath: "novahiz.sqlite",
+    skillRoots: ["./skills", "./bundled-skills"],
+    gate: {
+      enabled: true,
+      mode: "block",
+      envEscape: "NOVAHIZ_GATE",
+      tools: ["edit", "write", "patch", "apply_patch", "bash", "shell"]
+    },
+    classify: {
+      minScore: 1,
+      maxCategories: 3,
+      fallbackCategory: "general"
+    },
+    providers: {
+      autoRegister: true,
+      autoInstall: false,
+      disabled: []
+    }
+  };
+}
+
+async function main() {
+  const flags = parseArgs(process.argv.slice(2));
+  const dryRun = Boolean(flags["dry-run"]);
+  const force = Boolean(flags.force);
+  const withSkills = !flags["no-skills"];
+  const root = repoRoot(import.meta.url);
+  const home = novahizHome(flags);
+  const configDir = flags.scope === "project" ? resolve(".opencode") : opencodeConfigDir();
+  const skillsDir = join(configDir, "skills");
+  const pluginsDir = join(configDir, "plugins");
+
+  const note = (message) => process.stdout.write(`${dryRun ? "[dry-run] " : ""}${message}\n`);
+
+  note(`Novahiz home: ${home}`);
+  note(`opencode config: ${configDir}`);
+
+  if (!nodeVersionOk()) {
+    process.stderr.write(`Node ${process.versions.node} is too old. Node 22.18 or later is required.\n`);
+    process.exit(1);
+  }
+
+  const yes = Boolean(flags.yes) || Boolean(flags["yes"]);
+  const interactive = !yes && !dryRun && (Boolean(flags.interactive) || process.stdin.isTTY === true);
+  let providersChoice = null;
+
+  if (interactive) {
+    const prompt = createPrompt();
+    const providers = readJson(join(root, "catalog", "providers.json"), []);
+    process.stdout.write("\nNovahiz setup\n");
+    process.stdout.write(`  Home:            ${home}\n`);
+    process.stdout.write(`  opencode config: ${configDir}\n`);
+    process.stdout.write(`  Skills:          ${skillsDir}\n`);
+    process.stdout.write(`  Plugin:          ${join(pluginsDir, "novahiz.ts")}\n`);
+    process.stdout.write(`  Agent:           ${join(configDir, "agent", "novahiz-agent.md")}\n`);
+    process.stdout.write("\nProviders (optional, installed on your machine, never copied into the repo):\n");
+    for (const provider of providers) {
+      const source = provider.source ? ` ${provider.source}` : "";
+      process.stdout.write(`  [${provider.kind}] ${provider.id} - ${provider.purpose ?? ""}${source}\n`);
+    }
+    process.stdout.write("\n");
+    const proceed = await prompt.confirm("Install the Novahiz core (skills, plugin, agent)?", true);
+    if (!proceed) {
+      prompt.close();
+      process.stdout.write("Aborted. Nothing was written.\n");
+      return;
+    }
+    providersChoice = await prompt.confirm("Install provider packages and their prerequisites now?", false);
+    prompt.close();
+  }
+
+  const created = [];
+  const backups = [];
+  let coreCopied = false;
+  let configCreated = false;
+
+  const sameRoot = resolve(root) === resolve(home);
+  if (!sameRoot) {
+    note(`Copie du core vers ${home}`);
+    if (!dryRun) mkdirSync(home, { recursive: true });
+    for (const item of CORE_ITEMS) {
+      const source = join(root, item);
+      if (!existsSync(source)) continue;
+      if (dryRun) {
+        note(`  + ${item}`);
+        continue;
+      }
+      const target = join(home, item);
+      if (statSync(source).isDirectory()) {
+        const result = copyInto(source, target, true);
+        created.push(...result.created);
+        backups.push(...result.backups);
+      } else {
+        const result = copyFileWithBackup(source, target, true);
+        if (result.created) created.push(result.created);
+        if (result.backup) backups.push(result.backup);
+      }
+    }
+    coreCopied = true;
+  }
+
+  if (withSkills) {
+    const skillsSource = existsSync(join(home, "skills")) ? join(home, "skills") : join(root, "skills");
+    if (existsSync(skillsSource)) {
+      const externalRoots = [join(homedir(), ".agents", "skills")];
+      const alreadyInstalled = skillNamesIn(externalRoots);
+      const force = Boolean(flags["force-skills"]);
+      const entries = readdirSync(skillsSource, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .sort((a, b) => (a.name < b.name ? -1 : 1));
+      const skipped = force
+        ? []
+        : entries.filter((entry) => alreadyInstalled.has(entry.name)).map((entry) => entry.name);
+      const toCopy = entries.filter((entry) => !skipped.includes(entry.name));
+      note(`Installation des skills dans ${skillsDir} (${toCopy.length} a copier, ${skipped.length} deja presents ailleurs)`);
+      if (!dryRun) {
+        let total = 0;
+        let added = 0;
+        let saved = 0;
+        for (const entry of toCopy) {
+          const result = copyInto(join(skillsSource, entry.name), join(skillsDir, entry.name), true);
+          created.push(...result.created);
+          backups.push(...result.backups);
+          total += result.total;
+          added += result.created.length;
+          saved += result.backups.length;
+        }
+        note(`  ${total} fichiers, ${added} nouveaux, ${saved} sauvegardes`);
+      }
+      if (skipped.length > 0) {
+        note(`  deja presentes dans une autre racine, non recopiees: ${skipped.join(", ")}`);
+        note("  Relance avec --force-skills pour les recopier malgre tout.");
+      }
+    } else {
+      note(`Aucun dossier skills trouve a ${skillsSource}`);
+    }
+
+    // Copy bundled-skills
+    const bundledSource = existsSync(join(home, "bundled-skills")) ? join(home, "bundled-skills") : join(root, "bundled-skills");
+    if (existsSync(bundledSource)) {
+      const bundledTarget = join(home, "bundled-skills");
+      note(`Installation des bundled-skills dans ${bundledTarget}`);
+      if (!dryRun) {
+        const result = copyInto(bundledSource, bundledTarget, true);
+        created.push(...result.created);
+        backups.push(...result.backups);
+        note(`  ${result.total} fichiers copies`);
+      }
+    }
+  }
+
+  const pluginSource = join(home, "adapters", "opencode", "novahiz.ts");
+  const pluginTarget = join(pluginsDir, "novahiz.ts");
+  if (existsSync(pluginSource)) {
+    note(`Installation du plugin opencode dans ${pluginTarget}`);
+    if (!dryRun) {
+      const result = copyFileWithBackup(pluginSource, pluginTarget, true);
+      if (result.created) created.push(result.created);
+      if (result.backup) backups.push(result.backup);
+    }
+  }
+
+  const agentSource = existsSync(join(home, "adapters", "opencode", "agent", "novahiz-agent.md"))
+    ? join(home, "adapters", "opencode", "agent", "novahiz-agent.md")
+    : join(root, "adapters", "opencode", "agent", "novahiz-agent.md");
+  const agentTarget = join(configDir, "agent", "novahiz-agent.md");
+  if (existsSync(agentSource)) {
+    note(`Installation de l'agent Novahiz dans ${agentTarget}`);
+    if (!dryRun) {
+      const result = copyFileWithBackup(agentSource, agentTarget, true);
+      if (result.created) created.push(result.created);
+      if (result.backup) backups.push(result.backup);
+    }
+  }
+
+  const commandsSource = existsSync(join(home, "adapters", "opencode", "commands"))
+    ? join(home, "adapters", "opencode", "commands")
+    : join(root, "adapters", "opencode", "commands");
+  const commandsTarget = join(configDir, "commands");
+  if (existsSync(commandsSource)) {
+    note(`Installation des commandes Novahiz dans ${commandsTarget}`);
+    if (!dryRun) {
+      const result = copyInto(commandsSource, commandsTarget, true);
+      created.push(...result.created);
+      backups.push(...result.backups);
+    }
+  }
+
+  const configPath = join(home, "novahiz.config.json");
+  if (force || !existsSync(configPath)) {
+    note(`Ecriture de ${configPath}`);
+    if (!dryRun) {
+      const existedBefore = existsSync(configPath);
+      if (existedBefore) {
+        const backup = `${configPath}.novahiz-bak`;
+        if (!existsSync(backup)) cpSync(configPath, backup);
+        backups.push({ path: configPath, backup });
+      }
+      writeJson(configPath, defaultConfig(skillsDir));
+      configCreated = !existedBefore;
+    }
+  } else {
+    note(`Config existante conservee: ${configPath}`);
+  }
+
+  if (!dryRun) {
+    const previous = loadManifest(home);
+    saveManifest(home, {
+      version: "0.1.0",
+      installedAt: new Date().toISOString(),
+      harness: "opencode",
+      configDir,
+      home,
+      coreCopied: previous.coreCopied || coreCopied,
+      configCreated: previous.configCreated || configCreated,
+      created: mergeCreated(previous.created, created),
+      backups: mergeBackups(previous.backups, backups)
+    });
+  }
+
+  if (!dryRun) {
+    const cli = join(home, "src", "cli.ts");
+    if (existsSync(cli)) {
+      note("Construction du catalogue (sync)");
+      const result = spawnSync(process.execPath, [cli, "sync"], {
+        encoding: "utf8",
+        env: { ...process.env, NOVAHIZ_HOME: home }
+      });
+      if (result.stdout) process.stdout.write(result.stdout);
+      if (result.status !== 0 && result.stderr) process.stderr.write(result.stderr);
+    }
+  }
+
+  if (!dryRun) {
+    const cli = join(home, "src", "cli.ts");
+    const config = readJson(join(home, "novahiz.config.json"), {});
+    const autoInstall =
+      providersChoice !== null
+        ? providersChoice
+        : Boolean(flags["install-providers"]) || config?.providers?.autoInstall === true;
+    note("Verification des dependances");
+    const check = spawnSync(process.execPath, [cli, "deps"], {
+      encoding: "utf8",
+      env: { ...process.env, NOVAHIZ_HOME: home }
+    });
+    if (check.stdout) process.stdout.write(check.stdout);
+    if (autoInstall) {
+      note("Installation des dependances et des providers (MCP, skills, commands)");
+      const result = spawnSync(process.execPath, [cli, "deps", "--install"], {
+        encoding: "utf8",
+        env: { ...process.env, NOVAHIZ_HOME: home }
+      });
+      if (result.stdout) process.stdout.write(result.stdout);
+      if (result.status !== 0 && result.stderr) process.stderr.write(result.stderr);
+    }
+  }
+
+  // Install MCP servers globally
+  const mcpServers = [
+    { pkg: "@upstash/context7-mcp", bin: "context7-mcp", name: "context7" },
+    { pkg: "@anthropic-ai/narsil-mcp", bin: "narsil-mcp", name: "narsil" },
+    { pkg: "@anthropic-ai/mcp-cron", bin: "mcp-cron", name: "cron" },
+  ];
+
+  if (!dryRun) {
+    note("\nInstallation des MCP servers...");
+    for (const server of mcpServers) {
+      const check = spawnSync(process.platform === "win32" ? "where" : "which", [server.bin], {
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      if (check.status !== 0) {
+        note(`  Installation de ${server.pkg}...`);
+        const result = spawnSync("npm", ["install", "-g", server.pkg], {
+          encoding: "utf8",
+          stdio: "inherit"
+        });
+        if (result.status !== 0) {
+          note(`  ATTENTION: Echec installation ${server.pkg} (non bloquant)`);
+        } else {
+          note(`  ${server.pkg} installe`);
+        }
+      } else {
+        note(`  ${server.name} deja installe`);
+      }
+    }
+  }
+
+  // Install opencode plugins globally
+  const plugins = [
+    "@mohak34/opencode-notifier@0.2.8",
+    "@tarquinen/opencode-dcp@latest",
+  ];
+
+  if (!dryRun) {
+    note("\nInstallation des plugins opencode...");
+    for (const plugin of plugins) {
+      const pkgName = plugin.includes("@") ? plugin.split("@").slice(0, -1).join("@") || plugin.split("@")[1] : plugin;
+      note(`  Installation de ${plugin}...`);
+      const result = spawnSync("npm", ["install", "-g", plugin], {
+        encoding: "utf8",
+        stdio: "inherit"
+      });
+      if (result.status !== 0) {
+        note(`  ATTENTION: Echec installation ${plugin} (non bloquant)`);
+      } else {
+        note(`  ${plugin} installe`);
+      }
+    }
+  }
+
+  // Generate opencode.jsonc
+  if (!dryRun) {
+    const configPath = join(configDir, "opencode.jsonc");
+    if (!existsSync(configPath)) {
+      note(`\nCreation de ${configPath}`);
+      const bundledDir = join(home, "bundled-skills");
+      const agentsSkillsDir = join(homedir(), ".config", ".agents", "skills");
+      
+      const openCodeConfig = {
+        "$schema": "https://opencode.ai/config.json",
+        "mcp": {
+          "context7": {
+            "type": "local",
+            "command": ["context7-mcp", "--transport", "stdio"],
+            "enabled": true
+          },
+          "narsil": {
+            "type": "local",
+            "command": ["narsil-mcp", "--repos", ".", "--git", "--persist"],
+            "timeout": 120000,
+            "enabled": true
+          },
+          "cron": {
+            "type": "local",
+            "command": ["mcp-cron", "--transport", "stdio"],
+            "enabled": true
+          },
+          "playwright": {
+            "type": "local",
+            "command": ["npx", "@playwright/mcp@latest", "--browser=msedge"],
+            "enabled": true
+          },
+          "supabase": {
+            "type": "remote",
+            "url": "https://mcp.supabase.com/mcp?features=docs%2Caccount%2Cdatabase%2Cdebugging%2Cdevelopment%2Cfunctions%2Cbranching",
+            "enabled": true
+          },
+          "expo": {
+            "type": "remote",
+            "url": "https://mcp.expo.dev/mcp",
+            "enabled": true
+          }
+        },
+        "skills": {
+          "paths": [skillsDir]
+        },
+        "plugin": [
+          "@mohak34/opencode-notifier@0.2.8",
+          "@tarquinen/opencode-dcp@latest",
+          join(home, "adapters", "opencode", "novahiz.ts")
+        ],
+        "compaction": {
+          "auto": true,
+          "prune": true,
+          "reserved": 10000
+        },
+        "shell": process.platform === "win32" ? "pwsh" : "bash"
+      };
+
+      // Add bundled-skills if it exists
+      if (existsSync(bundledDir)) {
+        openCodeConfig.skills.paths.push(bundledDir);
+      }
+
+      // Add .agents/skills if it exists
+      if (existsSync(agentsSkillsDir)) {
+        openCodeConfig.skills.paths.push(agentsSkillsDir);
+      }
+
+      writeFileSync(configPath, JSON.stringify(openCodeConfig, null, 2) + "\n", "utf8");
+      note(`  ${configPath} cree`);
+    } else {
+      note(`\n${join(configDir, "opencode.jsonc")} existe deja, non ecrase`);
+    }
+  }
+
+  if (!dryRun) {
+    process.stdout.write(`\nNovahiz installe dans ${home}.\n`);
+    process.stdout.write("Redemarre opencode pour activer le plugin et le serveur MCP.\n");
+    process.stdout.write("Gate desactivable avec la variable d'environnement NOVAHIZ_GATE=off.\n");
+    
+    // Auto-update dependencies
+    note("Verification des mises a jour des dependances...");
+    const pkgPath = join(home, "package.json");
+    if (existsSync(pkgPath)) {
+      const npmCheck = spawnSync("npm", ["outdated", "--json"], {
+        encoding: "utf8",
+        cwd: home,
+        env: { ...process.env, NOVAHIZ_HOME: home }
+      });
+      if (npmCheck.stdout && npmCheck.stdout.trim().length > 2) {
+        note("Mises a jour disponibles, installation en cours...");
+        const npmUpdate = spawnSync("npm", ["update"], {
+          encoding: "utf8",
+          cwd: home,
+          env: { ...process.env, NOVAHIZ_HOME: home }
+        });
+        if (npmUpdate.stdout) process.stdout.write(npmUpdate.stdout);
+        if (npmUpdate.status !== 0 && npmUpdate.stderr) process.stderr.write(npmUpdate.stderr);
+        note("Dependances mises a jour.");
+      } else {
+        note("Dependances a jour.");
+      }
+    }
+  } else {
+    process.stdout.write("\nDry-run termine, aucune modification ecrite.\n");
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`${String(error)}\n`);
+  process.exit(1);
+});

package/install/install.ps1

@@ -0,0 +1,3 @@
+$ErrorActionPreference = "Stop"
+$dir = Split-Path -Parent $MyInvocation.MyCommand.Path
+node "$dir\install.mjs" @args

package/install/install.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec node "$DIR/install.mjs" "$@"

package/install/lib.mjs

@@ -0,0 +1,198 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function parseArgs(argv) {
+  const flags = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) continue;
+    const equals = arg.indexOf("=");
+    if (equals !== -1) {
+      flags[arg.slice(2, equals)] = arg.slice(equals + 1);
+      continue;
+    }
+    const next = argv[index + 1];
+    if (next !== undefined && !next.startsWith("--")) {
+      flags[arg.slice(2)] = next;
+      index += 1;
+    } else {
+      flags[arg.slice(2)] = true;
+    }
+  }
+  return flags;
+}
+
+export function expandHome(value) {
+  if (typeof value !== "string") return value;
+  if (value === "~") return homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) return join(homedir(), value.slice(2));
+  return value;
+}
+
+export function repoRoot(metaUrl) {
+  return resolve(dirname(fileURLToPath(metaUrl)), "..");
+}
+
+export function opencodeConfigDir(env = process.env) {
+  if (env.OPENCODE_CONFIG_DIR) return env.OPENCODE_CONFIG_DIR;
+  if (env.XDG_CONFIG_HOME) return join(env.XDG_CONFIG_HOME, "opencode");
+  return join(homedir(), ".config", "opencode");
+}
+
+export function novahizHome(flags = {}, env = process.env) {
+  if (typeof flags.home === "string") return resolve(expandHome(flags.home));
+  if (env.NOVAHIZ_HOME) return resolve(env.NOVAHIZ_HOME);
+  return join(homedir(), ".config", "novahiz");
+}
+
+export function listFiles(root) {
+  const out = [];
+  if (!existsSync(root)) return out;
+  const stack = [""];
+  while (stack.length > 0) {
+    const rel = stack.pop();
+    const dir = rel ? join(root, rel) : root;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const childRel = rel ? join(rel, entry.name) : entry.name;
+      if (entry.isDirectory()) stack.push(childRel);
+      else out.push(childRel);
+    }
+  }
+  return out;
+}
+
+export function skillNamesIn(roots) {
+  const names = new Set();
+  for (const root of roots) {
+    if (!existsSync(root)) continue;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (existsSync(join(root, entry.name, "SKILL.md"))) names.add(entry.name);
+    }
+  }
+  return names;
+}
+
+function sameContent(a, b) {
+  try {
+    return readFileSync(a, "utf8") === readFileSync(b, "utf8");
+  } catch {
+    return false;
+  }
+}
+
+export function copyFileWithBackup(srcPath, destPath, useBackup = true) {
+  mkdirSync(dirname(destPath), { recursive: true });
+  if (!existsSync(destPath)) {
+    cpSync(srcPath, destPath);
+    return { created: destPath, backup: null };
+  }
+  if (sameContent(srcPath, destPath)) return { created: null, backup: null };
+  let backup = null;
+  if (useBackup) {
+    backup = `${destPath}.novahiz-bak`;
+    if (!existsSync(backup)) cpSync(destPath, backup);
+  }
+  cpSync(srcPath, destPath);
+  return { created: null, backup: backup ? { path: destPath, backup } : null };
+}
+
+export function copyInto(srcDir, destDir, useBackup = true) {
+  const created = [];
+  const backups = [];
+  if (!existsSync(srcDir)) return { created, backups, total: 0 };
+  mkdirSync(destDir, { recursive: true });
+  const stack = [""];
+  while (stack.length > 0) {
+    const rel = stack.pop();
+    const src = rel ? join(srcDir, rel) : srcDir;
+    for (const entry of readdirSync(src, { withFileTypes: true }).sort((a, b) => (a.name < b.name ? -1 : 1))) {
+      const childRel = rel ? join(rel, entry.name) : entry.name;
+      const srcPath = join(srcDir, childRel);
+      const destPath = join(destDir, childRel);
+      if (entry.isDirectory()) {
+        mkdirSync(destPath, { recursive: true });
+        stack.push(childRel);
+      } else {
+        const result = copyFileWithBackup(srcPath, destPath, useBackup);
+        if (result.created) created.push(result.created);
+        if (result.backup) backups.push(result.backup);
+      }
+    }
+  }
+  return { created, backups, total: listFiles(srcDir).length };
+}
+
+export function readJson(path, fallback = null) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8").replace(/^\uFEFF/, ""));
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function loadManifest(home) {
+  return readJson(join(home, ".novahiz-install.json"), { created: [], backups: [] });
+}
+
+export function saveManifest(home, manifest) {
+  writeJson(join(home, ".novahiz-install.json"), manifest);
+}
+
+export function mergeCreated(previous = [], next = []) {
+  const set = new Set(previous);
+  for (const item of next) set.add(item);
+  return [...set].filter((item) => existsSync(item)).sort();
+}
+
+export function mergeBackups(previous = [], next = []) {
+  const map = new Map();
+  for (const entry of [...previous, ...next]) {
+    if (entry && entry.path && entry.backup) map.set(entry.path, entry);
+  }
+  return [...map.values()].sort((a, b) => (a.path < b.path ? -1 : 1));
+}
+
+export function pruneEmptyDirs(paths, stops = []) {
+  const stopSet = new Set(stops.map((value) => resolve(value)));
+  const candidates = new Set();
+  for (const item of paths) candidates.add(dirname(item));
+  const ordered = [...candidates].sort((a, b) => b.length - a.length);
+  // One pass is not enough: a directory emptied by a later candidate is only
+  // noticed on the next pass. Repeat until a full pass removes nothing.
+  let removed = true;
+  while (removed) {
+    removed = false;
+    for (const start of ordered) {
+      let current = start;
+      while (current && existsSync(current) && !stopSet.has(resolve(current))) {
+        try {
+          if (readdirSync(current).length !== 0) break;
+          rmSync(current, { recursive: false });
+          removed = true;
+          const parent = dirname(current);
+          if (parent === current) break;
+          current = parent;
+        } catch {
+          break;
+        }
+      }
+    }
+  }
+}
+
+export function nodeVersionOk(minimum = [22, 18, 0]) {
+  const parts = process.versions.node.split(".").map((value) => Number.parseInt(value, 10));
+  for (let index = 0; index < minimum.length; index += 1) {
+    if ((parts[index] ?? 0) > minimum[index]) return true;
+    if ((parts[index] ?? 0) < minimum[index]) return false;
+  }
+  return true;
+}

package/install/prompt.mjs

@@ -0,0 +1,16 @@
+import { createInterface } from "node:readline/promises";
+
+export function createPrompt(input = process.stdin, output = process.stdout) {
+  const rl = createInterface({ input, output });
+  return {
+    async confirm(question, defaultValue = true) {
+      const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+      const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase();
+      if (answer.length === 0) return defaultValue;
+      return ["y", "yes", "o", "oui"].includes(answer);
+    },
+    close() {
+      rl.close();
+    }
+  };
+}