@wentools/zli 0.2.0-beta.2dc33a43

package/esm/parse_args/mod.js

@@ -0,0 +1 @@
+export { parseArgs } from './parse_args.js';

package/esm/parse_args/parse_args.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parse command-line arguments
+ *
+ * Takes process.argv and arg definitions, returns parsed raw values (pre-validation).
+ *
+ * Parsing rules:
+ * 1. Positional args fill by position (left to right)
+ * 2. Named flags (--name or -short) can fill any arg
+ * 3. Explicit (named) overrides implicit (positional)
+ *
+ * @example
+ * const args = [
+ *   createPositionalArg('email', z.string(), { short: 'e' }),
+ *   createFlagArg('verbose', z.boolean(), { short: 'v' })
+ * ]
+ * const rawValues = parseArgs(process.argv.slice(2), args)
+ * // rawValues = { email: 'user@example.com', verbose: true }
+ */
+import type { Arg } from '../arg.js';
+type RawValues = Record<string, unknown>;
+declare const parseArgs: (argv: string[], args: readonly Arg[]) => RawValues;
+export { parseArgs };
+export type { RawValues };
+//# sourceMappingURL=parse_args.d.ts.map

package/esm/parse_args/parse_args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_args.d.ts","sourceRoot":"","sources":["../../src/parse_args/parse_args.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAGpC,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAExC,QAAA,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,EAAE,MAAM,SAAS,GAAG,EAAE,KAAG,SA4EzD,CAAA;AAED,OAAO,EAAE,SAAS,EAAE,CAAA;AACpB,YAAY,EAAE,SAAS,EAAE,CAAA"}

package/esm/parse_args/parse_args.js

@@ -0,0 +1,89 @@
+/**
+ * Parse command-line arguments
+ *
+ * Takes process.argv and arg definitions, returns parsed raw values (pre-validation).
+ *
+ * Parsing rules:
+ * 1. Positional args fill by position (left to right)
+ * 2. Named flags (--name or -short) can fill any arg
+ * 3. Explicit (named) overrides implicit (positional)
+ *
+ * @example
+ * const args = [
+ *   createPositionalArg('email', z.string(), { short: 'e' }),
+ *   createFlagArg('verbose', z.boolean(), { short: 'v' })
+ * ]
+ * const rawValues = parseArgs(process.argv.slice(2), args)
+ * // rawValues = { email: 'user@example.com', verbose: true }
+ */
+import { isBooleanSchema } from '../is_boolean_schema/mod.js';
+const parseArgs = (argv, args) => {
+    const rawValues = {};
+    const positionalArgs = args.filter((arg) => arg.type === 'positional');
+    const allArgs = args;
+    // Build lookup maps for quick access
+    const argByLongName = new Map();
+    const argByShortName = new Map();
+    for (const arg of allArgs) {
+        argByLongName.set(arg.name, arg);
+        if (arg.short) {
+            argByShortName.set(arg.short, arg);
+        }
+    }
+    let positionalIndex = 0;
+    for (let i = 0; i < argv.length; i++) {
+        const current = argv[i];
+        if (current === undefined)
+            continue;
+        // Long flag: --name or --name=value
+        if (current.startsWith('--')) {
+            const [flagName, ...valueParts] = current.slice(2).split('=');
+            if (flagName === undefined)
+                continue;
+            const arg = argByLongName.get(flagName);
+            if (!arg) {
+                // Unknown flag - skip for now (could error later)
+                continue;
+            }
+            if (isBooleanSchema(arg.schema)) {
+                rawValues[arg.name] = true;
+            }
+            else if (valueParts.length > 0) {
+                // --name=value format
+                rawValues[arg.name] = valueParts.join('=');
+            }
+            else {
+                // --name value format
+                i++;
+                rawValues[arg.name] = argv[i];
+            }
+            continue;
+        }
+        // Short flag: -v or -v value
+        if (current.startsWith('-') && current.length > 1) {
+            const shortName = current.slice(1);
+            const arg = argByShortName.get(shortName);
+            if (!arg) {
+                // Unknown flag - skip for now
+                continue;
+            }
+            if (isBooleanSchema(arg.schema)) {
+                rawValues[arg.name] = true;
+            }
+            else {
+                // -n value format
+                i++;
+                rawValues[arg.name] = argv[i];
+            }
+            continue;
+        }
+        // Positional value
+        const positionalArg = positionalArgs[positionalIndex];
+        if (positionalArg !== undefined) {
+            rawValues[positionalArg.name] = current;
+            positionalIndex++;
+        }
+    }
+    return rawValues;
+};
+export { parseArgs };

