@wentools/zli 0.2.0-beta.2dc33a43

package/script/deps/jsr.io/@wentools/result/0.1.0/src/is_result/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/is_result/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA"}

package/script/deps/jsr.io/@wentools/result/0.1.0/src/is_result/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResult = void 0;
+var is_result_js_1 = require("./is_result.js");
+Object.defineProperty(exports, "isResult", { enumerable: true, get: function () { return is_result_js_1.isResult; } });

package/script/deps/jsr.io/@wentools/result/0.1.0/src/is_result/is_result.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Check if a value is a neverthrow Result type
+ *
+ * Uses duck typing to detect Result objects without importing neverthrow types.
+ */
+declare const isResult: (value: unknown) => value is {
+    isOk: () => boolean;
+    isErr: () => boolean;
+};
+export { isResult };
+//# sourceMappingURL=is_result.d.ts.map

package/script/deps/jsr.io/@wentools/result/0.1.0/src/is_result/is_result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_result.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/is_result/is_result.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,QAAA,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI;IAAE,IAAI,EAAE,MAAM,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,OAAO,CAAA;CAStF,CAAA;AAED,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/script/deps/jsr.io/@wentools/result/0.1.0/src/is_result/is_result.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Check if a value is a neverthrow Result type
+ *
+ * Uses duck typing to detect Result objects without importing neverthrow types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResult = void 0;
+const isResult = (value) => {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'isOk' in value &&
+        'isErr' in value &&
+        typeof value.isOk === 'function' &&
+        typeof value.isErr === 'function');
+};
+exports.isResult = isResult;

package/script/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/index.d.ts

@@ -0,0 +1,2 @@
+export { propagateErr } from './propagate_err.js';
+//# sourceMappingURL=index.d.ts.map

package/script/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA"}

package/script/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateErr = void 0;
+var propagate_err_js_1 = require("./propagate_err.js");
+Object.defineProperty(exports, "propagateErr", { enumerable: true, get: function () { return propagate_err_js_1.propagateErr; } });

package/script/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/propagate_err.d.ts

@@ -0,0 +1,28 @@
+import type { Result } from 'neverthrow';
+/**
+ * Propagates an error Result to a different success type context.
+ *
+ * This is safe because error Results never contain the success value - only the error.
+ * TypeScript's structural typing prevents direct assignment of Result<T, E> to Result<U, E>
+ * even though the error type is identical and we're in the error branch.
+ *
+ * Common use case: Early return from a function that creates multiple items. If creating
+ * item 2 fails with Result<Item, DatabaseError>, we need to return Result<Item[], DatabaseError>.
+ *
+ * @example
+ * const result = await createUser(db, data) // Result<User, DatabaseError>
+ * if (result.isErr()) {
+ *   // Need to return Result<Profile, DatabaseError> but have Result<User, DatabaseError>
+ *   return propagateErr(result)
+ * }
+ *
+ * @example
+ * // In bulk creation, propagate single-item error to array context
+ * const itemResult = await createItem(data) // Result<Item, Error>
+ * if (itemResult.isErr()) {
+ *   return propagateErr<Item[], Error>(itemResult) // Result<Item[], Error>
+ * }
+ */
+declare const propagateErr: <TNew, E>(errorResult: Result<unknown, E>) => Result<TNew, E>;
+export { propagateErr };
+//# sourceMappingURL=propagate_err.d.ts.map

package/script/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/propagate_err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propagate_err.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/propagate_err.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,QAAA,MAAM,YAAY,GAAI,IAAI,EAAE,CAAC,EAAE,aAAa,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAI9E,CAAA;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/script/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/propagate_err.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateErr = void 0;
+/**
+ * Propagates an error Result to a different success type context.
+ *
+ * This is safe because error Results never contain the success value - only the error.
+ * TypeScript's structural typing prevents direct assignment of Result<T, E> to Result<U, E>
+ * even though the error type is identical and we're in the error branch.
+ *
+ * Common use case: Early return from a function that creates multiple items. If creating
+ * item 2 fails with Result<Item, DatabaseError>, we need to return Result<Item[], DatabaseError>.
+ *
+ * @example
+ * const result = await createUser(db, data) // Result<User, DatabaseError>
+ * if (result.isErr()) {
+ *   // Need to return Result<Profile, DatabaseError> but have Result<User, DatabaseError>
+ *   return propagateErr(result)
+ * }
+ *
+ * @example
+ * // In bulk creation, propagate single-item error to array context
+ * const itemResult = await createItem(data) // Result<Item, Error>
+ * if (itemResult.isErr()) {
+ *   return propagateErr<Item[], Error>(itemResult) // Result<Item[], Error>
+ * }
+ */
+const propagateErr = (errorResult) => {
+    // Type assertion is safe: we're only propagating errors, and error Results
+    // don't contain the success value. The error type E is preserved exactly.
+    return errorResult;
+};
+exports.propagateErr = propagateErr;

