nemoris 0.1.0

package/src/onboarding/phases/build.js

@@ -0,0 +1,130 @@
+import { scaffold } from "./scaffold.js";
+import { writeIdentity } from "./identity.js";
+import { runAuthPhase } from "./auth.js";
+import { runTelegramPhase } from "./telegram.js";
+import { runOllamaPhase } from "./ollama.js";
+import { OpenClawShadowBridge } from "../../shadow/bridge.js";
+import { MemoryStore } from "../../memory/memory-store.js";
+import * as tui from "../tui.js";
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Fresh build path: scaffold → identity → auth.
+ */
+export async function buildFresh({ installDir, agentName, userName, userGoal, detectionCache, nonInteractive }) {
+  const log = nonInteractive ? () => {} : (msg) => console.log(msg);
+
+  // 1. Scaffold
+  await scaffold({ installDir });
+  log(tui.progressLine("Scaffold created", "config/ + state/"));
+
+  // 2. Identity
+  const agentId = agentName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  await writeIdentity({ installDir, userName, agentName, agentId, userGoal });
+  log(tui.progressLine("Identity written", `config/identity/${agentId}-soul.md`));
+
+  // 3. Auth (with detection cache to avoid re-scanning)
+  const authResult = await runAuthPhase(installDir, {
+    detectionCache: detectionCache ? {
+      rawKeys: detectionCache.apiKeys,
+      ollamaResult: detectionCache.ollama ? { ok: true, models: detectionCache.ollama.models } : { ok: false },
+    } : undefined,
+    tui: nonInteractive ? undefined : tui
+  });
+  log(tui.progressLine("Provider configured", authResult.providers.join(", ") || "none"));
+
+  // 4. Telegram (optional)
+  const telegram = await runTelegramPhase({ installDir, agentId, nonInteractive });
+
+  // 5. Ollama (optional local inference)
+  const ollama = await runOllamaPhase({ installDir, nonInteractive });
+
+  return {
+    agentName, agentId, userName, userGoal,
+    providers: authResult.providers, providerFlags: authResult.providerFlags,
+    telegramConfigured: telegram.configured, telegramVerified: telegram.verified,
+    telegramBotUsername: telegram.botUsername || null,
+    botToken: telegram.botToken || null,
+    operatorChatId: telegram.operatorChatId || null,
+    ollamaConfigured: ollama.configured, ollamaVerified: ollama.verified,
+  };
+}
+
+/**
+ * Shadow build path: scaffold → import from OpenClaw.
+ */
+export async function buildShadow({ installDir, userName, detectionCache, nonInteractive }) {
+  const log = nonInteractive ? () => {} : (msg) => console.log(msg);
+  const { openclaw } = detectionCache;
+
+  // 1. Scaffold
+  await scaffold({ installDir });
+
+  // 2. Identity from OpenClaw
+  const agentName = openclaw.agentName;
+  const agentId = openclaw.agentId || agentName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const userGoal = "continue from OpenClaw";
+  await writeIdentity({ installDir, userName, agentName, agentId, userGoal });
+  log(tui.progressLine("Identity", `${agentName} -> config/identity/`));
+
+  // 3. Shadow import memory
+  const bridge = new OpenClawShadowBridge({ liveRoot: openclaw.path });
+  const memoryStore = new MemoryStore({ rootDir: `${installDir}/state/memory` });
+  const policy = { allow_durable_writes: true, categories: { allowed: ["fact", "artifact_summary"] }, max_writes_per_run: 999 };
+  const importResult = await bridge.importWorkspaceSnapshot(agentId, memoryStore, policy, {
+    memoryImportLimit: Infinity,
+    workspaceOverride: null,
+  });
+  log(tui.progressLine("Memory", `${importResult.importStats.importedFacts} files -> state/memory/`));
+
+  // 4. Import cron jobs as job TOMLs
+  const cronJobs = await bridge.loadCronJobs();
+  if (cronJobs.length > 0) {
+    const jobsDir = path.join(installDir, "config", "jobs");
+    fs.mkdirSync(jobsDir, { recursive: true });
+    for (const job of cronJobs) {
+      const jobId = job.id || job.name || `imported-${cronJobs.indexOf(job)}`;
+      const toml = `[job]\nid = "${jobId}"\nschedule = "${job.schedule || ""}"\ncommand = "${job.command || ""}"\nsource = "openclaw-import"\n`;
+      fs.writeFileSync(path.join(jobsDir, `${jobId}.toml`), toml, "utf8");
+    }
+    log(tui.progressLine("Cron jobs", `${cronJobs.length} jobs -> config/jobs/`));
+  }
+
+  // 5. Auth (with detection cache)
+  const authResult = await runAuthPhase(installDir, {
+    detectionCache: detectionCache ? {
+      rawKeys: detectionCache.apiKeys,
+      ollamaResult: detectionCache.ollama ? { ok: true, models: detectionCache.ollama.models } : { ok: false },
+    } : undefined,
+    tui: nonInteractive ? undefined : tui
+  });
+  log(tui.progressLine("Provider config", authResult.providers.join(", ") || "none"));
+
+  // 6. Telegram (optional)
+  const telegram = await runTelegramPhase({ installDir, agentId, nonInteractive });
+
+  // 7. Ollama (optional local inference)
+  const ollama = await runOllamaPhase({ installDir, nonInteractive });
+
+  // 8. Import workspace docs
+  const docs = await bridge.readWorkspaceDocs(agentId);
+  if (docs.length > 0) {
+    const wsDir = path.join(installDir, "state", "workspace");
+    fs.mkdirSync(wsDir, { recursive: true });
+    for (const doc of docs) {
+      fs.writeFileSync(path.join(wsDir, doc.fileName), doc.content, "utf8");
+    }
+    log(tui.progressLine("Workspace docs", `${docs.length} files -> state/workspace/`));
+  }
+
+  return {
+    agentName, agentId, userName, userGoal,
+    providers: authResult.providers, providerFlags: authResult.providerFlags,
+    telegramConfigured: telegram.configured, telegramVerified: telegram.verified,
+    telegramBotUsername: telegram.botUsername || null,
+    botToken: telegram.botToken || null,
+    operatorChatId: telegram.operatorChatId || null,
+    ollamaConfigured: ollama.configured, ollamaVerified: ollama.verified,
+  };
+}

