@bcts/seedtool-cli 1.0.0-alpha.14

package/src/formats/base10.ts

@@ -0,0 +1,39 @@
+/**
+ * Base10 format
+ * Ported from seedtool-cli-rust/src/formats/base10.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { sha256DeterministicRandomString } from "../random.js";
+import { dataToInts, digitsToData } from "../util.js";
+
+/**
+ * Base-10 format handler.
+ * NOT round-trippable: input is entropy source.
+ * Digits 0-9 (compatible with https://iancoleman.io/bip39/).
+ */
+export class Base10Format implements InputFormat, OutputFormat {
+  name(): string {
+    return "base10";
+  }
+
+  roundTrippable(): boolean {
+    return false;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    // Syntax check only - validates that all characters are 0-9
+    digitsToData(input, 0, 9);
+    // Use SHA256 deterministic random to generate seed from input
+    const data = sha256DeterministicRandomString(input, state.count);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return dataToInts(state.expectSeed().data(), 0, 9, "");
+  }
+}

package/src/formats/base6.ts

@@ -0,0 +1,39 @@
+/**
+ * Base6 format
+ * Ported from seedtool-cli-rust/src/formats/base6.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { sha256DeterministicRandomString } from "../random.js";
+import { dataToInts, digitsToData } from "../util.js";
+
+/**
+ * Base-6 format handler.
+ * NOT round-trippable: input is entropy source.
+ * Digits 0-5 (compatible with https://iancoleman.io/bip39/).
+ */
+export class Base6Format implements InputFormat, OutputFormat {
+  name(): string {
+    return "base6";
+  }
+
+  roundTrippable(): boolean {
+    return false;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    // Syntax check only - validates that all characters are 0-5
+    digitsToData(input, 0, 5);
+    // Use SHA256 deterministic random to generate seed from input
+    const data = sha256DeterministicRandomString(input, state.count);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return dataToInts(state.expectSeed().data(), 0, 5, "");
+  }
+}

package/src/formats/bip39.ts

@@ -0,0 +1,43 @@
+/**
+ * BIP39 mnemonic format
+ * Ported from seedtool-cli-rust/src/formats/bip39.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { mnemonicToEntropy, entropyToMnemonic, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+
+/**
+ * BIP39 mnemonic format handler.
+ * Round-trippable: mnemonic → seed → mnemonic.
+ */
+export class Bip39Format implements InputFormat, OutputFormat {
+  name(): string {
+    return "bip39";
+  }
+
+  roundTrippable(): boolean {
+    return true;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    // Normalize the mnemonic (lowercase, single spaces)
+    const normalized = input.toLowerCase().trim().replace(/\s+/g, " ");
+
+    if (!validateMnemonic(normalized, wordlist)) {
+      throw new Error("Invalid BIP39 mnemonic");
+    }
+
+    const entropy = mnemonicToEntropy(normalized, wordlist);
+    state.seed = Seed.new(entropy);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    const mnemonic = entropyToMnemonic(state.expectSeed().data(), wordlist);
+    return mnemonic;
+  }
+}

package/src/formats/bits.ts

@@ -0,0 +1,39 @@
+/**
+ * Bits format
+ * Ported from seedtool-cli-rust/src/formats/bits.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { sha256DeterministicRandomString } from "../random.js";
+import { dataToInts, digitsToData } from "../util.js";
+
+/**
+ * Binary format handler.
+ * NOT round-trippable: input is entropy source.
+ * Bits 0-1 (compatible with https://iancoleman.io/bip39/).
+ */
+export class BitsFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "bits";
+  }
+
+  roundTrippable(): boolean {
+    return false;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    // Syntax check only - validates that all characters are 0-1
+    digitsToData(input, 0, 1);
+    // Use SHA256 deterministic random to generate seed from input
+    const data = sha256DeterministicRandomString(input, state.count);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return dataToInts(state.expectSeed().data(), 0, 1, "");
+  }
+}

package/src/formats/bytewords-minimal.ts

@@ -0,0 +1,35 @@
+/**
+ * Bytewords Minimal format
+ * Ported from seedtool-cli-rust/src/formats/bytewords_minimal.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { encodeBytewords, decodeBytewords, BytewordsStyle } from "@bcts/uniform-resources";
+
+/**
+ * Bytewords Minimal format handler.
+ * Round-trippable: bytewords → seed → bytewords.
+ * Uses 2-letter abbreviations without separators.
+ */
+export class BytewordsMinimalFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "btwm";
+  }
+
+  roundTrippable(): boolean {
+    return true;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    const data = decodeBytewords(input, BytewordsStyle.Minimal);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return encodeBytewords(state.expectSeed().data(), BytewordsStyle.Minimal);
+  }
+}