package/esm/run.d.ts

@@ -0,0 +1,19 @@
+import type { Command } from './create_command.js';
+type CommandEntry = Command | CommandDirectory;
+type CommandDirectory = {
+    name: string;
+    description?: string;
+    commands: Record<string, CommandEntry>;
+};
+type CliInput = Command | CommandDirectory;
+/**
+ * Create a run function with explicit argv (for testing)
+ */
+declare const createRun: (argv: string[]) => (input: CliInput) => Promise<void>;
+/**
+ * Run a CLI command using Deno.args
+ */
+declare const run: (input: CliInput) => Promise<void>;
+export { run, createRun };
+export type { CommandDirectory, CommandEntry, CliInput };
+//# sourceMappingURL=run.d.ts.map

package/esm/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAQlD,KAAK,YAAY,GAAG,OAAO,GAAG,gBAAgB,CAAA;AAG9C,KAAK,gBAAgB,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACtC,CAAA;AAED,KAAK,QAAQ,GAAG,OAAO,GAAG,gBAAgB,CAAA;AAO1C;;GAEG;AACH,QAAA,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,aACE,QAAQ,KAAG,OAAO,CAAC,IAAI,CA+IzD,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,GAAG,GAAU,OAAO,QAAQ,KAAG,OAAO,CAAC,IAAI,CAGhD,CAAA;AAED,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,CAAA;AACzB,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAA"}

package/esm/run.js

