nemoris 0.1.0

package/src/runtime/migration.js

@@ -0,0 +1,323 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { OpenClawShadowBridge } from "../shadow/bridge.js";
+import { MemoryStore } from "../memory/memory-store.js";
+import { ensureDir, readText, statPath } from "../utils/fs.js";
+
+const MODEL_LANE_MAP = {
+  "anthropic/claude-opus-4-6": "interactive_primary",
+  "anthropic/claude-opus-4": "interactive_primary",
+  "anthropic/claude-sonnet-4-6": "interactive_primary",
+  "anthropic/claude-sonnet-4": "interactive_primary",
+  "anthropic/claude-haiku-4-5": "local_cheap",
+  "anthropic/claude-haiku-4": "local_cheap",
+  "openrouter/openai/gpt-5.2": "interactive_primary",
+  "openrouter/anthropic/claude-haiku-4-5": "local_cheap",
+  "ollama/qwen3:8b": "local_primary",
+};
+
+function modelToLane(primaryModel) {
+  if (!primaryModel) return "interactive_primary";
+  if (MODEL_LANE_MAP[primaryModel]) return MODEL_LANE_MAP[primaryModel];
+  // Fallback: contains-based detection
+  if (primaryModel.includes("haiku")) return "local_cheap";
+  if (primaryModel.startsWith("ollama/")) return "local_primary";
+  return "interactive_primary";
+}
+
+function escapeTOMLString(s) {
+  return String(s).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+/**
+ * Migrate agent configurations, cron jobs, and preferences from OpenClaw to Nemoris.
+ * 
+ * @param {Object} options
+ * @param {string} options.installDir - Target Nemoris installation directory
+ * @param {string} options.liveRoot - Source OpenClaw directory
+ * @param {boolean} options.dryRun - If true, do not write any files
+ * @returns {Promise<Object>} Migration report
+ */
+export async function runMigration({ installDir, liveRoot, dryRun, sessionSearch = null }) {
+  const bridge = new OpenClawShadowBridge({ liveRoot });
+  const report = {
+    agentsMigrated: [],
+    agentsSkipped: [],
+    cronJobsMigrated: [],
+    cronJobsSkipped: [],
+    telegramConfigMigrated: false,
+    telegramConfigSkipped: false,
+    memoryImported: 0,
+    memorySkipped: false,
+    workspaceDocsImported: 0,
+    agentSessionsIndexed: 0,
+    messagesIndexed: 0,
+    launchctlHint: null,
+    warnings: [],
+    dryRun
+  };
+
+  // Check if liveRoot exists
+  const rootStat = await statPath(liveRoot);
+  if (!rootStat) {
+    throw new Error(`OpenClaw live root not found at ${liveRoot}`);
+  }
+
+  // 1. Agents
+  const agents = await bridge.listAgents();
+  for (const agent of agents) {
+    const agentFile = path.join(installDir, "config", "agents", `${agent.id}.toml`);
+    const exists = await statPath(agentFile);
+    if (exists) {
+      report.agentsSkipped.push(agent.id);
+      continue;
+    }
+
+    const primaryLane = modelToLane(agent.primaryModel);
+
+    const soulRef = path.join(installDir, "config", "identity", `${agent.id}-soul.md`);
+    const purposeRef = path.join(installDir, "config", "identity", `${agent.id}-purpose.md`);
+
+    const tomlLines = [];
+    tomlLines.push(`# Generated by nemoris migrate — edit to personalise`);
+    if (agent.primaryModel) {
+      tomlLines.push(`# openclaw_model = "${escapeTOMLString(agent.primaryModel)}"`);
+    }
+    tomlLines.push(`id = "${agent.id}"`);
+    tomlLines.push(`primary_lane = "${primaryLane}"`);
+    tomlLines.push(`memory_policy = "default"`);
+    tomlLines.push(`tool_policy = "interactive_safe"`);
+    tomlLines.push(`soul_ref = "${soulRef}"`);
+    tomlLines.push(`purpose_ref = "${purposeRef}"`);
+    tomlLines.push(`workspace_root = "${agent.workspace}"`);
+    tomlLines.push(`workspace_context_files = ["MEMORY.md", "AGENTS.md"]`);
+    tomlLines.push(`workspace_context_cap = 8000`);
+    tomlLines.push(`checkpoint_policy = "compact"`);
+    if (agent.skills && agent.skills.length > 0) {
+      tomlLines.push(`skills = [${agent.skills.map(s => `"${escapeTOMLString(s)}"`).join(", ")}]`);
+      report.warnings.push(`Skills imported as references for ${agent.id} — Nemoris skill registry not yet active.`);
+    }
+    if (agent.deniedTools && agent.deniedTools.length > 0) {
+      tomlLines.push(`tools_deny = [${agent.deniedTools.map(t => `"${escapeTOMLString(t)}"`).join(", ")}]`);
+    }
+    tomlLines.push(``);
+    tomlLines.push(`[limits]`);
+    tomlLines.push(`max_tokens_per_turn = 16000`);
+    tomlLines.push(`max_tool_calls_per_turn = 6`);
+    tomlLines.push(`max_runtime_seconds = 120`);
+    tomlLines.push(``);
+    tomlLines.push(`[access]`);
+    tomlLines.push(`workspace = "rw"`);
+    tomlLines.push(`network = "restricted"`);
+    const toml = tomlLines.join("\n") + "\n";
+
+    if (!dryRun) {
+      await ensureDir(path.dirname(agentFile));
+      await fs.writeFile(agentFile, toml, "utf8");
+    }
+    report.agentsMigrated.push(agent.id);
+
+    // Generate soul/purpose files — use real content if available, stub as last resort
+    if (!dryRun) {
+      const identityDir = path.join(installDir, "config", "identity");
+      await ensureDir(identityDir);
+
+      const soulPath = path.join(identityDir, `${agent.id}-soul.md`);
+      if (!(await statPath(soulPath))) {
+        const realSoul = await bridge.readIdentityFile(agent, "SOUL.md");
+        if (realSoul) {
+          await fs.writeFile(soulPath, `# Imported from OpenClaw — edit to personalise\n\n${realSoul}\n`, "utf8");
+        } else {
+          await fs.writeFile(soulPath, [
+            `# ${agent.name} — Soul`,
+            ``,
+            `<!-- Generated by nemoris migrate — edit to personalise -->`,
+            ``,
+            `You are ${agent.name}, an AI assistant.`,
+            ``
+          ].join("\n"), "utf8");
+        }
+      }
+
+      const purposePath = path.join(identityDir, `${agent.id}-purpose.md`);
+      if (!(await statPath(purposePath))) {
+        // Check IDENTITY.md as the OpenClaw equivalent of purpose
+        const realPurpose = await bridge.readIdentityFile(agent, "IDENTITY.md");
+        if (realPurpose) {
+          await fs.writeFile(purposePath, `# Imported from OpenClaw — edit to personalise\n\n${realPurpose}\n`, "utf8");
+        } else {
+          await fs.writeFile(purposePath, [
+            `# ${agent.name} — Purpose`,
+            ``,
+            `<!-- Generated by nemoris migrate — edit to personalise -->`,
+            ``,
+            `Help your user accomplish their goals efficiently.`,
+            ``
+          ].join("\n"), "utf8");
+        }
+      }
+    }
+  }
+
+  // 1b. Memory import for migrated agents
+  const memoryRootDir = path.join(installDir, "state", "memory");
+  for (const agentId of report.agentsMigrated) {
+    try {
+      const memoryStore = new MemoryStore({ rootDir: memoryRootDir, agentId });
+      const existing = await memoryStore.listAll(agentId, Date.now(), { allowCrossAgentRead: true });
+      if (existing.length > 0) {
+        report.memorySkipped = true;
+        continue;
+      }
+
+      if (dryRun) {
+        const snapshot = await bridge.buildWorkspaceSnapshot(agentId);
+        report.memoryImported += snapshot.recentMemory.length;
+        continue;
+      }
+
+      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,
+      });
+      report.memoryImported = importResult.importStats.importedFacts;
+    } catch (err) {
+      report.warnings.push(`Memory import failed for ${agentId}: ${err.message}`);
+    }
+  }
+
+  // 1c. Workspace docs copy for migrated agents
+  for (const agentId of report.agentsMigrated) {
+    try {
+      const docs = await bridge.readWorkspaceDocs(agentId);
+      if (docs.length > 0 && !dryRun) {
+        const wsDir = path.join(installDir, "state", "workspace");
+        await ensureDir(wsDir);
+        for (const doc of docs) {
+          const targetPath = path.join(wsDir, doc.fileName);
+          if (!(await statPath(targetPath))) {
+            await fs.writeFile(targetPath, doc.content, "utf8");
+            report.workspaceDocsImported++;
+          }
+        }
+      } else if (docs.length > 0 && dryRun) {
+        report.workspaceDocsImported += docs.length;
+      }
+    } catch (err) {
+      report.warnings.push(`Workspace docs copy failed for ${agentId}: ${err.message}`);
+    }
+  }
+
+  // 1d. Session history import for FTS5 (if sessionSearch provided).
+  // Note: only indexes agents in report.agentsMigrated (first-time migrations).
+  // Agents already in report.agentsSkipped (existing .toml) are not re-indexed;
+  // this is intentional idempotency — call with a fresh sessionSearch to reindex.
+  if (sessionSearch && !dryRun) {
+    for (const agentId of report.agentsMigrated) {
+      try {
+        const messages = await bridge.readSessionMessages(agentId);
+        let indexed = 0;
+        for (const msg of messages) {
+          try {
+            sessionSearch.indexEvent(msg);
+            indexed++;
+          } catch (err) {
+            report.warnings.push(`Failed to index message ${msg.id}: ${err.message}`);
+          }
+        }
+        if (indexed > 0) {
+          report.agentSessionsIndexed++;
+          report.messagesIndexed += indexed;
+        }
+      } catch (err) {
+        report.warnings.push(`Session index failed for ${agentId}: ${err.message}`);
+      }
+    }
+  }
+
+  // 2. Cron Jobs
+  const jobs = await bridge.loadCronJobs();
+  for (const job of jobs) {
+    const jobFile = path.join(installDir, "config", "jobs", `${job.id}.toml`);
+    const exists = await statPath(jobFile);
+    if (exists) {
+      report.cronJobsSkipped.push(job.id);
+      continue;
+    }
+
+    // Convert OpenClaw job to Nemoris TOML
+    if (job.id && job.schedule) {
+      let trigger;
+      if (job.schedule.kind === "interval") {
+        trigger = `every:${job.schedule.expr || "30m"}`;
+      } else {
+        trigger = `cron:${job.schedule.expr || "0 * * * *"}`;
+      }
+
+      const toml = [
+        `# Generated by nemoris migrate — edit to personalise`,
+        `id = "${escapeTOMLString(job.id)}"`,
+        `trigger = "${escapeTOMLString(trigger)}"`,
+        `task_type = "${escapeTOMLString(job.id.toLowerCase())}"`,
+        `agent_id = "${escapeTOMLString(job.agentId || "ops")}"`,
+        `model_lane = "local_report"`,
+        `source = "openclaw-import"`,
+        ``,
+        `[budget]`,
+        `max_tokens = 4000`,
+        `max_runtime_seconds = 120`,
+        ``,
+        `[retry]`,
+        `max_attempts = 1`,
+      ].join("\n") + "\n";
+
+      if (!dryRun) {
+        await ensureDir(path.dirname(jobFile));
+        await fs.writeFile(jobFile, toml, "utf8");
+      }
+      report.cronJobsMigrated.push(job.id);
+    } else {
+      report.warnings.push(`Skipped invalid cron job: ${job.id || "unknown"}`);
+    }
+  }
+
+  // 3. Telegram Config
+  const ocConfig = await bridge.loadConfig();
+  const tg = ocConfig.telegram;
+  if (tg && (tg.botTokenEnv || tg.operatorChatId)) {
+    const runtimeFile = path.join(installDir, "config", "runtime.toml");
+    const runtimeContent = await readText(runtimeFile, "");
+    
+    if (runtimeContent.includes("[telegram]")) {
+      report.telegramConfigSkipped = true;
+    } else {
+      const telegramToml = [
+        "",
+        "[telegram]",
+        tg.botTokenEnv ? `botTokenEnv = "${escapeTOMLString(tg.botTokenEnv)}"` : null,
+        tg.operatorChatId ? `operatorChatId = "${escapeTOMLString(String(tg.operatorChatId))}"` : null,
+        "pollingMode = true"
+      ].filter(Boolean).join("\n") + "\n";
+
+      if (!dryRun) {
+        await fs.appendFile(runtimeFile, telegramToml, "utf8");
+      }
+      report.telegramConfigMigrated = true;
+    }
+  }
+
+  // 4. launchctl suggestion (macOS only, non-dry-run only)
+  if (!dryRun && process.platform === "darwin") {
+    const plistPath = path.join(process.env.HOME || "", "Library", "LaunchAgents", "ai.openclaw.daemon.plist");
+    if (await statPath(plistPath)) {
+      report.launchctlHint = `To disable OpenClaw: launchctl unload ${plistPath}`;
+    }
+  }
+
+  return report;
+}