package/src/formats/bytewords-standard.ts

@@ -0,0 +1,35 @@
+/**
+ * Bytewords Standard format
+ * Ported from seedtool-cli-rust/src/formats/bytewords_standard.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { encodeBytewords, decodeBytewords, BytewordsStyle } from "@bcts/uniform-resources";
+
+/**
+ * Bytewords Standard format handler.
+ * Round-trippable: bytewords → seed → bytewords.
+ * Uses full words separated by spaces.
+ */
+export class BytewordsStandardFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "btw";
+  }
+
+  roundTrippable(): boolean {
+    return true;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    const data = decodeBytewords(input, BytewordsStyle.Standard);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return encodeBytewords(state.expectSeed().data(), BytewordsStyle.Standard);
+  }
+}

package/src/formats/bytewords-uri.ts

@@ -0,0 +1,35 @@
+/**
+ * Bytewords URI format
+ * Ported from seedtool-cli-rust/src/formats/bytewords_uri.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { encodeBytewords, decodeBytewords, BytewordsStyle } from "@bcts/uniform-resources";
+
+/**
+ * Bytewords URI format handler.
+ * Round-trippable: bytewords → seed → bytewords.
+ * Uses full words separated by hyphens (URI-safe).
+ */
+export class BytewordsUriFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "btwu";
+  }
+
+  roundTrippable(): boolean {
+    return true;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    const data = decodeBytewords(input, BytewordsStyle.Uri);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return encodeBytewords(state.expectSeed().data(), BytewordsStyle.Uri);
+  }
+}

package/src/formats/cards.ts

@@ -0,0 +1,100 @@
+/**
+ * Cards format
+ * Ported from seedtool-cli-rust/src/formats/cards.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { deterministicRandom } from "../random.js";
+import { dataToAlphabet } from "../util.js";
+
+// Arrangement of cards per:
+// https://github.com/iancoleman/bip39/blob/master/src/js/entropy.js
+const CARD_SUITS = "cdhs";
+const CARD_RANKS = "a23456789tjqk";
+
+/**
+ * Parse a card rank character.
+ * Returns index 0-12.
+ */
+function parseRank(c: string): number {
+  const lower = c.toLowerCase();
+  const index = CARD_RANKS.indexOf(lower);
+  if (index === -1) {
+    throw new Error(`Invalid card rank: ${c}. Allowed: [A,2-9,T,J,Q,K]`);
+  }
+  return index;
+}
+
+/**
+ * Parse a card suit character.
+ * Returns index 0-3.
+ */
+function parseSuit(c: string): number {
+  const lower = c.toLowerCase();
+  const index = CARD_SUITS.indexOf(lower);
+  if (index === -1) {
+    throw new Error(`Invalid card suit: ${c}. Allowed: [C,D,H,S]`);
+  }
+  return index;
+}
+
+/**
+ * Convert card string to byte array.
+ * Each pair of characters represents one card.
+ */
+function cardsToData(cards: string): Uint8Array {
+  const len = cards.length;
+  if (len % 2 !== 0) {
+    throw new Error("Cards string must have even number of characters.");
+  }
+  const count = len / 2;
+  const result = new Uint8Array(count);
+  for (let i = 0; i < count; i++) {
+    const rank = parseRank(cards[i * 2]);
+    const suit = parseSuit(cards[i * 2 + 1]);
+    const n = suit * 13 + rank;
+    result[i] = n;
+  }
+  return result;
+}
+
+/**
+ * Convert a card index (0-51) to card string.
+ */
+function toCard(n: number): string {
+  if (n > 51) {
+    throw new Error(`Card index out of range: ${n}`);
+  }
+  const rank = n % 13;
+  const suit = Math.floor(n / 13);
+  return CARD_RANKS[rank] + CARD_SUITS[suit];
+}
+
+/**
+ * Playing cards format handler.
+ * NOT round-trippable: input is entropy source.
+ * Card notation: rank (A,2-9,T,J,Q,K) + suit (C,D,H,S).
+ */
+export class CardsFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "cards";
+  }
+
+  roundTrippable(): boolean {
+    return false;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    const entropy = cardsToData(input);
+    const data = deterministicRandom(entropy, state.count);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return dataToAlphabet(state.expectSeed().data(), 52, toCard);
+  }
+}

