@vizij/node-graph-authoring 0.0.2 → 0.0.5

package/dist/cli/reportIr.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import {
+  MACHINE_REPORT_VERSION,
+  buildMachineReport,
+  buildRigGraphSpec,
+  diffMachineReports
+} from "../chunk-XYPRZPXJ.js";
+
+// src/cli/reportIr.ts
+import { readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function usage() {
+  console.error(
+    [
+      "Usage: vizij-ir-report --input <path/to/buildGraphOptions.json> [options]",
+      "",
+      "Options:",
+      "  --dump <path|->         Write normalized machine-readable report (use '-' for stdout).",
+      "  --diff <path|->         Compare against a dumped report (use '-' or 'stdin').",
+      "  --diff-limit <number>   Maximum diff entries to emit (default 50).",
+      "  -h, --help              Show this message."
+    ].join("\n")
+  );
+  process.exit(1);
+  throw new Error("Unreachable");
+}
+function parseArgs(argv) {
+  const args = [...argv];
+  let inputPath = "";
+  let dumpPath;
+  let diffPath;
+  let diffLimit;
+  while (args.length > 0) {
+    const token = args.shift();
+    if (!token) {
+      break;
+    }
+    if (token === "--input" || token === "-i") {
+      const value = args.shift();
+      if (!value) {
+        usage();
+      }
+      inputPath = value;
+    } else if (token === "--help" || token === "-h") {
+      usage();
+    } else if (token === "--dump" || token === "--dump-json") {
+      const value = args.shift();
+      if (!value) {
+        usage();
+      }
+      dumpPath = normalizeStreamToken(value);
+    } else if (token === "--diff") {
+      const value = args.shift();
+      if (!value) {
+        usage();
+      }
+      diffPath = normalizeStreamToken(value);
+    } else if (token === "--diff-limit") {
+      const value = args.shift();
+      if (!value) {
+        usage();
+      }
+      diffLimit = parsePositiveInteger(value, "--diff-limit");
+    } else if (!token.startsWith("--") && !inputPath) {
+      inputPath = token;
+    }
+  }
+  if (!inputPath) {
+    usage();
+  }
+  return {
+    inputPath: resolve(process.cwd(), inputPath),
+    dumpPath: resolveOptionalPath(dumpPath),
+    diffPath: resolveOptionalPath(diffPath),
+    diffLimit
+  };
+}
+function loadCliInput(path) {
+  const raw = JSON.parse(readFileSync(path, "utf-8"));
+  const inputs = raw.inputs ?? [];
+  const inputsById = new Map(inputs.map((input) => [input.id, input]));
+  const inputMetadata = raw.inputMetadata ? new Map(
+    raw.inputMetadata.map((entry) => ({
+      id: entry.id,
+      value: entry
+    })).filter(
+      (entry) => Boolean(entry.id)
+    ).map((entry) => [entry.id, entry.value])
+  ) : void 0;
+  return {
+    faceId: raw.faceId,
+    animatables: raw.animatables,
+    components: raw.components,
+    bindings: raw.bindings,
+    inputsById,
+    inputBindings: raw.inputBindings ?? {},
+    inputMetadata
+  };
+}
+function printIssues(result) {
+  console.log(`
+IR Diagnostics for face "${result.summary.faceId}"`);
+  if (result.issues.fatal.length === 0) {
+    console.log("\u2022 No fatal binding issues detected.");
+  } else {
+    console.log("\u2022 Fatal issues:");
+    result.issues.fatal.forEach((issue) => console.log(`  - ${issue}`));
+  }
+  const targets = Object.entries(result.issues.byTarget);
+  if (targets.length > 0) {
+    console.log("\nPer-binding issues:");
+    targets.forEach(([targetId, issues]) => {
+      issues.forEach((issue) => {
+        console.log(`  - ${targetId}: ${issue}`);
+      });
+    });
+  }
+  const irIssues = result.ir?.graph.issues ?? [];
+  if (irIssues.length > 0) {
+    console.log("\nIR issues:");
+    irIssues.forEach((issue) => {
+      console.log(
+        `  - (${issue.severity}) ${issue.message}${issue.targetId ? ` [${issue.targetId}]` : ""}`
+      );
+    });
+  }
+}
+function printBindingSummary(result, _options) {
+  console.log("\nBinding summary:");
+  result.summary.bindings.forEach((binding) => {
+    console.log(
+      `  - ${binding.targetId} (${binding.slotAlias}): expr="${binding.expression}"`
+    );
+    if (binding.issues && binding.issues.length > 0) {
+      binding.issues.forEach((issue) => {
+        console.log(`      \u2022 ${issue}`);
+      });
+    }
+  });
+}
+async function main() {
+  const { inputPath, dumpPath, diffPath, diffLimit } = parseArgs(
+    process.argv.slice(2)
+  );
+  const options = loadCliInput(inputPath);
+  const result = buildRigGraphSpec(options);
+  const machineReport = buildMachineReport(result);
+  if (diffPath && dumpPath && diffPath !== "-" && dumpPath !== "-" && diffPath === dumpPath) {
+    throw new Error(
+      "Cannot reuse the same file path for --dump and --diff. Provide separate files."
+    );
+  }
+  if (diffPath) {
+    if (dumpPath === "-") {
+      throw new Error("Cannot dump to stdout while running --diff.");
+    }
+    if (dumpPath) {
+      writeMachineDump(machineReport, dumpPath);
+    }
+    const baseline = loadMachineDump(diffPath);
+    validateReportVersion(baseline.reportVersion);
+    const diffResult = diffMachineReports(machineReport, baseline, {
+      limit: diffLimit
+    });
+    const diffPayload = {
+      mode: "diff",
+      reportVersion: MACHINE_REPORT_VERSION,
+      faceId: machineReport.faceId,
+      inputPath,
+      baselinePath: diffPath,
+      equal: diffResult.equal,
+      differenceCount: diffResult.differences.length,
+      limitReached: diffResult.limitReached,
+      differences: diffResult.differences
+    };
+    console.log(JSON.stringify(diffPayload, null, 2));
+    process.exitCode = diffResult.equal ? 0 : 1;
+    return;
+  }
+  if (dumpPath) {
+    writeMachineDump(machineReport, dumpPath);
+    return;
+  }
+  console.log(
+    `Loaded ${options.components.length} components / ${options.faceId} from ${inputPath}`
+  );
+  printIssues(result);
+  printBindingSummary(result, options);
+  console.log("\nDone.");
+}
+main().catch((error) => {
+  console.error("[vizij-ir-report] Failed:", error);
+  process.exit(1);
+});
+function resolveOptionalPath(path) {
+  if (!path || path === "-") {
+    return path;
+  }
+  return resolve(process.cwd(), path);
+}
+function normalizeStreamToken(value) {
+  const lower = value.toLowerCase();
+  if (lower === "-" || lower === "stdout" || lower === "stdin") {
+    return "-";
+  }
+  return value;
+}
+function parsePositiveInteger(value, flag) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    console.error(`Invalid value for ${flag}: ${value}`);
+    usage();
+  }
+  return parsed;
+}
+function writeMachineDump(report, target) {
+  const payload = `${JSON.stringify(report, null, 2)}
+`;
+  if (target === "-") {
+    process.stdout.write(payload);
+    return;
+  }
+  writeFileSync(target, payload, "utf-8");
+}
+function loadMachineDump(path) {
+  const content = path === "-" ? readFileSync(0, "utf-8") : readFileSync(path, "utf-8");
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.reportVersion !== "number") {
+      throw new Error("Invalid machine report structure.");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("Failed to parse machine-readable report JSON.");
+    }
+    throw error;
+  }
+}
+function validateReportVersion(version) {
+  if (version !== MACHINE_REPORT_VERSION) {
+    throw new Error(
+      `Machine report version mismatch (expected ${MACHINE_REPORT_VERSION}, received ${version}).`
+    );
+  }
+}