package/src/runtime/model-resolution.js

@@ -0,0 +1,78 @@
+const MODEL_TIER_MAP = Object.freeze({
+  sonnet: "anthropic/claude-sonnet-4-6",
+  haiku: "anthropic/claude-haiku-4-5",
+  opus: "anthropic/claude-opus-4-6",
+});
+
+const CLAUDE_MODEL_BY_TIER = Object.freeze({
+  haiku: "claude-haiku-4-5",
+  sonnet: "claude-sonnet-4-6",
+  opus: "claude-opus-4-6",
+});
+
+function getLaneValue(lane, camelKey, snakeKey) {
+  if (!lane || typeof lane !== "object") return null;
+  return lane[camelKey] ?? lane[snakeKey] ?? null;
+}
+
+export function getInteractivePrimaryLane(routerConfig = null) {
+  return routerConfig?.interactive_primary || routerConfig?.interactivePrimary || null;
+}
+
+function inferAnthropicPrefix(routerConfig = null) {
+  const lane = getInteractivePrimaryLane(routerConfig);
+  const sourceModel = getLaneValue(lane, "manualBump", "manual_bump")
+    || getLaneValue(lane, "primary", "primary");
+
+  if (typeof sourceModel !== "string") return null;
+  if (sourceModel.startsWith("openrouter/anthropic/")) return "openrouter/anthropic";
+  if (sourceModel.startsWith("anthropic/")) return "anthropic";
+  return null;
+}
+
+function inferAnthropicModelForTier(tier, { routerConfig = null } = {}) {
+  const prefix = inferAnthropicPrefix(routerConfig);
+  const modelName = CLAUDE_MODEL_BY_TIER[tier] || null;
+  if (!prefix || !modelName) return null;
+  return `${prefix}/${modelName}`;
+}
+
+export function resolveModelOverride(modelOverride, { routerConfig = null } = {}) {
+  if (!modelOverride || modelOverride === "default") {
+    return null;
+  }
+  if (modelOverride.includes("/")) {
+    return modelOverride;
+  }
+
+  const interactivePrimaryLane = getInteractivePrimaryLane(routerConfig);
+  if (modelOverride === "haiku") {
+    return getLaneValue(interactivePrimaryLane, "primary", "primary")
+      || inferAnthropicModelForTier("haiku", { routerConfig })
+      || MODEL_TIER_MAP.haiku;
+  }
+  if (modelOverride === "sonnet") {
+    return getLaneValue(interactivePrimaryLane, "manualBump", "manual_bump")
+      || inferAnthropicModelForTier("sonnet", { routerConfig })
+      || MODEL_TIER_MAP.sonnet;
+  }
+  if (modelOverride === "opus") {
+    return inferAnthropicModelForTier("opus", { routerConfig }) || MODEL_TIER_MAP.opus;
+  }
+
+  return MODEL_TIER_MAP[modelOverride] || modelOverride;
+}
+
+export function resolveSessionStatusModel(session, { routerConfig = null, agentConfigs = null } = {}) {
+  const modelOverride = resolveModelOverride(session?.model_override, { routerConfig });
+  if (modelOverride) {
+    return modelOverride;
+  }
+
+  const agentConfig = agentConfigs?.[session?.agent_id] || null;
+  const primaryLane = agentConfig?.primaryLane || agentConfig?.primary_lane || "interactive_primary";
+  const resolvedModel = getLaneValue(routerConfig?.[primaryLane], "primary", "primary");
+  const interactivePrimaryModel = getLaneValue(getInteractivePrimaryLane(routerConfig), "primary", "primary");
+
+  return resolvedModel || interactivePrimaryModel || "default";
+}