@@ -0,0 +1,152 @@
+/**
+ * Run a command or multi-command CLI
+ *
+ * This is the main entry point that:
+ * 1. Detects if help is requested
+ * 2. Parses arguments
+ * 3. Validates against schemas
+ * 4. Executes handler
+ */
+import * as dntShim from "./_dnt.shims.js";
+import { parseArgs } from './parse_args/mod.js';
+import { validateArgs } from './validate_args/mod.js';
+import { detectArgConflicts } from './detect_arg_conflicts/mod.js';
+import { generateHelpText } from './generate_help_text/mod.js';
+import { isResult } from './deps/jsr.io/@wentools/result/0.1.0/src/index.js';
+// Type guard - check if entry is a directory
+const isCommandDirectory = (input) => {
+    return 'commands' in input;
+};
+/**
+ * Create a run function with explicit argv (for testing)
+ */
+const createRun = (argv) => {
+    const runWithArgs = async (input) => {
+        if (isCommandDirectory(input)) {
+            await runCommandDirectory(input, argv, []);
+        }
+        else {
+            // Single command mode
+            const command = input;
+            // Check for help
+            if (argv[0] === '--help' || argv[0] === '-h') {
+                console.log(generateHelpText(command));
+                return;
+            }
+            await runSingleCommand(command, argv);
+        }
+    };
+    const runCommandDirectory = async (dir, args, commandPath) => {
+        // Build full path
+        const fullPath = [...commandPath, dir.name];
+        // Help handling
+        if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+            showCommandDirectoryHelp(dir, fullPath);
+            return;
+        }
+        // Lookup subcommand
+        const subcommandName = args[0];
+        if (subcommandName === undefined) {
+            showCommandDirectoryHelp(dir, fullPath);
+            return;
+        }
+        const entry = dir.commands[subcommandName];
+        if (!entry) {
+            console.error(`❌ Unknown command: ${[...fullPath, subcommandName].join(' ')}`);
+            console.error(`\nAvailable commands: ${Object.keys(dir.commands).join(', ')}`);
+            dntShim.Deno.exit(1);
+        }
+        // Recurse or execute
+        if (isCommandDirectory(entry)) {
+            // Nested directory - recurse!
+            await runCommandDirectory(entry, args.slice(1), fullPath);
+        }
+        else {
+            // Leaf command - execute
+            const cmdPath = [...fullPath, subcommandName].join(' ');
+            // Check for command-specific help
+            if (args[1] === '--help' || args[1] === '-h') {
+                console.log(generateHelpText(entry, cmdPath));
+                return;
+            }
+            await runSingleCommand(entry, args.slice(1));
+        }
+    };
+    const showCommandDirectoryHelp = (dir, commandPath) => {
+        const pathStr = commandPath.join(' ');
+        console.log(`${dir.description || dir.name}\n`);
+        console.log('Commands:');
+        // Group and display commands
+        const entries = Object.entries(dir.commands);
+        const maxNameLength = Math.max(...entries.map(([name]) => name.length));
+        for (const [name, entry] of entries) {
+            const padding = ' '.repeat(maxNameLength - name.length + 2);
+            const indicator = isCommandDirectory(entry) ? '→ ' : '  ';
+            const desc = entry.description || '';
+            console.log(`  ${name}${padding}${indicator}${desc}`);
+        }
+        console.log(`\nUse '${pathStr} <command> --help' for command-specific help`);
+    };
+    const runSingleCommand = async (command, args) => {
+        // Check for conflicts
+        const conflicts = detectArgConflicts(command.args);
+        if (conflicts.length > 0) {
+            console.error('❌ Argument configuration error:');
+            for (const conflict of conflicts) {
+                if (conflict.type === 'duplicate_name') {
+                    console.error(`   Duplicate argument name: ${conflict.name}`);
+                }
+                else {
+                    console.error(`   Duplicate short flag: -${conflict.name} used by ${conflict.conflictingArgs.join(', ')}`);
+                }
+            }
+            dntShim.Deno.exit(1);
+        }
+        // Parse arguments
+        const rawValues = parseArgs(args, command.args);
+        // Validate arguments
+        const validatedResult = validateArgs(rawValues, command.args);
+        if (validatedResult.isErr()) {
+            const { argName, zodError } = validatedResult.error;
+            console.error(`❌ Validation error for argument '${argName}':`);
+            zodError.issues.forEach((issue) => {
+                console.error(`   ${issue.path.join('.')}: ${issue.message}`);
+            });
+            dntShim.Deno.exit(1);
+        }
+        // Safe: isErr() checked above, Deno.exit() terminates
+        const validatedValues = validatedResult._unsafeUnwrap();
+        // Execute handler
+        try {
+            const result = await command.handler(validatedValues);
+            // Check if handler returned a Result type
+            if (isResult(result)) {
+                if (result.isErr()) {
+                    const error = result.error;
+                    console.error('❌ Command failed:');
+                    if (error && typeof error === 'object') {
+                        console.error(JSON.stringify(error, null, 2));
+                    }
+                    else {
+                        console.error(String(error));
+                    }
+                    dntShim.Deno.exit(1);
+                }
+                // ok() - just return, script ends normally
+            }
+        }
+        catch (error) {
+            console.error('❌ Command execution failed:', error);
+            dntShim.Deno.exit(1);
+        }
+    };
+    return runWithArgs;
+};
+/**
+ * Run a CLI command using Deno.args
+ */
+const run = async (input) => {
+    const runWithArgs = createRun(dntShim.Deno.args);
+    await runWithArgs(input);
+};
+export { run, createRun };

package/esm/validate_args/mod.d.ts

@@ -0,0 +1,3 @@
+export { validateArgs } from './validate_args.js';
+export type { ValidationError, ValidatedValues } from './validate_args.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/validate_args/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/validate_args/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA"}

package/esm/validate_args/mod.js

@@ -0,0 +1 @@
+export { validateArgs } from './validate_args.js';