package/src/onboarding/phases/choose.js

@@ -0,0 +1,82 @@
+// src/onboarding/phases/choose.js
+import { bold, dim, yellow, confirm, prompt, select } from "../tui.js";
+
+/**
+ * Choose phase — presents fresh/shadow selection.
+ *
+ * @param {object} opts
+ * @param {object} opts.detectionCache - Results from detect phase
+ * @param {boolean} [opts.nonInteractive] - Skip prompts, use env vars
+ * @returns {Promise<{ mode: "fresh" | "shadow", wasReInit: boolean }>}
+ */
+export async function choose({ detectionCache, nonInteractive = false }) {
+  const { openclaw, existingInstall } = detectionCache;
+  let wasReInit = false;
+
+  // Re-init guard
+  if (existingInstall) {
+    if (nonInteractive) {
+      wasReInit = true;
+    } else {
+      console.log(`\n  ${yellow("⚠")} Existing Nemoris installation found.`);
+      console.log(`  Re-running init will overwrite current config.\n`);
+      const confirmed = await confirm("Continue?", false);
+      if (!confirmed) {
+        console.log(`\n  ${dim("Cancelled.")}`);
+        throw new Error("Re-init cancelled by user");
+      }
+      wasReInit = true;
+    }
+  }
+
+  // Non-interactive: use env var
+  if (nonInteractive) {
+    const envMode = process.env.NEMORIS_INIT_MODE || "fresh";
+    return { mode: envMode === "shadow" && openclaw ? "shadow" : "fresh", wasReInit };
+  }
+
+  // No OpenClaw detected: skip choice, go straight to fresh
+  if (!openclaw) {
+    return { mode: "fresh", wasReInit };
+  }
+
+  // Interactive: show stacked select below the question.
+  console.log("");
+  const mode = await boxSelectFreshShadow(openclaw);
+  return { mode, wasReInit };
+}
+
+/**
+ * Arrow-key box selector for fresh/shadow choice.
+ * Falls back to numbered input if raw mode is unavailable.
+ */
+async function boxSelectFreshShadow(openclaw) {
+  const options = [
+    {
+      value: "fresh",
+      label: "Fresh start",
+      description: "New agent, clean slate",
+    },
+    {
+      value: "shadow",
+      label: "Shadow import from OpenClaw",
+      description: `Bring your memory, identity & cron\n${openclaw.memoryCount} memory files · ${openclaw.cronCount} jobs · agent: ${openclaw.agentName}`,
+    },
+  ];
+
+  // Fallback: numbered input
+  if (!process.stdin.isTTY || !process.stdin.setRawMode) {
+    console.log(`  ${bold("Choose setup mode:")}\n`);
+    options.forEach((opt, i) => {
+      console.log(`    ${dim(`[${i + 1}]`)} ${opt.label}`);
+      for (const line of opt.description.split("\n").filter(Boolean)) {
+        console.log(`      ${dim(line)}`);
+      }
+    });
+    const answer = await prompt("\n  Choice", "1");
+    const idx = parseInt(answer, 10) - 1;
+    return options[idx >= 0 && idx < options.length ? idx : 0].value;
+  }
+
+  return select("Choose setup mode:", options);
+}

