@bcts/dcbor-cli 1.0.0-alpha.13

package/src/format.ts

@@ -0,0 +1,82 @@
+/**
+ * Format utilities for dcbor-cli
+ * Contains InputFormat, OutputFormat enums and formatOutput function
+ * Equivalent to the format-related code in Rust's main.rs
+ */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+
+import {
+  type Cbor,
+  type Result,
+  diagnosticOpt,
+  hexOpt,
+  bytesToHex,
+  cborData,
+  errorMsg,
+} from "@bcts/dcbor";
+
+/**
+ * Input format options
+ */
+export type InputFormat = "diag" | "hex" | "bin";
+
+/**
+ * Output format options
+ */
+export type OutputFormat = "diag" | "hex" | "bin" | "none";
+
+/**
+ * Format CBOR output in the specified format
+ * Equivalent to Rust's format_output function
+ */
+export function formatOutput(
+  cbor: Cbor,
+  outFormat: OutputFormat,
+  annotate: boolean,
+): Result<string> {
+  try {
+    switch (outFormat) {
+      case "diag":
+        // Use flat: true for compact single-line output (matching Rust CLI behavior)
+        if (annotate) {
+          return { ok: true, value: diagnosticOpt(cbor, { annotate: true, flat: true }) };
+        } else {
+          return { ok: true, value: diagnosticOpt(cbor, { flat: true }) };
+        }
+
+      case "hex":
+        if (annotate) {
+          return { ok: true, value: hexOpt(cbor, { annotate: true }) };
+        } else {
+          return { ok: true, value: bytesToHex(cborData(cbor)) };
+        }
+
+      case "bin":
+        // For binary output, return hex representation
+        // The caller will handle converting to actual binary
+        return { ok: true, value: bytesToHex(cborData(cbor)) };
+
+      case "none":
+        return { ok: true, value: "" };
+
+      default:
+        return { ok: false, error: errorMsg(`Unknown output format: ${outFormat}`) };
+    }
+  } catch (e) {
+    return { ok: false, error: errorMsg(e instanceof Error ? e.message : String(e)) };
+  }
+}
+
+/**
+ * Read binary data from a buffer
+ */
+export function readData(data: Uint8Array): Uint8Array {
+  return data;
+}
+
+/**
+ * Read string data from a buffer
+ */
+export function readString(data: Uint8Array): string {
+  return new TextDecoder().decode(data);
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+/**
+ * @bcts/dcbor-cli - Command line parser/validator for deterministic CBOR (dCBOR)
+ *
+ * A command line tool for composing, parsing and validating Gordian dCBOR.
+ *
+ * @packageDocumentation
+ */
+
+export const VERSION = "1.0.0-alpha.13";
+
+// Export format utilities
+export { formatOutput, readData, readString } from "./format.js";
+export type { InputFormat, OutputFormat } from "./format.js";
+
+// Export command modules
+export {
+  // Exec interface
+  type Exec,
+  // Array command
+  type ArrayCommandArgs,
+  execArray,
+  createArrayCommand,
+  // Map command
+  type MapCommandArgs,
+  execMap,
+  createMapCommand,
+  // Default command
+  type DefaultCommandArgs,
+  execDefault,
+  execDefaultWithReader,
+  createDefaultCommand,
+  // Match command
+  type MatchOutputFormat,
+  type MatchCommandArgs,
+  execMatch,
+  createMatchCommand,
+} from "./cmd/index.js";
+
+// Export the run function for programmatic use
+export { run } from "./run.js";
+export type { RunOptions, RunResult, Command } from "./run.js";

package/src/run.ts

@@ -0,0 +1,134 @@
+/**
+ * Main run function for dcbor-cli
+ * Equivalent to Rust's run function in main.rs
+ */
+
+import { registerTags, errorToString } from "@bcts/dcbor";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { execArray, execDefault, execMap, execMatch, type MatchOutputFormat } from "./cmd/index.js";
+
+/**
+ * Command type discriminator
+ */
+export type Command =
+  | { type: "array"; elements: string[]; out: OutputFormat; annotate: boolean }
+  | { type: "map"; kvPairs: string[]; out: OutputFormat; annotate: boolean }
+  | {
+      type: "match";
+      pattern: string;
+      input?: string | undefined;
+      in: InputFormat;
+      out: MatchOutputFormat;
+      noIndent: boolean;
+      lastOnly: boolean;
+      annotate: boolean;
+      captures: boolean;
+    }
+  | {
+      type: "default";
+      input?: string | undefined;
+      in: InputFormat;
+      out: OutputFormat;
+      annotate: boolean;
+    };
+
+export interface RunOptions {
+  command: Command;
+  stdinContent?: string | undefined;
+}
+
+export interface RunResult {
+  output: string;
+  isBinary: boolean;
+}
+
+/**
+ * Main execution function
+ * Equivalent to Rust's run<I, T, R, W> function
+ */
+export function run(
+  options: RunOptions,
+): { ok: true; value: RunResult } | { ok: false; error: Error } {
+  // Register BC components tags
+  registerTags();
+
+  const { command, stdinContent } = options;
+
+  let output: string;
+  let isBinary = false;
+
+  switch (command.type) {
+    case "array": {
+      const result = execArray({
+        elements: command.elements,
+        out: command.out,
+        annotate: command.annotate,
+      });
+      if (!result.ok) {
+        return { ok: false, error: new Error(errorToString(result.error)) };
+      }
+      output = result.value;
+      isBinary = command.out === "bin";
+      break;
+    }
+
+    case "map": {
+      const result = execMap({
+        kvPairs: command.kvPairs,
+        out: command.out,
+        annotate: command.annotate,
+      });
+      if (!result.ok) {
+        return { ok: false, error: new Error(errorToString(result.error)) };
+      }
+      output = result.value;
+      isBinary = command.out === "bin";
+      break;
+    }
+
+    case "match": {
+      const result = execMatch(
+        {
+          pattern: command.pattern,
+          input: command.input,
+          in: command.in,
+          out: command.out,
+          noIndent: command.noIndent,
+          lastOnly: command.lastOnly,
+          annotate: command.annotate,
+          captures: command.captures,
+        },
+        stdinContent,
+      );
+      if (!result.ok) {
+        return { ok: false, error: new Error(errorToString(result.error)) };
+      }
+      output = result.value;
+      isBinary = command.out === "bin";
+      break;
+    }
+
+    case "default": {
+      const result = execDefault(
+        {
+          input: command.input,
+          in: command.in,
+          out: command.out,
+          annotate: command.annotate,
+        },
+        stdinContent,
+      );
+      if (!result.ok) {
+        return { ok: false, error: new Error(errorToString(result.error)) };
+      }
+      output = result.value;
+      isBinary = command.out === "bin";
+      break;
+    }
+
+    default:
+      return { ok: false, error: new Error("Unknown command type") };
+  }
+
+  return { ok: true, value: { output, isBinary } };
+}