nemoris 0.1.0 → 0.1.2

package/src/onboarding/phases/validate.js

@@ -1,204 +1,204 @@
-/**
- * Validate phase — checks that the scaffolded config directory is well-formed.
- *
- * Loads config files that are present, runs schema validation, checks that
- * state directories exist and are writable, and probes any configured
- * providers via their adapter healthCheck(). A freshly scaffolded directory
- * has no providers and no router.toml (written later by the hatch phase), so
- * those sections are treated as optional at this stage.
- */
-
-import fs from "node:fs";
-import path from "node:path";
-import { readText, listFilesRecursive } from "../../utils/fs.js";
-import { parseToml } from "../../config/toml-lite.js";
-import { validateAllConfigs } from "../../config/schema-validator.js";
-
-// State directories that must exist and be writable after scaffold
-const STATE_DIRS = ["state", path.join("state", "memory")];
-
-/**
- * Normalise TOML snake_case keys to camelCase (mirrors ConfigLoader behaviour).
- * @param {unknown} value
- * @returns {unknown}
- */
-function normalizeKeys(value) {
-  if (Array.isArray(value)) return value.map(normalizeKeys);
-  if (!value || typeof value !== "object") return value;
-
-  const out = {};
-  for (const [k, v] of Object.entries(value)) {
-    const norm = k.replace(/_([a-z])/g, (_, l) => l.toUpperCase());
-    out[norm] = normalizeKeys(v);
-  }
-  return out;
-}
-
-/**
- * Load all TOML files in a directory into an id-keyed map.
- * Returns an empty object if the directory is absent.
- *
- * @param {string} dirPath
- * @returns {Promise<Record<string, object>>}
- */
-async function loadDirAsMap(dirPath) {
-  if (!fs.existsSync(dirPath)) return {};
-
-  const files = (await listFilesRecursive(dirPath)).filter((f) => f.endsWith(".toml"));
-  const entries = [];
-  for (const filePath of files) {
-    const parsed = normalizeKeys(parseToml(await readText(filePath, "")));
-    const id = parsed.id || path.basename(filePath, ".toml");
-    entries.push([id, { ...parsed, __filePath: filePath }]);
-  }
-  return Object.fromEntries(entries);
-}
-
-/**
- * Check that state directories exist and are writable.
- *
- * @param {string} installDir
- * @returns {{ ready: boolean, missing: string[] }}
- */
-function checkStateDirs(installDir) {
-  const missing = [];
-  for (const rel of STATE_DIRS) {
-    const absPath = path.join(installDir, rel);
-    if (!fs.existsSync(absPath)) {
-      missing.push(rel);
-      continue;
-    }
-    try {
-      fs.accessSync(absPath, fs.constants.W_OK);
-    } catch {
-      missing.push(rel);
-    }
-  }
-  return { ready: missing.length === 0, missing };
-}
-
-/**
- * Probe a single provider via its adapter's healthCheck(), if available.
- *
- * @param {string} id
- * @param {object} providerConfig
- * @returns {Promise<{ id: string, healthy: boolean, error?: string }>}
- */
-async function probeProvider(id, providerConfig) {
-  const adapterName = providerConfig.adapter || providerConfig.type;
-  if (!adapterName) {
-    return { id, healthy: false, error: "no adapter or type configured" };
-  }
-
-  try {
-    // Attempt to dynamically load the adapter module
-    const adapterPath = new URL(
-      `../../providers/adapters/${adapterName}.js`,
-      import.meta.url
-    );
-    const mod = await import(adapterPath.href);
-    const AdapterClass = mod.default || mod[Object.keys(mod)[0]];
-
-    if (typeof AdapterClass?.prototype?.healthCheck === "function") {
-      const instance = new AdapterClass(providerConfig);
-      await instance.healthCheck();
-      return { id, healthy: true };
-    }
-
-    // Static healthCheck
-    if (typeof AdapterClass?.healthCheck === "function") {
-      await AdapterClass.healthCheck(providerConfig);
-      return { id, healthy: true };
-    }
-
-    // No healthCheck available — treat as healthy (unchecked)
-    return { id, healthy: true };
-  } catch (err) {
-    return { id, healthy: false, error: err.message };
-  }
-}
-
-/**
- * Validate a scaffolded nemoris installation directory.
- *
- * @param {string} installDir  Absolute path to the installation root.
- * @returns {Promise<{
- *   configValid: boolean,
- *   errors: string[],
- *   stateDirsReady: boolean,
- *   providerHealth: Array<{ id: string, healthy: boolean, error?: string }>,
- * }>}
- */
-export async function validateScaffold(installDir) {
-  const configDir = path.join(installDir, "config");
-
-  // ── 1. Load config sections that are present ──────────────────────────────
-
-  const [agents, jobs, providers] = await Promise.all([
-    loadDirAsMap(path.join(configDir, "agents")),
-    loadDirAsMap(path.join(configDir, "jobs")),
-    loadDirAsMap(path.join(configDir, "providers")),
-  ]);
-
-  // Runtime — required by schema validator; will produce errors if missing
-  const runtimeRaw = normalizeKeys(
-    parseToml(await readText(path.join(configDir, "runtime.toml"), ""))
-  );
-  const runtime = Object.keys(runtimeRaw).length > 0 ? runtimeRaw : null;
-
-  // Router — optional at scaffold stage (written during hatch phase)
-  const routerFilePath = path.join(configDir, "router.toml");
-  let router = null;
-  if (fs.existsSync(routerFilePath)) {
-    const raw = parseToml(await readText(routerFilePath, ""));
-    const lanes = {};
-    for (const [laneName, value] of Object.entries(raw.lanes || {})) {
-      lanes[laneName] = {
-        primary: value.primary,
-        fallback: value.fallback,
-        manualBump: value.manual_bump,
-      };
-    }
-    if (Object.keys(lanes).length > 0) {
-      router = lanes;
-    }
-  }
-
-  // ── 2. Build a minimal config object and run schema validation ────────────
-
-  const config = {
-    agents,
-    jobs,
-    providers,
-    ...(runtime ? { runtime } : {}),
-    ...(router ? { router } : {}),
-  };
-
-  const validationResult = validateAllConfigs(config, configDir);
-
-  // router.toml is written during the hatch phase (after providers are
-  // configured). At scaffold+identity stage it is not yet present, so we
-  // treat the router-missing error as non-fatal when no router is loaded.
-  const errors = router
-    ? validationResult.errors
-    : validationResult.errors.filter((e) => !e.includes("router config is missing entirely"));
-
-  const ok = errors.length === 0;
-
-  // ── 3. Check state directories ────────────────────────────────────────────
-
-  const { ready: stateDirsReady } = checkStateDirs(installDir);
-
-  // ── 4. Probe configured providers ─────────────────────────────────────────
-
-  const providerHealth = await Promise.all(
-    Object.entries(providers).map(([id, cfg]) => probeProvider(id, cfg))
-  );
-
-  return {
-    configValid: ok,
-    errors,
-    stateDirsReady,
-    providerHealth,
-  };
-}
+/**
+ * Validate phase — checks that the scaffolded config directory is well-formed.
+ *
+ * Loads config files that are present, runs schema validation, checks that
+ * state directories exist and are writable, and probes any configured
+ * providers via their adapter healthCheck(). A freshly scaffolded directory
+ * has no providers and no router.toml (written later by the hatch phase), so
+ * those sections are treated as optional at this stage.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { readText, listFilesRecursive } from "../../utils/fs.js";
+import { parseToml } from "../../config/toml-lite.js";
+import { validateAllConfigs } from "../../config/schema-validator.js";
+
+// State directories that must exist and be writable after scaffold
+const STATE_DIRS = ["state", path.join("state", "memory")];
+
+/**
+ * Normalise TOML snake_case keys to camelCase (mirrors ConfigLoader behaviour).
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+function normalizeKeys(value) {
+  if (Array.isArray(value)) return value.map(normalizeKeys);
+  if (!value || typeof value !== "object") return value;
+
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    const norm = k.replace(/_([a-z])/g, (_, l) => l.toUpperCase());
+    out[norm] = normalizeKeys(v);
+  }
+  return out;
+}
+
+/**
+ * Load all TOML files in a directory into an id-keyed map.
+ * Returns an empty object if the directory is absent.
+ *
+ * @param {string} dirPath
+ * @returns {Promise<Record<string, object>>}
+ */
+async function loadDirAsMap(dirPath) {
+  if (!fs.existsSync(dirPath)) return {};
+
+  const files = (await listFilesRecursive(dirPath)).filter((f) => f.endsWith(".toml"));
+  const entries = [];
+  for (const filePath of files) {
+    const parsed = normalizeKeys(parseToml(await readText(filePath, "")));
+    const id = parsed.id || path.basename(filePath, ".toml");
+    entries.push([id, { ...parsed, __filePath: filePath }]);
+  }
+  return Object.fromEntries(entries);
+}
+
+/**
+ * Check that state directories exist and are writable.
+ *
+ * @param {string} installDir
+ * @returns {{ ready: boolean, missing: string[] }}
+ */
+function checkStateDirs(installDir) {
+  const missing = [];
+  for (const rel of STATE_DIRS) {
+    const absPath = path.join(installDir, rel);
+    if (!fs.existsSync(absPath)) {
+      missing.push(rel);
+      continue;
+    }
+    try {
+      fs.accessSync(absPath, fs.constants.W_OK);
+    } catch {
+      missing.push(rel);
+    }
+  }
+  return { ready: missing.length === 0, missing };
+}
+
+/**
+ * Probe a single provider via its adapter's healthCheck(), if available.
+ *
+ * @param {string} id
+ * @param {object} providerConfig
+ * @returns {Promise<{ id: string, healthy: boolean, error?: string }>}
+ */
+async function probeProvider(id, providerConfig) {
+  const adapterName = providerConfig.adapter || providerConfig.type;
+  if (!adapterName) {
+    return { id, healthy: false, error: "no adapter or type configured" };
+  }
+
+  try {
+    // Attempt to dynamically load the adapter module
+    const adapterPath = new URL(
+      `../../providers/adapters/${adapterName}.js`,
+      import.meta.url
+    );
+    const mod = await import(adapterPath.href);
+    const AdapterClass = mod.default || mod[Object.keys(mod)[0]];
+
+    if (typeof AdapterClass?.prototype?.healthCheck === "function") {
+      const instance = new AdapterClass(providerConfig);
+      await instance.healthCheck();
+      return { id, healthy: true };
+    }
+
+    // Static healthCheck
+    if (typeof AdapterClass?.healthCheck === "function") {
+      await AdapterClass.healthCheck(providerConfig);
+      return { id, healthy: true };
+    }
+
+    // No healthCheck available — treat as healthy (unchecked)
+    return { id, healthy: true };
+  } catch (err) {
+    return { id, healthy: false, error: err.message };
+  }
+}
+
+/**
+ * Validate a scaffolded nemoris installation directory.
+ *
+ * @param {string} installDir  Absolute path to the installation root.
+ * @returns {Promise<{
+ *   configValid: boolean,
+ *   errors: string[],
+ *   stateDirsReady: boolean,
+ *   providerHealth: Array<{ id: string, healthy: boolean, error?: string }>,
+ * }>}
+ */
+export async function validateScaffold(installDir) {
+  const configDir = path.join(installDir, "config");
+
+  // ── 1. Load config sections that are present ──────────────────────────────
+
+  const [agents, jobs, providers] = await Promise.all([
+    loadDirAsMap(path.join(configDir, "agents")),
+    loadDirAsMap(path.join(configDir, "jobs")),
+    loadDirAsMap(path.join(configDir, "providers")),
+  ]);
+
+  // Runtime — required by schema validator; will produce errors if missing
+  const runtimeRaw = normalizeKeys(
+    parseToml(await readText(path.join(configDir, "runtime.toml"), ""))
+  );
+  const runtime = Object.keys(runtimeRaw).length > 0 ? runtimeRaw : null;
+
+  // Router — optional at scaffold stage (written during hatch phase)
+  const routerFilePath = path.join(configDir, "router.toml");
+  let router = null;
+  if (fs.existsSync(routerFilePath)) {
+    const raw = parseToml(await readText(routerFilePath, ""));
+    const lanes = {};
+    for (const [laneName, value] of Object.entries(raw.lanes || {})) {
+      lanes[laneName] = {
+        primary: value.primary,
+        fallback: value.fallback,
+        manualBump: value.manual_bump,
+      };
+    }
+    if (Object.keys(lanes).length > 0) {
+      router = lanes;
+    }
+  }
+
+  // ── 2. Build a minimal config object and run schema validation ────────────
+
+  const config = {
+    agents,
+    jobs,
+    providers,
+    ...(runtime ? { runtime } : {}),
+    ...(router ? { router } : {}),
+  };
+
+  const validationResult = validateAllConfigs(config, configDir);
+
+  // router.toml is written during the hatch phase (after providers are
+  // configured). At scaffold+identity stage it is not yet present, so we
+  // treat the router-missing error as non-fatal when no router is loaded.
+  const errors = router
+    ? validationResult.errors
+    : validationResult.errors.filter((e) => !e.includes("router config is missing entirely"));
+
+  const ok = errors.length === 0;
+
+  // ── 3. Check state directories ────────────────────────────────────────────
+
+  const { ready: stateDirsReady } = checkStateDirs(installDir);
+
+  // ── 4. Probe configured providers ─────────────────────────────────────────
+
+  const providerHealth = await Promise.all(
+    Object.entries(providers).map(([id, cfg]) => probeProvider(id, cfg))
+  );
+
+  return {
+    configValid: ok,
+    errors,
+    stateDirsReady,
+    providerHealth,
+  };
+}