@cs-object/cli 0.1.0

package/dist/chunk-KYWIVB2V.js

@@ -0,0 +1,341 @@
+import {
+  stringifyJson
+} from "./chunk-MOM6Q2VG.js";
+
+// src/reports.ts
+import { CommandReportSchema } from "@cs-object/core";
+
+// package.json
+var version = "0.1.0";
+
+// src/reports.ts
+function initialReport(command) {
+  return {
+    reportVersion: "1",
+    command,
+    toolVersion: version,
+    ok: false,
+    provenance: {},
+    numericPolicy: {
+      absoluteTolerance: 1e-9,
+      relativeTolerance: 1e-12,
+      numberDomain: "finite-real-typed-safe-integer"
+    },
+    checks: {
+      executionValidity: { status: "not_applicable" },
+      inputConsistency: { status: "not_applicable" },
+      constantConsistency: { status: "not_applicable" },
+      formulaConsistency: { status: "not_applicable" },
+      outputConsistency: {
+        status: "not_applicable",
+        counts: { checked: 0, passed: 0, failed: 0 }
+      },
+      sourceToDocumentConsistency: { status: "not_applicable" },
+      independentReferenceAgreement: { status: "not_applicable" },
+      documentContent: { status: "not_applicable" },
+      rendering: { status: "not_applicable" },
+      visualInspection: { status: "not_applicable" }
+    },
+    diagnostics: []
+  };
+}
+function usageReport(failure) {
+  return CommandReportSchema.parse({
+    reportVersion: "1",
+    command: failure.kind === "unavailable" ? failure.command : void 0,
+    toolVersion: version,
+    ok: false,
+    provenance: {},
+    numericPolicy: {
+      absoluteTolerance: 1e-9,
+      relativeTolerance: 1e-12,
+      numberDomain: "finite-real-typed-safe-integer"
+    },
+    checks: Object.fromEntries(
+      [
+        "executionValidity",
+        "inputConsistency",
+        "constantConsistency",
+        "formulaConsistency",
+        "outputConsistency",
+        "sourceToDocumentConsistency",
+        "independentReferenceAgreement",
+        "documentContent",
+        "rendering",
+        "visualInspection"
+      ].map((name) => [
+        name,
+        {
+          status: "not_applicable",
+          ...name === "outputConsistency" ? { counts: { checked: 0, passed: 0, failed: 0 } } : {}
+        }
+      ])
+    ),
+    diagnostics: [
+      {
+        code: failure.kind === "unavailable" ? "COMMAND_UNAVAILABLE" : "UNKNOWN_COMMAND",
+        stage: "usage",
+        message: failure.kind === "unavailable" ? "Verified commands are unavailable until ticket11 integration. No execution, verification, rendering or inspection ran." : `Unknown command ${failure.command}. Use cso --help for supported commands. No checks ran.`
+      }
+    ]
+  });
+}
+
+// src/strict-json.ts
+var structureTokens = /("(?:[^"\\]|\\.)*")(\s*:)?|[{}[\]]/g;
+function parseStrictJson(text) {
+  const parsed = JSON.parse(text);
+  const containers = [];
+  for (const token of text.matchAll(structureTokens)) {
+    if (token[0] === "{") {
+      containers.push(/* @__PURE__ */ new Set());
+    } else if (token[0] === "[") {
+      containers.push(null);
+    } else if (token[0] === "}" || token[0] === "]") {
+      containers.pop();
+    } else if (token[1] && token[2]) {
+      const key = JSON.parse(token[1]);
+      if (typeof key !== "string") {
+        throw new Error("Expected JSON string key");
+      }
+      const keys = containers.at(-1);
+      if (keys?.has(key)) {
+        throw new Error(`Duplicate JSON key ${JSON.stringify(key)}`);
+      }
+      keys?.add(key);
+    }
+  }
+  return parsed;
+}
+
+// src/verification.ts
+import {
+  executionBindingFrom as executionBindingFrom2,
+  CommandReportSchema as CommandReportSchema2,
+  verifyExecution
+} from "@cs-object/core";
+
+// src/reference.ts
+import { readFileSync } from "fs";
+import { createHash } from "crypto";
+import {
+  executionBindingFrom,
+  ReferenceFileSchema,
+  contractIssuesToDiagnostics,
+  referenceBindingKey
+} from "@cs-object/core";
+function captureReference(path, execution) {
+  let provenance;
+  try {
+    const bytes = readFileSync(path);
+    provenance = {
+      path,
+      sha256: createHash("sha256").update(bytes).digest("hex"),
+      revisions: []
+    };
+    const raw = parseStrictJson(
+      new TextDecoder("utf-8", { fatal: true }).decode(bytes)
+    );
+    const parsed = ReferenceFileSchema.safeParse(raw);
+    if (!parsed.success) {
+      return {
+        kind: "failed",
+        provenance,
+        diagnostics: contractIssuesToDiagnostics(parsed.error.issues).map(
+          (diagnostic) => ({ ...diagnostic, stage: "reference" })
+        )
+      };
+    }
+    const binding = referenceBindingKey(executionBindingFrom(execution));
+    provenance.revisions = parsed.data.cases.filter((item) => referenceBindingKey(item.binding) === binding).map((item) => item.revision);
+    return { kind: "parsed", cases: parsed.data.cases, bytes, provenance };
+  } catch (error) {
+    return {
+      kind: "failed",
+      provenance,
+      diagnostics: [
+        {
+          code: "REFERENCE_CAPTURE_FAILED",
+          stage: "reference",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ]
+    };
+  }
+}
+
+// src/execution.ts
+import { spawnSync } from "child_process";
+import {
+  ExecutionResponseSchema,
+  contractIssuesToDiagnostics as contractIssuesToDiagnostics2
+} from "@cs-object/core";
+var message = (error) => error instanceof Error ? error.message : String(error);
+function runPythonExecution(options, timeoutMs) {
+  const environment = { ...process.env };
+  for (const key of ["PYTHONPATH", "PYTHONHOME", "NODE_PATH"]) {
+    Reflect.deleteProperty(environment, key);
+  }
+  const result = spawnSync(
+    process.env.PYTHON ?? "python3",
+    [
+      "-I",
+      "-m",
+      "cso_python",
+      "execute",
+      options.sourcePath,
+      "--function",
+      options.functionName,
+      "--inputs-json",
+      stringifyJson(options.inputs)
+    ],
+    {
+      env: environment,
+      maxBuffer: 64 * 1024 * 1024,
+      timeout: timeoutMs,
+      killSignal: "SIGKILL"
+    }
+  );
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  if (result.error || result.signal) {
+    return {
+      kind: "failed",
+      diagnostics: [
+        {
+          code: "PYTHON_PROCESS_FAILED",
+          stage: "execution",
+          message: result.error ? message(result.error) : `Python terminated by ${result.signal}`
+        }
+      ]
+    };
+  }
+  let raw;
+  try {
+    raw = parseStrictJson(
+      new TextDecoder("utf-8", { fatal: true }).decode(result.stdout)
+    );
+  } catch (error) {
+    return {
+      kind: "failed",
+      diagnostics: [
+        {
+          code: "INVALID_EXECUTION_JSON",
+          stage: "contract",
+          message: message(error)
+        }
+      ]
+    };
+  }
+  const parsed = ExecutionResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      kind: "failed",
+      diagnostics: contractIssuesToDiagnostics2(parsed.error.issues)
+    };
+  }
+  return {
+    kind: "response",
+    response: parsed.data,
+    bytes: result.stdout,
+    exitCode: result.status
+  };
+}
+
+// src/verification.ts
+function executeAndVerify(options, timeoutMs) {
+  const report = initialReport("verify");
+  report.provenance.function = options.functionName;
+  const finish = (exitCode) => ({
+    kind: "failed",
+    outcome: {
+      report: CommandReportSchema2.parse({
+        ...report,
+        command: options.command
+      }),
+      exitCode
+    }
+  });
+  const attempt = runPythonExecution(options, timeoutMs);
+  if (attempt.kind === "failed") {
+    report.diagnostics.push(...attempt.diagnostics);
+    report.checks.executionValidity = { status: "failed" };
+    report.checks.sourceToDocumentConsistency = { status: "failed" };
+    return finish(1);
+  }
+  const response = attempt.response;
+  report.diagnostics.push(...response.diagnostics);
+  if (!response.ok) {
+    report.provenance = response.provenance ?? {};
+    const usage = attempt.exitCode === 2 && response.diagnostics.every((diagnostic) => diagnostic.stage === "usage");
+    if (!usage) {
+      report.checks.executionValidity = { status: "failed" };
+      report.checks.sourceToDocumentConsistency = { status: "failed" };
+      if (!response.diagnostics.some(
+        (diagnostic) => ["source", "execution", "contract"].includes(diagnostic.stage)
+      )) {
+        report.diagnostics.push({
+          code: "PYTHON_PROCESS_FAILED",
+          stage: "execution",
+          message: `Python failed with exit ${attempt.exitCode}`
+        });
+      }
+    }
+    return finish(usage ? 2 : 1);
+  }
+  if (attempt.exitCode !== 0) {
+    report.diagnostics.push({
+      code: "EXECUTION_EXIT_MISMATCH",
+      stage: "execution",
+      message: `Python returned success with exit ${attempt.exitCode}`
+    });
+    report.checks.executionValidity = { status: "failed" };
+    report.checks.sourceToDocumentConsistency = { status: "failed" };
+    return finish(1);
+  }
+  const execution = response.execution;
+  report.provenance = {
+    ...executionBindingFrom2(execution),
+    sourceManifest: execution.sourceManifest,
+    versions: execution.versions
+  };
+  const reference = options.referencePath ? captureReference(options.referencePath, execution) : void 0;
+  if (reference?.provenance) {
+    report.provenance.reference = reference.provenance;
+  }
+  const verified = verifyExecution({
+    execution,
+    referenceCases: reference?.kind === "parsed" ? reference.cases : void 0
+  });
+  report.numericPolicy = verified.numericPolicy;
+  Object.assign(report.checks, verified.checks);
+  report.diagnostics.push(...verified.diagnostics);
+  if (reference?.kind === "failed") {
+    report.diagnostics.push(...reference.diagnostics);
+  }
+  report.ok = verified.ok && reference?.kind !== "failed";
+  if (!report.ok) return finish(1);
+  return {
+    kind: "verified",
+    report: CommandReportSchema2.parse(report),
+    capture: {
+      execution,
+      executionBytes: attempt.bytes,
+      verification: verified,
+      referenceBytes: reference?.kind === "parsed" ? reference.bytes : void 0
+    }
+  };
+}
+function verifyCommand(options) {
+  const result = executeAndVerify(options);
+  return result.kind === "failed" ? result.outcome : { report: result.report, exitCode: 0 };
+}
+
+export {
+  initialReport,
+  usageReport,
+  parseStrictJson,
+  executeAndVerify,
+  verifyCommand
+};

