@nimiplatform/nimi-coding 0.1.0

package/cli/lib/internal/governance/config.mjs

@@ -0,0 +1,150 @@
+import path from "node:path";
+
+import { readTextIfFile } from "../../fs-helpers.mjs";
+import { parseYamlText } from "../../yaml-helpers.mjs";
+import { isPlainObject } from "../../value-helpers.mjs";
+
+const GOVERNANCE_CONFIG_RELATIVE_PATH = ".nimi/config/governance.yaml";
+
+function normalizeAgentsTarget(entry) {
+  if (!isPlainObject(entry) || typeof entry.rel !== "string") {
+    return null;
+  }
+
+  return {
+    rel: entry.rel.trim(),
+    maxLines: Number(entry.max_lines ?? entry.maxLines ?? 0),
+  };
+}
+
+function normalizeGovernanceConfig(parsed) {
+  if (!isPlainObject(parsed)) {
+    return null;
+  }
+
+  const profileId = typeof parsed.profile_id === "string" ? parsed.profile_id.trim() : null;
+  const specGovernance = isPlainObject(parsed.spec_governance) ? parsed.spec_governance : {};
+  const aiGovernance = isPlainObject(parsed.ai_governance) ? parsed.ai_governance : {};
+  const agentsFreshness = isPlainObject(aiGovernance.agents_freshness)
+    ? aiGovernance.agents_freshness
+    : {};
+
+  function normalizeCommandMap(section) {
+    if (!isPlainObject(section)) {
+      return {};
+    }
+
+    const output = {};
+    for (const [key, value] of Object.entries(section)) {
+      if (Array.isArray(value)) {
+        output[key] = value.map((entry) => String(entry || "").trim()).filter(Boolean);
+      } else if (typeof value === "string" && value.trim().length > 0) {
+        output[key] = [value.trim()];
+      }
+    }
+    return output;
+  }
+
+  const normalized = {
+    profileId,
+    specGovernance: {
+      canonicalRoot: typeof specGovernance.canonical_root === "string"
+        ? specGovernance.canonical_root.trim()
+        : ".nimi/spec",
+      domainChecks: isPlainObject(specGovernance.domain_checks)
+        ? specGovernance.domain_checks
+        : {},
+      validateCommands: normalizeCommandMap(specGovernance.validate_commands),
+      generateCommands: normalizeCommandMap(specGovernance.generate_commands),
+      singleSource: isPlainObject(specGovernance.single_source)
+        ? specGovernance.single_source
+        : {},
+      realmAlignment: isPlainObject(specGovernance.realm_alignment)
+        ? specGovernance.realm_alignment
+        : {},
+      legacyVocabulary: isPlainObject(specGovernance.legacy_vocabulary)
+        ? specGovernance.legacy_vocabulary
+        : {},
+    },
+    aiGovernance: {
+      agentsFreshness: {
+        targets: Array.isArray(agentsFreshness.targets)
+          ? agentsFreshness.targets.map(normalizeAgentsTarget).filter(Boolean)
+          : [],
+        requiredSections: Array.isArray(agentsFreshness.required_sections)
+          ? agentsFreshness.required_sections
+              .map((entry) => String(entry || "").trim())
+              .filter(Boolean)
+          : [],
+        staleTokens: Array.isArray(agentsFreshness.stale_tokens)
+          ? agentsFreshness.stale_tokens.map((entry) => String(entry || "").trim()).filter(Boolean)
+          : [],
+      },
+      contextBudget: isPlainObject(aiGovernance.context_budget)
+        ? aiGovernance.context_budget
+        : {},
+      structureBudget: isPlainObject(aiGovernance.structure_budget)
+        ? aiGovernance.structure_budget
+        : {},
+      highRiskDocMetadata: isPlainObject(aiGovernance.high_risk_doc_metadata)
+        ? aiGovernance.high_risk_doc_metadata
+        : {},
+    },
+  };
+
+  if (!normalized.profileId) {
+    return null;
+  }
+
+  return normalized;
+}
+
+export async function loadGovernanceConfig(projectRoot = process.cwd()) {
+  const configPath = path.join(projectRoot, GOVERNANCE_CONFIG_RELATIVE_PATH);
+  const text = await readTextIfFile(configPath);
+
+  if (text === null) {
+    return {
+      ok: false,
+      path: configPath,
+      reason: "missing governance config",
+      config: null,
+    };
+  }
+
+  const parsed = parseYamlText(text);
+  const normalized = normalizeGovernanceConfig(parsed);
+
+  if (!normalized) {
+    return {
+      ok: false,
+      path: configPath,
+      reason: "invalid governance config",
+      config: null,
+    };
+  }
+
+  return {
+    ok: true,
+    path: configPath,
+    reason: null,
+    config: normalized,
+  };
+}
+
+export function requireProfile(governanceConfig, requestedProfile) {
+  const effectiveProfile = requestedProfile || governanceConfig.profileId;
+  if (effectiveProfile !== governanceConfig.profileId) {
+    return {
+      ok: false,
+      error: `governance profile mismatch: expected ${governanceConfig.profileId} but received ${effectiveProfile}`,
+      profile: effectiveProfile,
+    };
+  }
+
+  return {
+    ok: true,
+    error: null,
+    profile: effectiveProfile,
+  };
+}