package/esm/validate_args/validate_args.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Validate parsed argument values against Zod schemas
+ *
+ * Takes raw parsed values and arg definitions, validates each value,
+ * returns validated & typed values or validation errors.
+ */
+import type { Arg } from '../arg.js';
+import type { RawValues } from '../parse_args/mod.js';
+import { type Result } from '../deps/jsr.io/@wentools/result/0.1.0/src/index.js';
+import type { ZodError } from 'zod';
+type ValidationError = {
+    type: 'validation_error';
+    argName: string;
+    zodError: ZodError;
+};
+type ValidatedValues = Record<string, unknown>;
+declare const validateArgs: (rawValues: RawValues, args: readonly Arg[]) => Result<ValidatedValues, ValidationError>;
+export { validateArgs };
+export type { ValidationError, ValidatedValues };
+//# sourceMappingURL=validate_args.d.ts.map

package/esm/validate_args/validate_args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate_args.d.ts","sourceRoot":"","sources":["../../src/validate_args/validate_args.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,oDAAoD,CAAA;AACzF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AAEnC,KAAK,eAAe,GAAG;IACtB,IAAI,EAAE,kBAAkB,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,QAAQ,CAAA;CAClB,CAAA;AAED,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAE9C,QAAA,MAAM,YAAY,GACjB,WAAW,SAAS,EACpB,MAAM,SAAS,GAAG,EAAE,KAClB,MAAM,CAAC,eAAe,EAAE,eAAe,CAkBzC,CAAA;AAED,OAAO,EAAE,YAAY,EAAE,CAAA;AACvB,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,CAAA"}

package/esm/validate_args/validate_args.js

@@ -0,0 +1,23 @@
+/**
+ * Validate parsed argument values against Zod schemas
+ *
+ * Takes raw parsed values and arg definitions, validates each value,
+ * returns validated & typed values or validation errors.
+ */
+import { err, ok } from '../deps/jsr.io/@wentools/result/0.1.0/src/index.js';
+const validateArgs = (rawValues, args) => {
+    const validated = {};
+    for (const arg of args) {
+        const rawValue = rawValues[arg.name];
+        const result = arg.schema.safeParse(rawValue);
+        if (!result.success) {
+            return err('validation_error', `Validation failed for argument: ${arg.name}`, {
+                argName: arg.name,
+                zodError: result.error,
+            });
+        }
+        validated[arg.name] = result.data;
+    }
+    return ok(validated);
+};
+export { validateArgs };

package/esm/zli.d.ts