package/src/formats/dice.ts

@@ -0,0 +1,39 @@
+/**
+ * Dice format
+ * Ported from seedtool-cli-rust/src/formats/dice.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { sha256DeterministicRandomString } from "../random.js";
+import { dataToInts, digitsToData } from "../util.js";
+
+/**
+ * Dice roll format handler.
+ * NOT round-trippable: input is entropy source.
+ * Digits 1-6 (compatible with https://iancoleman.io/bip39/).
+ */
+export class DiceFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "dice";
+  }
+
+  roundTrippable(): boolean {
+    return false;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    // Syntax check only - validates that all characters are 1-6
+    digitsToData(input, 1, 6);
+    // Use SHA256 deterministic random to generate seed from input
+    const data = sha256DeterministicRandomString(input, state.count);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return dataToInts(state.expectSeed().data(), 1, 6, "");
+  }
+}

package/src/formats/envelope.ts

@@ -0,0 +1,34 @@
+/**
+ * Envelope format
+ * Ported from seedtool-cli-rust/src/formats/envelope.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { Envelope } from "@bcts/envelope";
+
+/**
+ * Gordian Envelope format handler.
+ * Round-trippable: envelope UR → seed → envelope UR.
+ */
+export class EnvelopeFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "envelope";
+  }
+
+  roundTrippable(): boolean {
+    return true;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    const envelope = Envelope.fromURString(input);
+    state.seed = Seed.fromEnvelope(envelope);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return state.toEnvelope().urString();
+  }
+}

package/src/formats/format.ts

@@ -0,0 +1,145 @@
+/**
+ * Format traits and factory functions
+ * Ported from seedtool-cli-rust/src/formats/format.rs
+ */
+
+import type { Cli, InputFormatKey, OutputFormatKey } from "../cli.js";
+
+// ============================================================================
+// Format Interfaces (Traits)
+// ============================================================================
+
+/**
+ * Base format interface.
+ * Matches Rust Format trait.
+ */
+export interface Format {
+  /** Get the format name */
+  name(): string;
+  /** Whether this format supports round-trip conversion */
+  roundTrippable(): boolean;
+}
+
+/**
+ * Input format interface.
+ * Matches Rust InputFormat trait.
+ */
+export interface InputFormat extends Format {
+  /** Process input and update CLI state with seed */
+  processInput(state: Cli): Cli;
+}
+
+/**
+ * Output format interface.
+ * Matches Rust OutputFormat trait.
+ */
+export interface OutputFormat extends Format {
+  /** Process seed from CLI state and return output string */
+  processOutput(state: Cli): string;
+}
+
+// ============================================================================
+// Format Factory Functions
+// ============================================================================
+
+// Import formats (will be implemented in subsequent files)
+import { HexFormat } from "./hex.js";
+import { Bip39Format } from "./bip39.js";
+import { SSKRFormat } from "./sskr.js";
+import { EnvelopeFormat } from "./envelope.js";
+import { SeedFormat } from "./seed-format.js";
+import { MultipartFormat } from "./multipart.js";
+import { RandomFormat } from "./random.js";
+import { Base6Format } from "./base6.js";
+import { Base10Format } from "./base10.js";
+import { BitsFormat } from "./bits.js";
+import { DiceFormat } from "./dice.js";
+import { CardsFormat } from "./cards.js";
+import { IntsFormat } from "./ints.js";
+import { BytewordsStandardFormat } from "./bytewords-standard.js";
+import { BytewordsMinimalFormat } from "./bytewords-minimal.js";
+import { BytewordsUriFormat } from "./bytewords-uri.js";
+
+/**
+ * Select input format by key.
+ * Matches Rust select_input_format function.
+ */
+export function selectInputFormat(key: InputFormatKey): InputFormat {
+  switch (key) {
+    case "random":
+      return new RandomFormat();
+    case "hex":
+      return new HexFormat();
+    case "btw":
+      return new BytewordsStandardFormat();
+    case "btwu":
+      return new BytewordsUriFormat();
+    case "btwm":
+      return new BytewordsMinimalFormat();
+    case "bits":
+      return new BitsFormat();
+    case "cards":
+      return new CardsFormat();
+    case "dice":
+      return new DiceFormat();
+    case "base6":
+      return new Base6Format();
+    case "base10":
+      return new Base10Format();
+    case "ints":
+      return new IntsFormat();
+    case "bip39":
+      return new Bip39Format();
+    case "sskr":
+      return new SSKRFormat();
+    case "envelope":
+      return new EnvelopeFormat();
+    case "multipart":
+      return new MultipartFormat();
+    case "seed":
+      return new SeedFormat();
+    default:
+      throw new Error(`Unknown input format: ${key}`);
+  }
+}
+
+/**
+ * Select output format by key.
+ * Matches Rust select_output_format function.
+ */
+export function selectOutputFormat(key: OutputFormatKey): OutputFormat {
+  switch (key) {
+    case "hex":
+      return new HexFormat();
+    case "btw":
+      return new BytewordsStandardFormat();
+    case "btwu":
+      return new BytewordsUriFormat();
+    case "btwm":
+      return new BytewordsMinimalFormat();
+    case "bits":
+      return new BitsFormat();
+    case "cards":
+      return new CardsFormat();
+    case "dice":
+      return new DiceFormat();
+    case "base6":
+      return new Base6Format();
+    case "base10":
+      return new Base10Format();
+    case "ints":
+      return new IntsFormat();
+    case "bip39":
+      return new Bip39Format();
+    case "sskr":
+      return new SSKRFormat();
+    case "envelope":
+      return new EnvelopeFormat();
+    case "multipart":
+      return new MultipartFormat();
+    case "seed":
+      return new SeedFormat();
+    default:
+      throw new Error(`Unknown output format: ${key}`);
+  }
+}