package/dist/chunk-MOM6Q2VG.js

@@ -0,0 +1,44 @@
+// src/json.ts
+function stringifyJson(value) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const encode = (item) => {
+    if (Object.is(item, -0)) {
+      return "-0.0";
+    }
+    if (typeof item === "number" && Number.isFinite(item) && Number.isInteger(item) && !Number.isSafeInteger(item)) {
+      return item.toExponential();
+    }
+    if (item === null || typeof item !== "object") {
+      return JSON.stringify(item);
+    }
+    if (ancestors.has(item)) {
+      throw new TypeError("Cannot serialize cyclic JSON");
+    }
+    ancestors.add(item);
+    try {
+      if (Array.isArray(item)) {
+        return `[${Array.from(item, (child) => encode(child) ?? "null").join(",")}]`;
+      }
+      const prototype = Object.getPrototypeOf(item);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError("Expected a plain JSON object");
+      }
+      const fields = Object.entries(item).flatMap(([key, child]) => {
+        const encoded2 = encode(child);
+        return encoded2 === void 0 ? [] : [`${JSON.stringify(key)}:${encoded2}`];
+      });
+      return `{${fields.join(",")}}`;
+    } finally {
+      ancestors.delete(item);
+    }
+  };
+  const encoded = encode(value);
+  if (encoded === void 0) {
+    throw new TypeError("Expected a JSON value");
+  }
+  return encoded;
+}
+
+export {
+  stringifyJson
+};

