arkaos 2.10.0 → 2.11.0

package/installer/platform.js

@@ -0,0 +1,20 @@
+/**
+ * ArkaOS Platform Helpers — single source of truth for platform branching.
+ *
+ * Centralises the ~19 scattered `process.platform === "win32"` checks into
+ * one importable module. Other installer files should import from here
+ * instead of inlining platform ternaries.
+ */
+
+import { platform } from "node:os";
+
+export const IS_WINDOWS = platform() === "win32";
+
+/** Hook script extension: `.ps1` on Windows, `.sh` elsewhere. */
+export const HOOK_EXT = IS_WINDOWS ? ".ps1" : ".sh";
+
+/** Command-line tool to locate executables. */
+export const CMD_FINDER = IS_WINDOWS ? "where" : "which";
+
+/** Python binary name (venv resolution is in python-resolver.js). */
+export const PYTHON_CMD = IS_WINDOWS ? "python" : "python3";

package/installer/prompts.js

@@ -5,16 +5,26 @@
  */
 
 import { createInterface } from "node:readline";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
-const rl = createInterface({ input: process.stdin, output: process.stdout });
+// Readline interface is lazily created so headless upgrade runs can
+// return without ever opening stdin. Eagerly constructing the interface
+// at module import caused `npx arkaos install --force` to block on a
+// closed-stdin pipe even when the wizard short-circuited below.
+let rl = null;
+function getRl() {
+  if (!rl) {
+    rl = createInterface({ input: process.stdin, output: process.stdout });
+  }
+  return rl;
+}
 
 function ask(question, defaultValue = "") {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
   return new Promise((resolve) => {
-    rl.question(`  ${question}${suffix}: `, (answer) => {
+    getRl().question(`  ${question}${suffix}: `, (answer) => {
       resolve(answer.trim() || defaultValue);
     });
   });
@@ -23,7 +33,7 @@ function ask(question, defaultValue = "") {
 function askYN(question, defaultYes = true) {
   const suffix = defaultYes ? " [Y/n]" : " [y/N]";
   return new Promise((resolve) => {
-    rl.question(`  ${question}${suffix}: `, (answer) => {
+    getRl().question(`  ${question}${suffix}: `, (answer) => {
       const a = answer.trim().toLowerCase();
       if (!a) resolve(defaultYes);
       else resolve(a === "y" || a === "yes");
@@ -37,7 +47,7 @@ function askChoice(question, options) {
     options.forEach((opt, i) => {
       console.log(`    ${i + 1}) ${opt.label}`);
     });
-    rl.question(`  Choose [1-${options.length}]: `, (answer) => {
+    getRl().question(`  Choose [1-${options.length}]: `, (answer) => {
       const idx = parseInt(answer.trim()) - 1;
       if (idx >= 0 && idx < options.length) {
         resolve(options[idx].value);
@@ -48,7 +58,101 @@ function askChoice(question, options) {
   });
 }
 
+// Canonical ArkaOS data directory. Mirrors the fallback used at the
+// top of installer/index.js::install so headless upgrade detection
+// can reach the existing profile.json before the wizard tries to ask
+// the user where their install lives.
+const DEFAULT_INSTALL_DIR = join(homedir(), ".arkaos");
+
+// When called on an upgrade and a valid profile.json already exists,
+// honor the rule documented in .claude/rules/node-installer.md:
+//
+//     No interactive prompts during headless/CI runs
+//
+// An upgrade by definition means the user already answered these
+// questions on a prior install, so re-asking every field (language,
+// market, role, company, project dir, vault, feature flags, keys)
+// blocks `npx arkaos install --force` even from a redirected-stdin
+// context like `/dev/null` or CI. readline reads directly from
+// process.stdin and does not honor those redirects.
+//
+// The short-circuit reads the existing profile and returns a config
+// compatible with installer/index.js::install's downstream expectations:
+//
+//   - User metadata fields (language, market, role, company,
+//     projectsDir, vaultPath) come from profile.json.
+//   - installDir is the directory we found the profile in.
+//   - Feature flags (installDashboard, installKnowledge,
+//     installTranscription) default to false on upgrade — an upgrade
+//     should NOT reinstall optional features; if the user wants to
+//     add one, they re-run a fresh install with the wizard. This
+//     preserves the existing install exactly.
+//   - API key fields are left empty; keys live in keys.json and the
+//     installer already merges them non-destructively.
+//
+// Returns null when the short-circuit conditions are not met, which
+// falls through to the interactive wizard below (fresh install or
+// upgrade with a corrupt/missing profile).
+function loadExistingProfileConfig(installDir) {
+  const profilePath = join(installDir, "profile.json");
+  if (!existsSync(profilePath)) return null;
+  try {
+    const profile = JSON.parse(readFileSync(profilePath, "utf-8"));
+    // Require the fields the downstream installer flow actually uses.
+    // Any missing field forces the wizard so we never write a
+    // half-populated profile back to disk on upgrade.
+    if (!profile.language || !profile.role) return null;
+    return {
+      language: profile.language,
+      market: profile.market || "",
+      role: profile.role,
+      company: profile.company || "",
+      projectsDir: profile.projectsDir || join(homedir(), "Projects"),
+      vaultPath: profile.vaultPath || "",
+      installDir,
+      // Upgrades preserve the existing install footprint; they do not
+      // re-opt-in to optional features. A user who wants to flip a
+      // feature flag on upgrade can re-run with the wizard.
+      // Exception: knowledge deps are always installed on upgrade because
+      // they are required for `npx arkaos index/search` to use vector
+      // search instead of degraded keyword fallback.
+      installDashboard: false,
+      installKnowledge: true,
+      installTranscription: false,
+      openaiKey: "",
+      googleKey: "",
+      falKey: "",
+    };
+  } catch {
+    // Corrupt profile.json — fall through to the wizard so the user
+    // has a path to fix it.
+    return null;
+  }
+}
+
 export async function runSetupPrompts(isUpgrade = false) {
+  // Headless upgrade short-circuit. See loadExistingProfileConfig.
+  if (isUpgrade) {
+    const existing = loadExistingProfileConfig(DEFAULT_INSTALL_DIR);
+    if (existing) {
+      console.log(`
+  ╔══════════════════════════════════════════════════════╗
+  ║  ArkaOS Upgrade — using existing profile            ║
+  ╚══════════════════════════════════════════════════════╝
+
+    Language:       ${existing.language}
+    Market:         ${existing.market || "(not set)"}
+    Role:           ${existing.role}
+    Company:        ${existing.company || "(not set)"}
+    Install dir:    ${existing.installDir}
+
+    Optional features are NOT re-installed on upgrade.
+    Re-run without --force to flip feature flags interactively.
+  `);
+      return existing;
+    }
+  }
+
   console.log(`
   ╔══════════════════════════════════════════════════════╗
   ║  ArkaOS Setup — Let's configure your environment    ║

package/installer/python-resolver.js

@@ -0,0 +1,251 @@
+/**
+ * ArkaOS Python Resolver — single source of truth for Python interpreter.
+ *
+ * Strategy: always use ~/.arkaos/venv. This isolates ArkaOS from system
+ * Python, avoids PEP 668 issues on macOS/Homebrew and Ubuntu 23.04+,
+ * and guarantees the doctor checks the same interpreter the installer uses.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import { execSync } from "node:child_process";
+
+const INSTALL_DIR = join(homedir(), ".arkaos");
+
+/**
+ * Return the path to the venv's Python interpreter.
+ * On Windows: ~/.arkaos/venv/Scripts/python.exe
+ * On Unix:    ~/.arkaos/venv/bin/python
+ */
+export function getVenvPython() {
+  if (platform() === "win32") {
+    return join(INSTALL_DIR, "venv", "Scripts", "python.exe");
+  }
+  return join(INSTALL_DIR, "venv", "bin", "python");
+}
+
+/**
+ * Return the path to the venv's pip.
+ */
+export function getVenvPip() {
+  if (platform() === "win32") {
+    return join(INSTALL_DIR, "venv", "Scripts", "pip.exe");
+  }
+  return join(INSTALL_DIR, "venv", "bin", "pip");
+}
+
+/**
+ * Return the ArkaOS Python interpreter — venv if it exists, fallback to system.
+ * This is the ONLY function other modules should use to get a Python path.
+ */
+export function getArkaosPython() {
+  const venvPy = getVenvPython();
+  if (existsSync(venvPy)) {
+    return venvPy;
+  }
+  // Fallback to system Python (for pre-venv installations)
+  return findSystemPython();
+}
+
+/**
+ * Return the ArkaOS pip — venv if it exists, fallback to system.
+ */
+export function getArkaosPip() {
+  const venvPip = getVenvPip();
+  if (existsSync(venvPip)) {
+    return venvPip;
+  }
+  // Fallback: use python -m pip with PEP 668 handling
+  return null;
+}
+
+/**
+ * Find system Python 3.11+ (used only during initial venv creation).
+ */
+export function findSystemPython() {
+  const isWindows = platform() === "win32";
+  const candidates = ["python3", "python"];
+  const finder = isWindows ? "where" : "which";
+
+  for (const cmd of candidates) {
+    try {
+      // stderr redirected via stdio, not shell operators, so it works the
+      // same on bash, zsh, and cmd.exe.
+      const version = execSync(`${cmd} --version`, {
+        stdio: ["pipe", "pipe", "pipe"],
+      }).toString().trim();
+      const match = version.match(/(\d+)\.(\d+)/);
+      if (match && parseInt(match[1]) >= 3 && parseInt(match[2]) >= 11) {
+        // Resolve to an absolute path using the platform-native locator.
+        try {
+          const resolved = execSync(`${finder} ${cmd}`, {
+            stdio: ["pipe", "pipe", "ignore"],
+          }).toString().trim().split(/\r?\n/)[0];
+          return resolved || cmd;
+        } catch {
+          return cmd;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+/**
+ * Create the ArkaOS venv if it doesn't exist.
+ * Returns true on success, false on failure.
+ */
+export function ensureVenv(log = console.log) {
+  const venvDir = join(INSTALL_DIR, "venv");
+  const venvPy = getVenvPython();
+
+  if (existsSync(venvPy)) {
+    return true; // Already exists
+  }
+
+  const systemPython = findSystemPython();
+  if (!systemPython) {
+    log("         \u26a0 No Python 3.11+ found — cannot create venv");
+    return false;
+  }
+
+  try {
+    execSync(`"${systemPython}" -m venv "${venvDir}"`, { stdio: "pipe", timeout: 60000 });
+    log(`         \u2713 Virtual environment created at ${venvDir}`);
+
+    // Upgrade pip inside the venv
+    try {
+      execSync(`"${venvPy}" -m pip install --upgrade pip --quiet`, { stdio: "pipe", timeout: 60000 });
+    } catch { /* pip upgrade is non-critical */ }
+
+    return true;
+  } catch (err) {
+    log(`         \u26a0 Failed to create venv: ${err.message.slice(0, 100)}`);
+    return false;
+  }
+}
+
+/**
+ * Extract a meaningful error message from a failed execSync error.
+ * Prefers stderr (the actual pip output), falls back to err.message.
+ * Collapses multi-line output into a single line and caps the length
+ * so a traceback does not dominate the installer log, while keeping
+ * the failing package name and the key "No matching distribution" /
+ * "error: subprocess-exited-with-error" markers visible.
+ */
+function formatPipError(err) {
+  let text = "";
+  if (err.stderr) {
+    text = err.stderr.toString();
+  } else if (err.stdout) {
+    text = err.stdout.toString();
+  } else if (err.message) {
+    text = err.message;
+  }
+  text = text
+    .replace(/\r/g, "")
+    .split("\n")
+    .map((l) => l.trimEnd())
+    .filter((l) => l.trim().length > 0)
+    .join(" | ");
+  if (text.length > 400) text = text.slice(0, 400) + "...";
+  return text;
+}
+
+/**
+ * Install Python packages using the ArkaOS interpreter.
+ * Uses venv pip (no PEP 668 issues) or falls back with --break-system-packages.
+ */
+export function pipInstall(packages, opts = {}) {
+  const { quiet = true, upgrade = false, editable = null, timeout = 120000, log = console.log } = opts;
+
+  const venvPip = getArkaosPip();
+  const arkaosPy = getArkaosPython();
+
+  const flags = [];
+  if (quiet) flags.push("--quiet");
+  if (upgrade) flags.push("--upgrade");
+
+  const pkgArg = editable ? `-e "${editable}"` : packages;
+
+  // Strategy 1: Use venv pip directly (preferred — no PEP 668)
+  if (venvPip && existsSync(venvPip)) {
+    try {
+      execSync(`"${venvPip}" install ${flags.join(" ")} ${pkgArg}`, { stdio: "pipe", timeout });
+      return true;
+    } catch (err) {
+      log(`         \u26a0 Venv pip install failed for ${packages}: ${formatPipError(err)}`);
+      return false;
+    }
+  }
+
+  // Strategy 2: Use python -m pip (system Python — handle PEP 668)
+  if (arkaosPy) {
+    // Try without --break-system-packages first
+    try {
+      execSync(`"${arkaosPy}" -m pip install ${flags.join(" ")} ${pkgArg}`, { stdio: "pipe", timeout });
+      return true;
+    } catch (err) {
+      const stderr = err.stderr ? err.stderr.toString() : err.message;
+      if (stderr.includes("externally-managed-environment")) {
+        // PEP 668 — retry with --break-system-packages
+        log("         \u26a0 PEP 668 detected — retrying with --break-system-packages");
+        try {
+          execSync(`"${arkaosPy}" -m pip install --break-system-packages ${flags.join(" ")} ${pkgArg}`, {
+            stdio: "pipe", timeout,
+          });
+          return true;
+        } catch (err2) {
+          log(`         \u26a0 pip install with --break-system-packages also failed for ${packages}: ${formatPipError(err2)}`);
+          return false;
+        }
+      }
+      log(`         \u26a0 pip install failed for ${packages}: ${formatPipError(err)}`);
+      return false;
+    }
+  }
+
+  log("         \u26a0 No Python interpreter available for pip install");
+  return false;
+}
+
+/**
+ * Check if the ArkaOS Python can import the core engine.
+ */
+export function canImportCore() {
+  const py = getArkaosPython();
+  if (!py || !existsSync(py)) return false;
+  try {
+    execSync(`"${py}" -c "from core.synapse.engine import SynapseEngine"`, {
+      stdio: "pipe",
+      timeout: 10000,
+      cwd: getRepoRoot(),
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the ArkaOS repo root from .repo-path or manifest.
+ */
+export function getRepoRoot() {
+  const repoPathFile = join(INSTALL_DIR, ".repo-path");
+  if (existsSync(repoPathFile)) {
+    const p = readFileSync(repoPathFile, "utf-8").trim();
+    if (existsSync(p)) return p;
+  }
+  // Fallback: try manifest
+  const manifestPath = join(INSTALL_DIR, "install-manifest.json");
+  if (existsSync(manifestPath)) {
+    try {
+      const m = JSON.parse(readFileSync(manifestPath, "utf-8"));
+      if (m.repoRoot && existsSync(m.repoRoot)) return m.repoRoot;
+    } catch {}
+  }
+  return null;
+}