@sushanglewis/lincoln 1.5.5 → 1.6.1

package/dist/postinstall.js

@@ -1,18 +1,824 @@
 #!/usr/bin/env node
 
+// src/commands/install.ts
+import fs5 from "fs";
+import path6 from "path";
+import { spawn as spawn2 } from "child_process";
+
+// src/lib/paths.ts
+import path from "path";
+import os from "os";
+function resolveLincolnPaths(overrideHomeDir) {
+  const homeDir = overrideHomeDir ?? os.homedir();
+  const lincolnHome = process.env.LINCOLN_HOME ? path.resolve(process.env.LINCOLN_HOME) : path.join(homeDir, ".lincoln");
+  return {
+    homeDir,
+    lincolnHome,
+    versionsDir: path.join(lincolnHome, "versions"),
+    currentDir: path.join(lincolnHome, "current"),
+    versionMarker: path.join(lincolnHome, "marker.json"),
+    venvDir: path.join(lincolnHome, "venv"),
+    claudeDir: path.join(homeDir, ".claude"),
+    codexDir: path.join(homeDir, ".codex"),
+    opencodeDir: path.join(homeDir, ".opencode")
+  };
+}
+
+// src/lib/versionMarker.ts
+import fs from "fs";
+import path2 from "path";
+function writeVersionMarker(paths, marker) {
+  fs.mkdirSync(path2.dirname(paths.versionMarker), { recursive: true });
+  fs.writeFileSync(paths.versionMarker, JSON.stringify(marker, null, 2) + "\n");
+}
+
+// src/lib/packageInfo.ts
+import fs2 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+function readLocalPackageRoot() {
+  try {
+    let dir = path3.dirname(fileURLToPath(import.meta.url));
+    const root = path3.parse(dir).root;
+    while (dir !== root) {
+      const pkgPath = path3.join(dir, "package.json");
+      if (fs2.existsSync(pkgPath)) {
+        const parsed = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+        if (parsed.name === "@sushanglewis/lincoln") {
+          return dir;
+        }
+      }
+      dir = path3.dirname(dir);
+    }
+  } catch {
+  }
+  return void 0;
+}
+function readLocalPackageVersion() {
+  try {
+    const root = readLocalPackageRoot();
+    if (!root) return void 0;
+    const parsed = JSON.parse(fs2.readFileSync(path3.join(root, "package.json"), "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolvePayloadRoot() {
+  const root = readLocalPackageRoot();
+  if (!root) return void 0;
+  const payload = path3.join(root, "framework");
+  return fs2.existsSync(payload) ? payload : void 0;
+}
+
+// src/lib/syncClaude.ts
+import fs3 from "fs";
+import path4 from "path";
+import crypto from "crypto";
+
+// src/lib/claudeMdMerge.ts
+var BEGIN = "<!-- lincoln:begin -->";
+var END = "<!-- lincoln:end -->";
+function mergeManagedBlock(existing, block) {
+  const wrapped = `${BEGIN}
+${block}
+${END}`;
+  const text = existing ?? "";
+  const beginIndex = text.indexOf(BEGIN);
+  const endIndex = text.indexOf(END);
+  if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
+    return text.slice(0, beginIndex) + wrapped + text.slice(endIndex + END.length);
+  }
+  if (text.trim().length === 0) {
+    return wrapped;
+  }
+  return `${text.trimEnd()}
+
+${wrapped}
+`;
+}
+
+// src/lib/syncClaude.ts
+var COPY_SUBDIRS = [
+  "agents",
+  "skills",
+  "workflows",
+  "stages",
+  "schemas",
+  "templates",
+  "harnesses"
+];
+function sha256(filePath) {
+  const data = fs3.readFileSync(filePath);
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+function sameContent(a, b) {
+  return sha256(a) === sha256(b);
+}
+function deepMergeSettings(existing, incoming) {
+  if (Array.isArray(existing) && Array.isArray(incoming)) {
+    return incoming;
+  }
+  if (typeof existing === "object" && existing !== null && typeof incoming === "object" && incoming !== null) {
+    const result = { ...existing };
+    for (const [key, value] of Object.entries(incoming)) {
+      if (key in result) {
+        result[key] = deepMergeSettings(result[key], value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  return incoming;
+}
+function syncClaudeCode(opts) {
+  const report = {
+    written: [],
+    skipped: [],
+    preserved: [],
+    warnings: [],
+    settingsTouched: []
+  };
+  const payloadClaude = path4.join(opts.payloadRoot, ".claude");
+  if (!fs3.existsSync(payloadClaude)) {
+    report.warnings.push(`payload .claude directory not found: ${payloadClaude}`);
+    return report;
+  }
+  if (!opts.dryRun) {
+    fs3.mkdirSync(opts.targetDir, { recursive: true });
+  }
+  for (const subdir of COPY_SUBDIRS) {
+    const srcDir = path4.join(payloadClaude, subdir);
+    if (!fs3.existsSync(srcDir)) {
+      continue;
+    }
+    const destDir = path4.join(opts.targetDir, subdir);
+    if (!opts.dryRun) {
+      fs3.mkdirSync(destDir, { recursive: true });
+    }
+    for (const entry of walkSync(srcDir)) {
+      const relativePath = path4.relative(srcDir, entry);
+      const srcFile = entry;
+      const destFile = path4.join(destDir, relativePath);
+      if (fs3.existsSync(destFile) && sameContent(srcFile, destFile)) {
+        report.skipped.push(path4.join(".claude", subdir, relativePath));
+        continue;
+      }
+      if (!opts.dryRun) {
+        fs3.mkdirSync(path4.dirname(destFile), { recursive: true });
+        fs3.copyFileSync(srcFile, destFile);
+      }
+      report.written.push(path4.join(".claude", subdir, relativePath));
+    }
+  }
+  const payloadSettings = path4.join(payloadClaude, "settings.json");
+  const targetSettings = path4.join(opts.targetDir, "settings.json");
+  if (fs3.existsSync(payloadSettings)) {
+    const incoming = JSON.parse(fs3.readFileSync(payloadSettings, "utf8"));
+    let merged = incoming;
+    if (fs3.existsSync(targetSettings)) {
+      const existing = JSON.parse(fs3.readFileSync(targetSettings, "utf8"));
+      merged = deepMergeSettings(existing, incoming);
+    }
+    const wouldChange = !fs3.existsSync(targetSettings) || JSON.stringify(merged) !== JSON.stringify(JSON.parse(fs3.readFileSync(targetSettings, "utf8")));
+    if (wouldChange) {
+      if (!opts.dryRun) {
+        fs3.writeFileSync(targetSettings, JSON.stringify(merged, null, 2) + "\n");
+      }
+      report.written.push(".claude/settings.json");
+      report.settingsTouched = [".claude/settings.json"];
+    } else {
+      report.skipped.push(".claude/settings.json");
+    }
+  }
+  const payloadClaudeMd = path4.join(opts.payloadRoot, "CLAUDE.md");
+  const targetClaudeMd = path4.join(path4.dirname(opts.targetDir), "CLAUDE.md");
+  if (fs3.existsSync(payloadClaudeMd)) {
+    const incomingBlock = fs3.readFileSync(payloadClaudeMd, "utf8");
+    const existing = fs3.existsSync(targetClaudeMd) ? fs3.readFileSync(targetClaudeMd, "utf8") : void 0;
+    const merged = mergeManagedBlock(existing, incomingBlock);
+    if (merged !== existing) {
+      if (!opts.dryRun) {
+        fs3.writeFileSync(targetClaudeMd, merged);
+      }
+      report.written.push("CLAUDE.md");
+    } else {
+      report.skipped.push("CLAUDE.md");
+    }
+  }
+  return report;
+}
+function* walkSync(dir) {
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkSync(fullPath);
+    } else {
+      yield fullPath;
+    }
+  }
+}
+
+// src/lib/runHarnessAdapter.ts
+import { spawn } from "child_process";
+function runCommand(command, args, spawnCommand) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawnCommand(command, args, { stdio: "inherit" });
+    child.on("close", (code) => {
+      resolvePromise(code);
+    });
+    child.on("error", (err) => {
+      rejectPromise(err);
+    });
+  });
+}
+async function runHarnessAdapter(opts) {
+  const report = {
+    written: [],
+    skipped: [],
+    preserved: [],
+    warnings: []
+  };
+  if (opts.dryRun) {
+    report.written.push(`${opts.harnessId} (dry run)`);
+    return report;
+  }
+  const args = [
+    `${opts.payloadRoot}/scripts/lincoln_harness_adapter.py`,
+    "--harness",
+    opts.harnessId,
+    "--root",
+    opts.payloadRoot,
+    "--project-dir",
+    opts.projectDir,
+    "--home-dir",
+    opts.homeDir
+  ];
+  try {
+    const spawnCommand = opts.spawnCommand ?? spawn;
+    const code = await runCommand(opts.pythonPath, args, spawnCommand);
+    if (code === 0) {
+      report.written.push(opts.harnessId);
+    } else {
+      report.warnings.push(
+        `Adapter for ${opts.harnessId} exited with code ${code}. Run manually to diagnose.`
+      );
+    }
+  } catch (err) {
+    report.warnings.push(
+      `Failed to run adapter for ${opts.harnessId}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return report;
+}
+
+// src/lib/syncHarness.ts
+function emptyReport() {
+  return {
+    written: [],
+    skipped: [],
+    preserved: [],
+    warnings: []
+  };
+}
+async function syncHarnesses(opts) {
+  const reports = {};
+  const syncClaude = opts.syncClaude ?? syncClaudeCode;
+  for (const harnessId of opts.harnesses) {
+    reports[harnessId] = await syncHarness(harnessId, opts, syncClaude);
+  }
+  return reports;
+}
+async function syncHarness(harnessId, opts, syncClaude) {
+  if (harnessId === "claude-code") {
+    return syncClaude({
+      payloadRoot: opts.payloadRoot,
+      targetDir: opts.paths.claudeDir,
+      version: opts.version,
+      dryRun: opts.dryRun
+    });
+  }
+  if (harnessId === "codex" || harnessId === "opencode") {
+    if (opts.dryRun) {
+      const report2 = emptyReport();
+      report2.written.push(`${harnessId} (dry run)`);
+      return report2;
+    }
+    if (!opts.pythonPath) {
+      const report2 = emptyReport();
+      report2.warnings.push(
+        `Skipped ${harnessId} sync because Python is not available. Install Python 3.10+ or run without --no-venv.`
+      );
+      return report2;
+    }
+    return runHarnessAdapter({
+      harnessId,
+      payloadRoot: opts.payloadRoot,
+      projectDir: opts.projectDir,
+      homeDir: opts.paths.homeDir,
+      pythonPath: opts.pythonPath,
+      dryRun: opts.dryRun
+    });
+  }
+  const report = emptyReport();
+  report.warnings.push(`Unsupported harness: ${harnessId}`);
+  return report;
+}
+
+// src/lib/harnessDetect.ts
+import fs4 from "fs";
+import path5 from "path";
+import os2 from "os";
+var HARNESS_SPECS = [
+  {
+    id: "claude-code",
+    configDirName: ".claude",
+    pluginMarker: "plugins/lincoln"
+  },
+  { id: "codex", configDirName: ".codex" },
+  { id: "opencode", configDirName: ".opencode" }
+];
+function detectGlobalHarnesses(overrideHomeDir) {
+  const homeDir = overrideHomeDir ?? os2.homedir();
+  return HARNESS_SPECS.map((spec) => {
+    const configDir = path5.join(homeDir, spec.configDirName);
+    const installed = fs4.existsSync(configDir);
+    const pluginManaged = spec.pluginMarker ? fs4.existsSync(path5.join(configDir, spec.pluginMarker)) : false;
+    return {
+      id: spec.id,
+      installed,
+      configDir,
+      pluginManaged
+    };
+  });
+}
+function installedHarnessIds(homeDir) {
+  return detectGlobalHarnesses(homeDir).filter((h) => h.installed).map((h) => h.id);
+}
+var HARNESS_IDS = HARNESS_SPECS.map((spec) => spec.id);
+function isValidHarnessId(value) {
+  return HARNESS_SPECS.some((spec) => spec.id === value);
+}
+
+// src/lib/harnessSelect.ts
+var HARNESS_LABELS = {
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  opencode: "OpenCode"
+};
+function buildHarnessOptions(detected) {
+  return detected.map((harness) => ({
+    id: harness.id,
+    label: HARNESS_LABELS[harness.id],
+    checked: harness.installed
+  }));
+}
+function resolveHarnessSelection(detected, selection) {
+  if (selection === void 0) {
+    return detected.filter((harness) => harness.installed).map((harness) => harness.id);
+  }
+  const validIds = /* @__PURE__ */ new Set();
+  for (const id of selection) {
+    const match = detected.find((harness) => harness.id === id);
+    if (match) {
+      validIds.add(match.id);
+    }
+  }
+  return Array.from(validIds);
+}
+
+// src/lib/prompt.ts
+function createLineReader(input, output) {
+  const buffer = [];
+  const queue = [];
+  let remainder = "";
+  let ended = false;
+  function flushQueue() {
+    while (queue.length > 0 && buffer.length > 0) {
+      const next = queue.shift();
+      const line = buffer.shift();
+      if (next && line !== void 0) {
+        next.resolve(line);
+      }
+    }
+  }
+  input.on("data", (chunk) => {
+    const text = remainder + chunk.toString("utf-8");
+    const lines = text.split("\n");
+    remainder = lines.pop() ?? "";
+    for (const line of lines) {
+      buffer.push(line.replace(/\r$/, ""));
+    }
+    flushQueue();
+  });
+  input.on("end", () => {
+    ended = true;
+    if (remainder.length > 0) {
+      buffer.push(remainder.replace(/\r$/, ""));
+      remainder = "";
+    }
+    flushQueue();
+    while (queue.length > 0) {
+      const next = queue.shift();
+      next?.resolve("");
+    }
+  });
+  input.on("error", (err) => {
+    while (queue.length > 0) {
+      queue.shift()?.reject(err);
+    }
+  });
+  return {
+    readLine(prompt) {
+      output.write(prompt);
+      if (buffer.length > 0) {
+        return Promise.resolve(buffer.shift() ?? "");
+      }
+      if (ended) {
+        return Promise.resolve("");
+      }
+      return new Promise((resolve, reject) => {
+        queue.push({ resolve, reject });
+      });
+    },
+    close() {
+    }
+  };
+}
+function normalizeAnswer(text) {
+  return text.trim().toLowerCase();
+}
+function createPrompt(streams = {}) {
+  const input = streams.input ?? process.stdin;
+  const output = streams.output ?? process.stdout;
+  const reader = createLineReader(input, output);
+  async function ask(question) {
+    return reader.readLine(question);
+  }
+  return {
+    async confirm(question, defaultValue = true) {
+      const hint = defaultValue ? "[Y/n]" : "[y/N]";
+      const first = await ask(`${question} ${hint} `);
+      const normalized = normalizeAnswer(first);
+      if (normalized === "y" || normalized === "yes") {
+        return true;
+      }
+      if (normalized === "n" || normalized === "no") {
+        return false;
+      }
+      if (normalized === "") {
+        return defaultValue;
+      }
+      const second = await ask("Please answer y or n: ");
+      const secondNormalized = normalizeAnswer(second);
+      if (secondNormalized === "y" || secondNormalized === "yes") {
+        return true;
+      }
+      if (secondNormalized === "n" || secondNormalized === "no") {
+        return false;
+      }
+      return defaultValue;
+    },
+    async multiSelect(question, options) {
+      const lines = options.map((opt, index) => {
+        const mark = opt.checked ? "x" : " ";
+        return `  [${mark}] ${index + 1}. ${opt.label}`;
+      });
+      const promptText = `${question}
+${lines.join("\n")}
+Enter numbers (e.g. 1,3), 'all', 'none', or harness names: `;
+      async function parse(answer) {
+        const normalized = normalizeAnswer(answer);
+        if (normalized === "all") {
+          return options.map((opt) => opt.id);
+        }
+        if (normalized === "none") {
+          return [];
+        }
+        if (normalized === "") {
+          return options.filter((opt) => opt.checked).map((opt) => opt.id);
+        }
+        const parts = normalized.split(/[,\s]+/).filter((part) => part.length > 0);
+        const selected = /* @__PURE__ */ new Set();
+        for (const part of parts) {
+          const index = Number(part);
+          if (!Number.isNaN(index) && index >= 1 && index <= options.length) {
+            selected.add(options[index - 1].id);
+            continue;
+          }
+          const match = options.find((opt) => opt.id === part);
+          if (match) {
+            selected.add(match.id);
+            continue;
+          }
+          return void 0;
+        }
+        return Array.from(selected);
+      }
+      let result = await parse(await ask(promptText));
+      if (result !== void 0) {
+        return result;
+      }
+      const retry = await ask("Invalid selection. Please try again: ");
+      result = await parse(retry);
+      return result ?? [];
+    },
+    close() {
+      reader.close();
+    }
+  };
+}
+
+// src/commands/install.ts
+function createDefaultDeps() {
+  return {
+    paths: resolveLincolnPaths(),
+    payloadRoot: resolvePayloadRoot() || "",
+    syncHarnesses,
+    createPrompt,
+    resolvePythonForVenv,
+    isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+  };
+}
+async function install(options, deps = createDefaultDeps()) {
+  const version = readLocalPackageVersion();
+  if (!version) {
+    console.error("Could not determine Lincoln version");
+    return 1;
+  }
+  const payloadRoot = deps.payloadRoot;
+  if (!payloadRoot || !fs5.existsSync(payloadRoot)) {
+    console.error('Lincoln payload not found. Run "npm install -g @sushanglewis/lincoln" first.');
+    return 1;
+  }
+  if (!options.dryRun && !options.yes && (options.noInteractive || !deps.isTTY)) {
+    console.error(
+      "This will install Lincoln globally. Run with --yes to proceed, or run interactively in a TTY."
+    );
+    return 1;
+  }
+  const harnesses = await resolveHarnesses(options, deps);
+  if (harnesses.length === 0) {
+    return 1;
+  }
+  const pythonPath = await resolvePythonIfNeeded(options, deps, harnesses);
+  if (pythonPath === null) {
+    return 1;
+  }
+  if (!options.dryRun) {
+    const versionDir = path6.join(deps.paths.versionsDir, version);
+    fs5.mkdirSync(versionDir, { recursive: true });
+    fs5.cpSync(payloadRoot, versionDir, { recursive: true, force: true });
+    try {
+      fs5.rmSync(deps.paths.currentDir, { recursive: true, force: true });
+      fs5.symlinkSync(versionDir, deps.paths.currentDir);
+    } catch {
+      fs5.rmSync(deps.paths.currentDir, { recursive: true, force: true });
+      fs5.cpSync(versionDir, deps.paths.currentDir, { recursive: true, force: true });
+    }
+  }
+  const reports = await deps.syncHarnesses({
+    harnesses,
+    payloadRoot: deps.paths.currentDir,
+    paths: deps.paths,
+    projectDir: deps.paths.lincolnHome,
+    version,
+    dryRun: options.dryRun,
+    pythonPath
+  });
+  if (!options.dryRun) {
+    writeVersionMarker(deps.paths, {
+      version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      harnesses,
+      managedFiles: collectManagedFiles(reports)
+    });
+  }
+  printSummary(options, version, harnesses, reports);
+  return 0;
+}
+async function resolvePythonIfNeeded(options, deps, harnesses) {
+  const needsPython = !options.dryRun && !options.noVenv && harnesses.some((id) => id === "codex" || id === "opencode");
+  if (!needsPython) {
+    return void 0;
+  }
+  const pythonCommand = await deps.resolvePythonForVenv();
+  if (!pythonCommand) {
+    console.error(
+      "Python 3.10+ is required for Codex/OpenCode sync but was not found. Set LINCOLN_PYTHON to a compatible Python executable, or run with --no-venv."
+    );
+    return null;
+  }
+  await setupVenv(deps.paths, deps.payloadRoot, pythonCommand);
+  return venvPythonPath(deps.paths);
+}
+async function resolveHarnesses(options, deps) {
+  const detected = detectGlobalHarnesses(deps.paths.homeDir);
+  if (options.harnesses.length > 0) {
+    const invalid = options.harnesses.filter((id) => !isValidHarnessId(id));
+    if (invalid.length > 0) {
+      console.error(`Unknown harness id(s): ${invalid.join(", ")}`);
+      console.error(`Valid ids: ${HARNESS_IDS.join(", ")}`);
+      return [];
+    }
+    return options.harnesses;
+  }
+  const selected = installedHarnessIds(deps.paths.homeDir);
+  if (selected.length > 0 && !options.dryRun && !options.yes && !options.noInteractive && deps.isTTY) {
+    const prompt = deps.createPrompt();
+    try {
+      const answer = await prompt.multiSelect(
+        "Select agent harnesses to install Lincoln into:",
+        buildHarnessOptions(detected)
+      );
+      const resolved = resolveHarnessSelection(detected, answer);
+      if (resolved.length === 0) {
+        console.error("No harnesses selected. Aborting.");
+        return [];
+      }
+      return resolved;
+    } catch (err) {
+      console.error(`Interactive selection failed: ${err instanceof Error ? err.message : String(err)}`);
+      return [];
+    } finally {
+      prompt.close();
+    }
+  }
+  if (selected.length === 0 && !options.dryRun) {
+    console.error("No agent harness detected. Install Claude Code, Codex, or OpenCode first.");
+    return [];
+  }
+  return selected;
+}
+function collectManagedFiles(reports) {
+  const files = [];
+  for (const report of Object.values(reports)) {
+    files.push(...report.written, ...report.skipped, ...report.preserved);
+  }
+  return files;
+}
+function printSummary(options, version, harnesses, reports) {
+  const warnings = collectWarnings(reports);
+  if (options.dryRun) {
+    console.log(`Dry run: would install Lincoln ${version} for harnesses: ${harnesses.join(", ")}`);
+  } else {
+    console.log(`Installed Lincoln ${version} for harnesses: ${harnesses.join(", ")}`);
+  }
+  for (const [harnessId, report] of Object.entries(reports)) {
+    const count = report.written.length + report.skipped.length + report.preserved.length;
+    console.log(`  ${harnessId}: ${count} file(s)`);
+  }
+  for (const warning of warnings) {
+    console.warn(`  warning: ${warning}`);
+  }
+}
+function collectWarnings(reports) {
+  const warnings = [];
+  for (const report of Object.values(reports)) {
+    warnings.push(...report.warnings);
+  }
+  return warnings;
+}
+function runCommand2(command, args) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn2(command, args, { stdio: "inherit" });
+    child.on("close", (code) => resolvePromise(code ?? 1));
+    child.on("error", (err) => rejectPromise(err));
+  });
+}
+var MIN_PYTHON_MAJOR = 3;
+var MIN_PYTHON_MINOR = 10;
+var DEFAULT_PYTHON_CANDIDATES = ["python3.12", "python3.11", "python3.10", "python3"];
+function parsePythonVersion(version) {
+  const match = /(\d+)\.(\d+)/.exec(version);
+  if (!match) {
+    return void 0;
+  }
+  return { major: Number(match[1]), minor: Number(match[2]) };
+}
+async function queryPythonVersion(command) {
+  return new Promise((resolvePromise) => {
+    const child = spawn2(command, ["--version"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      shell: process.platform === "win32"
+    });
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.on("close", (code) => {
+      const text = stdout.trim();
+      resolvePromise(code === 0 && text.length > 0 ? text : void 0);
+    });
+    child.on("error", () => resolvePromise(void 0));
+  });
+}
+async function resolvePythonForVenv(envOverride = process.env.LINCOLN_PYTHON, candidates = DEFAULT_PYTHON_CANDIDATES, queryVersion = queryPythonVersion) {
+  const list = envOverride ? [envOverride] : candidates;
+  for (const cmd of list) {
+    const version = await queryVersion(cmd);
+    if (!version) {
+      continue;
+    }
+    const parsed = parsePythonVersion(version);
+    if (parsed && parsed.major >= MIN_PYTHON_MAJOR && (parsed.major > MIN_PYTHON_MAJOR || parsed.minor >= MIN_PYTHON_MINOR)) {
+      return cmd;
+    }
+  }
+  return void 0;
+}
+function venvPythonPath(paths) {
+  return path6.join(
+    paths.venvDir,
+    process.platform === "win32" ? "Scripts" : "bin",
+    process.platform === "win32" ? "python.exe" : "python"
+  );
+}
+async function setupVenv(paths, payloadRoot, pythonCommand) {
+  const pythonExe = venvPythonPath(paths);
+  if (!fs5.existsSync(pythonExe)) {
+    console.log("Creating Lincoln virtual environment...");
+    const venvCode = await runCommand2(pythonCommand, ["-m", "venv", paths.venvDir]);
+    if (venvCode !== 0) {
+      throw new Error(`Failed to create virtual environment (exit code ${venvCode})`);
+    }
+  }
+  const requirementsPath = path6.join(payloadRoot, "requirements.txt");
+  if (fs5.existsSync(requirementsPath)) {
+    console.log("Installing Python dependencies...");
+    const pipExe = path6.join(
+      paths.venvDir,
+      process.platform === "win32" ? "Scripts" : "bin",
+      process.platform === "win32" ? "pip.exe" : "pip"
+    );
+    const pipCode = await runCommand2(pipExe, ["install", "-r", requirementsPath]);
+    if (pipCode !== 0) {
+      throw new Error(`Failed to install Python dependencies (exit code ${pipCode})`);
+    }
+  }
+}
+
 // src/postinstall.ts
-function runPostinstall() {
-  if (process.env.CI || process.env.NODE_ENV === "test") {
+function isSkipped(env) {
+  if (env.CI) {
+    return true;
+  }
+  if (env.NODE_ENV === "test") {
+    return true;
+  }
+  if (env.LINCOLN_SKIP_POSTINSTALL) {
+    return true;
+  }
+  return false;
+}
+function createDefaultDeps2() {
+  return {
+    isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    confirm: async (question) => {
+      const prompt = createPrompt();
+      try {
+        return await prompt.confirm(question, true);
+      } finally {
+        prompt.close();
+      }
+    },
+    install: async () => install({ yes: false, dryRun: false, force: false, harnesses: [], noVenv: false, noInteractive: false }),
+    env: process.env
+  };
+}
+async function runPostinstall(deps = createDefaultDeps2()) {
+  if (isSkipped(deps.env)) {
+    return 0;
+  }
+  if (!deps.isTTY) {
+    console.log("Lincoln installed globally.");
+    console.log('Run "lincoln install" to finish setup.');
+    return 0;
+  }
+  try {
+    const ok = await deps.confirm("Configure Lincoln harnesses now?");
+    if (!ok) {
+      console.log('Run "lincoln install" anytime to finish setup.');
+      return 0;
+    }
+    await deps.install();
+    return 0;
+  } catch (err) {
+    console.log("Lincoln installed globally.");
+    console.log('Run "lincoln install" anytime to finish setup.');
+    if (err instanceof Error) {
+      console.error(`Postinstall setup skipped: ${err.message}`);
+    }
     return 0;
   }
-  console.log("Lincoln installed globally.");
-  console.log('Run "lincoln install" to finish setup.');
-  return 0;
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
-  process.exit(runPostinstall());
+  runPostinstall().then((code) => process.exit(code)).catch(() => process.exit(0));
 }
 export {
+  createDefaultDeps2 as createDefaultDeps,
   runPostinstall
 };
 //# sourceMappingURL=postinstall.js.map