package/cli/lib/internal/governance/runner.mjs

@@ -0,0 +1,35 @@
+import { spawnSync } from "node:child_process";
+
+export function runNodeScript(scriptPath, args = [], options = {}) {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: options.cwd ?? process.cwd(),
+    env: { ...process.env, ...(options.env ?? {}) },
+    stdio: "pipe",
+    encoding: "utf8",
+    shell: false,
+  });
+
+  return {
+    ok: result.status === 0,
+    exitCode: result.status ?? 1,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+  };
+}
+
+export function runCommand(command, options = {}) {
+  const result = spawnSync(command, {
+    cwd: options.cwd ?? process.cwd(),
+    env: { ...process.env, ...(options.env ?? {}) },
+    stdio: "pipe",
+    encoding: "utf8",
+    shell: true,
+  });
+
+  return {
+    ok: result.status === 0,
+    exitCode: result.status ?? 1,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+  };
+}

package/cli/lib/internal/governance/shared/read-yaml-with-fragments.mjs

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+
+function isRecord(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function mergeFragmentValues(key, currentValue, nextValue, sourcePath) {
+  if (typeof currentValue === 'undefined') {
+    return nextValue;
+  }
+  if (Array.isArray(currentValue) && Array.isArray(nextValue)) {
+    return [...currentValue, ...nextValue];
+  }
+  if (isRecord(currentValue) && isRecord(nextValue)) {
+    return { ...currentValue, ...nextValue };
+  }
+  throw new Error(`fragment merge type mismatch for ${key} in ${sourcePath}`);
+}
+
+export function readYamlWithFragments(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf8');
+  const parsed = YAML.parse(raw);
+  if (!isRecord(parsed) || !isRecord(parsed.fragments)) {
+    return parsed;
+  }
+
+  const resolved = { ...parsed };
+  const fragmentEntries = Object.entries(parsed.fragments);
+  delete resolved.fragments;
+
+  for (const [key, fragmentSpec] of fragmentEntries) {
+    const refs = Array.isArray(fragmentSpec) ? fragmentSpec : [fragmentSpec];
+    let mergedValue;
+    for (const ref of refs) {
+      const relativeRef = String(ref || '').trim();
+      if (!relativeRef) {
+        throw new Error(`empty fragment reference for ${key} in ${filePath}`);
+      }
+      const fragmentPath = path.resolve(path.dirname(filePath), relativeRef);
+      const fragmentValue = readYamlWithFragments(fragmentPath);
+      mergedValue = mergeFragmentValues(key, mergedValue, fragmentValue, filePath);
+    }
+    resolved[key] = mergedValue;
+  }
+
+  return resolved;
+}