package/src/runtime/network.js

@@ -0,0 +1,64 @@
+export function classifyNetworkFailure(errorOrMessage, { surface = "runtime" } = {}) {
+  const error = typeof errorOrMessage === "string" ? null : errorOrMessage;
+  const message = String(error?.message || errorOrMessage || "");
+  const normalized = message.toLowerCase();
+  const code = String(error?.code || "").toUpperCase();
+  const errno = String(error?.errno || "").toUpperCase();
+  const signalTimedOut =
+    error?.name === "TimeoutError" ||
+    error?.name === "AbortError" ||
+    normalized.includes("timed out") ||
+    normalized.includes("timeout");
+
+  let networkClass = null;
+  if (signalTimedOut || code === "ETIMEDOUT" || errno === "ETIMEDOUT") {
+    networkClass = normalized.includes("read") ? "read_timeout" : "connect_timeout";
+  } else if (code === "EHOSTUNREACH" || errno === "EHOSTUNREACH" || normalized.includes("hostunreach")) {
+    networkClass = "host_unreachable";
+  } else if (code === "ENETUNREACH" || errno === "ENETUNREACH" || normalized.includes("network is unreachable")) {
+    networkClass = "network_unreachable";
+  } else if (
+    code === "ENOTFOUND" ||
+    code === "EAI_AGAIN" ||
+    errno === "ENOTFOUND" ||
+    errno === "EAI_AGAIN" ||
+    normalized.includes("getaddrinfo") ||
+    normalized.includes("dns")
+  ) {
+    networkClass = "dns_resolution_failure";
+  }
+
+  let failureClass = null;
+  if (surface === "provider") {
+    if (signalTimedOut || networkClass === "connect_timeout" || networkClass === "read_timeout") {
+      failureClass = "provider_timeout";
+    } else if (networkClass) {
+      failureClass = networkClass;
+    }
+  } else if (surface === "delivery") {
+    if (signalTimedOut || networkClass === "connect_timeout" || networkClass === "read_timeout") {
+      failureClass = "delivery_timeout";
+    } else if (networkClass) {
+      failureClass = networkClass;
+    }
+  } else if (networkClass) {
+    failureClass = networkClass;
+  }
+
+  return {
+    failureClass,
+    networkClass
+  };
+}
+
+export function annotateError(errorOrMessage, options = {}) {
+  const error = typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  const classification = classifyNetworkFailure(error, options);
+  if (classification.failureClass && !error.failureClass) {
+    error.failureClass = classification.failureClass;
+  }
+  if (classification.networkClass && !error.networkClass) {
+    error.networkClass = classification.networkClass;
+  }
+  return error;
+}

