@cs-object/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+import {
+  UsageError,
+  help,
+  parseCliArgs
+} from "./chunk-OYQDZWT7.js";
+import {
+  initialReport,
+  usageReport,
+  verifyCommand
+} from "./chunk-KYWIVB2V.js";
+import {
+  stringifyJson
+} from "./chunk-MOM6Q2VG.js";
+
+// src/cli.ts
+import { CommandReportSchema } from "@cs-object/core";
+
+// src/verified-arguments.ts
+import { resolve } from "path";
+function parseVerifiedArgs(command2, args2) {
+  const [source, ...options] = args2;
+  if (!source || source.startsWith("--")) {
+    throw new UsageError("A source file is required");
+  }
+  const forwarded = ["--source", source];
+  const seen = /* @__PURE__ */ new Set();
+  let referencePath;
+  let outPath;
+  let retainEvidence = true;
+  let checkLayout = false;
+  for (let index = 0; index < options.length; ) {
+    const key = options[index];
+    if (key === "--no-evidence" || key === "--check-layout") {
+      if (key === "--no-evidence" && command2 === "verify" || key === "--check-layout" && command2 !== "html") {
+        throw new UsageError(`Unknown option ${key}`);
+      }
+      if (seen.has(key)) {
+        throw new UsageError(`${key} was provided more than once`);
+      }
+      seen.add(key);
+      if (key === "--no-evidence") retainEvidence = false;
+      else checkLayout = true;
+      index += 1;
+      continue;
+    }
+    const value = options[index + 1];
+    if (![
+      "--function",
+      "--input",
+      "--reference",
+      "--format",
+      ...command2 !== "verify" ? ["--out"] : []
+    ].includes(key)) {
+      throw new UsageError(`Unknown option ${key}`);
+    }
+    if (!value || value.startsWith("--")) {
+      throw new UsageError(`${key} requires a value`);
+    }
+    if (key !== "--input" && seen.has(key)) {
+      throw new UsageError(`${key} was provided more than once`);
+    }
+    seen.add(key);
+    if (key === "--format") {
+      if (value !== "json") {
+        throw new UsageError("--format must be json");
+      }
+    } else if (key === "--reference") {
+      referencePath = resolve(value);
+    } else if (key === "--out") {
+      outPath = resolve(value);
+    } else {
+      forwarded.push(key, value);
+    }
+    index += 2;
+  }
+  if (command2 !== "verify" && !outPath) {
+    throw new UsageError("--out is required");
+  }
+  const parsed = parseCliArgs([...forwarded, "--out", outPath ?? "."]);
+  const common = {
+    sourcePath: parsed.sourcePath,
+    functionName: parsed.functionName,
+    inputs: parsed.inputs,
+    referencePath
+  };
+  if (command2 === "html") {
+    return {
+      ...common,
+      command: command2,
+      outPath: parsed.outPath,
+      retainEvidence,
+      checkLayout
+    };
+  }
+  if (command2 === "pdf") {
+    return { ...common, command: command2, outPath: parsed.outPath, retainEvidence };
+  }
+  return { ...common, command: command2 };
+}
+function verifiedHelp(command2) {
+  if (command2 === "html")
+    return `Usage: cso html <file.cso.py> --function <name> [--input <name=number>] [--reference <file.json>] --out <path.html> [--format json] [--no-evidence] [--check-layout]
+
+Verify one captured execution and atomically publish standalone HTML with embedded CSS/assets.
+--check-layout uses Chromium to check assets, presentation and screen/print overflow before publication.
+Without --check-layout, no browser runs and rendering is not_applicable. Visual inspection stays pending.
+--no-evidence omits the sibling evidence bundle; verification and atomic replacement still apply.
+Inputs, reference matching, JSON reports, PYTHON and exit codes follow cso verify.
+Paths resolve against the caller directory. --help executes neither Python nor Chromium.
+`;
+  return `Usage: cso ${command2} <file.cso.py> --function <name> [--input <name=number>] [--reference <file.json>]${command2 === "pdf" ? " --out <path.pdf>" : ""} [--format json]${command2 === "pdf" ? " [--no-evidence]" : ""}
+
+${command2 === "verify" ? "Execute once with installed cso-python and independently evaluate every documented result." : "Verify once, render the captured execution, and atomically replace the PDF. Evidence is retained unless --no-evidence is set."}
+Repeat --input for distinct parameters. Duplicate, unknown and invalid inputs fail.
+--reference captures one explicit versioned reference file. Missing matches are not_applicable.
+--format json emits one public CommandReport, including on errors.
+${command2 === "pdf" ? "--no-evidence writes only the PDF; no sibling evidence bundle or stderr locator.\n" : ""}--help shows this command help without executing Python.
+Paths resolve against the caller directory. PYTHON selects the installed interpreter.
+Exit codes: 0 success, 1 verification/generation failure, 2 invalid usage.
+Tolerance: abs(actual - expected) <= max(1e-9, 1e-12 * max(abs(actual), abs(expected))).
+Document, rendering and visual checks do not apply to verify.
+${command2 === "pdf" ? "PDF evidence is retained at <output>.evidence/<manifest-hash>/ unless --no-evidence is set; its locator/hash goes to stderr.\nGenerated PDFs have pending visual inspection. Evidence alone is not proof of PDF publication.\n" : ""}`;
+}
+
+// src/bindings.ts
+import { spawnSync } from "child_process";
+var bindingsHelp = `Usage: cso bindings <directory> [--check]
+
+Generate importable _cso_bindings modules and typed signatures from .cso.py files.
+--check reports stale or missing files without writing. Calculations are not executed.
+Python-only equivalent: python -m cso_python bindings <directory> [--check]
+Set PYTHON to the interpreter with cso-python installed.
+Exit codes: 0 current/generated, 1 stale/source/write failure, 2 invalid usage.
+`;
+function bindingsCommand(args2) {
+  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", "bindings", ...args2],
+    { env: environment, maxBuffer: 64 * 1024 * 1024 }
+  );
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.error || result.signal) {
+    process.stdout.write(
+      `${JSON.stringify({
+        ok: false,
+        diagnostics: [
+          {
+            code: "PYTHON_PROCESS_FAILED",
+            message: result.error?.message ?? `Python terminated by ${result.signal}`
+          }
+        ]
+      })}
+`
+    );
+    return 1;
+  }
+  process.stdout.write(result.stdout);
+  return result.status ?? 1;
+}
+
+// src/cli.ts
+var [command, ...args] = process.argv.slice(2);
+if (command === "--help" || command === void 0 || [
+  "verify",
+  "pdf",
+  "html",
+  "bindings",
+  "dev",
+  "dev-export",
+  "dev-render"
+].includes(command) && args.includes("--help")) {
+  process.stdout.write(
+    command === "verify" || command === "pdf" || command === "html" ? verifiedHelp(command) : command === "dev" ? (await import("./dev-server-BVY4Q6R6.js")).devHelp : command === "bindings" ? bindingsHelp : help
+  );
+} else if (command === "dev") {
+  try {
+    const { devCommand } = await import("./dev-server-BVY4Q6R6.js");
+    await devCommand(args);
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : String(error)}
+`
+    );
+    process.exitCode = error instanceof UsageError ? 2 : 1;
+  }
+} else if (command === "bindings") {
+  process.exitCode = bindingsCommand(args);
+} else if (command === "verify" || command === "pdf" || command === "html") {
+  let outcome;
+  try {
+    const options = parseVerifiedArgs(command, args);
+    if (options.command === "html") {
+      const { htmlCommand } = await import("./html-AAIMIB2S.js");
+      outcome = await htmlCommand(options);
+    } else if (options.command === "pdf") {
+      const { pdfCommand } = await import("./pdf-WXWGZ6NC.js");
+      outcome = await pdfCommand(options);
+    } else {
+      outcome = verifyCommand(options);
+    }
+  } catch (error) {
+    const report = initialReport(command);
+    report.diagnostics.push({
+      code: error instanceof UsageError ? "INVALID_USAGE" : "COMMAND_FAILED",
+      stage: error instanceof UsageError ? "usage" : "execution",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    outcome = {
+      report: CommandReportSchema.parse(report),
+      exitCode: error instanceof UsageError ? 2 : 1
+    };
+  }
+  if (outcome.evidence)
+    process.stderr.write(`CSO evidence ${stringifyJson(outcome.evidence)}
+`);
+  process.stdout.write(
+    outcome.stdoutBytes ?? `${stringifyJson(outcome.report)}
+`
+  );
+  process.exitCode = outcome.exitCode;
+} else if (["dev-export", "dev-render"].includes(command)) {
+  try {
+    const options = parseCliArgs(args);
+    const development = await import("./development.js");
+    if (command === "dev-export") {
+      development.writeAtomically(
+        options.outPath,
+        `${stringifyJson(development.runPythonExporter(options))}
+`
+      );
+    } else {
+      await development.renderAnnotatedPythonPdf(options);
+    }
+    process.stderr.write(
+      `Unverified development ${command === "dev-export" ? "CSO" : "PDF"} written to ${options.outPath}
+`
+    );
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : String(error)}
+`
+    );
+    process.exitCode = error instanceof UsageError ? 2 : 1;
+  }
+} else {
+  const report = usageReport({ kind: "unknown", command });
+  if (args.some(
+    (value, index) => value === "--format" && args[index + 1] === "json"
+  )) {
+    process.stdout.write(`${stringifyJson(report)}
+`);
+  } else {
+    process.stderr.write(`${report.diagnostics[0]?.message}
+${help}`);
+  }
+  process.exitCode = 2;
+}