@hpx7/delta-pack-cli 0.1.1 → 0.1.3

package/README.md

@@ -20,12 +20,13 @@ Generate code from a YAML schema.
 delta-pack generate <schema.yml> -l <language> [-o output]
 ```
 
-| Flag | Description |
-|------|-------------|
+| Flag                    | Description                                       |
+| ----------------------- | ------------------------------------------------- |
 | `-l, --language <lang>` | Target language: `typescript`/`ts`, `csharp`/`cs` |
-| `-o, --output <file>` | Output file (default: stdout) |
+| `-o, --output <file>`   | Output file (default: stdout)                     |
 
 Examples:
+
 ```bash
 # Output to stdout
 delta-pack generate schema.yml -l typescript
@@ -45,13 +46,14 @@ Encode JSON to binary.
 delta-pack encode <schema.yml> -t <type> [-i input] [-o output]
 ```
 
-| Flag | Description |
-|------|-------------|
-| `-t, --type <name>` | Type name (required) |
-| `-i, --input <file>` | JSON input file (default: stdin) |
+| Flag                  | Description                          |
+| --------------------- | ------------------------------------ |
+| `-t, --type <name>`   | Type name (required)                 |
+| `-i, --input <file>`  | JSON input file (default: stdin)     |
 | `-o, --output <file>` | Binary output file (default: stdout) |
 
 Examples:
+
 ```bash
 # File to file
 delta-pack encode schema.yml -t Player -i player.json -o player.bin
@@ -71,13 +73,14 @@ Decode binary to JSON.
 delta-pack decode <schema.yml> -t <type> [-i input] [-o output]
 ```
 
-| Flag | Description |
-|------|-------------|
-| `-t, --type <name>` | Type name (required) |
-| `-i, --input <file>` | Binary input file (default: stdin) |
+| Flag                  | Description                        |
+| --------------------- | ---------------------------------- |
+| `-t, --type <name>`   | Type name (required)               |
+| `-i, --input <file>`  | Binary input file (default: stdin) |
 | `-o, --output <file>` | JSON output file (default: stdout) |
 
 Examples:
+
 ```bash
 # File to file
 delta-pack decode schema.yml -t Player -i player.bin -o player.json
@@ -97,14 +100,15 @@ Encode the diff between two JSON states to binary.
 delta-pack encode-diff <schema.yml> -t <type> --old <file> --new <file> [-o output]
 ```
 
-| Flag | Description |
-|------|-------------|
-| `-t, --type <name>` | Type name (required) |
-| `--old <file>` | Old state JSON file (required) |
-| `--new <file>` | New state JSON file (required) |
+| Flag                  | Description                          |
+| --------------------- | ------------------------------------ |
+| `-t, --type <name>`   | Type name (required)                 |
+| `--old <file>`        | Old state JSON file (required)       |
+| `--new <file>`        | New state JSON file (required)       |
 | `-o, --output <file>` | Binary output file (default: stdout) |
 
 Examples:
+
 ```bash
 # Output to file
 delta-pack encode-diff schema.yml -t GameState --old state1.json --new state2.json -o diff.bin
@@ -121,14 +125,15 @@ Apply a binary diff to a JSON state.
 delta-pack decode-diff <schema.yml> -t <type> --old <file> [--diff <file>] [-o output]
 ```
 
-| Flag | Description |
-|------|-------------|
-| `-t, --type <name>` | Type name (required) |
-| `--old <file>` | Old state JSON file (required) |
-| `--diff <file>` | Binary diff file (default: stdin) |
+| Flag                  | Description                        |
+| --------------------- | ---------------------------------- |
+| `-t, --type <name>`   | Type name (required)               |
+| `--old <file>`        | Old state JSON file (required)     |
+| `--diff <file>`       | Binary diff file (default: stdin)  |
 | `-o, --output <file>` | JSON output file (default: stdout) |
 
 Examples:
+
 ```bash
 # File to file
 delta-pack decode-diff schema.yml -t GameState --old state1.json --diff diff.bin -o state2.json
