@alecsibilia/luca 13.0.0-alpha.1

package/dist/chunks/init.mjs

@@ -0,0 +1,715 @@
+import * as p from '@clack/prompts';
+import { defineCommand, runMain } from 'citty';
+import { existsSync, chmodSync } from 'node:fs';
+import { mkdir, writeFile, readFile, readdir, copyFile } from 'node:fs/promises';
+import { join, dirname, delimiter } from 'node:path';
+import { l as lucaStateSchema } from '../shared/luca.CRmaAfXR.mjs';
+import 'node:crypto';
+import 'node:module';
+import 'node:url';
+import 'node:child_process';
+import { g as generateRunId } from '../shared/luca.naWEcQ4B.mjs';
+import { LUCA_VERSION } from '../index.mjs';
+import { d as defaultClaudeHome, r as resolveBundledArtifactsForHooks, i as installSkills } from '../shared/luca.B3saVjJm.mjs';
+import { l as logger } from '../shared/luca.dM-MKlNE.mjs';
+import { M as MuninndbInstallResultSchema, r as resolvePlatformTarget, g as getLucaHomePaths, a as MUNINNDB_BINARY_NAME, b as getCommonBinaryPaths, c as resolveMuninndbPort, d as checkMuninndbService, e as MuninndbServiceStatusSchema, w as waitForMuninndbHealthy, f as ensureLucaHome, h as checkMuninndbBinary, i as MUNINNDB_DEFAULT_PORT } from '../shared/luca.BYdjkfnz.mjs';
+import { join as join$1 } from 'pathe';
+import { c as checkPrerequisites, p as promptBunInstall } from '../shared/luca.DTomPq7I.mjs';
+import 'zod';
+import 'node:os';
+import 'consola';
+import 'semver';
+
+async function writeProjectSkeleton(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const lucaDir = join(opts.cwd, ".luca");
+  await mkdir(lucaDir, { recursive: true });
+  await writeIfMissing({
+    path: join(lucaDir, "state.json"),
+    contents: JSON.stringify(
+      lucaStateSchema.parse({ sessionId: generateRunId() }),
+      null,
+      2
+    ) + "\n",
+    force: opts.force ?? false,
+    log
+  });
+  await writeIfMissing({
+    path: join(lucaDir, "config.json"),
+    contents: JSON.stringify(
+      {
+        lucaVersion: LUCA_VERSION,
+        vault: null,
+        oversight: "full-auto"
+      },
+      null,
+      2
+    ) + "\n",
+    force: opts.force ?? false,
+    log
+  });
+}
+async function writeIfMissing(args) {
+  if (existsSync(args.path) && !args.force) {
+    args.log(`  skip:  ${args.path} (already exists)`);
+    return;
+  }
+  await writeFile(args.path, args.contents);
+  args.log(`  write: ${args.path}`);
+}
+
+const STAGE_GATE_MATCHER = "Edit|Write|NotebookEdit|Bash";
+const STAGE_GATE_COMMAND = "luca hook stage-gate";
+async function wireClaudeHooks(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const claudeHome = opts.claudeHome ?? defaultClaudeHome();
+  const settingsPath = join(claudeHome, "settings.json");
+  await mkdir(claudeHome, { recursive: true });
+  const existing = existsSync(settingsPath) ? JSON.parse(
+    await readFile(settingsPath, "utf-8")
+  ) ?? {} : {};
+  const next = mergeStageGateRegistration(existing);
+  await writeFile(settingsPath, JSON.stringify(next, null, 2) + "\n");
+  log(`  write: ${settingsPath}`);
+}
+function mergeStageGateRegistration(settings) {
+  const next = { ...settings };
+  next.hooks = { ...settings.hooks ?? {} };
+  const preToolUse = [...next.hooks.PreToolUse ?? []];
+  const alreadyRegistered = preToolUse.some(
+    (entry) => entry.hooks?.some((h) => h.command?.includes("stage-gate"))
+  );
+  if (alreadyRegistered) {
+    next.hooks.PreToolUse = preToolUse;
+    return next;
+  }
+  preToolUse.push({
+    matcher: STAGE_GATE_MATCHER,
+    hooks: [
+      {
+        type: "command",
+        command: STAGE_GATE_COMMAND,
+        timeout: 30
+      }
+    ]
+  });
+  next.hooks.PreToolUse = preToolUse;
+  return next;
+}
+
+const LUCA_HOOK_HANDLER_MARKER = "/.claude/hooks/";
+async function installHooks(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const artifactsRoot = opts.claudeArtifactsRoot ?? resolveBundledArtifactsForHooks();
+  if (artifactsRoot === null) {
+    log(
+      "  skip:  bundled hook artifacts not found \u2014 could not locate the @alecsibilia/luca package root (running from a non-bundled dev tree?)"
+    );
+    return;
+  }
+  const hooksSrcDir = join(artifactsRoot, "hooks");
+  const hooksDestDir = join(opts.cwd, ".claude", "hooks");
+  if (existsSync(hooksSrcDir)) {
+    await mkdir(hooksDestDir, { recursive: true });
+    const entries = await readdir(hooksSrcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".ts")) continue;
+      const from = join(hooksSrcDir, entry.name);
+      const to = join(hooksDestDir, entry.name);
+      await copyFile(from, to);
+      log(`  write: ${to}`);
+    }
+  } else {
+    log(`  skip:  bundled hook handlers missing (${hooksSrcDir})`);
+  }
+  const settingsSrc = join(artifactsRoot, "settings.json");
+  const settingsDest = join(opts.cwd, ".claude", "settings.json");
+  if (existsSync(settingsSrc)) {
+    await mkdir(dirname(settingsDest), { recursive: true });
+    const bundled = JSON.parse(
+      await readFile(settingsSrc, "utf-8")
+    );
+    const existing = existsSync(settingsDest) ? JSON.parse(
+      await readFile(settingsDest, "utf-8")
+    ) ?? {} : {};
+    const merged = mergeLucaHookSettings(existing, bundled);
+    await writeFile(settingsDest, JSON.stringify(merged, null, 2) + "\n");
+    log(`  write: ${settingsDest}`);
+  } else {
+    log(`  skip:  bundled settings.json missing (${settingsSrc})`);
+  }
+}
+function mergeLucaHookSettings(existing, bundled) {
+  const next = { ...existing };
+  const existingHooks = existing.hooks ?? {};
+  const bundledHooks = bundled.hooks ?? {};
+  const mergedHooks = {};
+  const events = /* @__PURE__ */ new Set([
+    ...Object.keys(existingHooks),
+    ...Object.keys(bundledHooks)
+  ]);
+  for (const event of events) {
+    const existingEntries = existingHooks[event] ?? [];
+    const bundledEntries = bundledHooks[event] ?? [];
+    const filtered = existingEntries.filter(
+      (entry) => !entry.hooks.some(
+        (h) => h.command?.includes(LUCA_HOOK_HANDLER_MARKER)
+      )
+    );
+    const combined = [...filtered, ...bundledEntries];
+    if (combined.length > 0) {
+      mergedHooks[event] = combined;
+    }
+  }
+  next.hooks = mergedHooks;
+  return next;
+}
+
+const MUNINNDB_DOWNLOAD_BASE = process.env.MUNINNDB_DOWNLOAD_BASE ?? "https://muninndb.com";
+const TRUSTED_INSTALL_HOSTS = /* @__PURE__ */ new Set(["muninndb.com", "www.muninndb.com"]);
+const MUNINNDB_INSTALL_SCRIPT_URL = process.env.MUNINNDB_INSTALL_SCRIPT_URL ?? `${MUNINNDB_DOWNLOAD_BASE}/install.sh`;
+function validateDownloadUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return {
+      valid: false,
+      error: `Invalid download URL: "${url}" is not a valid URL.`
+    };
+  }
+  if (parsed.protocol !== "https:") {
+    return {
+      valid: false,
+      error: `Download URL must use HTTPS. Got: ${parsed.protocol} in "${url}"`
+    };
+  }
+  return { valid: true };
+}
+function extractPathFromOutput(stdout) {
+  const binaryName = MUNINNDB_BINARY_NAME;
+  const lines = stdout.split("\n");
+  for (const line of lines) {
+    const installPattern = new RegExp(
+      `(?:installed?\\s+(?:to|at|in)?|saved?\\s+(?:to|at|in)?|binary\\s+(?:at|in)?)\\s+(\\S*${binaryName}\\S*)`,
+      "i"
+    );
+    const installMatch = line.match(installPattern);
+    if (installMatch?.[1]) {
+      const candidate = installMatch[1].replace(/['"]+/g, "");
+      if (candidate.startsWith("/") && existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const pathPattern = new RegExp(`(\\/\\S*\\/${binaryName})(?:\\s|$)`);
+    const pathMatch = line.match(pathPattern);
+    if (pathMatch?.[1]) {
+      const candidate = pathMatch[1].replace(/['"]+/g, "");
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+async function findInstalledBinary(preferredDir, installStdout) {
+  const preferredPath = join$1(preferredDir, MUNINNDB_BINARY_NAME);
+  if (existsSync(preferredPath)) {
+    return preferredPath;
+  }
+  if (installStdout) {
+    const outputPath = extractPathFromOutput(installStdout);
+    if (outputPath) {
+      return outputPath;
+    }
+  }
+  const commonPaths = getCommonBinaryPaths();
+  for (const candidate of commonPaths) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  const whichResult = Bun.which(MUNINNDB_BINARY_NAME);
+  if (whichResult && existsSync(whichResult)) {
+    return whichResult;
+  }
+  const home = process.env.HOME;
+  if (home) {
+    try {
+      const findResult = await Bun.$`find ${home} -maxdepth 4 -name ${MUNINNDB_BINARY_NAME} -type f 2>/dev/null | head -1`.nothrow().quiet();
+      const foundPath = findResult.stdout.toString().trim();
+      if (foundPath && existsSync(foundPath)) {
+        return foundPath;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function downloadMuninndbBinary(targetDir, options = {}) {
+  const { showProgress = true } = options;
+  const urlValidation = validateDownloadUrl(MUNINNDB_INSTALL_SCRIPT_URL);
+  if (!urlValidation.valid) {
+    return MuninndbInstallResultSchema.parse({
+      success: false,
+      binaryPath: null,
+      error: urlValidation.error
+    });
+  }
+  if (process.env.MUNINNDB_ALLOW_UNTRUSTED !== "1") {
+    try {
+      const parsed = new URL(MUNINNDB_INSTALL_SCRIPT_URL);
+      if (!TRUSTED_INSTALL_HOSTS.has(parsed.hostname)) {
+        return MuninndbInstallResultSchema.parse({
+          success: false,
+          binaryPath: null,
+          error: `Install script URL hostname "${parsed.hostname}" is not in the trusted hosts list. Set MUNINNDB_ALLOW_UNTRUSTED=1 to bypass this check.`
+        });
+      }
+    } catch {
+    }
+  }
+  const platformResult = resolvePlatformTarget();
+  if (!platformResult.success) {
+    return MuninndbInstallResultSchema.parse({
+      success: false,
+      binaryPath: null,
+      error: platformResult.error
+    });
+  }
+  const dir = getLucaHomePaths().bin;
+  const spinner = showProgress ? p.spinner() : null;
+  try {
+    spinner?.start(
+      `Installing MuninnDB via official install script (${platformResult.target})...`
+    );
+    const curlResult = await Bun.$`curl -sSL -f ${MUNINNDB_INSTALL_SCRIPT_URL}`.nothrow().quiet();
+    if (curlResult.exitCode !== 0) {
+      const stderr = curlResult.stderr.toString().trim();
+      const errorMsg = stderr ? `Failed to download install script (exit ${curlResult.exitCode}): ${stderr}` : `Failed to download install script (exit ${curlResult.exitCode}) from ${MUNINNDB_INSTALL_SCRIPT_URL}`;
+      spinner?.stop(`Install failed: ${errorMsg}`);
+      return MuninndbInstallResultSchema.parse({
+        success: false,
+        binaryPath: null,
+        error: errorMsg
+      });
+    }
+    const scriptContent = curlResult.stdout.toString();
+    if (!scriptContent.trim()) {
+      spinner?.stop("Install failed: downloaded script is empty");
+      return MuninndbInstallResultSchema.parse({
+        success: false,
+        binaryPath: null,
+        error: "Downloaded install script is empty."
+      });
+    }
+    const installResult = await Bun.$`INSTALL_DIR=${dir} BIN_DIR=${dir} PREFIX=${dir} sh -c ${scriptContent}`.nothrow().quiet();
+    const installStdout = installResult.stdout.toString();
+    const installStderr = installResult.stderr.toString().trim();
+    if (installResult.exitCode !== 0) {
+      const errorMsg = installStderr ? `Install script failed (exit ${installResult.exitCode}): ${installStderr}` : `Install script failed with exit code ${installResult.exitCode}`;
+      spinner?.stop(`Install failed: ${errorMsg}`);
+      return MuninndbInstallResultSchema.parse({
+        success: false,
+        binaryPath: null,
+        error: errorMsg
+      });
+    }
+    const foundPath = await findInstalledBinary(dir, installStdout);
+    if (!foundPath) {
+      const outputHint = installStdout.trim() ? `
+Install script output:
+${installStdout.trim().slice(0, 500)}` : "";
+      const stderrHint = installStderr ? `
+Install script stderr:
+${installStderr.slice(0, 300)}` : "";
+      spinner?.stop(
+        "Install script succeeded but binary not found on system"
+      );
+      return MuninndbInstallResultSchema.parse({
+        success: false,
+        binaryPath: null,
+        error: `MuninnDB install script completed successfully but the binary could not be found. Check that the install script placed it in a standard location (~/.local/bin/, /usr/local/bin/, ~/bin/, or ~/.muninndb/bin/).${outputHint}${stderrHint}`
+      });
+    }
+    const preferredPath = join$1(dir, MUNINNDB_BINARY_NAME);
+    if (foundPath !== preferredPath) {
+      try {
+        const sourceFile = Bun.file(foundPath);
+        await Bun.write(preferredPath, sourceFile);
+        await Bun.$`chmod 755 ${preferredPath}`.quiet();
+      } catch {
+        spinner?.stop(`MuninnDB installed at ${foundPath}`);
+        return MuninndbInstallResultSchema.parse({
+          success: true,
+          binaryPath: foundPath,
+          error: null
+        });
+      }
+    }
+    spinner?.stop("MuninnDB installed successfully");
+    return MuninndbInstallResultSchema.parse({
+      success: true,
+      binaryPath: preferredPath,
+      error: null
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : "Unknown install error";
+    spinner?.stop(`Install failed: ${errorMsg}`);
+    return MuninndbInstallResultSchema.parse({
+      success: false,
+      binaryPath: null,
+      error: errorMsg
+    });
+  }
+}
+
+async function startMuninndb(options = {}) {
+  const {
+    port: rawPort,
+    dataDir: rawDataDir,
+    timeoutMs = 1e4,
+    binaryPath: rawBinaryPath
+  } = options;
+  const port = resolveMuninndbPort(rawPort);
+  const homePaths = getLucaHomePaths();
+  const binaryPath = rawBinaryPath ?? join$1(homePaths.bin, MUNINNDB_BINARY_NAME);
+  const dataDir = rawDataDir ?? process.env.MUNINNDB_DATA_DIR ?? join$1(homePaths.root, "muninndb-data");
+  const pidfilePath = join$1(homePaths.root, "muninndb.pid");
+  const existingStatus = await checkMuninndbService(port);
+  if (existingStatus.healthy) {
+    return existingStatus;
+  }
+  await cleanStalePidfile(pidfilePath);
+  try {
+    await Bun.$`mkdir -p ${dataDir}`.quiet();
+  } catch {
+  }
+  try {
+    const proc = Bun.spawn(
+      [binaryPath, "--port", String(port), "--data-dir", dataDir],
+      {
+        stdout: "ignore",
+        stderr: "ignore",
+        stdin: "ignore"
+      }
+    );
+    if (proc.pid) {
+      await Bun.write(pidfilePath, String(proc.pid));
+      chmodSync(pidfilePath, 384);
+      proc.unref();
+    }
+  } catch {
+    return MuninndbServiceStatusSchema.parse({
+      running: false,
+      port,
+      pid: null,
+      healthy: false
+    });
+  }
+  return waitForMuninndbHealthy({ port, timeoutMs });
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removePidfile(pidfilePath) {
+  try {
+    await Bun.$`rm -f ${pidfilePath}`.quiet();
+  } catch {
+  }
+}
+async function cleanStalePidfile(pidfilePath) {
+  try {
+    const exists = await Bun.file(pidfilePath).exists();
+    if (!exists) return;
+    const pidStr = await Bun.file(pidfilePath).text();
+    const pid = parseInt(pidStr.trim(), 10);
+    if (isNaN(pid) || pid <= 0 || !isProcessRunning(pid)) {
+      await removePidfile(pidfilePath);
+      return;
+    }
+    if (!await verifyProcessIdentity(pid)) {
+      console.warn(
+        `[muninndb-service] PID ${pid} in pidfile is not a MuninnDB process. Removing stale pidfile.`
+      );
+      await removePidfile(pidfilePath);
+    }
+  } catch {
+  }
+}
+async function verifyProcessIdentity(pid) {
+  try {
+    const result = await Bun.$`ps -p ${pid} -o comm=`.quiet();
+    const comm = result.text().trim().toLowerCase();
+    return comm.includes("muninn");
+  } catch {
+    return false;
+  }
+}
+
+function isOnPath(dir) {
+  const pathEnv = process.env.PATH ?? "";
+  const entries = pathEnv.split(delimiter);
+  return entries.includes(dir);
+}
+function getPathGuidance(dir) {
+  const shell = process.env.SHELL ?? "";
+  const shellName = shell.split("/").pop() ?? "";
+  switch (shellName) {
+    case "zsh":
+      return [
+        "Add to your shell config (~/.zshrc):",
+        `  export PATH="${dir}:$PATH"`,
+        "",
+        "Then reload:",
+        "  source ~/.zshrc"
+      ].join("\n");
+    case "bash":
+      return [
+        "Add to your shell config (~/.bashrc or ~/.bash_profile):",
+        `  export PATH="${dir}:$PATH"`,
+        "",
+        "Then reload:",
+        "  source ~/.bashrc"
+      ].join("\n");
+    case "fish":
+      return [
+        "Add to your fish config (~/.config/fish/config.fish):",
+        `  fish_add_path ${dir}`,
+        "",
+        "Then reload:",
+        "  source ~/.config/fish/config.fish"
+      ].join("\n");
+    default:
+      return [
+        "Add to your shell config:",
+        `  export PATH="${dir}:$PATH"`
+      ].join("\n");
+  }
+}
+
+const initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Bootstrap MuninnDB and set up the Luca home directory"
+  },
+  args: {
+    "skip-prerequisites": {
+      type: "boolean",
+      description: "Skip prerequisite checks",
+      default: false
+    },
+    "skip-muninndb": {
+      type: "boolean",
+      description: "Skip MuninnDB binary download and service setup",
+      default: false
+    },
+    "skip-claude": {
+      type: "boolean",
+      description: "Skip the global Claude integration (~/.claude/ skills, commands, agents, stage-gate hook)",
+      default: false
+    },
+    "skip-project": {
+      type: "boolean",
+      description: "Skip the per-project .luca/ skeleton",
+      default: false
+    }
+  },
+  async run({ args }) {
+    p.intro("luca init");
+    let prereqsVersion = null;
+    let prereqsPlatform = "";
+    let muninndbHealthy = false;
+    let muninndbPort = null;
+    let muninndbBinaryPath = null;
+    if (!args["skip-prerequisites"]) {
+      p.log.step("Step 1/5: Prerequisites");
+      const prereqs = checkPrerequisites();
+      if (!prereqs.ok) {
+        const shouldContinue = await promptBunInstall();
+        if (!shouldContinue) {
+          p.outro(
+            "Setup cancelled. Install Bun and run `luca init` again."
+          );
+          process.exit(1);
+        }
+        const recheck = checkPrerequisites();
+        if (!recheck.ok) {
+          logger.error(
+            "Bun still not detected. Please install Bun and try again."
+          );
+          process.exit(1);
+        }
+      }
+      prereqsVersion = prereqs.bun.version ?? "detected";
+      prereqsPlatform = `${prereqs.platform.os}/${prereqs.platform.arch}`;
+      p.log.success(`Bun ${prereqsVersion} (${prereqsPlatform})`);
+    } else {
+      p.log.info("Step 1/5: Prerequisites (skipped)");
+    }
+    p.log.step("Step 2/5: Luca home directory");
+    const homePaths = await ensureLucaHome();
+    p.log.success(`Luca home directory: ${homePaths.root}`);
+    if (!args["skip-muninndb"]) {
+      p.log.step("Step 3/5: MuninnDB");
+      const binaryStatus = await checkMuninndbBinary();
+      if (!binaryStatus.installed) {
+        p.log.info("MuninnDB not found. Downloading...");
+        const installResult = await downloadMuninndbBinary();
+        if (!installResult.success) {
+          p.log.warn(
+            `MuninnDB download failed: ${installResult.error ?? "unknown error"}`
+          );
+          p.log.warn(
+            "You can install MuninnDB later or run `luca init` again."
+          );
+        } else {
+          muninndbBinaryPath = installResult.binaryPath;
+          p.log.success(
+            `MuninnDB binary installed: ${installResult.binaryPath}`
+          );
+        }
+      } else {
+        muninndbBinaryPath = binaryStatus.path;
+        p.log.success(
+          `MuninnDB binary found: ${binaryStatus.path}${binaryStatus.version ? ` (${binaryStatus.version})` : ""}`
+        );
+      }
+      const recheckBinary = await checkMuninndbBinary();
+      if (recheckBinary.installed && recheckBinary.executable) {
+        p.log.info("Starting MuninnDB service...");
+        const serviceStatus = await startMuninndb();
+        if (serviceStatus.healthy) {
+          muninndbHealthy = true;
+          muninndbPort = serviceStatus.port;
+          p.log.success(
+            `MuninnDB running on port ${serviceStatus.port}${serviceStatus.pid ? ` (PID ${serviceStatus.pid})` : ""}`
+          );
+        } else {
+          p.log.warn(
+            "MuninnDB started but health check failed. It may need a moment to initialize."
+          );
+          p.log.info("Check status with: luca doctor");
+        }
+      }
+      if (!isOnPath(homePaths.bin)) {
+        const guidance = getPathGuidance(homePaths.bin);
+        p.note(
+          [
+            `${homePaths.bin} is not on your PATH.`,
+            "Add it so the MuninnDB binary is available globally:",
+            "",
+            guidance
+          ].join("\n"),
+          "PATH Setup Required"
+        );
+      }
+    } else {
+      p.log.info("Step 3/5: MuninnDB (skipped)");
+    }
+    const claudeHome = defaultClaudeHome();
+    let claudeSetupRan = false;
+    if (!args["skip-claude"]) {
+      p.log.step("Step 4/5: Claude integration (~/.claude/)");
+      await installSkills({ log: (msg) => p.log.info(msg) });
+      await wireClaudeHooks({ log: (msg) => p.log.info(msg) });
+      claudeSetupRan = true;
+      p.log.success(`Claude skills and stage-gate hook installed to ${claudeHome}`);
+    } else {
+      p.log.info("Step 4/5: Claude integration (skipped)");
+    }
+    let projectSetupRan = false;
+    if (!args["skip-project"]) {
+      p.log.step("Step 5/5: Project skeleton (.luca/ + .claude/hooks/)");
+      const projectCwd = process.cwd();
+      await writeProjectSkeleton({
+        cwd: projectCwd,
+        log: (msg) => p.log.info(msg)
+      });
+      await installHooks({
+        cwd: projectCwd,
+        log: (msg) => p.log.info(msg)
+      });
+      projectSetupRan = true;
+      p.log.success(`Per-project skeleton written to ${projectCwd}/.luca/ + ${projectCwd}/.claude/`);
+    } else {
+      p.log.info("Step 5/5: Project skeleton (skipped)");
+    }
+    const readout = [];
+    readout.push("Prerequisites:");
+    if (prereqsVersion) {
+      readout.push(`  Bun ${prereqsVersion} (${prereqsPlatform})`);
+    } else {
+      readout.push("  Skipped");
+    }
+    readout.push("");
+    readout.push("MuninnDB:");
+    if (args["skip-muninndb"]) {
+      readout.push("  Skipped");
+    } else if (muninndbHealthy) {
+      readout.push(`  Running on port ${muninndbPort}`);
+      if (muninndbBinaryPath) {
+        readout.push(`  Binary: ${muninndbBinaryPath}`);
+      }
+    } else {
+      readout.push(
+        "  Not running (start with `muninn start` or re-run `luca init`)"
+      );
+    }
+    readout.push("");
+    readout.push("Directories:");
+    readout.push(`  ${homePaths.root}/`);
+    readout.push(`  ${homePaths.bin}/`);
+    if (claudeSetupRan) {
+      readout.push(`  ${claudeHome}/  (Claude skills, agents, hook \u2014 global)`);
+    }
+    if (projectSetupRan) {
+      readout.push(`  ${process.cwd()}/.luca/  (per-project planning)`);
+    }
+    readout.push("");
+    readout.push("Next steps:");
+    readout.push(
+      "  To set up a project vault: cd <project> && luca vault:init"
+    );
+    readout.push('  To start the pipeline:     lu "<your task>"');
+    readout.push(
+      "  To seed project conventions:        invoke /luca-init from Claude Code"
+    );
+    readout.push(
+      "    (probes branching/commits/PR/release/tracker conventions and"
+    );
+    readout.push(
+      "     stores them in MuninnDB; downstream pipeline modes consult them)"
+    );
+    const mcpPort = muninndbPort ?? MUNINNDB_DEFAULT_PORT;
+    readout.push(
+      "  To expose MuninnDB to Claude Code: register it as an MCP server,"
+    );
+    readout.push(
+      `    e.g. claude mcp add --transport http muninn http://localhost:${mcpPort}/mcp \\`
+    );
+    readout.push(
+      '         --header "Authorization: Bearer <your-muninn-api-key>"'
+    );
+    readout.push(
+      '    (or add a "muninn" entry under mcpServers in .mcp.json). Use the'
+    );
+    readout.push(
+      "    same key as `luca vault:init` (.env MUNINN_DB_API_KEY). See the"
+    );
+    readout.push('    README "MuninnDB" section for details.');
+    p.note(readout.join("\n"), "Setup Complete");
+    p.outro("Luca is ready. Happy building!");
+  }
+});
+const runInit = () => runMain(initCommand);
+
+export { initCommand, runInit };