package/src/formats/hex.ts

@@ -0,0 +1,34 @@
+/**
+ * Hex format
+ * Ported from seedtool-cli-rust/src/formats/hex.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { hexToData, dataToHex } from "../util.js";
+
+/**
+ * Hexadecimal format handler.
+ * Round-trippable: hex → seed → hex.
+ */
+export class HexFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "hex";
+  }
+
+  roundTrippable(): boolean {
+    return true;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    const seed = Seed.new(hexToData(input));
+    state.seed = seed;
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return dataToHex(state.expectSeed().data());
+  }
+}

package/src/formats/index.ts

@@ -0,0 +1,31 @@
+/**
+ * Format exports
+ * Ported from seedtool-cli-rust/src/formats/mod.rs
+ */
+
+// Re-export format traits and utilities
+export {
+  type Format,
+  type InputFormat,
+  type OutputFormat,
+  selectInputFormat,
+  selectOutputFormat,
+} from "./format.js";
+
+// Re-export individual formats
+export { Base6Format } from "./base6.js";
+export { Base10Format } from "./base10.js";
+export { Bip39Format } from "./bip39.js";
+export { BitsFormat } from "./bits.js";
+export { BytewordsMinimalFormat } from "./bytewords-minimal.js";
+export { BytewordsUriFormat } from "./bytewords-uri.js";
+export { BytewordsStandardFormat } from "./bytewords-standard.js";
+export { CardsFormat } from "./cards.js";
+export { DiceFormat } from "./dice.js";
+export { HexFormat } from "./hex.js";
+export { IntsFormat } from "./ints.js";
+export { RandomFormat } from "./random.js";
+export { SSKRFormat } from "./sskr.js";
+export { EnvelopeFormat } from "./envelope.js";
+export { SeedFormat } from "./seed-format.js";
+export { MultipartFormat } from "./multipart.js";

package/src/formats/ints.ts

@@ -0,0 +1,37 @@
+/**
+ * Ints format
+ * Ported from seedtool-cli-rust/src/formats/ints.rs
+ */
+
+import type { Cli } from "../cli.js";
+import type { InputFormat, OutputFormat } from "./format.js";
+import { Seed } from "../seed.js";
+import { deterministicRandom } from "../random.js";
+import { dataToInts, parseInts } from "../util.js";
+
+/**
+ * Integer list format handler.
+ * NOT round-trippable: input is entropy source.
+ * Configurable range via --low and --high CLI options.
+ */
+export class IntsFormat implements InputFormat, OutputFormat {
+  name(): string {
+    return "ints";
+  }
+
+  roundTrippable(): boolean {
+    return false;
+  }
+
+  processInput(state: Cli): Cli {
+    const input = state.expectInput();
+    const entropy = parseInts(input);
+    const data = deterministicRandom(entropy, state.count);
+    state.seed = Seed.new(data);
+    return state;
+  }
+
+  processOutput(state: Cli): string {
+    return dataToInts(state.expectSeed().data(), state.low, state.high, " ");
+  }
+}