nemoris 0.1.0

package/src/onboarding/phases/ollama.js

@@ -0,0 +1,345 @@
+/**
+ * Ollama onboarding sub-phase — optional, runs inside Build (Phase 3).
+ *
+ * Steps: binary check → optional install/start → model selection → config write → smoke test.
+ * Fully skippable — never blocks setup if Ollama is not installed.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import {
+  prompt, select, confirm,
+  green, yellow, dim, cyan, progressLine,
+} from "../tui.js";
+import { writeEnvFile } from "../auth/api-key.js";
+import { detectOllama } from "../auth/ollama-detect.js";
+
+const execFileAsync = promisify(execFile);
+
+const DEFAULT_PRIMARY_MODEL = "kimi-k2.5";
+const DEFAULT_FALLBACK_MODEL = "qwen3:8b";
+const DEFAULT_BUMP_MODEL = "qwen3:14b";
+const EMBEDDING_MODEL = "nomic-embed-text";
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+/**
+ * Parse the text output of `ollama list` into model name strings.
+ * Skips the header row (starts with "NAME").
+ */
+export function parseOllamaList(output) {
+  const models = [];
+  for (const line of output.trim().split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || /^NAME\s/i.test(trimmed)) continue;
+    const name = trimmed.split(/\s+/)[0];
+    if (name) models.push(name);
+  }
+  return models;
+}
+
+function upsertRouterSection(content, sectionName, sectionBody) {
+  const escaped = sectionName.replace(/\./g, "\\.");
+  const sectionRe = new RegExp(`\\n?\\[${escaped}\\][\\s\\S]*?(?=\\n\\[|$)`, "s");
+  if (sectionRe.test(content)) {
+    return content.replace(sectionRe, `\n${sectionBody}`);
+  }
+  return content.trimEnd() + `\n\n${sectionBody}`;
+}
+
+/**
+ * Patch config/router.toml to set or update the local Ollama lanes.
+ */
+export function patchRouterLocalModels(installDir, models = []) {
+  const routerPath = path.join(installDir, "config", "router.toml");
+  let content = "";
+  try { content = fs.readFileSync(routerPath, "utf8"); } catch { /* new file */ }
+
+  const primaryModel = models[0] || DEFAULT_PRIMARY_MODEL;
+  const reportModel = models[1] || models[0] || DEFAULT_FALLBACK_MODEL;
+  const bumpModel = models[2] || models[1] || DEFAULT_BUMP_MODEL;
+  const fallbackMatch = content.match(/\[lanes\.local_report\][\s\S]*?fallback = "([^"]+)"/);
+  const fallbackLine = fallbackMatch?.[1] ? `fallback = "${fallbackMatch[1]}"\n` : "";
+
+  content = upsertRouterSection(
+    content,
+    "lanes.local_primary",
+    `[lanes.local_primary]\nprimary = "ollama/${primaryModel}"\n`,
+  );
+  content = upsertRouterSection(
+    content,
+    "lanes.local_cheap",
+    `[lanes.local_cheap]\nprimary = "ollama/${primaryModel}"\n`,
+  );
+  content = upsertRouterSection(
+    content,
+    "lanes.local_report",
+    `[lanes.local_report]\nprimary = "ollama/${reportModel}"\n${fallbackLine}manual_bump = "ollama/${bumpModel}"\n`,
+  );
+
+  fs.writeFileSync(routerPath, content.trimStart() + "\n", "utf8");
+}
+
+export function patchRouterLocalPrimary(installDir, model) {
+  patchRouterLocalModels(installDir, [model]);
+}
+
+/**
+ * Pull the embedding model if not already present.
+ * Returns true if the model is available after the attempt.
+ */
+export async function pullEmbeddingModel(exec, availableModels = []) {
+  const baseName = EMBEDDING_MODEL.split(":")[0];
+  if (availableModels.some((m) => m.startsWith(baseName))) {
+    return true;
+  }
+  try {
+    await exec("ollama", ["pull", EMBEDDING_MODEL], { timeout: 120000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Enable embeddings in config and env after Ollama setup succeeds.
+ */
+export function enableEmbeddings(installDir) {
+  const embeddingsPath = path.join(installDir, "config", "embeddings.toml");
+  try {
+    let content = fs.readFileSync(embeddingsPath, "utf8");
+    content = content.replace(/^enabled\s*=\s*false/m, "enabled = true");
+    content = content.replace(/^index_on_write\s*=\s*false/m, "index_on_write = true");
+    fs.writeFileSync(embeddingsPath, content, "utf8");
+  } catch { /* file may not exist yet — will be created on first run */ }
+
+  writeEnvFile(installDir, { NEMORIS_ALLOW_EMBEDDINGS: "1" });
+}
+
+async function hasCommand(exec, command) {
+  try {
+    await exec(command, ["--version"], { timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForOllamaReady({ fetchImpl = globalThis.fetch, timeoutMs = 30000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await detectOllama({ fetchImpl });
+    if (result.ok) {
+      return result;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  return { ok: false, modelCount: 0, models: [] };
+}
+
+export async function installAndStartOllama(exec, { platform = process.platform, fetchImpl = globalThis.fetch } = {}) {
+  try {
+    const useBrew = platform === "darwin" && await hasCommand(exec, "brew");
+    if (useBrew) {
+      await exec("brew", ["install", "ollama"], { timeout: 300000 });
+    } else {
+      await exec("sh", ["-lc", "curl -fsSL https://ollama.com/install.sh | sh"], { timeout: 300000 });
+    }
+
+    await exec("sh", ["-lc", "nohup ollama serve >/tmp/nemoris-ollama.log 2>&1 &"], { timeout: 5000 });
+    const ready = await waitForOllamaReady({ fetchImpl, timeoutMs: 30000 });
+    return ready.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function chooseOllamaModels(availableModels = []) {
+  const curated = [];
+  const addChoice = (value, description) => {
+    if (!curated.some((item) => item.value === value)) {
+      curated.push({ label: value, value, description });
+    }
+  };
+
+  for (const model of availableModels.slice(0, 8)) {
+    addChoice(model, "Already installed.");
+  }
+  addChoice(DEFAULT_PRIMARY_MODEL, "Fast default for local work.");
+  addChoice(DEFAULT_FALLBACK_MODEL, "Reliable local fallback.");
+  addChoice(DEFAULT_BUMP_MODEL, "Heavier local bump option.");
+
+  const chosen = [];
+  while (chosen.length < 3) {
+    const remaining = curated.filter((item) => !chosen.includes(item.value));
+    const options = [...remaining];
+    if (chosen.length > 0) {
+      options.push({
+        label: "Done",
+        value: "__done__",
+        description: "Continue setup with the models already selected.",
+      });
+    }
+    options.push({
+      label: "Enter a different model name...",
+      value: "__custom__",
+      description: "Use a specific Ollama tag not shown here.",
+    });
+
+    const picked = await select(
+      chosen.length === 0 ? "Local default model:" : `Add another local model (${chosen.length}/3 selected):`,
+      options,
+    );
+
+    if (picked === "__done__") {
+      break;
+    }
+
+    let model = picked;
+    if (picked === "__custom__") {
+      model = await prompt("Model name", DEFAULT_PRIMARY_MODEL);
+    }
+
+    model = String(model || "").trim();
+    if (model && !chosen.includes(model)) {
+      chosen.push(model);
+    }
+  }
+
+  return chosen;
+}
+
+// ── Main Phase ───────────────────────────────────────────────────
+
+/**
+ * Run the Ollama onboarding sub-phase.
+ *
+ * @param {{ installDir: string, nonInteractive?: boolean, execImpl?: Function, fetchImpl?: Function, platform?: string }} options
+ * @returns {Promise<{ configured: boolean, verified: boolean, model?: string, models?: string[] }>}
+ */
+export async function runOllamaPhase({ installDir, nonInteractive = false, execImpl = null, fetchImpl = globalThis.fetch, platform = process.platform }) {
+  const exec = execImpl || (async (cmd, args, opts) => execFileAsync(cmd, args, opts));
+
+  if (nonInteractive) {
+    if (process.env.NEMORIS_SKIP_OLLAMA === "true") {
+      return { configured: false, verified: false };
+    }
+
+    try {
+      await exec("ollama", ["--version"], { timeout: 5000 });
+    } catch {
+      console.log(`  ${yellow("!")} Ollama not installed — skipping local model setup.`);
+      console.log(`  ${dim("Install from https://ollama.com then run: nemoris setup ollama")}`);
+      return { configured: false, verified: false };
+    }
+
+    const requestedModels = String(process.env.NEMORIS_OLLAMA_MODELS || process.env.NEMORIS_OLLAMA_MODEL || "")
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean);
+    let model = requestedModels[0] || DEFAULT_PRIMARY_MODEL;
+
+    try {
+      const { stdout } = await exec("ollama", ["list"], { timeout: 10000 });
+      const available = parseOllamaList(stdout);
+      const baseName = model.split(":")[0];
+      if (available.length > 0 && !available.some((item) => item.startsWith(baseName))) {
+        model = available[0];
+      }
+    } catch { /* keep configured/default model */ }
+
+    const localModels = requestedModels.length > 0 ? requestedModels : [model];
+    patchRouterLocalModels(installDir, localModels);
+
+    let availableForEmbed = [];
+    try {
+      const { stdout } = await exec("ollama", ["list"], { timeout: 10000 });
+      availableForEmbed = parseOllamaList(stdout);
+    } catch { /* best effort */ }
+    const embeddingReady = await pullEmbeddingModel(exec, availableForEmbed);
+    if (embeddingReady) {
+      enableEmbeddings(installDir);
+    }
+
+    try {
+      await exec("ollama", ["run", localModels[0], "say hello"], { timeout: 30000 });
+      console.log(`  ${green("✅")} Ollama connected — local inference ready`);
+      return { configured: true, verified: true, model: localModels[0], models: localModels, embeddingReady };
+    } catch (err) {
+      if (err.killed || err.signal || err.code === "ETIMEDOUT") {
+        console.log(`  ${yellow("⚠️")} Model didn't respond — it may still be loading — you can try again later with \`nemoris setup ollama\``);
+      } else {
+        console.log(`  ${yellow("⚠️")} Model test failed — you can try again later with \`nemoris setup ollama\``);
+      }
+      return { configured: true, verified: false, model: localModels[0], models: localModels, embeddingReady };
+    }
+  }
+
+  console.log(`\n  Want to run AI locally on your machine? ${cyan("Ollama")} lets you use powerful models for free — no API keys, no cloud costs.\n`);
+
+  const gate = await confirm("Want to add a free local fallback using Ollama?", true);
+  if (!gate) {
+    return { configured: false, verified: false };
+  }
+
+  let version = "";
+  try {
+    const { stdout } = await exec("ollama", ["--version"], { timeout: 5000 });
+    version = stdout.trim();
+  } catch {
+    console.log(`\n  ${yellow("!")} Ollama is not installed on this machine.`);
+    const shouldInstall = await confirm("Want to install Ollama now?", true);
+    if (!shouldInstall) {
+      console.log(`  ${dim("Skipping local model setup for now.")}\n`);
+      return { configured: false, verified: false };
+    }
+
+    console.log(`\n  ${dim("Installing Ollama and waiting for it to start...")}`);
+    const installed = await installAndStartOllama(exec, { platform, fetchImpl });
+    if (!installed) {
+      console.log(`  ${yellow("!")} Ollama install or startup failed — continuing without local models.\n`);
+      return { configured: false, verified: false };
+    }
+    version = "installed during setup";
+  }
+
+  console.log(progressLine("Ollama found", version || "installed"));
+
+  let availableModels = [];
+  try {
+    const { stdout } = await exec("ollama", ["list"], { timeout: 10000 });
+    availableModels = parseOllamaList(stdout);
+  } catch { /* no models listed */ }
+
+  console.log(`\n  Which local models would you like to use? ${dim(`(${DEFAULT_PRIMARY_MODEL} is fastest, ${DEFAULT_FALLBACK_MODEL} is reliable)`)}`);
+  const chosenModels = await chooseOllamaModels(availableModels);
+  const localModels = chosenModels.length > 0 ? chosenModels : [DEFAULT_PRIMARY_MODEL];
+
+  patchRouterLocalModels(installDir, localModels);
+  console.log(progressLine("Local models set", `config/router.toml (${localModels.join(", ")})`));
+
+  console.log(`\n  Pulling embedding model (${dim(EMBEDDING_MODEL)})...`);
+  const embeddingReady = await pullEmbeddingModel(exec, availableModels);
+  if (embeddingReady) {
+    enableEmbeddings(installDir);
+    console.log(progressLine("Embeddings enabled", `${EMBEDDING_MODEL} → semantic search`));
+  } else {
+    console.log(`  ${yellow("!")} Embedding model pull failed — semantic search disabled for now.`);
+  }
+
+  console.log(`\n  Testing ${cyan(localModels[0])}...`);
+  try {
+    await exec("ollama", ["run", localModels[0], "say hello"], { timeout: 30000 });
+    console.log(`  ${green("✅")} Ollama connected — local inference ready`);
+    return { configured: true, verified: true, model: localModels[0], models: localModels, embeddingReady };
+  } catch (err) {
+    if (err.killed || err.signal || err.code === "ETIMEDOUT") {
+      console.log(`  ${yellow("⚠️")} Model didn't respond — it may still be loading — you can try again later with \`nemoris setup ollama\``);
+    } else {
+      console.log(`  ${yellow("⚠️")} Model test failed — you can try again later with \`nemoris setup ollama\``);
+    }
+    return { configured: true, verified: false, model: localModels[0], models: localModels, embeddingReady };
+  }
+}

package/src/onboarding/phases/scaffold.js

@@ -0,0 +1,99 @@
+/**
+ * Scaffold phase — creates the full directory tree and writes default config
+ * files from templates. Safe to run multiple times (idempotent).
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  runtimeTemplate,
+  deliveryTemplate,
+  peersTemplate,
+  outputContractsTemplate,
+  embeddingsTemplate,
+  improvementTargetsTemplate,
+  jobTemplate,
+  policyTemplates,
+  scaffoldToolsAndSkills,
+} from "../templates.js";
+
+// Directories to create under installDir
+const DIRECTORIES = [
+  path.join("config", "agents"),
+  path.join("config", "providers"),
+  path.join("config", "jobs"),
+  path.join("config", "policies"),
+  path.join("config", "identity"),
+  "state",
+  path.join("state", "memory"),
+];
+
+/**
+ * Write a file only if it does not already exist (idempotency).
+ * @param {string} filePath  Absolute path to the target file.
+ * @param {string} content   Content to write.
+ * @returns {"created"|"exists"}
+ */
+function writeIfMissing(filePath, content) {
+  if (fs.existsSync(filePath)) {
+    return "exists";
+  }
+  fs.writeFileSync(filePath, content, "utf8");
+  return "created";
+}
+
+/**
+ * Scaffold the nemoris installation directory.
+ *
+ * @param {{ installDir: string }} options
+ * @returns {Promise<{ dirs: string[], files: { path: string, status: "created"|"exists" }[] }>}
+ */
+export async function scaffold({ installDir }) {
+  const createdDirs = [];
+
+  // 1. Create all required directories
+  for (const rel of DIRECTORIES) {
+    const absPath = path.join(installDir, rel);
+    if (!fs.existsSync(absPath)) {
+      fs.mkdirSync(absPath, { recursive: true });
+      createdDirs.push(rel);
+    }
+  }
+
+  const fileResults = [];
+
+  // 2. Write top-level config files
+  const topLevelConfigs = [
+    { rel: path.join("config", "runtime.toml"), content: runtimeTemplate() },
+    { rel: path.join("config", "delivery.toml"), content: deliveryTemplate() },
+    { rel: path.join("config", "peers.toml"), content: peersTemplate() },
+    { rel: path.join("config", "output-contracts.toml"), content: outputContractsTemplate() },
+    { rel: path.join("config", "embeddings.toml"), content: embeddingsTemplate() },
+    { rel: path.join("config", "improvement-targets.toml"), content: improvementTargetsTemplate() },
+  ];
+
+  for (const { rel, content } of topLevelConfigs) {
+    const absPath = path.join(installDir, rel);
+    const status = writeIfMissing(absPath, content);
+    fileResults.push({ path: rel, status });
+  }
+
+  // 3. Write default job manifest
+  const jobId = "workspace-health";
+  const jobRel = path.join("config", "jobs", `${jobId}.toml`);
+  const jobStatus = writeIfMissing(path.join(installDir, jobRel), jobTemplate(jobId));
+  fileResults.push({ path: jobRel, status: jobStatus });
+
+  // 4. Write default policy files
+  const policies = policyTemplates();
+  for (const [stem, content] of Object.entries(policies)) {
+    const rel = path.join("config", "policies", `${stem}.toml`);
+    const status = writeIfMissing(path.join(installDir, rel), content);
+    fileResults.push({ path: rel, status });
+  }
+
+  // 5. Scaffold execution layer directories and files
+  await scaffoldToolsAndSkills(installDir);
+
+  return { dirs: createdDirs, files: fileResults };
+}