package/src/runtime/notification-store.js

@@ -0,0 +1,97 @@
+import path from "node:path";
+import { ensureDir, listFilesRecursive, readJson, writeJson } from "../utils/fs.js";
+import { buildRetentionPolicy, pruneJsonBuckets } from "./retention.js";
+import { createRuntimeId } from "../utils/ids.js";
+
+function stamp() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+function normalizeFilePath(filePath) {
+  return path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+}
+
+export class NotificationStore {
+  constructor({ rootDir, retention = {} }) {
+    this.rootDir = rootDir;
+    this.setRetentionPolicy(retention);
+  }
+
+  setRetentionPolicy(retention = {}) {
+    this.retentionPolicy = buildRetentionPolicy(retention, {
+      ttlDays: 14,
+      maxFilesPerBucket: 1000
+    });
+  }
+
+  async saveNotification(jobId, notification) {
+    const notificationDir = path.join(this.rootDir, jobId);
+    await ensureDir(notificationDir);
+    const filePath = path.join(notificationDir, `${stamp()}.json`);
+    await writeJson(filePath, {
+      id: notification.id || createRuntimeId("notification"),
+      ...notification
+    });
+    await pruneJsonBuckets(this.rootDir, this.retentionPolicy);
+    return filePath;
+  }
+
+  async updateNotification(filePath, patch = {}) {
+    const resolvedPath = normalizeFilePath(filePath);
+    const current = await readJson(resolvedPath, null);
+    if (!current) {
+      throw new Error(`Notification file not found: ${resolvedPath}`);
+    }
+    const updated = {
+      ...current,
+      ...patch
+    };
+    await writeJson(resolvedPath, updated);
+    return {
+      filePath: resolvedPath,
+      ...updated
+    };
+  }
+
+  async getNotification(filePath) {
+    const resolvedPath = normalizeFilePath(filePath);
+    const current = await readJson(resolvedPath, null);
+    if (!current) return null;
+    return {
+      filePath: resolvedPath,
+      ...current
+    };
+  }
+
+  async getNotifications(filePaths = []) {
+    const notifications = await Promise.all((filePaths || []).map((filePath) => this.getNotification(filePath)));
+    return notifications.filter(Boolean);
+  }
+
+  async listRecent(limit = 10) {
+    const notifications = await this.listAll();
+    return notifications
+      .sort((a, b) => String(b.timestamp || "").localeCompare(String(a.timestamp || "")))
+      .slice(0, limit);
+  }
+
+  async listAll() {
+    const files = (await listFilesRecursive(this.rootDir)).filter((filePath) => filePath.endsWith(".json"));
+    const notifications = [];
+
+    for (const filePath of files) {
+      const data = await readJson(filePath, null);
+      if (!data) continue;
+      notifications.push({
+        filePath,
+        ...data
+      });
+    }
+
+    return notifications.sort((a, b) => String(b.timestamp || "").localeCompare(String(a.timestamp || "")));
+  }
+
+  async prune(options = {}) {
+    return pruneJsonBuckets(this.rootDir, this.retentionPolicy, options);
+  }
+}