@@ -0,0 +1,118 @@
+/**
+ * ZLI - Lightweight CLI builder with Zod validation
+ *
+ * A minimal, type-safe CLI argument parser built on Zod.
+ * Zero dependencies beyond Zod (already in project).
+ *
+ * ## Goals
+ *
+ * - Type-safe arguments inferred from Zod schemas
+ * - Flexible parsing: positional args by order OR by --name
+ * - Short flags: --verbose or -v
+ * - Copy-paste friendly: easy to expand from simple to multi-command scripts
+ * - Auto-generated help text
+ * - Pretty validation error messages
+ * - Conflict detection (duplicate names/shorts)
+ *
+ * ## API
+ *
+ * - `zli.p(name, schema, options?)` - Create positional argument
+ * - `zli.f(name, schema, options?)` - Create flag argument
+ * - `zli.c(args, handler, options?)` - Create command
+ * - `zli.d(name, options)` - Create command directory
+ * - `zli.run(command | multiCommand)` - Execute CLI
+ *
+ * ## Usage - Simple Single Command
+ *
+ * ```typescript
+ * import { zli } from '@wentools/zli'
+ * import { z } from 'zod'
+ *
+ * const command = zli.c(
+ *   [
+ *     zli.p('email', z.string().email(), {
+ *       description: 'User email address',
+ *       short: 'e'
+ *     }),
+ *     zli.f('verbose', z.boolean(), {
+ *       description: 'Verbose output',
+ *       short: 'v'
+ *     })
+ *   ],
+ *   (args) => {
+ *     console.log(args.email)    // typed as string
+ *     console.log(args.verbose)  // typed as boolean | undefined
+ *   },
+ *   { description: 'Check user permissions' }
+ * )
+ *
+ * zli.run(command)
+ * ```
+ *
+ * **Invocation:**
+ * ```bash
+ * # Positional
+ * pnpm exec tsx --env-file=.env script.ts user@example.com
+ *
+ * # Named
+ * pnpm exec tsx --env-file=.env script.ts --email user@example.com
+ *
+ * # Short flag
+ * pnpm exec tsx --env-file=.env script.ts -e user@example.com
+ *
+ * # With flags
+ * pnpm exec tsx --env-file=.env script.ts user@example.com --verbose
+ * pnpm exec tsx --env-file=.env script.ts user@example.com -v
+ *
+ * # Help
+ * pnpm exec tsx --env-file=.env script.ts --help
+ * ```
+ *
+ * ## Usage - Multi-Command Script
+ *
+ * ```typescript
+ * import { zli } from '@wentools/zli'
+ * import { z } from 'zod'
+ *
+ * const checkPermissions = zli.c(
+ *   [
+ *     zli.p('email', z.string().email(), { description: 'User email' }),
+ *     zli.f('verbose', z.boolean(), { description: 'Verbose output', short: 'v' })
+ *   ],
+ *   (args) => {
+ *     console.log(`Checking permissions for ${args.email}`)
+ *   },
+ *   { description: 'Check user permissions' }
+ * )
+ *
+ * const promote = zli.c(
+ *   [
+ *     zli.p('email', z.string().email(), { description: 'User email' })
+ *   ],
+ *   async (args) => {
+ *     console.log(`Promoting ${args.email} to admin`)
+ *   },
+ *   { description: 'Promote user to admin' }
+ * )
+ *
+ * zli.run({
+ *   name: 'user',
+ *   description: 'User management commands',
+ *   commands: {
+ *     'check-permissions': checkPermissions,
+ *     'promote': promote
+ *   }
+ * })
+ * ```
+ */
+declare const zli: {
+    p: <TSchema extends import("zod").ZodType>(name: string, schema: TSchema, options?: import("./create_positional_arg.js").PositionalArgOptions) => import("./create_positional_arg.js").PositionalArg<TSchema>;
+    f: <TSchema extends import("zod").ZodType>(name: string, schema: TSchema, options?: import("./create_flag_arg.js").FlagArgOptions) => import("./create_flag_arg.js").FlagArg<TSchema>;
+    c: <const TArgs extends readonly import("./arg.js").Arg[]>(args: TArgs, handler: import("./create_command.js").CommandHandler<import("./infer_args_type.js").InferArgsType<TArgs>>, options?: import("./create_command.js").CommandOptions) => import("./create_command.js").Command<TArgs>;
+    d: <const TCommands extends Record<string, import("./run.js").CommandEntry>>(name: string, options: import("./create_command_directory.js").CommandDirectoryOptions & {
+        commands: TCommands;
+    }) => import("./create_command_directory.js").CommandDirectory;
+    run: (input: import("./run.js").CliInput) => Promise<void>;
+};
+export { zli };
+//# sourceMappingURL=zli.d.ts.map

package/esm/zli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zli.d.ts","sourceRoot":"","sources":["../src/zli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AAaH,QAAA,MAAM,GAAG;;;;;;;;CAMR,CAAA;AAED,OAAO,EAAE,GAAG,EAAE,CAAA"}

package/esm/zli.js