package/script/detect_arg_conflicts/detect_arg_conflicts.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Detect conflicts in argument definitions
+ *
+ * Checks for:
+ * - Duplicate arg names
+ * - Duplicate short names
+ *
+ * Returns list of conflicts found.
+ */
+import type { Arg } from '../arg.js';
+type ArgConflict = {
+    type: 'duplicate_name' | 'duplicate_short';
+    name: string;
+    conflictingArgs: string[];
+};
+declare const detectArgConflicts: (args: readonly Arg[]) => ArgConflict[];
+export { detectArgConflicts };
+export type { ArgConflict };
+//# sourceMappingURL=detect_arg_conflicts.d.ts.map

package/script/detect_arg_conflicts/detect_arg_conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect_arg_conflicts.d.ts","sourceRoot":"","sources":["../../src/detect_arg_conflicts/detect_arg_conflicts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAEpC,KAAK,WAAW,GAAG;IAClB,IAAI,EAAE,gBAAgB,GAAG,iBAAiB,CAAA;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,eAAe,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,QAAA,MAAM,kBAAkB,GAAI,MAAM,SAAS,GAAG,EAAE,KAAG,WAAW,EA8C7D,CAAA;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAA;AAC7B,YAAY,EAAE,WAAW,EAAE,CAAA"}

package/script/detect_arg_conflicts/detect_arg_conflicts.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Detect conflicts in argument definitions
+ *
+ * Checks for:
+ * - Duplicate arg names
+ * - Duplicate short names
+ *
+ * Returns list of conflicts found.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectArgConflicts = void 0;
+const detectArgConflicts = (args) => {
+    const conflicts = [];
+    const namesSeen = new Map();
+    const shortsSeen = new Map();
+    for (const arg of args) {
+        // Check for duplicate names
+        if (namesSeen.has(arg.name)) {
+            namesSeen.get(arg.name).push(arg.name);
+        }
+        else {
+            namesSeen.set(arg.name, [arg.name]);
+        }
+        // Check for duplicate shorts
+        if (arg.short) {
+            if (shortsSeen.has(arg.short)) {
+                shortsSeen.get(arg.short).push(arg.name);
+            }
+            else {
+                shortsSeen.set(arg.short, [arg.name]);
+            }
+        }
+    }
+    // Report duplicate names
+    for (const [name, argNames] of namesSeen) {
+        if (argNames.length > 1) {
+            conflicts.push({
+                type: 'duplicate_name',
+                name,
+                conflictingArgs: argNames,
+            });
+        }
+    }
+    // Report duplicate shorts
+    for (const [short, argNames] of shortsSeen) {
+        if (argNames.length > 1) {
+            conflicts.push({
+                type: 'duplicate_short',
+                name: short,
+                conflictingArgs: argNames,
+            });
+        }
+    }
+    return conflicts;
+};
+exports.detectArgConflicts = detectArgConflicts;

package/script/detect_arg_conflicts/mod.d.ts

@@ -0,0 +1,3 @@
+export { detectArgConflicts } from './detect_arg_conflicts.js';
+export type { ArgConflict } from './detect_arg_conflicts.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/detect_arg_conflicts/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/detect_arg_conflicts/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA"}

package/script/detect_arg_conflicts/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectArgConflicts = void 0;
+var detect_arg_conflicts_js_1 = require("./detect_arg_conflicts.js");
+Object.defineProperty(exports, "detectArgConflicts", { enumerable: true, get: function () { return detect_arg_conflicts_js_1.detectArgConflicts; } });

