tokenfill 0.0.1

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runCli } from "./cli.js";
+const exitCode = await runCli();
+if (exitCode !== 0) {
+    process.exit(exitCode);
+}

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+interface CliWriter {
+    write(chunk: string | Uint8Array): boolean;
+}
+interface CliOutput {
+    stdout: CliWriter;
+    stderr: CliWriter;
+}
+export declare function runCli(args?: string[], output?: CliOutput): Promise<number>;
+export {};

package/dist/cli.js

@@ -0,0 +1,65 @@
+import { Command, CommanderError, InvalidArgumentError } from "commander";
+import { tokenfill } from "./tokenfill.js";
+import { DEFAULT_ENCODING } from "./tokenizer.js";
+const defaultOutput = {
+    stdout: process.stdout,
+    stderr: process.stderr
+};
+function parseTokenCount(value) {
+    const tokenCount = Number(value);
+    if (!Number.isInteger(tokenCount) || tokenCount < 0) {
+        throw new InvalidArgumentError("count must be a non-negative integer");
+    }
+    return tokenCount;
+}
+function createTokenfillProgram(output) {
+    const program = new Command();
+    program
+        .name("tokenfill")
+        .description("Generate deterministic text with exact token counts")
+        .argument("<count>", "Number of tokens to generate", parseTokenCount)
+        .option("--json", "Output structured JSON to stdout")
+        .option("--tokenizer <encoding>", `Tokenizer encoding (default: ${DEFAULT_ENCODING})`)
+        .action((count, options) => {
+        const encoding = (options.tokenizer ?? DEFAULT_ENCODING);
+        const result = tokenfill(count, { encoding });
+        if (options.json) {
+            output.stdout.write(`${JSON.stringify({
+                text: result.text,
+                stats: {
+                    requestedTokens: count,
+                    actualTokens: result.actualTokens,
+                    encoding
+                }
+            })}\n`);
+            return;
+        }
+        output.stdout.write(result.text);
+        output.stderr.write(`Generated ${result.actualTokens} tokens using ${encoding}\n`);
+    });
+    program.configureOutput({
+        writeOut: value => {
+            output.stdout.write(value);
+        },
+        writeErr: value => {
+            output.stderr.write(value);
+        }
+    });
+    return program;
+}
+export async function runCli(args = process.argv.slice(2), output = defaultOutput) {
+    const program = createTokenfillProgram(output);
+    program.exitOverride();
+    try {
+        await program.parseAsync(args, { from: "user" });
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof CommanderError) {
+            return error.exitCode;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        output.stderr.write(`Error: ${message}\n`);
+        return 1;
+    }
+}