@sushanglewis/lincoln 1.5.5 → 1.6.2

package/dist/main.js

@@ -16,6 +16,7 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "help",
   "h",
   "no-venv",
+  "no-interactive",
   "version",
   "v"
 ]);
@@ -400,7 +401,7 @@ function initProject(projectRoot, options = {}) {
 // src/commands/install.ts
 import fs7 from "fs";
 import path8 from "path";
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 
 // src/lib/syncClaude.ts
 import fs5 from "fs";
@@ -552,6 +553,112 @@ function* walkSync(dir) {
   }
 }
 
+// src/lib/runHarnessAdapter.ts
+import { spawn as spawn2 } 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 ?? spawn2;
+    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 fs6 from "fs";
 import path7 from "path";
@@ -582,39 +689,218 @@ function detectGlobalHarnesses(overrideHomeDir) {
 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 createDefaultDeps2() {
   return {
     paths: resolveLincolnPaths(),
     payloadRoot: resolvePayloadRoot() || "",
-    syncClaude: syncClaudeCode
+    syncHarnesses,
+    createPrompt,
+    resolvePythonForVenv,
+    isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY)
   };
 }
 async function install(options, deps = createDefaultDeps2()) {
-  if (!options.dryRun && !options.yes) {
-    console.error("This will install Lincoln globally. Run with --yes to proceed.");
-    return 1;
-  }
   const version = readLocalPackageVersion();
   if (!version) {
     console.error("Could not determine Lincoln version");
     return 1;
   }
-  const harnesses = options.harnesses.length > 0 ? options.harnesses : installedHarnessIds(deps.paths.homeDir);
-  if (harnesses.length === 0) {
-    console.error("No agent harness detected. Install Claude Code, Codex, or OpenCode first.");
-    return 1;
-  }
   const payloadRoot = deps.payloadRoot;
   if (!payloadRoot || !fs7.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(
-      `Lincoln payload not found. Run "npm install -g @sushanglewis/lincoln" first.`
+      "This will install Lincoln globally. Run with --yes to proceed, or run interactively in a TTY."
     );
     return 1;
   }
-  const versionDir = path8.join(deps.paths.versionsDir, version);
+  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 = path8.join(deps.paths.versionsDir, version);
     fs7.mkdirSync(versionDir, { recursive: true });
     fs7.cpSync(payloadRoot, versionDir, { recursive: true, force: true });
     try {
@@ -625,42 +911,111 @@ async function install(options, deps = createDefaultDeps2()) {
       fs7.cpSync(versionDir, deps.paths.currentDir, { recursive: true, force: true });
     }
   }
-  const report = deps.syncClaude({
+  const reports = await deps.syncHarnesses({
+    harnesses,
     payloadRoot: deps.paths.currentDir,
-    targetDir: deps.paths.claudeDir,
+    paths: deps.paths,
+    projectDir: deps.paths.lincolnHome,
     version,
-    dryRun: options.dryRun
+    dryRun: options.dryRun,
+    pythonPath
   });
-  if (!options.dryRun && !options.noVenv) {
-    const python = await resolvePythonForVenv();
-    if (!python) {
-      console.error(
-        "Python 3.10+ is required but was not found. Set LINCOLN_PYTHON to a compatible Python executable."
-      );
-      return 1;
-    }
-    await setupVenv(deps.paths, payloadRoot, python);
-  }
   if (!options.dryRun) {
     writeVersionMarker(deps.paths, {
       version,
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
       harnesses,
-      managedFiles: report.written
+      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(", ")}`);
-    console.log(`Would write ${report.written.length} files`);
   } else {
     console.log(`Installed Lincoln ${version} for harnesses: ${harnesses.join(", ")}`);
-    console.log(`Wrote ${report.written.length} files`);
   }
-  return 0;
+  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 runCommand(command, args) {
+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" });
+    const child = spawn3(command, args, { stdio: "inherit" });
     child.on("close", (code) => resolvePromise(code ?? 1));
     child.on("error", (err) => rejectPromise(err));
   });
@@ -677,7 +1032,7 @@ function parsePythonVersion2(version) {
 }
 async function queryPythonVersion(command) {
   return new Promise((resolvePromise) => {
-    const child = spawn2(command, ["--version"], {
+    const child = spawn3(command, ["--version"], {
       stdio: ["ignore", "pipe", "ignore"],
       shell: process.platform === "win32"
     });
@@ -706,15 +1061,21 @@ async function resolvePythonForVenv(envOverride = process.env.LINCOLN_PYTHON, ca
   }
   return void 0;
 }
-async function setupVenv(paths, payloadRoot, pythonCommand) {
-  const pythonExe = path8.join(
+function venvPythonPath(paths) {
+  return path8.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 (!fs7.existsSync(pythonExe)) {
     console.log("Creating Lincoln virtual environment...");
-    await runCommand(pythonCommand, ["-m", "venv", paths.venvDir]);
+    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 = path8.join(payloadRoot, "requirements.txt");
   if (fs7.existsSync(requirementsPath)) {
@@ -724,12 +1085,15 @@ async function setupVenv(paths, payloadRoot, pythonCommand) {
       process.platform === "win32" ? "Scripts" : "bin",
       process.platform === "win32" ? "pip.exe" : "pip"
     );
-    await runCommand(pipExe, ["install", "-r", requirementsPath]);
+    const pipCode = await runCommand2(pipExe, ["install", "-r", requirementsPath]);
+    if (pipCode !== 0) {
+      throw new Error(`Failed to install Python dependencies (exit code ${pipCode})`);
+    }
   }
 }
 
 // src/commands/update.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 
 // src/lib/npmRegistry.ts
 var DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
@@ -897,13 +1261,14 @@ async function update(options, deps = {}) {
   return 0;
 }
 function defaultInstallOptions() {
-  return { yes: true, dryRun: false, force: false, harnesses: [], noVenv: true };
+  return { yes: true, dryRun: false, force: false, harnesses: [], noVenv: true, noInteractive: true };
 }
 function runNpmInstallGlobal(packageName, version) {
   return new Promise((resolvePromise) => {
-    const child = spawn3("npm", ["install", "-g", `${packageName}@${version}`], {
+    const child = spawn4("npm", ["install", "-g", `${packageName}@${version}`], {
       stdio: "inherit",
-      shell: process.platform === "win32"
+      shell: process.platform === "win32",
+      env: { ...process.env, LINCOLN_SKIP_POSTINSTALL: "1" }
     });
     child.on("close", (code) => resolvePromise(code ?? 1));
     child.on("error", () => resolvePromise(1));
@@ -913,7 +1278,7 @@ function runNpmInstallGlobal(packageName, version) {
 // src/commands/use.ts
 import fs8 from "fs";
 import path9 from "path";
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 var PACKAGE_NAME2 = "@sushanglewis/lincoln";
 var SEMVER_REGEX = /^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
 var STRICT_SEMVER_REGEX = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -1042,13 +1407,14 @@ function switchCurrentLink(paths, versionDir) {
   }
 }
 function defaultInstallOptions2() {
-  return { yes: true, dryRun: false, force: false, harnesses: [], noVenv: true };
+  return { yes: true, dryRun: false, force: false, harnesses: [], noVenv: true, noInteractive: true };
 }
 function runNpmInstallGlobal2(packageName, version) {
   return new Promise((resolvePromise) => {
-    const child = spawn4("npm", ["install", "-g", `${packageName}@${version}`], {
+    const child = spawn5("npm", ["install", "-g", `${packageName}@${version}`], {
       stdio: "inherit",
-      shell: process.platform === "win32"
+      shell: process.platform === "win32",
+      env: { ...process.env, LINCOLN_SKIP_POSTINSTALL: "1" }
     });
     child.on("close", (code) => resolvePromise(code ?? 1));
     child.on("error", () => resolvePromise(1));
@@ -1056,7 +1422,7 @@ function runNpmInstallGlobal2(packageName, version) {
 }
 function runNpmRootGlobal() {
   return new Promise((resolvePromise) => {
-    const child = spawn4("npm", ["root", "-g"], {
+    const child = spawn5("npm", ["root", "-g"], {
       stdio: ["ignore", "pipe", "ignore"],
       shell: process.platform === "win32"
     });
@@ -1274,10 +1640,10 @@ async function migrateProject(projectRoot, options = {}, deps = createDefaultDep
 }
 
 // src/commands/record.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { EventEmitter } from "events";
 function createDefaultDeps6() {
-  return { spawn: spawn5 };
+  return { spawn: spawn6 };
 }
 function record(args, deps = createDefaultDeps6()) {
   return new Promise((resolve) => {
@@ -1312,6 +1678,8 @@ Options:
   --yes, -y        Skip confirmation prompts
   --dry-run        Show what would be done without making changes
   --force          Force re-install even if up to date
+  --harnesses      Comma-separated harness ids (claude-code, codex, opencode)
+  --no-interactive Never prompt; fail if --yes is also missing
   --check          Check for available updates without installing (update)
   --json           Output machine-readable JSON (where supported)
   --help, -h       Show this help message
@@ -1329,12 +1697,15 @@ async function main(argv) {
     return 0;
   }
   if (parsed.command === "install") {
+    const harnessesFlag = typeof parsed.flags.harnesses === "string" ? String(parsed.flags.harnesses).split(",").map((id) => id.trim()).filter((id) => id.length > 0) : [];
+    const harnesses = harnessesFlag.length > 0 ? harnessesFlag : parsed.args;
     return install({
       yes: Boolean(parsed.flags.yes || parsed.flags.y),
       dryRun: Boolean(parsed.flags["dry-run"]),
       force: Boolean(parsed.flags.force),
-      harnesses: parsed.args,
-      noVenv: Boolean(parsed.flags["no-venv"])
+      harnesses,
+      noVenv: Boolean(parsed.flags["no-venv"]),
+      noInteractive: Boolean(parsed.flags["no-interactive"])
     });
   }
   if (parsed.command === "update") {
@@ -1379,7 +1750,10 @@ async function main(argv) {
   return 0;
 }
 if (process.argv[1] && path12.resolve(fs11.realpathSync(fileURLToPath2(import.meta.url))) === path12.resolve(fs11.realpathSync(process.argv[1]))) {
-  main(process.argv).then((code) => process.exit(code));
+  main(process.argv).then((code) => process.exit(code)).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
 }
 export {
   main