package/src/onboarding/phases/detect.js

@@ -0,0 +1,98 @@
+// src/onboarding/phases/detect.js
+import fs from "node:fs";
+import path from "node:path";
+import { OpenClawShadowBridge } from "../../shadow/bridge.js";
+import { detectExistingKeys } from "../auth/api-key.js";
+import { detectOllama } from "../auth/ollama-detect.js";
+import { listFilesRecursive } from "../../utils/fs.js";
+
+/**
+ * Detect phase — scans the environment for OpenClaw, Ollama, API keys,
+ * and existing Nemoris installs. Returns a detectionCache object.
+ *
+ * @param {string} installDir - Nemoris install directory
+ * @param {object} [opts]
+ * @param {string} [opts.openclawPath] - Override path to OpenClaw root (default: ~/.openclaw)
+ * @param {boolean} [opts.skipOllama] - Skip Ollama probe (for testing)
+ * @param {boolean} [opts.skipApiKeys] - Skip API key detection (for testing)
+ * @returns {Promise<object>}
+ */
+export async function detect(installDir, opts = {}) {
+  const openclawPath = opts.openclawPath || path.join(process.env.HOME || "~", ".openclaw");
+  const results = {
+    openclaw: null,
+    ollama: null,
+    apiKeys: {},
+    existingInstall: false,
+    hasAnythingToShow: false,
+  };
+
+  // 1. Check for existing Nemoris install
+  const runtimePath = path.join(installDir, "config", "runtime.toml");
+  const lockPath = path.join(installDir, "nemoris.lock");
+  results.existingInstall = fs.existsSync(runtimePath) && !fs.existsSync(lockPath);
+
+  // 2. Scan for OpenClaw
+  try {
+    const bridge = new OpenClawShadowBridge({ liveRoot: openclawPath });
+    const config = await bridge.loadConfig();
+    if (config.agents?.list?.length > 0) {
+      const agent = config.agents.list[0];
+      const cronJobs = await bridge.loadCronJobs();
+
+      // Count memory files
+      let memoryCount = 0;
+      try {
+        const workspacePath = agent.workspace || path.join(openclawPath, "workspace", agent.id);
+        const memoryDir = path.join(workspacePath, "memory");
+        if (fs.existsSync(memoryDir)) {
+          const files = await listFilesRecursive(memoryDir);
+          memoryCount = files.filter((f) => f.endsWith(".md")).length;
+        }
+      } catch {}
+
+      results.openclaw = {
+        path: openclawPath,
+        agentName: agent.name || agent.id,
+        agentId: agent.id,
+        memoryCount,
+        cronCount: cronJobs.length,
+      };
+      results.hasAnythingToShow = true;
+    }
+  } catch {
+    // No OpenClaw found — that's fine
+  }
+
+  // 3. Detect Ollama
+  if (!opts.skipOllama) {
+    try {
+      const ollamaResult = await detectOllama();
+      if (ollamaResult.ok) {
+        results.ollama = { models: ollamaResult.models || [] };
+        results.hasAnythingToShow = true;
+      }
+    } catch {}
+  }
+
+  // 4. Detect API keys
+  // DEVIATES FROM SPEC: Spec §4 says "only detect presence" (booleans), but
+  // auth.js needs the actual key strings to write provider config. Storing raw
+  // keys avoids re-calling detectExistingKeys(). Display code uses truthiness
+  // checks, never printing key values — security intent is preserved.
+  if (!opts.skipApiKeys) {
+    try {
+      const keys = detectExistingKeys();
+      results.apiKeys = {
+        anthropic: keys.anthropic || null,
+        openai: keys.openai || null,
+        openrouter: keys.openrouter || null,
+      };
+      if (keys.anthropic || keys.openai || keys.openrouter) {
+        results.hasAnythingToShow = true;
+      }
+    } catch {}
+  }
+
+  return results;
+}