package/dist/chunk-OYQDZWT7.js

@@ -0,0 +1,145 @@
+// src/arguments.ts
+import { PythonIdentifierSchema } from "@cs-object/core";
+import { resolve } from "path";
+var UsageError = class extends Error {
+};
+var numericPattern = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+function inputNumber(text) {
+  const value = Number(text);
+  if (!numericPattern.test(text) || !Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw new UsageError(
+      "Inputs must be finite JSON numbers in the safe integer range"
+    );
+  }
+  return value;
+}
+function jsonInputs(text) {
+  const entries = [];
+  const body = text.trim();
+  try {
+    JSON.parse(body);
+  } catch {
+    throw new UsageError("--inputs-json must be valid JSON");
+  }
+  if (!body.startsWith("{") || !body.endsWith("}")) {
+    throw new UsageError("--inputs-json must be a JSON object of numbers");
+  }
+  let rest = body.slice(1, -1).trim();
+  while (rest.length > 0) {
+    const match = /^("(?:[^"\\]|\\(?:["\\/bfnrt]|u[\da-fA-F]{4}))*")\s*:\s*([^,]+)(,|$)/.exec(
+      rest
+    );
+    if (!match || !match[1] || !match[2]) {
+      throw new UsageError("--inputs-json must be a JSON object of numbers");
+    }
+    const key = JSON.parse(match[1]);
+    if (typeof key !== "string") throw new UsageError("Invalid input name");
+    entries.push([key, inputNumber(match[2].trim())]);
+    rest = rest.slice(match[0].length).trim();
+    if (match[3] === "," && rest.length === 0) {
+      throw new UsageError("--inputs-json cannot have a trailing comma");
+    }
+  }
+  return entries;
+}
+function parseCliArgs(args) {
+  const values = /* @__PURE__ */ new Map();
+  const inputs = /* @__PURE__ */ new Map();
+  const setInput = (spelling, value) => {
+    if (!PythonIdentifierSchema.safeParse(spelling).success) {
+      throw new UsageError(`Input ${spelling} is not a valid Python parameter`);
+    }
+    const name = spelling.normalize("NFKC");
+    if (!PythonIdentifierSchema.safeParse(name).success) {
+      throw new UsageError(
+        `Input ${spelling} does not normalize to a valid Python parameter`
+      );
+    }
+    if (inputs.has(name))
+      throw new UsageError(`Input ${name} was provided more than once`);
+    inputs.set(name, value);
+  };
+  const allowed = /* @__PURE__ */ new Set([
+    "--source",
+    "--function",
+    "--out",
+    "--inputs-json",
+    "--input"
+  ]);
+  for (let index = 0; index < args.length; index += 2) {
+    const option = args[index];
+    const value = args[index + 1];
+    if (!option || !allowed.has(option))
+      throw new UsageError(`Unknown option ${option}`);
+    if (!value || value.startsWith("--"))
+      throw new UsageError(`${option} requires a value`);
+    if (option !== "--input") {
+      if (values.has(option))
+        throw new UsageError(`${option} was provided more than once`);
+      values.set(option, value);
+    }
+    if (option === "--input") {
+      const separator = value.indexOf("=");
+      if (separator < 1)
+        throw new UsageError("--input must use name=value format");
+      setInput(
+        value.slice(0, separator),
+        inputNumber(value.slice(separator + 1))
+      );
+    } else if (option === "--inputs-json") {
+      for (const [name, number] of jsonInputs(value)) setInput(name, number);
+    }
+  }
+  const source = values.get("--source");
+  const functionName = values.get("--function");
+  const out = values.get("--out");
+  if (!source) throw new UsageError("--source is required");
+  if (!functionName || !PythonIdentifierSchema.safeParse(functionName).success)
+    throw new UsageError("--function requires a valid Python identifier");
+  const normalizedFunction = functionName.normalize("NFKC");
+  if (!PythonIdentifierSchema.safeParse(normalizedFunction).success) {
+    throw new UsageError(
+      "--function does not normalize to a valid Python identifier"
+    );
+  }
+  if (!out) throw new UsageError("--out is required");
+  return {
+    sourcePath: resolve(source),
+    functionName: normalizedFunction,
+    outPath: resolve(out),
+    inputs: Object.fromEntries(inputs)
+  };
+}
+var help = `Usage: cso <verify|html|pdf|bindings|dev|dev-export|dev-render> [arguments]
+Use cso <command> --help for usage. dev-export and dev-render require
+--source <file.cso.py> --function <name> --out <path>.
+
+verify evaluates documented formulas and optional independent references.
+Development export/render establishes no numerical verification or independent
+reference agreement. Inspect every PDF page before delivery.
+
+Commands:
+  dev                    Serve a verified calculation, editable inputs and report on localhost.
+  bindings               Generate typed calculation handles; --check reports stale files without writing.
+  dev-export             Export CSO JSON using the selected installed Python module.
+  dev-render             Export once and render a development PDF with installed React/CSS.
+  verify                 Execute once and verify formulas; use cso verify --help.
+  html                   Verify once and publish standalone HTML; --check-layout adds browser checks.
+  pdf                    Verify once, retain evidence unless --no-evidence, and atomically publish a PDF.
+
+Options:
+  --input <name=number>   Repeat for distinct Python function parameters.
+  --inputs-json <object> Flat JSON object of numeric parameters; duplicates rejected.
+  --help                 Show usage without executing Python or launching Chromium.
+
+Paths resolve from the caller's directory. Set PYTHON to the interpreter with the
+cso-python wheel installed. dev-render requires Playwright Chromium.
+Development exit codes: 0 exported/rendered, 1 execution/render/write failed,
+2 invalid usage. verify/html/pdf --format json emit one public CommandReport.
+`;
+
+export {
+  UsageError,
+  parseCliArgs,
+  help
+};

package/dist/chunk-UCPKZ67Z.js

@@ -0,0 +1,88 @@
+import {
+  LayoutInspectionError,
+  buildPreparedHtml,
+  captureAssets,
+  inspectPreparedHtml,
+  jsonBytes,
+  publishDocumentEvidence,
+  renderPreparedPdf,
+  retainSource,
+  sha256
+} from "./chunk-7XCJ6AF3.js";
+import {
+  executeAndVerify
+} from "./chunk-KYWIVB2V.js";
+
+// src/document.ts
+import { CommandReportSchema } from "@cs-object/core";
+import {
+  prepareExecutionDocument,
+  DocumentPreparationError
+} from "@cs-object/react";
+async function documentCommand(options) {
+  const result = executeAndVerify(options);
+  if (result.kind === "failed") return result.outcome;
+  const report = { ...result.report, command: options.command, ok: false };
+  let stage = "document";
+  try {
+    const document = prepareExecutionDocument({
+      execution: result.capture.execution,
+      assets: captureAssets(options.sourcePath, result.capture.execution)
+    });
+    const retained = retainSource(result.capture, document);
+    report.checks.documentContent = { status: "passed" };
+    let bytes;
+    let presentation = [];
+    if (options.command === "pdf") {
+      stage = "rendering";
+      const rendered = await renderPreparedPdf(document);
+      bytes = rendered.pdf;
+      presentation = rendered.presentation;
+      report.checks.rendering = { status: "passed" };
+    } else {
+      const html = buildPreparedHtml(document);
+      bytes = Buffer.from(html);
+      if (options.checkLayout) {
+        stage = "rendering";
+        presentation = await inspectPreparedHtml(document, html);
+        report.checks.rendering = { status: "passed" };
+      }
+    }
+    stage = "write";
+    const successful = CommandReportSchema.parse({
+      ...report,
+      ok: true,
+      checks: { ...report.checks, visualInspection: { status: "pending" } },
+      output: { path: options.outPath, sha256: sha256(bytes) }
+    });
+    const stdoutBytes = jsonBytes(successful);
+    const evidence = publishDocumentEvidence({
+      outPath: options.outPath,
+      artifact: { kind: options.command, bytes },
+      presentationCheck: options.command === "pdf" || options.checkLayout ? "passed" : "not_applicable",
+      reportBytes: stdoutBytes,
+      retained,
+      presentation,
+      retainEvidence: options.retainEvidence
+    });
+    return { report: successful, exitCode: 0, stdoutBytes, evidence };
+  } catch (error) {
+    if (stage === "document")
+      report.checks.documentContent = { status: "failed" };
+    if (stage === "rendering") report.checks.rendering = { status: "failed" };
+    report.diagnostics.push(
+      ...error instanceof DocumentPreparationError || error instanceof LayoutInspectionError ? error.diagnostics : [
+        {
+          code: stage === "document" ? "DOCUMENT_PREPARATION_FAILED" : stage === "rendering" ? `${options.command.toUpperCase()}_RENDERING_FAILED` : `${options.command.toUpperCase()}_PUBLICATION_FAILED`,
+          stage,
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ]
+    );
+    return { report: CommandReportSchema.parse(report), exitCode: 1 };
+  }
+}
+
+export {
+  documentCommand
+};