@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/chunk-V76WTFTW.js

@@ -0,0 +1,318 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  compareCodepoints
+} from "./chunk-I5FWO7L5.js";
+import {
+  byteLength
+} from "./chunk-6XLNIQDB.js";
+import {
+  resolveSafeCwd
+} from "./chunk-TOIVGRUX.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/safety/validation-contract.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+var VALIDATION_CONTRACT_VERSION = 1;
+var VALIDATION_CONTRACT_YAML_PATHS = [
+  ".clio-coder/validation.yaml",
+  ".clio-coder/validation.yml",
+  "validation.yaml",
+  "validation.yml"
+];
+var VALIDATION_CONTRACT_MARKDOWN_PATH = "VALIDATION.md";
+var VALIDATION_CONTRACT_CAPS = Object.freeze({
+  fileBytes: 256 * 1024,
+  textBytes: 4096,
+  notesBytes: 16 * 1024,
+  artifacts: 256,
+  validators: 128,
+  modules: 64,
+  mapEntries: 256,
+  mapKeyBytes: 256
+});
+var RUNTIME_KINDS = ["local", "slurm", "mpi", "other"];
+var ROOT_FIELDS = /* @__PURE__ */ new Set(["version", "task", "runtime", "artifacts", "validators", "notes"]);
+var RUNTIME_FIELDS = /* @__PURE__ */ new Set(["kind", "nodes", "ranks", "walltime", "modules"]);
+var ARTIFACT_FIELDS = /* @__PURE__ */ new Set([
+  "path",
+  "format",
+  "expected_dimensions",
+  "expected_attributes",
+  "numerical_tolerances",
+  "preserve"
+]);
+var TOLERANCE_FIELDS = /* @__PURE__ */ new Set(["relative", "absolute", "ulp"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function unknownFields(record, allowed) {
+  return Object.keys(record).filter((key) => !allowed.has(key)).sort(compareCodepoints);
+}
+function boundedText(value, location, cap) {
+  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
+  if (value.includes("\0")) return new Error(`${location} must not contain a NUL byte`);
+  if (byteLength(value) > cap) return new Error(`${location} exceeds the ${cap}-byte cap`);
+  return value;
+}
+function positiveInteger(value, location) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return new Error(`${location} must be a positive integer`);
+  }
+  return value;
+}
+function nonNegativeNumber(value, location) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return new Error(`${location} must be a finite non-negative number`);
+  }
+  return value;
+}
+function boundedStringList(value, location, cap) {
+  if (!Array.isArray(value)) return new Error(`${location} must be an array of strings`);
+  if (value.length > cap) return new Error(`${location} exceeds the ${cap}-entry cap`);
+  const items = [];
+  for (const [index, entry] of value.entries()) {
+    const text = boundedText(entry, `${location}[${index}]`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (text instanceof Error) return text;
+    items.push(text);
+  }
+  return items;
+}
+function boundedMap(value, location, validateEntry) {
+  if (!isRecord(value)) return new Error(`${location} must be a map`);
+  const keys = Object.keys(value);
+  if (keys.length > VALIDATION_CONTRACT_CAPS.mapEntries) {
+    return new Error(`${location} exceeds the ${VALIDATION_CONTRACT_CAPS.mapEntries}-entry cap`);
+  }
+  const out = {};
+  for (const key of keys.sort(compareCodepoints)) {
+    const entryLocation = `${location}.${key}`;
+    if (key.length === 0) return new Error(`${location} has an empty key`);
+    if (byteLength(key) > VALIDATION_CONTRACT_CAPS.mapKeyBytes) {
+      return new Error(`${entryLocation} key exceeds the ${VALIDATION_CONTRACT_CAPS.mapKeyBytes}-byte cap`);
+    }
+    const entry = validateEntry(value[key], entryLocation);
+    if (entry instanceof Error) return entry;
+    out[key] = entry;
+  }
+  return out;
+}
+function validateRuntime(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object with a kind field`);
+  const unknown = unknownFields(value, RUNTIME_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  if (!Object.hasOwn(value, "kind")) return new Error(`${location}.kind is required`);
+  const kind = value.kind;
+  if (typeof kind !== "string" || !RUNTIME_KINDS.includes(kind)) {
+    return new Error(`${location}.kind must be one of ${RUNTIME_KINDS.join(", ")}`);
+  }
+  const runtime = { kind };
+  if (Object.hasOwn(value, "nodes")) {
+    const nodes = positiveInteger(value.nodes, `${location}.nodes`);
+    if (nodes instanceof Error) return nodes;
+    runtime.nodes = nodes;
+  }
+  if (Object.hasOwn(value, "ranks")) {
+    const ranks = positiveInteger(value.ranks, `${location}.ranks`);
+    if (ranks instanceof Error) return ranks;
+    runtime.ranks = ranks;
+  }
+  if (Object.hasOwn(value, "walltime")) {
+    const walltime = boundedText(value.walltime, `${location}.walltime`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (walltime instanceof Error) return walltime;
+    runtime.walltime = walltime;
+  }
+  if (Object.hasOwn(value, "modules")) {
+    const modules = boundedStringList(value.modules, `${location}.modules`, VALIDATION_CONTRACT_CAPS.modules);
+    if (modules instanceof Error) return modules;
+    runtime.modules = modules;
+  }
+  return runtime;
+}
+function validateTolerances(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object`);
+  const unknown = unknownFields(value, TOLERANCE_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  const tolerances = {};
+  if (Object.hasOwn(value, "relative")) {
+    const relative = nonNegativeNumber(value.relative, `${location}.relative`);
+    if (relative instanceof Error) return relative;
+    tolerances.relative = relative;
+  }
+  if (Object.hasOwn(value, "absolute")) {
+    const absolute = nonNegativeNumber(value.absolute, `${location}.absolute`);
+    if (absolute instanceof Error) return absolute;
+    tolerances.absolute = absolute;
+  }
+  if (Object.hasOwn(value, "ulp")) {
+    const ulp = value.ulp;
+    if (typeof ulp !== "number" || !Number.isInteger(ulp) || ulp < 0) {
+      return new Error(`${location}.ulp must be a non-negative integer`);
+    }
+    tolerances.ulp = ulp;
+  }
+  return tolerances;
+}
+function validateArtifact(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object with a path field`);
+  const unknown = unknownFields(value, ARTIFACT_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  if (!Object.hasOwn(value, "path")) return new Error(`${location}.path is required`);
+  const artifactPath = boundedText(value.path, `${location}.path`, VALIDATION_CONTRACT_CAPS.textBytes);
+  if (artifactPath instanceof Error) return artifactPath;
+  const artifact = { path: artifactPath };
+  if (Object.hasOwn(value, "format")) {
+    const format = boundedText(value.format, `${location}.format`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (format instanceof Error) return format;
+    artifact.format = format;
+  }
+  if (Object.hasOwn(value, "expected_dimensions")) {
+    const dimensions = boundedMap(
+      value.expected_dimensions,
+      `${location}.expected_dimensions`,
+      (entry, entryLocation) => typeof entry === "number" && Number.isInteger(entry) && entry >= 0 ? entry : new Error(`${entryLocation} must be a non-negative integer`)
+    );
+    if (dimensions instanceof Error) return dimensions;
+    artifact.expected_dimensions = dimensions;
+  }
+  if (Object.hasOwn(value, "expected_attributes")) {
+    const attributes = boundedMap(
+      value.expected_attributes,
+      `${location}.expected_attributes`,
+      (entry, entryLocation) => typeof entry === "string" ? boundedText(entry, entryLocation, VALIDATION_CONTRACT_CAPS.textBytes) : new Error(`${entryLocation} must be a string`)
+    );
+    if (attributes instanceof Error) return attributes;
+    artifact.expected_attributes = attributes;
+  }
+  if (Object.hasOwn(value, "numerical_tolerances")) {
+    const tolerances = validateTolerances(value.numerical_tolerances, `${location}.numerical_tolerances`);
+    if (tolerances instanceof Error) return tolerances;
+    artifact.numerical_tolerances = tolerances;
+  }
+  if (Object.hasOwn(value, "preserve")) {
+    if (typeof value.preserve !== "boolean") return new Error(`${location}.preserve must be a boolean`);
+    artifact.preserve = value.preserve;
+  }
+  return artifact;
+}
+function parseValidationContractText(text, contractPath) {
+  const invalid = (reason) => ({ ok: false, path: contractPath, reason });
+  const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
+  if (document.errors.length > 0) {
+    return invalid(`invalid YAML: ${document.errors.map((error) => error.message).join("; ")}`);
+  }
+  let parsed;
+  try {
+    parsed = document.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    return invalid(`invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) return invalid("root must be an object with a version field");
+  const rootUnknown = unknownFields(parsed, ROOT_FIELDS);
+  if (rootUnknown.length > 0) return invalid(`root has unknown field(s): ${rootUnknown.join(", ")}`);
+  if (!Object.hasOwn(parsed, "version")) return invalid("root.version is required");
+  if (parsed.version !== VALIDATION_CONTRACT_VERSION) {
+    return invalid(
+      `unsupported version ${JSON.stringify(parsed.version)}; supported version is ${VALIDATION_CONTRACT_VERSION}`
+    );
+  }
+  const contract = { version: VALIDATION_CONTRACT_VERSION };
+  if (Object.hasOwn(parsed, "task")) {
+    const task = boundedText(parsed.task, "root.task", VALIDATION_CONTRACT_CAPS.textBytes);
+    if (task instanceof Error) return invalid(task.message);
+    contract.task = task;
+  }
+  if (Object.hasOwn(parsed, "runtime")) {
+    const runtime = validateRuntime(parsed.runtime, "root.runtime");
+    if (runtime instanceof Error) return invalid(runtime.message);
+    contract.runtime = runtime;
+  }
+  if (Object.hasOwn(parsed, "artifacts")) {
+    if (!Array.isArray(parsed.artifacts)) return invalid("root.artifacts must be an array");
+    if (parsed.artifacts.length > VALIDATION_CONTRACT_CAPS.artifacts) {
+      return invalid(`root.artifacts exceeds the ${VALIDATION_CONTRACT_CAPS.artifacts}-entry cap`);
+    }
+    const artifacts = [];
+    for (const [index, value] of parsed.artifacts.entries()) {
+      const artifact = validateArtifact(value, `artifacts[${index}]`);
+      if (artifact instanceof Error) return invalid(artifact.message);
+      artifacts.push(artifact);
+    }
+    contract.artifacts = artifacts;
+  }
+  if (Object.hasOwn(parsed, "validators")) {
+    const validators = boundedStringList(parsed.validators, "root.validators", VALIDATION_CONTRACT_CAPS.validators);
+    if (validators instanceof Error) return invalid(validators.message);
+    contract.validators = validators;
+  }
+  if (Object.hasOwn(parsed, "notes")) {
+    const notes = boundedText(parsed.notes, "root.notes", VALIDATION_CONTRACT_CAPS.notesBytes);
+    if (notes instanceof Error) return invalid(notes.message);
+    contract.notes = notes;
+  }
+  return { ok: true, contract, path: contractPath };
+}
+function readContractText(absolutePath, workspaceRoot) {
+  let realPath;
+  try {
+    const realRoot = realpathSync(workspaceRoot);
+    realPath = realpathSync(absolutePath);
+    resolveSafeCwd(realPath, realRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`contract file must resolve inside the workspace root (${message})`);
+  }
+  try {
+    const stats = statSync(realPath);
+    if (!stats.isFile()) return new Error("contract path must be a regular file");
+    if (stats.size > VALIDATION_CONTRACT_CAPS.fileBytes) {
+      return new Error(`file exceeds the ${VALIDATION_CONTRACT_CAPS.fileBytes}-byte cap`);
+    }
+    return readFileSync(realPath, "utf8");
+  } catch (error) {
+    return new Error(`cannot read contract (${error instanceof Error ? error.message : String(error)})`);
+  }
+}
+function loadValidationContract(workspaceRoot) {
+  let contractPath = null;
+  try {
+    contractPath = VALIDATION_CONTRACT_YAML_PATHS.find((relative) => existsSync(path.join(workspaceRoot, relative))) ?? null;
+    if (contractPath === null) {
+      if (existsSync(path.join(workspaceRoot, VALIDATION_CONTRACT_MARKDOWN_PATH))) {
+        return { ok: true, contract: null, path: VALIDATION_CONTRACT_MARKDOWN_PATH, advisory: true };
+      }
+      return { ok: true, contract: null };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      path: contractPath ?? VALIDATION_CONTRACT_YAML_PATHS[0] ?? "validation.yaml",
+      reason: `cannot inspect workspace root (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+  const text = readContractText(path.join(workspaceRoot, contractPath), workspaceRoot);
+  if (text instanceof Error) return { ok: false, path: contractPath, reason: text.message };
+  return parseValidationContractText(text, contractPath);
+}
+function describeValidationContract(result) {
+  if (!result.ok) return `${result.path}: ${result.reason}`;
+  if (result.contract === null) {
+    return "advisory" in result ? `${result.path} is advisory prose and does not raise rigor; add a version-1 validation.yaml to raise the default to high` : null;
+  }
+  return null;
+}
+
+export {
+  VALIDATION_CONTRACT_MARKDOWN_PATH,
+  loadValidationContract,
+  describeValidationContract
+};
+//# sourceMappingURL=chunk-V76WTFTW.js.map

package/dist/{chunk-NMJXSHBJ.js → chunk-W54I7H25.js}

@@ -3,7 +3,7 @@ import {
   gitCommitAttributionEnabled,
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-JIEGK6UF.js";
+} from "./chunk-U6TMQNSI.js";
 import {
   clampTimerDelayMs
 } from "./chunk-EBY63B7G.js";
@@ -280,4 +280,4 @@ export {
   combineBashOutput,
   runBashCommand
 };
-//# sourceMappingURL=chunk-NMJXSHBJ.js.map
+//# sourceMappingURL=chunk-W54I7H25.js.map

package/dist/{chunk-KPXDY6QF.js → chunk-XRZT5WY5.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   atomicWrite
-} from "./chunk-MQXIVJ35.js";
+} from "./chunk-HAXOFFRH.js";
 import {
   clioStateDir
 } from "./chunk-BYP5D4HI.js";
@@ -44,4 +44,4 @@ export {
   writeCodeStepRecord,
   readCodeStepRecords
 };
-//# sourceMappingURL=chunk-KPXDY6QF.js.map
+//# sourceMappingURL=chunk-XRZT5WY5.js.map