nemoris 0.1.0 → 0.1.2

package/src/config/schema-validator.js

@@ -1,214 +1,214 @@
-/**
- * TOML config schema validation — validates parsed config objects against
- * expected schemas at load time so that missing/malformed fields fail loudly
- * instead of silently degrading at runtime.
- */
-
-import { formatRuntimeError, RuntimeError } from "../utils/errors.js";
-
-// ── Schema definitions ──────────────────────────────────────────────
-
-const AGENT_SCHEMA = {
-  label: "agent",
-  required: {
-    id: "string",
-    primaryLane: "string",
-    memoryPolicy: "string",
-    toolPolicy: "string"
-  }
-};
-
-const JOB_SCHEMA = {
-  label: "job",
-  required: {
-    id: "string",
-    modelLane: "string"
-  },
-  atLeastOne: [["schedule", "trigger"]]
-};
-
-const PROVIDER_SCHEMA = {
-  label: "provider",
-  required: {
-    id: "string"
-  },
-  atLeastOne: [["adapter", "type"]]
-};
-
-const RUNTIME_SCHEMA = {
-  label: "runtime",
-  requiredSections: {
-    safety: {
-      contextTokens: "number"
-    }
-  }
-};
-
-const ROUTER_SCHEMA = {
-  label: "router",
-  minLanes: 1
-};
-
-export const SCHEMAS = {
-  agent: AGENT_SCHEMA,
-  job: JOB_SCHEMA,
-  provider: PROVIDER_SCHEMA,
-  runtime: RUNTIME_SCHEMA,
-  router: ROUTER_SCHEMA
-};
-
-// ── Validation engine ───────────────────────────────────────────────
-
-export class ConfigSchemaError extends Error {
-  constructor(message, errors) {
-    super(message);
-    this.name = "ConfigSchemaError";
-    this.validationErrors = errors;
-  }
-}
-
-function typeLabel(value) {
-  if (value === null || value === undefined) return "missing";
-  if (Array.isArray(value)) return "array";
-  return typeof value;
-}
-
-function checkType(value, expectedType) {
-  if (value === null || value === undefined) return false;
-  if (expectedType === "array") return Array.isArray(value);
-  return typeof value === expectedType;
-}
-
-/**
- * Validate a parsed config object against a schema definition.
- *
- * @param {object} config  – the parsed (and key-normalised) config object
- * @param {object} schema  – one of the SCHEMAS entries
- * @param {string} filePath – file path for error messages
- * @returns {{ ok: boolean, errors: string[] }}
- */
-export function validateConfig(config, schema, filePath) {
-  const errors = [];
-  const ctx = filePath || schema.label || "config";
-
-  if (!config || typeof config !== "object") {
-    errors.push(`${ctx}: config is ${typeLabel(config)}, expected an object`);
-    return { ok: false, errors };
-  }
-
-  // Check required fields
-  if (schema.required) {
-    for (const [field, expectedType] of Object.entries(schema.required)) {
-      if (!(field in config) || config[field] === undefined || config[field] === null || config[field] === "") {
-        errors.push(`${ctx}: missing required field "${field}"`);
-      } else if (!checkType(config[field], expectedType)) {
-        errors.push(
-          `${ctx}: field "${field}" should be ${expectedType}, got ${typeLabel(config[field])}`
-        );
-      }
-    }
-  }
-
-  // Check at-least-one groups (e.g. schedule OR trigger)
-  if (schema.atLeastOne) {
-    for (const group of schema.atLeastOne) {
-      const present = group.filter((field) => field in config && config[field] !== undefined && config[field] !== null && config[field] !== "");
-      if (present.length === 0) {
-        errors.push(`${ctx}: must have at least one of: ${group.join(", ")}`);
-      }
-    }
-  }
-
-  // Check required sections (nested objects with typed sub-fields)
-  if (schema.requiredSections) {
-    for (const [section, subFields] of Object.entries(schema.requiredSections)) {
-      if (!(section in config) || !config[section] || typeof config[section] !== "object") {
-        errors.push(`${ctx}: missing required section [${section}]`);
-      } else {
-        for (const [subField, expectedType] of Object.entries(subFields)) {
-          const value = config[section][subField];
-          if (value === undefined || value === null) {
-            errors.push(`${ctx}: missing required field "${section}.${subField}"`);
-          } else if (!checkType(value, expectedType)) {
-            errors.push(
-              `${ctx}: field "${section}.${subField}" should be ${expectedType}, got ${typeLabel(value)}`
-            );
-          }
-        }
-      }
-    }
-  }
-
-  // Router-specific: must have at least N lane definitions
-  if (schema.minLanes !== undefined) {
-    const laneCount = Object.keys(config).length;
-    if (laneCount < schema.minLanes) {
-      errors.push(`${ctx}: must define at least ${schema.minLanes} lane(s), found ${laneCount}`);
-    }
-  }
-
-  return { ok: errors.length === 0, errors };
-}
-
-/**
- * Validate and throw if invalid — convenience wrapper used by the config loader.
- */
-export function validateOrThrow(config, schema, filePath) {
-  const result = validateConfig(config, schema, filePath);
-  if (!result.ok) {
-    const runtimeError = new RuntimeError(
-      `Config schema validation failed for ${filePath || schema.label}`,
-      { category: "config", context: { filePath, schema: schema.label, errorCount: result.errors.length }, recoverable: false }
-    );
-    const formatted = formatRuntimeError(runtimeError, { details: result.errors.join("; ") });
-    throw new ConfigSchemaError(formatted, result.errors);
-  }
-  return config;
-}
-
-/**
- * Validate all config sections in a full loadAll() result.
- * Returns { ok, errors[] } for CLI / test consumption.
- */
-export function validateAllConfigs(config, rootDir) {
-  const allErrors = [];
-
-  // Agents
-  for (const [id, agent] of Object.entries(config.agents || {})) {
-    const filePath = agent.__filePath || `${rootDir}/agents/${id}.toml`;
-    const result = validateConfig(agent, AGENT_SCHEMA, filePath);
-    allErrors.push(...result.errors);
-  }
-
-  // Jobs
-  for (const [id, job] of Object.entries(config.jobs || {})) {
-    const filePath = job.__filePath || `${rootDir}/jobs/${id}.toml`;
-    const result = validateConfig(job, JOB_SCHEMA, filePath);
-    allErrors.push(...result.errors);
-  }
-
-  // Providers
-  for (const [id, provider] of Object.entries(config.providers || {})) {
-    const filePath = provider.__filePath || `${rootDir}/providers/${id}.toml`;
-    const result = validateConfig(provider, PROVIDER_SCHEMA, filePath);
-    allErrors.push(...result.errors);
-  }
-
-  // Runtime
-  if (config.runtime) {
-    const result = validateConfig(config.runtime, RUNTIME_SCHEMA, `${rootDir}/runtime.toml`);
-    allErrors.push(...result.errors);
-  } else {
-    allErrors.push(`${rootDir}/runtime.toml: runtime config is missing entirely`);
-  }
-
-  // Router
-  if (config.router) {
-    const result = validateConfig(config.router, ROUTER_SCHEMA, `${rootDir}/router.toml`);
-    allErrors.push(...result.errors);
-  } else {
-    allErrors.push(`${rootDir}/router.toml: router config is missing entirely`);
-  }
-
-  return { ok: allErrors.length === 0, errors: allErrors };
-}
+/**
+ * TOML config schema validation — validates parsed config objects against
+ * expected schemas at load time so that missing/malformed fields fail loudly
+ * instead of silently degrading at runtime.
+ */
+
+import { formatRuntimeError, RuntimeError } from "../utils/errors.js";
+
+// ── Schema definitions ──────────────────────────────────────────────
+
+const AGENT_SCHEMA = {
+  label: "agent",
+  required: {
+    id: "string",
+    primaryLane: "string",
+    memoryPolicy: "string",
+    toolPolicy: "string"
+  }
+};
+
+const JOB_SCHEMA = {
+  label: "job",
+  required: {
+    id: "string",
+    modelLane: "string"
+  },
+  atLeastOne: [["schedule", "trigger"]]
+};
+
+const PROVIDER_SCHEMA = {
+  label: "provider",
+  required: {
+    id: "string"
+  },
+  atLeastOne: [["adapter", "type"]]
+};
+
+const RUNTIME_SCHEMA = {
+  label: "runtime",
+  requiredSections: {
+    safety: {
+      contextTokens: "number"
+    }
+  }
+};
+
+const ROUTER_SCHEMA = {
+  label: "router",
+  minLanes: 1
+};
+
+export const SCHEMAS = {
+  agent: AGENT_SCHEMA,
+  job: JOB_SCHEMA,
+  provider: PROVIDER_SCHEMA,
+  runtime: RUNTIME_SCHEMA,
+  router: ROUTER_SCHEMA
+};
+
+// ── Validation engine ───────────────────────────────────────────────
+
+export class ConfigSchemaError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.name = "ConfigSchemaError";
+    this.validationErrors = errors;
+  }
+}
+
+function typeLabel(value) {
+  if (value === null || value === undefined) return "missing";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+
+function checkType(value, expectedType) {
+  if (value === null || value === undefined) return false;
+  if (expectedType === "array") return Array.isArray(value);
+  return typeof value === expectedType;
+}
+
+/**
+ * Validate a parsed config object against a schema definition.
+ *
+ * @param {object} config  – the parsed (and key-normalised) config object
+ * @param {object} schema  – one of the SCHEMAS entries
+ * @param {string} filePath – file path for error messages
+ * @returns {{ ok: boolean, errors: string[] }}
+ */
+export function validateConfig(config, schema, filePath) {
+  const errors = [];
+  const ctx = filePath || schema.label || "config";
+
+  if (!config || typeof config !== "object") {
+    errors.push(`${ctx}: config is ${typeLabel(config)}, expected an object`);
+    return { ok: false, errors };
+  }
+
+  // Check required fields
+  if (schema.required) {
+    for (const [field, expectedType] of Object.entries(schema.required)) {
+      if (!(field in config) || config[field] === undefined || config[field] === null || config[field] === "") {
+        errors.push(`${ctx}: missing required field "${field}"`);
+      } else if (!checkType(config[field], expectedType)) {
+        errors.push(
+          `${ctx}: field "${field}" should be ${expectedType}, got ${typeLabel(config[field])}`
+        );
+      }
+    }
+  }
+
+  // Check at-least-one groups (e.g. schedule OR trigger)
+  if (schema.atLeastOne) {
+    for (const group of schema.atLeastOne) {
+      const present = group.filter((field) => field in config && config[field] !== undefined && config[field] !== null && config[field] !== "");
+      if (present.length === 0) {
+        errors.push(`${ctx}: must have at least one of: ${group.join(", ")}`);
+      }
+    }
+  }
+
+  // Check required sections (nested objects with typed sub-fields)
+  if (schema.requiredSections) {
+    for (const [section, subFields] of Object.entries(schema.requiredSections)) {
+      if (!(section in config) || !config[section] || typeof config[section] !== "object") {
+        errors.push(`${ctx}: missing required section [${section}]`);
+      } else {
+        for (const [subField, expectedType] of Object.entries(subFields)) {
+          const value = config[section][subField];
+          if (value === undefined || value === null) {
+            errors.push(`${ctx}: missing required field "${section}.${subField}"`);
+          } else if (!checkType(value, expectedType)) {
+            errors.push(
+              `${ctx}: field "${section}.${subField}" should be ${expectedType}, got ${typeLabel(value)}`
+            );
+          }
+        }
+      }
+    }
+  }
+
+  // Router-specific: must have at least N lane definitions
+  if (schema.minLanes !== undefined) {
+    const laneCount = Object.keys(config).length;
+    if (laneCount < schema.minLanes) {
+      errors.push(`${ctx}: must define at least ${schema.minLanes} lane(s), found ${laneCount}`);
+    }
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+/**
+ * Validate and throw if invalid — convenience wrapper used by the config loader.
+ */
+export function validateOrThrow(config, schema, filePath) {
+  const result = validateConfig(config, schema, filePath);
+  if (!result.ok) {
+    const runtimeError = new RuntimeError(
+      `Config schema validation failed for ${filePath || schema.label}`,
+      { category: "config", context: { filePath, schema: schema.label, errorCount: result.errors.length }, recoverable: false }
+    );
+    const formatted = formatRuntimeError(runtimeError, { details: result.errors.join("; ") });
+    throw new ConfigSchemaError(formatted, result.errors);
+  }
+  return config;
+}
+
+/**
+ * Validate all config sections in a full loadAll() result.
+ * Returns { ok, errors[] } for CLI / test consumption.
+ */
+export function validateAllConfigs(config, rootDir) {
+  const allErrors = [];
+
+  // Agents
+  for (const [id, agent] of Object.entries(config.agents || {})) {
+    const filePath = agent.__filePath || `${rootDir}/agents/${id}.toml`;
+    const result = validateConfig(agent, AGENT_SCHEMA, filePath);
+    allErrors.push(...result.errors);
+  }
+
+  // Jobs
+  for (const [id, job] of Object.entries(config.jobs || {})) {
+    const filePath = job.__filePath || `${rootDir}/jobs/${id}.toml`;
+    const result = validateConfig(job, JOB_SCHEMA, filePath);
+    allErrors.push(...result.errors);
+  }
+
+  // Providers
+  for (const [id, provider] of Object.entries(config.providers || {})) {
+    const filePath = provider.__filePath || `${rootDir}/providers/${id}.toml`;
+    const result = validateConfig(provider, PROVIDER_SCHEMA, filePath);
+    allErrors.push(...result.errors);
+  }
+
+  // Runtime
+  if (config.runtime) {
+    const result = validateConfig(config.runtime, RUNTIME_SCHEMA, `${rootDir}/runtime.toml`);
+    allErrors.push(...result.errors);
+  } else {
+    allErrors.push(`${rootDir}/runtime.toml: runtime config is missing entirely`);
+  }
+
+  // Router
+  if (config.router) {
+    const result = validateConfig(config.router, ROUTER_SCHEMA, `${rootDir}/router.toml`);
+    allErrors.push(...result.errors);
+  } else {
+    allErrors.push(`${rootDir}/router.toml: router config is missing entirely`);
+  }
+
+  return { ok: allErrors.length === 0, errors: allErrors };
+}

package/src/config/toml-lite.js

@@ -1,8 +1,8 @@
-import { parse } from "smol-toml";
-
-export function parseToml(source) {
-  if (!source || !String(source).trim()) {
-    return {};
-  }
-  return parse(String(source));
-}
+import { parse } from "smol-toml";
+
+export function parseToml(source) {
+  if (!source || !String(source).trim()) {
+    return {};
+  }
+  return parse(String(source));
+}

package/src/daemon/action-handlers.js

@@ -1,71 +1,71 @@
-/**
- * Factory that creates an action executor wired to real system components.
- * Returns an async function: (actionName, context) => boolean (success).
- */
-export function createActionHandler({ getBreaker, mcpConsumer, stateStore, telegramSendFn, lastFailedMessage }) {
-  const handlers = {
-    async circuit_break(ctx) {
-      const breaker = getBreaker(ctx.provider);
-      if (breaker) breaker.recordFailure(ctx.code || 500);
-      return true;
-    },
-    async retry_then_break(ctx) {
-      // Retry once, then circuit break
-      const breaker = getBreaker(ctx.provider);
-      if (breaker) breaker.recordFailure(ctx.code || 408);
-      return true;
-    },
-    async restart(ctx) {
-      if (!mcpConsumer) return false;
-      await mcpConsumer.ensureRunning(ctx.server);
-      return true;
-    },
-    async kill_restart(ctx) {
-      if (!mcpConsumer) return false;
-      await mcpConsumer.shutdown(ctx.server);
-      await mcpConsumer.ensureRunning(ctx.server);
-      return true;
-    },
-    async compact() {
-      // Trigger is handled by existing maintenance cycle — just return true
-      return true;
-    },
-    async rebuild_index() {
-      return true; // Existing embedding rebuild runs in maintenance
-    },
-    async reap() {
-      try {
-        const { reapOrphanedJobs } = await import("../runtime/orphan-reaper.js");
-        reapOrphanedJobs(stateStore);
-      } catch {
-        // stateStore may be a stub in tests or unavailable — best-effort
-      }
-      return true;
-    },
-    async retry_backoff(ctx) {
-      if (!telegramSendFn) return false;
-      const delays = [1000, 2000, 4000]; // 3 retries with exponential backoff
-      for (const delay of delays) {
-        await new Promise(r => setTimeout(r, delay));
-        const result = await telegramSendFn(lastFailedMessage || "Retry");
-        if (result?.ok) return true;
-      }
-      return false;
-    },
-    async resend(ctx) {
-      if (!telegramSendFn || !lastFailedMessage) return false;
-      const result = await telegramSendFn(lastFailedMessage);
-      return !!result?.ok;
-    }
-  };
-
-  return async (actionName, context) => {
-    const handler = handlers[actionName];
-    if (!handler) return false;
-    try {
-      return await handler(context || {});
-    } catch {
-      return false;
-    }
-  };
-}
+/**
+ * Factory that creates an action executor wired to real system components.
+ * Returns an async function: (actionName, context) => boolean (success).
+ */
+export function createActionHandler({ getBreaker, mcpConsumer, stateStore, telegramSendFn, lastFailedMessage }) {
+  const handlers = {
+    async circuit_break(ctx) {
+      const breaker = getBreaker(ctx.provider);
+      if (breaker) breaker.recordFailure(ctx.code || 500);
+      return true;
+    },
+    async retry_then_break(ctx) {
+      // Retry once, then circuit break
+      const breaker = getBreaker(ctx.provider);
+      if (breaker) breaker.recordFailure(ctx.code || 408);
+      return true;
+    },
+    async restart(ctx) {
+      if (!mcpConsumer) return false;
+      await mcpConsumer.ensureRunning(ctx.server);
+      return true;
+    },
+    async kill_restart(ctx) {
+      if (!mcpConsumer) return false;
+      await mcpConsumer.shutdown(ctx.server);
+      await mcpConsumer.ensureRunning(ctx.server);
+      return true;
+    },
+    async compact() {
+      // Trigger is handled by existing maintenance cycle — just return true
+      return true;
+    },
+    async rebuild_index() {
+      return true; // Existing embedding rebuild runs in maintenance
+    },
+    async reap() {
+      try {
+        const { reapOrphanedJobs } = await import("../runtime/orphan-reaper.js");
+        reapOrphanedJobs(stateStore);
+      } catch {
+        // stateStore may be a stub in tests or unavailable — best-effort
+      }
+      return true;
+    },
+    async retry_backoff(ctx) {
+      if (!telegramSendFn) return false;
+      const delays = [1000, 2000, 4000]; // 3 retries with exponential backoff
+      for (const delay of delays) {
+        await new Promise(r => setTimeout(r, delay));
+        const result = await telegramSendFn(lastFailedMessage || "Retry");
+        if (result?.ok) return true;
+      }
+      return false;
+    },
+    async resend(ctx) {
+      if (!telegramSendFn || !lastFailedMessage) return false;
+      const result = await telegramSendFn(lastFailedMessage);
+      return !!result?.ok;
+    }
+  };
+
+  return async (actionName, context) => {
+    const handler = handlers[actionName];
+    if (!handler) return false;
+    try {
+      return await handler(context || {});
+    } catch {
+      return false;
+    }
+  };
+}