nemoris 0.1.0

package/src/tui/renderer.js

@@ -0,0 +1,175 @@
+const ANSI_PATTERN = /\x1b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))/g;
+
+export const ANSI = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  accent: "\x1b[38;2;45;212;191m",
+  primary: "\x1b[38;2;232;232;236m",
+  secondary: "\x1b[38;2;161;161;170m",
+  muted: "\x1b[38;2;82;82;91m",
+  error: "\x1b[38;2;255;95;87m",
+  warning: "\x1b[38;2;255;189;46m",
+  success: "\x1b[38;2;40;200;64m",
+  codeBg: "\x1b[48;2;34;34;39m",
+  barBg: "\x1b[48;2;24;24;27m",
+};
+
+export const THINKING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function colorsEnabled(options = {}) {
+  return !(options.noColor || process.env.NO_COLOR);
+}
+
+function stylize(text, codes = [], options = {}) {
+  const value = String(text ?? "");
+  if (!colorsEnabled(options)) {
+    return stripAnsi(value);
+  }
+  return `${codes.join("")}${value}${ANSI.reset}`;
+}
+
+function visibleLength(text) {
+  return stripAnsi(text).length;
+}
+
+function padVisible(text, width) {
+  const pad = Math.max(0, width - visibleLength(text));
+  return `${text}${" ".repeat(pad)}`;
+}
+
+function stringifyValue(value) {
+  if (value == null) {
+    return "None";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+function pushField(lines, label, value, labelColor, valueColor, options = {}) {
+  const rendered = stringifyValue(value).split("\n");
+  if (rendered.length === 0) {
+    lines.push(`${stylize(label, [labelColor], options)} ${stylize("None", [valueColor], options)}`);
+    return;
+  }
+  lines.push(`${stylize(label, [labelColor], options)} ${stylize(rendered[0], [valueColor], options)}`);
+  for (const line of rendered.slice(1)) {
+    lines.push(stylize(`     ${line}`, [valueColor], options));
+  }
+}
+
+function boxify(lines, { borderColor = ANSI.accent, bodyColor = ANSI.primary, options = {} } = {}) {
+  const width = Math.max(...lines.map((line) => visibleLength(line)), 0);
+  const top = stylize(`┌${"─".repeat(width + 2)}┐`, [borderColor], options);
+  const bottom = stylize(`└${"─".repeat(width + 2)}┘`, [borderColor], options);
+  const body = lines.map((line) => {
+    const padded = padVisible(line, width);
+    const content = stylize(` ${padded} `, [bodyColor], options);
+    const left = stylize("│", [borderColor], options);
+    const right = stylize("│", [borderColor], options);
+    return `${left}${content}${right}`;
+  });
+  return [top, ...body, bottom].join("\n");
+}
+
+function renderCodeBlock(content, options = {}) {
+  const lines = String(content || "")
+    .replace(/\n$/, "")
+    .split("\n")
+    .map((line) => stylize(`  ${line}`, [ANSI.codeBg, ANSI.secondary], options));
+  return lines.join("\n");
+}
+
+function renderInlineMarkdown(text, options = {}) {
+  return String(text || "")
+    .replace(/\*\*(.+?)\*\*/g, (_, content) => stylize(content, [ANSI.bold, ANSI.primary], options))
+    .replace(/`([^`\n]+)`/g, (_, content) => stylize(` ${content} `, [ANSI.codeBg, ANSI.secondary], options));
+}
+
+export function stripAnsi(text) {
+  return String(text ?? "").replace(ANSI_PATTERN, "");
+}
+
+export function renderAgentResponse(text, options = {}) {
+  const blocks = [];
+  const withPlaceholders = String(text || "").replace(/```(?:[\w-]+)?\n?([\s\S]*?)```/g, (_, content) => {
+    const marker = `__CODE_BLOCK_${blocks.length}__`;
+    blocks.push(renderCodeBlock(content, options));
+    return marker;
+  });
+
+  let rendered = renderInlineMarkdown(withPlaceholders, options);
+  rendered = blocks.reduce(
+    (value, block, index) => value.replace(`__CODE_BLOCK_${index}__`, block),
+    rendered,
+  );
+  rendered = rendered
+    .split("\n")
+    .map((line) => stylize(line, [ANSI.primary], options))
+    .join("\n");
+
+  return colorsEnabled(options) ? rendered : stripAnsi(rendered);
+}
+
+export function renderToolCard({ name, args, result, isError, durationMs } = {}, options = {}) {
+  const titleColor = isError ? ANSI.error : ANSI.success;
+  const lines = [];
+  pushField(lines, "Tool", stylize(name || "tool", [ANSI.bold, titleColor], options), ANSI.secondary, ANSI.primary, options);
+  pushField(lines, "Args", args, ANSI.secondary, ANSI.primary, options);
+
+  if (result !== undefined) {
+    pushField(lines, "Result", result, ANSI.secondary, isError ? ANSI.error : ANSI.primary, options);
+  }
+  if (durationMs != null) {
+    pushField(lines, "Duration", `${durationMs}ms`, ANSI.secondary, ANSI.primary, options);
+  }
+
+  return boxify(lines, { borderColor: ANSI.accent, bodyColor: ANSI.primary, options });
+}
+
+export function renderApprovalPrompt({ tool, args, jobId } = {}, options = {}) {
+  const lines = [stylize("Exec approval required", [ANSI.bold, ANSI.warning], options)];
+  pushField(lines, "Tool", tool || "tool", ANSI.secondary, ANSI.primary, options);
+  pushField(lines, "Args", args, ANSI.secondary, ANSI.primary, options);
+  pushField(lines, "Job", jobId || "unknown", ANSI.secondary, ANSI.primary, options);
+  lines.push(stylize("[Y/n]", [ANSI.bold, ANSI.warning], options));
+  return boxify(lines, { borderColor: ANSI.warning, bodyColor: ANSI.primary, options });
+}
+
+export function renderStatusBar({ agent, model, tokens, cost, connected } = {}, options = {}) {
+  const tokenCount = Number.isFinite(tokens) ? tokens : 0;
+  const numericCost = Number.isFinite(Number(cost)) ? Number(cost) : 0;
+  const parts = [
+    `agent ${agent || "main"}`,
+    `model ${model || "default"}`,
+    `tokens ${tokenCount}`,
+    `cost $${numericCost.toFixed(4)}`,
+    connected ? "online" : "offline",
+  ];
+  return stylize(` ${parts.join("  ·  ")} `, [ANSI.barBg, ANSI.muted], options);
+}
+
+export function renderThinking(frameIndex = 0, options = {}) {
+  const frame = THINKING_FRAMES[Math.abs(frameIndex) % THINKING_FRAMES.length];
+  return stylize(frame, [ANSI.accent], options);
+}
+
+export function renderWordmark(options = {}) {
+  const lines = [
+    "███╗   ██╗███████╗███╗   ███╗ ██████╗ ██████╗ ██╗███████╗",
+    "████╗  ██║██╔════╝████╗ ████║██╔═══██╗██╔══██╗██║██╔════╝",
+    "██╔██╗ ██║█████╗  ██╔████╔██║██║   ██║██████╔╝██║███████╗",
+    "██║╚██╗██║██╔══╝  ██║╚██╔╝██║██║   ██║██╔══██╗██║╚════██║",
+    "██║ ╚████║███████╗██║ ╚═╝ ██║╚██████╔╝██║  ██║██║███████║",
+    "╚═╝  ╚═══╝╚══════╝╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝╚══════╝",
+    "NEMORIS",
+  ];
+  const rendered = lines.map((line) => stylize(line, [ANSI.accent], options)).join("\n");
+  return colorsEnabled(options) ? rendered : stripAnsi(rendered);
+}

package/src/tui/socket-client.js

@@ -0,0 +1,217 @@
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+
+export function resolveSocketPath({ platform = process.platform, stateDir, homedir = os.homedir } = {}) {
+  if (platform === "win32") {
+    return "\\\\.\\pipe\\nemoris-daemon";
+  }
+  const root = stateDir || path.join(homedir(), ".nemoris", "state");
+  return path.join(root, "daemon.sock");
+}
+
+export function getReconnectDelay(attempt, { baseMs = 1000, maxMs = 30000 } = {}) {
+  return Math.min(maxMs, baseMs * (2 ** Math.max(0, attempt)));
+}
+
+export function parseNdjsonChunk(buffer = "", chunk = "") {
+  const input = `${buffer}${chunk}`;
+  const lines = input.split("\n");
+  const nextBuffer = lines.pop() || "";
+  const messages = [];
+  const errors = [];
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    try {
+      messages.push(JSON.parse(line));
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+
+  return { buffer: nextBuffer, messages, errors };
+}
+
+function emitSafeError(target, error) {
+  if (target.listenerCount("error") > 0) {
+    target.emit("error", error);
+  }
+}
+
+export class TuiSocketClient extends EventEmitter {
+  constructor({
+    socketPath,
+    stateDir,
+    platform = process.platform,
+    homedir = os.homedir,
+    createConnection = net.createConnection,
+    reconnectBaseMs = 1000,
+    reconnectMaxMs = 30000,
+    keepaliveMs = 30000,
+    autoReconnect = true,
+    setTimeoutFn = setTimeout,
+    clearTimeoutFn = clearTimeout,
+    setIntervalFn = setInterval,
+    clearIntervalFn = clearInterval,
+  } = {}) {
+    super();
+    this.socketPath = socketPath || resolveSocketPath({ platform, stateDir, homedir });
+    this.createConnection = createConnection;
+    this.reconnectBaseMs = reconnectBaseMs;
+    this.reconnectMaxMs = reconnectMaxMs;
+    this.keepaliveMs = keepaliveMs;
+    this.autoReconnect = autoReconnect;
+    this.setTimeoutFn = setTimeoutFn;
+    this.clearTimeoutFn = clearTimeoutFn;
+    this.setIntervalFn = setIntervalFn;
+    this.clearIntervalFn = clearIntervalFn;
+
+    this.socket = null;
+    this.buffer = "";
+    this.connected = false;
+    this.closed = false;
+    this.reconnectAttempt = 0;
+    this.reconnectTimer = null;
+    this.keepaliveTimer = null;
+  }
+
+  async connect() {
+    this.closed = false;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const cleanup = () => {
+        this.off("connected", onConnected);
+        this.off("error", onError);
+      };
+      const onConnected = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve(this);
+      };
+      const onError = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+      this.once("connected", onConnected);
+      this.once("error", onError);
+      this._openSocket();
+    });
+  }
+
+  _openSocket() {
+    if (this.closed) {
+      return;
+    }
+    this.buffer = "";
+    const socket = this.createConnection(this.socketPath);
+    this.socket = socket;
+    socket.setEncoding?.("utf8");
+
+    socket.on("connect", () => {
+      this.connected = true;
+      this.reconnectAttempt = 0;
+      this._clearReconnectTimer();
+      this._startKeepalive();
+      this.emit("connected");
+    });
+
+    socket.on("data", (chunk) => {
+      const parsed = parseNdjsonChunk(this.buffer, chunk);
+      this.buffer = parsed.buffer;
+      for (const message of parsed.messages) {
+        this.emit("message", message);
+      }
+      for (const error of parsed.errors) {
+        emitSafeError(this, error);
+      }
+    });
+
+    socket.on("error", (error) => {
+      emitSafeError(this, error);
+    });
+
+    socket.on("close", () => {
+      const wasConnected = this.connected;
+      this.connected = false;
+      this._stopKeepalive();
+      this.emit("disconnected");
+      if (!this.closed && this.autoReconnect) {
+        this._scheduleReconnect();
+      }
+      if (!wasConnected && this.closed) {
+        this.buffer = "";
+      }
+    });
+  }
+
+  _scheduleReconnect() {
+    if (this.reconnectTimer || this.closed) {
+      return null;
+    }
+    const delay = getReconnectDelay(this.reconnectAttempt, {
+      baseMs: this.reconnectBaseMs,
+      maxMs: this.reconnectMaxMs,
+    });
+    this.reconnectAttempt += 1;
+    this.reconnectTimer = this.setTimeoutFn(() => {
+      this.reconnectTimer = null;
+      this._openSocket();
+    }, delay);
+    return delay;
+  }
+
+  _clearReconnectTimer() {
+    if (!this.reconnectTimer) {
+      return;
+    }
+    this.clearTimeoutFn(this.reconnectTimer);
+    this.reconnectTimer = null;
+  }
+
+  _startKeepalive() {
+    this._stopKeepalive();
+    this.keepaliveTimer = this.setIntervalFn(() => {
+      this.send({ type: "ping" });
+    }, this.keepaliveMs);
+  }
+
+  _stopKeepalive() {
+    if (!this.keepaliveTimer) {
+      return;
+    }
+    this.clearIntervalFn(this.keepaliveTimer);
+    this.keepaliveTimer = null;
+  }
+
+  send(payload) {
+    if (!this.socket || this.socket.destroyed || !this.socket.writable) {
+      return false;
+    }
+    this.socket.write(`${JSON.stringify(payload)}\n`);
+    return true;
+  }
+
+  close() {
+    this.closed = true;
+    this.connected = false;
+    this._clearReconnectTimer();
+    this._stopKeepalive();
+    if (this.socket && !this.socket.destroyed) {
+      this.socket.end();
+      this.socket.destroy();
+    }
+    this.socket = null;
+  }
+}

package/src/utils/canonical-json.js

@@ -0,0 +1,29 @@
+/**
+ * Canonical JSON serializer — deterministic, stable output.
+ *
+ * Rules:
+ * - Object keys sorted lexicographically (recursive)
+ * - No insignificant whitespace
+ * - Stable number formatting (JSON.stringify default)
+ * - null, boolean, string, number pass through normally
+ * - UTF-8 (Node default)
+ */
+
+export function canonicalJson(value) {
+  if (value === null || value === undefined) return "null";
+  if (typeof value === "boolean" || typeof value === "number") return JSON.stringify(value);
+  if (typeof value === "string") return JSON.stringify(value);
+
+  if (Array.isArray(value)) {
+    const items = value.map((item) => canonicalJson(item));
+    return "[" + items.join(",") + "]";
+  }
+
+  if (typeof value === "object") {
+    const keys = Object.keys(value).sort();
+    const pairs = keys.map((key) => JSON.stringify(key) + ":" + canonicalJson(value[key]));
+    return "{" + pairs.join(",") + "}";
+  }
+
+  return JSON.stringify(value);
+}

package/src/utils/compaction.js

@@ -0,0 +1,30 @@
+export const COMPACTION_NOTICE_TEXT = "Compressing context to stay within limits — resuming in a moment…";
+
+export function resolveCompactionThreshold(agentConfig) {
+  return agentConfig?.limits?.compaction_threshold_turns ?? 20;
+}
+
+export function resolveCompactionCondensedFanout(agentConfig) {
+  return agentConfig?.limits?.compaction_condensed_fanout ?? 4;
+}
+
+export function parseConversationTurns(contextJson) {
+  if (!contextJson) return [];
+
+  try {
+    const turns = JSON.parse(contextJson);
+    return Array.isArray(turns) ? turns : [];
+  } catch {
+    return [];
+  }
+}
+
+export function shouldCompactConversation(contextJson, agentConfig) {
+  return parseConversationTurns(contextJson).length >= resolveCompactionThreshold(agentConfig);
+}
+
+export async function notifyCompaction(sendFn, chatId) {
+  if (!sendFn || !chatId) return false;
+  await sendFn(chatId, COMPACTION_NOTICE_TEXT);
+  return true;
+}

package/src/utils/env-loader.js

@@ -0,0 +1,5 @@
+import path from "node:path";
+
+export function resolveEnvPath(srcDir) {
+  return path.resolve(srcDir, "..", ".env");
+}

package/src/utils/errors.js

@@ -0,0 +1,80 @@
+/**
+ * Shared error formatting utility for Nemoris V2.
+ * Provides consistent, structured error output across all modules.
+ */
+
+const VALID_CATEGORIES = new Set([
+  "config",
+  "provider",
+  "memory",
+  "delivery",
+  "security",
+  "execution"
+]);
+
+export class RuntimeError extends Error {
+  /**
+   * @param {string} message
+   * @param {object} options
+   * @param {string} options.category - one of: config, provider, memory, delivery, security, execution
+   * @param {object} [options.context] - key-value context for diagnostics
+   * @param {boolean} [options.recoverable] - whether the caller can retry/recover
+   */
+  constructor(message, { category, context = {}, recoverable = false } = {}) {
+    super(message);
+    this.name = "RuntimeError";
+    this.category = VALID_CATEGORIES.has(category) ? category : "execution";
+    this.context = context;
+    this.recoverable = recoverable;
+  }
+}
+
+/**
+ * Format any error into a consistent Nemoris error string.
+ *
+ * Output format:
+ *   [Nemoris] <category>: <message>
+ *     context: <key=value pairs>
+ *     source: <file:line if available>
+ *
+ * @param {Error|RuntimeError} error
+ * @param {object} [context] - additional context merged with error.context
+ * @returns {string}
+ */
+export function formatRuntimeError(error, context = {}) {
+  const category = error?.category || "execution";
+  const message = error?.message || String(error);
+
+  const mergedContext = { ...(error?.context || {}), ...context };
+  const contextEntries = Object.entries(mergedContext);
+  const contextLine = contextEntries.length
+    ? contextEntries.map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(", ")
+    : "none";
+
+  const source = extractSource(error);
+
+  const lines = [`[Nemoris] ${category}: ${message}`];
+  lines.push(`  context: ${contextLine}`);
+  lines.push(`  source: ${source}`);
+
+  return lines.join("\n");
+}
+
+function extractSource(error) {
+  if (!error?.stack) return "unknown";
+  const lines = error.stack.split("\n");
+  // Find first stack frame that is not this file
+  for (const line of lines) {
+    const match = line.match(/at\s+.+?\((.+:\d+:\d+)\)/);
+    if (match && !match[1].includes("utils/errors.js")) {
+      return match[1];
+    }
+    const matchNoParens = line.match(/at\s+(.+:\d+:\d+)$/);
+    if (matchNoParens && !matchNoParens[1].includes("utils/errors.js")) {
+      return matchNoParens[1];
+    }
+  }
+  return "unknown";
+}
+
+export { VALID_CATEGORIES };

package/src/utils/fs.js

@@ -0,0 +1,101 @@
+import { mkdir, readFile, writeFile, appendFile, readdir, rm, stat } from "node:fs/promises";
+import path from "node:path";
+
+export async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+
+export async function readJson(filePath, fallback = null) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+
+export async function readText(filePath, fallback = null) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+
+export async function writeJson(filePath, value) {
+  await ensureDir(path.dirname(filePath));
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export async function appendJsonLine(filePath, value) {
+  await ensureDir(path.dirname(filePath));
+  await appendFile(filePath, `${JSON.stringify(value)}\n`, "utf8");
+}
+
+export async function readJsonLines(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return raw
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+export async function listFiles(dirPath) {
+  try {
+    return await readdir(dirPath);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+export async function listFilesRecursive(dirPath) {
+  const results = [];
+
+  async function walk(currentPath) {
+    let entries;
+    try {
+      entries = await readdir(currentPath, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  await walk(dirPath);
+  return results;
+}
+
+export async function resetDir(dirPath) {
+  await rm(dirPath, { recursive: true, force: true });
+}
+
+export async function removePath(targetPath) {
+  await rm(targetPath, { recursive: true, force: true });
+}
+
+export async function statPath(targetPath) {
+  try {
+    return await stat(targetPath);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}

package/src/utils/ids.js

@@ -0,0 +1,5 @@
+import crypto from "node:crypto";
+
+export function createRuntimeId(prefix = "id") {
+  return `${prefix}:${crypto.randomUUID()}`;
+}

package/src/utils/model-context-limits.js

@@ -0,0 +1,30 @@
+/**
+ * Model context window and output token limits by model ID.
+ */
+
+/**
+ * Return the context window size for a given model ID.
+ * @param {string} modelId
+ * @returns {number}
+ */
+export function getContextLimit(modelId) {
+  const id = String(modelId || "").toLowerCase();
+  if (id.includes("opus") || id.includes("sonnet") || id.includes("haiku")) return 200000;
+  if (id.includes("gpt-4")) return 128000;
+  if (id.includes("gpt-3.5")) return 16000;
+  return 100000;
+}
+
+/**
+ * Return the max output tokens for a given model ID.
+ * @param {string} modelId
+ * @returns {number}
+ */
+export function getMaxOutputTokens(modelId) {
+  const id = String(modelId || "").toLowerCase();
+  if (id.includes("anthropic") || id.includes("claude") || id.includes("opus") ||
+      id.includes("sonnet") || id.includes("haiku")) {
+    return 8192;
+  }
+  return 4096;
+}