package/script/generate_help_text/generate_help_text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generate help text for commands
+ *
+ * Creates formatted help text showing:
+ * - Description
+ * - Usage line
+ * - Positional args
+ * - Flags
+ */
+import type { Command } from '../create_command.js';
+declare const generateHelpText: (command: Command, commandName?: string) => string;
+export { generateHelpText };
+//# sourceMappingURL=generate_help_text.d.ts.map

package/script/generate_help_text/generate_help_text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_help_text.d.ts","sourceRoot":"","sources":["../../src/generate_help_text/generate_help_text.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAEnD,QAAA,MAAM,gBAAgB,GAAI,SAAS,OAAO,EAAE,cAAc,MAAM,KAAG,MAoDlE,CAAA;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/script/generate_help_text/generate_help_text.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Generate help text for commands
+ *
+ * Creates formatted help text showing:
+ * - Description
+ * - Usage line
+ * - Positional args
+ * - Flags
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHelpText = void 0;
+const generateHelpText = (command, commandName) => {
+    const lines = [];
+    // Description
+    if (command.description) {
+        lines.push(command.description);
+        lines.push('');
+    }
+    // Usage line
+    const usageParts = [];
+    if (commandName) {
+        usageParts.push(commandName);
+    }
+    const positionals = command.args.filter((arg) => arg.type === 'positional');
+    const flags = command.args.filter((arg) => arg.type === 'flag');
+    for (const arg of positionals) {
+        usageParts.push(`<${arg.name}>`);
+    }
+    if (flags.length > 0) {
+        usageParts.push('[options]');
+    }
+    lines.push(`Usage: ${usageParts.join(' ')}`);
+    lines.push('');
+    // Positional arguments
+    if (positionals.length > 0) {
+        lines.push('Arguments:');
+        for (const arg of positionals) {
+            const shortPart = arg.short ? `, -${arg.short}` : '';
+            const descPart = arg.description ? `  ${arg.description}` : '';
+            lines.push(`  ${arg.name}${shortPart}${descPart}`);
+        }
+        lines.push('');
+    }
+    // Flags
+    if (flags.length > 0) {
+        lines.push('Options:');
+        for (const arg of flags) {
+            const shortPart = arg.short ? `-${arg.short}, ` : '';
+            const descPart = arg.description ? `  ${arg.description}` : '';
+            lines.push(`  ${shortPart}--${arg.name}${descPart}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+};
+exports.generateHelpText = generateHelpText;

package/script/generate_help_text/mod.d.ts

@@ -0,0 +1,2 @@
+export { generateHelpText } from './generate_help_text.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/generate_help_text/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/generate_help_text/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA"}

package/script/generate_help_text/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHelpText = void 0;
+var generate_help_text_js_1 = require("./generate_help_text.js");
+Object.defineProperty(exports, "generateHelpText", { enumerable: true, get: function () { return generate_help_text_js_1.generateHelpText; } });

package/script/infer_args_type.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Type utilities for inferring handler arg types from Zod schemas
+ *
+ * Extracts the TypeScript type from an array of arg definitions.
+ */
+import type { z } from 'zod';
+import type { Arg } from './arg.js';
+/**
+ * Infer the handler args object type from an array of arg definitions
+ *
+ * Takes an array like:
+ *   [
+ *     { name: 'email', schema: z.string().email() },
+ *     { name: 'verbose', schema: z.boolean().optional() }
+ *   ]
+ *
+ * And produces:
+ *   { email: string, verbose?: boolean }
+ */
+type InferArgsType<TArgs extends readonly Arg[]> = TArgs extends readonly [
+    infer First,
+    ...infer Rest
+] ? First extends Arg ? Rest extends readonly Arg[] ? {
+    [K in First['name']]: z.infer<First['schema']>;
+} & InferArgsType<Rest> : {
+    [K in First['name']]: z.infer<First['schema']>;
+} : never : Record<string, never>;
+export type { InferArgsType };
+//# sourceMappingURL=infer_args_type.d.ts.map

package/script/infer_args_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer_args_type.d.ts","sourceRoot":"","sources":["../src/infer_args_type.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;;;;;;;GAWG;AACH,KAAK,aAAa,CAAC,KAAK,SAAS,SAAS,GAAG,EAAE,IAAI,KAAK,SAAS,SAAS;IACzE,MAAM,KAAK;IACX,GAAG,MAAM,IAAI;CACb,GACE,KAAK,SAAS,GAAG,GAChB,IAAI,SAAS,SAAS,GAAG,EAAE,GAC1B;KAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;CAAE,GAAG,aAAa,CAAC,IAAI,CAAC,GACxE;KAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;CAAE,GACnD,KAAK,GACN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AAExB,YAAY,EAAE,aAAa,EAAE,CAAA"}

package/script/infer_args_type.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Type utilities for inferring handler arg types from Zod schemas
+ *
+ * Extracts the TypeScript type from an array of arg definitions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/is_boolean_schema/is_boolean_schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Check if a Zod schema is a boolean type
+ *
+ * Uses internal Zod _def API, isolated here for easy testing and maintenance.
+ * If Zod changes their internal structure, we only need to update this function.
+ *
+ * Handles wrapped schemas (default, optional, nullable) by recursively unwrapping.
+ */
+import type { ZodSchema } from 'zod';
+declare const isBooleanSchema: (schema: ZodSchema) => boolean;
+export { isBooleanSchema };
+//# sourceMappingURL=is_boolean_schema.d.ts.map

package/script/is_boolean_schema/is_boolean_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_boolean_schema.d.ts","sourceRoot":"","sources":["../../src/is_boolean_schema/is_boolean_schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAEpC,QAAA,MAAM,eAAe,GAAI,QAAQ,SAAS,KAAG,OAa5C,CAAA;AAED,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/script/is_boolean_schema/is_boolean_schema.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Check if a Zod schema is a boolean type
+ *
+ * Uses internal Zod _def API, isolated here for easy testing and maintenance.
+ * If Zod changes their internal structure, we only need to update this function.
+ *
+ * Handles wrapped schemas (default, optional, nullable) by recursively unwrapping.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBooleanSchema = void 0;
+const isBooleanSchema = (schema) => {
+    // Direct boolean check
+    if ('type' in schema._def && schema._def.type === 'boolean') {
+        return true;
+    }
+    // Unwrap wrappers (ZodDefault, ZodOptional, ZodNullable)
+    // These store the inner schema in _def.innerType
+    if ('innerType' in schema._def) {
+        return isBooleanSchema(schema._def.innerType);
+    }
+    return false;
+};
+exports.isBooleanSchema = isBooleanSchema;

package/script/is_boolean_schema/mod.d.ts

@@ -0,0 +1,2 @@
+export { isBooleanSchema } from './is_boolean_schema.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/is_boolean_schema/mod.d.ts.map

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

package/script/is_boolean_schema/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBooleanSchema = void 0;
+var is_boolean_schema_js_1 = require("./is_boolean_schema.js");
+Object.defineProperty(exports, "isBooleanSchema", { enumerable: true, get: function () { return is_boolean_schema_js_1.isBooleanSchema; } });

package/script/mod.d.ts

@@ -0,0 +1,8 @@
+export { zli } from './zli.js';
+export type { CommandDirectory, CommandEntry } from './run.js';
+export type { Command, CommandHandler, CommandOptions, MaybeResult } from './create_command.js';
+export type { PositionalArg, PositionalArgOptions } from './create_positional_arg.js';
+export type { FlagArg, FlagArgOptions } from './create_flag_arg.js';
+export type { Arg } from './arg.js';
+export type { InferArgsType } from './infer_args_type.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAC9D,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAC/F,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AACrF,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACnE,YAAY,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AACnC,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA"}

package/script/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zli = void 0;
+var zli_js_1 = require("./zli.js");
+Object.defineProperty(exports, "zli", { enumerable: true, get: function () { return zli_js_1.zli; } });

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/parse_args/mod.d.ts

@@ -0,0 +1,3 @@
+export { parseArgs } from './parse_args.js';
+export type { RawValues } from './parse_args.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/parse_args/mod.d.ts.map

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

package/script/parse_args/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = void 0;
+var parse_args_js_1 = require("./parse_args.js");
+Object.defineProperty(exports, "parseArgs", { enumerable: true, get: function () { return parse_args_js_1.parseArgs; } });

package/script/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/script/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/script/parse_args/parse_args.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * 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 }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = void 0;
+const mod_js_1 = require("../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 ((0, mod_js_1.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 ((0, mod_js_1.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;
+};
+exports.parseArgs = parseArgs;

package/script/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/script/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"}