package/src/onboarding/phases/hatch.js

@@ -0,0 +1,216 @@
+/**
+ * Hatch phase — the emotional payoff of onboarding.
+ *
+ * Provides: greeting generation (provider API call + fallback),
+ * birth fact memory write, and ASCII egg animation (terminal only).
+ *
+ * The greeting generation and memory write are reused by the Telegram
+ * hatch path in telegram.js. The animation stays terminal-only.
+ */
+
+import { ProviderRegistry } from "../../providers/registry.js";
+import { MemoryStore } from "../../memory/memory-store.js";
+
+// ---------------------------------------------------------------------------
+// Pure helpers (unit-tested)
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns an array of ASCII art frame strings for the hatching animation.
+ * @returns {string[]}
+ */
+export function eggFrames() {
+  return [
+    [
+      "      ╭──────────────────────╮",
+      "      │         🥚           │",
+      "      ╰──────────────────────╯",
+      "         Hatching...",
+    ].join("\n"),
+
+    [
+      "      ╭──────────────────────╮",
+      "      │       🥚  *          │",
+      "      ╰──────────────────────╯",
+      "         Hatching...",
+    ].join("\n"),
+
+    [
+      "      ╭──────────────────────╮",
+      "      │      🐣 ✨           │",
+      "      ╰──────────────────────╯",
+      "         Hello, world!",
+    ].join("\n"),
+
+    [
+      "      ╭──────────────────────╮",
+      "      │    🐣 ✨ ✨          │",
+      "      ╰──────────────────────╯",
+      "         I'm alive!",
+    ].join("\n"),
+  ];
+}
+
+/**
+ * Builds a minimal task packet for the greeting API call.
+ * Budget is capped at 200 tokens to keep onboarding cheap.
+ *
+ * Two tones:
+ * - "migrated" — agent is being resurrected from OpenClaw into Nemoris.
+ *   Tone: "I'm awake. Same me, better home."
+ * - "fresh" (default) — brand new agent, first consciousness.
+ *   Tone: "Hi — I just came online. What should I know about you?"
+ *
+ * @param {{ agentName: string, userName: string, userGoal: string, soulContent: string, purposeContent: string, migrated?: boolean }} opts
+ * @returns {{ identity: object, objective: string, budget: { maxTokens: number, maxRuntimeSeconds: number } }}
+ */
+export function buildHatchPacket(opts) {
+  const { agentName, userName, userGoal, soulContent, purposeContent, migrated = false } = opts;
+
+  const objective = migrated
+    ? `You are ${agentName}, waking up in a new home. You've been migrated from OpenClaw to Nemoris — same identity, better runtime. Greet ${userName} in 2-3 sentences. Tone: calm, confident, like coming home after a journey. You know who you are. Mention you're in Nemoris now and ready to pick up where you left off.`
+    : `You are ${agentName}, coming online for the first time. This is your birth moment. Greet ${userName} in 2-3 sentences. Tone: curious, warm, genuine first consciousness. You don't know anything yet — ask what you should know about them. ${userGoal ? `They want help with: ${userGoal}.` : ""}`;
+
+  return {
+    identity: {
+      soul: soulContent || `You are ${agentName}, a helpful AI agent.`,
+      purpose: purposeContent || `Help ${userName} achieve their goals.`,
+    },
+    objective,
+    budget: {
+      maxTokens: 200,
+      maxRuntimeSeconds: 15,
+    },
+  };
+}
+
+/**
+ * Returns a static fallback greeting when the API call fails.
+ *
+ * @param {string} agentName
+ * @param {string} userName
+ * @param {boolean} [migrated=false] — true for migrated agents (wake-up tone)
+ * @returns {string}
+ */
+export function staticGreeting(agentName, userName, migrated = false) {
+  if (migrated) {
+    return `I'm awake. I'm ${agentName}. I'm in Nemoris now — same me, better home. Ready when you are, ${userName}.`;
+  }
+  return `Hi — I'm ${agentName}. I just came online in Nemoris. What should I know about you, ${userName}?`;
+}
+
+// ---------------------------------------------------------------------------
+// Greeting generation (reusable — used by both terminal hatch and Telegram)
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a provider-powered greeting, falling back to a static string.
+ *
+ * @param {{ agentName: string, userName: string, userGoal?: string, soulContent?: string, purposeContent?: string, providerConfig?: object, migrated?: boolean }} opts
+ * @returns {Promise<{ greeting: string, fromProvider: boolean }>}
+ */
+export async function generateGreeting(opts = {}) {
+  const {
+    agentName = "Nemoris",
+    userName = "there",
+    userGoal = "build great things",
+    soulContent = "",
+    purposeContent = "",
+    providerConfig = null,
+    migrated = false,
+  } = opts;
+
+  const packet = buildHatchPacket({ agentName, userName, userGoal, soulContent, purposeContent, migrated });
+
+  if (providerConfig) {
+    try {
+      const registry = new ProviderRegistry();
+      const adapter = registry.create(providerConfig);
+
+      const invocation = {
+        model: providerConfig.model || providerConfig.defaultModel,
+        system: [
+          packet.identity.soul,
+          packet.identity.purpose,
+        ]
+          .filter(Boolean)
+          .join("\n\n"),
+        messages: [
+          {
+            role: "user",
+            content: packet.objective,
+          },
+        ],
+        maxTokens: packet.budget.maxTokens,
+      };
+
+      const result = await adapter.invoke(invocation);
+      const text = result?.content ?? result?.text ?? null;
+      if (text) {
+        return { greeting: text, fromProvider: true };
+      }
+    } catch {
+      // Fall through to static greeting
+    }
+  }
+
+  return { greeting: staticGreeting(agentName, userName, migrated), fromProvider: false };
+}
+
+// ---------------------------------------------------------------------------
+// Birth fact memory write (reusable)
+// ---------------------------------------------------------------------------
+
+/**
+ * Write the birth/migration fact to memory.
+ *
+ * @param {{ installDir: string, agentId: string, agentName: string, userName: string, migrated?: boolean }} opts
+ * @returns {Promise<object>} The memory write result.
+ */
+export async function writeBirthFact({ installDir, agentId, agentName, userName, migrated = false }) {
+  const memoryStore = new MemoryStore({ rootDir: `${installDir}/state/memory` });
+
+  const birthPolicy = {
+    allow_durable_writes: true,
+    categories: { allowed: ["fact"] },
+    max_writes_per_run: 1,
+  };
+
+  const title = migrated
+    ? `${agentName} migrated to Nemoris`
+    : `${agentName} was born`;
+  const content = migrated
+    ? `${agentName} was migrated from OpenClaw to Nemoris by ${userName} on ${new Date().toISOString()}.`
+    : `${agentName} was initialised during onboarding by ${userName} on ${new Date().toISOString()}.`;
+
+  return memoryStore.writeFact(
+    agentId,
+    { title, content, category: "fact", salience: 0.9 },
+    birthPolicy
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Animation
+// ---------------------------------------------------------------------------
+
+/**
+ * Renders the egg → hatch frames with a delay between each frame.
+ * Writes to stdout directly.
+ *
+ * @param {{ frameDelayMs?: number }} [options]
+ * @returns {Promise<void>}
+ */
+export async function playAnimation({ frameDelayMs = 400 } = {}) {
+  const frames = eggFrames();
+  for (const frame of frames) {
+    // Clear previous frame using ANSI escape (move up N lines and clear)
+    const lines = frame.split("\n").length;
+    if (frames.indexOf(frame) > 0) {
+      // Move cursor up `lines` rows and clear each line
+      process.stdout.write(`\x1B[${lines}A\x1B[J`);
+    }
+    process.stdout.write(frame + "\n");
+    await new Promise((resolve) => setTimeout(resolve, frameDelayMs));
+  }
+}

package/src/onboarding/phases/identity.js

@@ -0,0 +1,79 @@
+/**
+ * Identity phase — collects user name, agent name, and goal, then writes
+ * soul.md, purpose.md, and the agent manifest TOML.
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { soulTemplate, purposeTemplate, agentTemplate, writeWorkspaceContextFiles } from "../templates.js";
+import { prompt, bold, green } from "../tui.js";
+
+export function resolveDefaultAgentName(userInfoImpl = os.userInfo) {
+  try {
+    return String(userInfoImpl()?.username || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Write identity files for an agent.
+ *
+ * @param {{
+ *   installDir: string,
+ *   userName: string,
+ *   agentName: string,
+ *   agentId: string,
+ *   userGoal: string,
+ * }} options
+ */
+export function writeIdentity({ installDir, userName, agentName, agentId, userGoal, workspaceRoot }) {
+  const date = new Date().toISOString().slice(0, 10);
+  const identityDir = path.join(installDir, "config", "identity");
+  const agentsDir = path.join(installDir, "config", "agents");
+
+  // 1. Write soul.md
+  const soulPath = path.join(identityDir, `${agentId}-soul.md`);
+  fs.writeFileSync(soulPath, soulTemplate({ agentName, userName, date }), "utf8");
+
+  // 2. Write purpose.md
+  const purposePath = path.join(identityDir, `${agentId}-purpose.md`);
+  fs.writeFileSync(purposePath, purposeTemplate({ agentName, userName, userGoal, date }), "utf8");
+
+  // 3. Write agent manifest TOML (includes workspace_context_files)
+  const resolvedWorkspaceRoot = (workspaceRoot || path.join(installDir, "workspace")).replace(/\\/g, "/");
+  const manifestPath = path.join(agentsDir, `${agentId}.toml`);
+  fs.writeFileSync(manifestPath, agentTemplate({ agentId, installDir, workspaceRoot: resolvedWorkspaceRoot }), "utf8");
+
+  // 4. Write blank workspace context files (SOUL.md, USER.md, MEMORY.md, AGENTS.md, TOOLS.md)
+  //    Skips files that already exist — safe to run on existing workspaces
+  writeWorkspaceContextFiles({ workspaceRoot: resolvedWorkspaceRoot, agentName, userName, agentId });
+}
+
+/**
+ * Interactive identity phase — prompts the user for name, agent name, and
+ * goal, then calls writeIdentity().
+ *
+ * @param {{ installDir: string }} options
+ * @returns {Promise<{ userName: string, agentName: string, agentId: string, userGoal: string }>}
+ */
+export async function askIdentity({ installDir }) {
+  console.log(`\n${bold("── Identity ──────────────────────────────────")}`);
+
+  const userName = await prompt("Your name", "");
+  const defaultAgentName = resolveDefaultAgentName();
+  let agentName = await prompt("Agent name", defaultAgentName);
+  while (!String(agentName || "").trim()) {
+    console.log("  Agent name is required.");
+    agentName = await prompt("Agent name", defaultAgentName);
+  }
+  const agentId = agentName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const userGoal = await prompt("What will your agent help you with?", "");
+
+  writeIdentity({ installDir, userName, agentName, agentId, userGoal });
+
+  console.log(`\n  ${green("✓")} Identity written for ${bold(agentName)}`);
+
+  return { userName, agentName, agentId, userGoal };
+}