@@ -0,0 +1,124 @@
+/**
+ * ZLI - Lightweight CLI builder with Zod validation
+ *
+ * A minimal, type-safe CLI argument parser built on Zod.
+ * Zero dependencies beyond Zod (already in project).
+ *
+ * ## Goals
+ *
+ * - Type-safe arguments inferred from Zod schemas
+ * - Flexible parsing: positional args by order OR by --name
+ * - Short flags: --verbose or -v
+ * - Copy-paste friendly: easy to expand from simple to multi-command scripts
+ * - Auto-generated help text
+ * - Pretty validation error messages
+ * - Conflict detection (duplicate names/shorts)
+ *
+ * ## API
+ *
+ * - `zli.p(name, schema, options?)` - Create positional argument
+ * - `zli.f(name, schema, options?)` - Create flag argument
+ * - `zli.c(args, handler, options?)` - Create command
+ * - `zli.d(name, options)` - Create command directory
+ * - `zli.run(command | multiCommand)` - Execute CLI
+ *
+ * ## Usage - Simple Single Command
+ *
+ * ```typescript
+ * import { zli } from '@wentools/zli'
+ * import { z } from 'zod'
+ *
+ * const command = zli.c(
+ *   [
+ *     zli.p('email', z.string().email(), {
+ *       description: 'User email address',
+ *       short: 'e'
+ *     }),
+ *     zli.f('verbose', z.boolean(), {
+ *       description: 'Verbose output',
+ *       short: 'v'
+ *     })
+ *   ],
+ *   (args) => {
+ *     console.log(args.email)    // typed as string
+ *     console.log(args.verbose)  // typed as boolean | undefined
+ *   },
+ *   { description: 'Check user permissions' }
+ * )
+ *
+ * zli.run(command)
+ * ```
+ *
+ * **Invocation:**
+ * ```bash
+ * # Positional
+ * pnpm exec tsx --env-file=.env script.ts user@example.com
+ *
+ * # Named
+ * pnpm exec tsx --env-file=.env script.ts --email user@example.com
+ *
+ * # Short flag
+ * pnpm exec tsx --env-file=.env script.ts -e user@example.com
+ *
+ * # With flags
+ * pnpm exec tsx --env-file=.env script.ts user@example.com --verbose
+ * pnpm exec tsx --env-file=.env script.ts user@example.com -v
+ *
+ * # Help
+ * pnpm exec tsx --env-file=.env script.ts --help
+ * ```
+ *
+ * ## Usage - Multi-Command Script
+ *
+ * ```typescript
+ * import { zli } from '@wentools/zli'
+ * import { z } from 'zod'
+ *
+ * const checkPermissions = zli.c(
+ *   [
+ *     zli.p('email', z.string().email(), { description: 'User email' }),
+ *     zli.f('verbose', z.boolean(), { description: 'Verbose output', short: 'v' })
+ *   ],
+ *   (args) => {
+ *     console.log(`Checking permissions for ${args.email}`)
+ *   },
+ *   { description: 'Check user permissions' }
+ * )
+ *
+ * const promote = zli.c(
+ *   [
+ *     zli.p('email', z.string().email(), { description: 'User email' })
+ *   ],
+ *   async (args) => {
+ *     console.log(`Promoting ${args.email} to admin`)
+ *   },
+ *   { description: 'Promote user to admin' }
+ * )
+ *
+ * zli.run({
+ *   name: 'user',
+ *   description: 'User management commands',
+ *   commands: {
+ *     'check-permissions': checkPermissions,
+ *     'promote': promote
+ *   }
+ * })
+ * ```
+ */
+import { createPositionalArg } from './create_positional_arg.js';
+import { createFlagArg } from './create_flag_arg.js';
+import { createCommand } from './create_command.js';
+import { createCommandDirectory } from './create_command_directory.js';
+import { run } from './run.js';
+const p = createPositionalArg;
+const f = createFlagArg;
+const c = createCommand;
+const d = createCommandDirectory;
+const zli = {
+    p,
+    f,
+    c,
+    d,
+    run,
+};
+export { zli };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@wentools/zli",
+  "version": "0.2.0-beta.2dc33a43",
+  "description": "Lightweight CLI builder with Zod validation and type-safe argument parsing",
+  "keywords": [
+    "cli",
+    "command-line",
+    "zod",
+    "typescript",
+    "type-safe",
+    "argument-parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/wentools/zli"
+  },
+  "license": "MIT",
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "scripts": {},
+  "dependencies": {
+    "neverthrow": "^8.2.0",
+    "zod": "^4.1.0",
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,6 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}