@@ -138,12 +143,26 @@ delta-pack encode-diff schema.yml -t GameState --old state1.json --new state2.js
   delta-pack decode-diff schema.yml -t GameState --old state1.json
 ```
 
+## Inspecting Binary Output
+
+```bash
+# View binary as hex dump
+delta-pack encode schema.yml -t Player -i player.json | xxd
+
+# Check encoded size in bytes
+delta-pack encode schema.yml -t Player -i player.json | wc -c
+
+# Compare full encode vs diff size
+delta-pack encode schema.yml -t GameState -i state2.json | wc -c
+delta-pack encode-diff schema.yml -t GameState --old state1.json --new state2.json | wc -c
+```
+
 ## Exit Codes
 
-| Code | Meaning |
-|------|---------|
-| 0 | Success |
-| 1 | Error (invalid arguments, schema error, data validation error) |
+| Code | Meaning                                                        |
+| ---- | -------------------------------------------------------------- |
+| 0    | Success                                                        |
+| 1    | Error (invalid arguments, schema error, data validation error) |
 
 ## Development
 

package/dist/index.js

@@ -8003,6 +8003,35 @@ var require_dist = __commonJS((exports) => {
   exports.visit = visit.visit;
   exports.visitAsync = visit.visitAsync;
 });
+// package.json
+var package_default = {
+  name: "@hpx7/delta-pack-cli",
+  version: "0.1.3",
+  license: "MIT",
+  author: "hpx7",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/hpx7/delta-pack.git",
+    directory: "cli"
+  },
+  type: "module",
+  bin: {
+    "delta-pack": "dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun build src/index.ts --outdir dist --target node",
+    test: "bun test"
+  },
+  dependencies: {
+    "@hpx7/delta-pack": "^0.2.2"
+  },
+  devDependencies: {
+    "@types/bun": "latest"
+  }
+};
 
 // src/commands/generate.ts
 import { readFile as readFile2 } from "node:fs/promises";
@@ -10364,15 +10393,23 @@ async function writeOutput(path, data) {
   }
 }
 
+// src/utils/errors.ts
+class ArgError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ArgError";
+  }
+}
+
 // src/commands/generate.ts
 async function generate(schemaPath, flags) {
   if (!schemaPath) {
-    throw new Error("Schema file required");
+    throw new ArgError("generate: schema file required");
   }
   const lang = flags.get("l") ?? flags.get("language");
   const output = flags.get("o") ?? flags.get("output");
   if (!lang || lang === true) {
-    throw new Error("Language required: -l <typescript|csharp>");
+    throw new ArgError("generate: language required (-l <typescript|csharp>)");
   }
   const content = await readFile2(schemaPath, "utf-8");
   const schema2 = parseSchemaYml(content);
@@ -10384,9 +10421,9 @@ async function generate(schemaPath, flags) {
       break;
     case "csharp":
     case "cs":
-      throw new Error("C# codegen not yet implemented");
+      throw new ArgError("generate: C# codegen not yet implemented");
     default:
-      throw new Error(`Unknown language: ${lang}`);
+      throw new ArgError(`generate: unknown language '${lang}'`);
   }
   await writeOutput(output === true ? undefined : output, code);
 }
@@ -10411,13 +10448,13 @@ function getRootType(schema2, typeName) {
 // src/commands/encode.ts
 async function encode(schemaPath, flags) {
   if (!schemaPath) {
-    throw new Error("Schema file required");
+    throw new ArgError("encode: schema file required");
   }
   const typeName = flags.get("t") ?? flags.get("type");
   const input = flags.get("i") ?? flags.get("input");
   const output = flags.get("o") ?? flags.get("output");
   if (!typeName || typeName === true) {
-    throw new Error("Type required: -t <name>");
+    throw new ArgError("encode: type required (-t <name>)");
   }
   const schema2 = await loadSchema(schemaPath);
   const rootType = getRootType(schema2, typeName);
@@ -10431,13 +10468,13 @@ async function encode(schemaPath, flags) {
 // src/commands/decode.ts
 async function decode(schemaPath, flags) {
   if (!schemaPath) {
-    throw new Error("Schema file required");
+    throw new ArgError("decode: schema file required");
   }
   const typeName = flags.get("t") ?? flags.get("type");
   const input = flags.get("i") ?? flags.get("input");
   const output = flags.get("o") ?? flags.get("output");
   if (!typeName || typeName === true) {
-    throw new Error("Type required: -t <name>");
+    throw new ArgError("decode: type required (-t <name>)");
   }
   const schema2 = await loadSchema(schemaPath);
   const rootType = getRootType(schema2, typeName);
@@ -10453,20 +10490,20 @@ async function decode(schemaPath, flags) {
 import { readFile as readFile4 } from "node:fs/promises";
 async function encodeDiff(schemaPath, flags) {
   if (!schemaPath) {
-    throw new Error("Schema file required");
+    throw new ArgError("encode-diff: schema file required");
   }
   const typeName = flags.get("t") ?? flags.get("type");
   const oldPath = flags.get("old");
   const newPath = flags.get("new");
   const output = flags.get("o") ?? flags.get("output");
   if (!typeName || typeName === true) {
-    throw new Error("Type required: -t <name>");
+    throw new ArgError("encode-diff: type required (-t <name>)");
   }
   if (!oldPath || oldPath === true) {
-    throw new Error("Old state required: --old <file>");
+    throw new ArgError("encode-diff: old state required (--old <file>)");
   }
   if (!newPath || newPath === true) {
-    throw new Error("New state required: --new <file>");
+    throw new ArgError("encode-diff: new state required (--new <file>)");
   }
   const schema2 = await loadSchema(schemaPath);
   const rootType = getRootType(schema2, typeName);
@@ -10483,17 +10520,17 @@ async function encodeDiff(schemaPath, flags) {
 import { readFile as readFile5 } from "node:fs/promises";
 async function decodeDiff(schemaPath, flags) {
   if (!schemaPath) {
-    throw new Error("Schema file required");
+    throw new ArgError("decode-diff: schema file required");
   }
   const typeName = flags.get("t") ?? flags.get("type");
   const oldPath = flags.get("old");
   const diffPath = flags.get("diff");
   const output = flags.get("o") ?? flags.get("output");
   if (!typeName || typeName === true) {
-    throw new Error("Type required: -t <name>");
+    throw new ArgError("decode-diff: type required (-t <name>)");
   }
   if (!oldPath || oldPath === true) {
-    throw new Error("Old state required: --old <file>");
+    throw new ArgError("decode-diff: old state required (--old <file>)");
   }
   const schema2 = await loadSchema(schemaPath);
   const rootType = getRootType(schema2, typeName);
@@ -10508,6 +10545,12 @@ async function decodeDiff(schemaPath, flags) {
 }
 
 // src/index.ts
+process.stdout.on("error", (err) => {
+  if (err.code === "EPIPE") {
+    process.exit(0);
+  }
+  throw err;
+});
 var args = process.argv.slice(2);
 var command = args[0];
 function parseFlags(args2) {
@@ -10562,6 +10605,10 @@ Options:
 `);
 }
 async function main() {
+  if (command === "--version" || command === "-v") {
+    console.log(package_default.version);
+    process.exit(0);
+  }
   if (!command || command === "help" || command === "--help" || command === "-h") {
     printUsage();
     process.exit(0);
@@ -10593,6 +10640,10 @@ async function main() {
     }
   } catch (err) {
     console.error(err instanceof Error ? err.message : err);
+    if (err instanceof ArgError) {
+      console.error();
+      printUsage();
+    }
     process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hpx7/delta-pack-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "license": "MIT",
   "author": "hpx7",
   "repository": {