@sayknow-cli/utils 0.3.11 → 0.3.13

package/src/prompt.ts

@@ -1,5 +1,4 @@
 import type { HelperDelegate, HelperOptions, Template, TemplateDelegate } from "handlebars";
-import Handlebars from "handlebars";
 
 export type { HelperDelegate, HelperOptions, Template, TemplateDelegate };
 
@@ -223,107 +222,133 @@ export interface TemplateContext extends Record<string, unknown> {
 	arguments?: string;
 }
 
-const handlebars = Handlebars.create();
+type HandlebarsRuntime = typeof import("handlebars");
+type HandlebarsInstance = ReturnType<HandlebarsRuntime["create"]>;
+
+let handlebars: HandlebarsInstance | undefined;
+
+function getHandlebars(): HandlebarsInstance {
+	if (handlebars) return handlebars;
+	// Lazy bare-literal require: statically traceable, so the bundler always
+	// embeds handlebars in the main bundle (compiled binaries included), while
+	// the module still loads only on first template render. The previous
+	// bunfs extra-entrypoint require crashed v0.9.3–v0.9.6 compiled releases
+	// at startup when --minify dropped the entrypoint (#1939).
+	const Handlebars = asHandlebarsRuntime(require("handlebars"));
+	handlebars = Handlebars.create();
+	registerBuiltinHelpers(handlebars);
+	return handlebars;
+}
 
-handlebars.registerHelper("arg", function (this: TemplateContext, index: number | string): string {
-	const args = this.args ?? [];
-	const parsedIndex = typeof index === "number" ? index : Number.parseInt(index, 10);
-	if (!Number.isFinite(parsedIndex)) return "";
-	const zeroBased = parsedIndex - 1;
-	if (zeroBased < 0) return "";
-	return args[zeroBased] ?? "";
-});
+function asHandlebarsRuntime(value: unknown): HandlebarsRuntime {
+	if (isHandlebarsRuntime(value)) return value;
+	if (isObjectRecord(value) && isHandlebarsRuntime(value.default)) return value.default;
+	throw new Error("Loaded handlebars module does not expose the expected runtime API.");
+}
 
-/**
- * {{#list items prefix="- " suffix="" join="\n"}}{{this}}{{/list}}
- * Renders an array with customizable prefix, suffix, and join separator.
- * Note: Use \n in join for newlines (will be unescaped automatically).
- */
-handlebars.registerHelper(
-	"list",
-	function (this: unknown, context: unknown[], options: Handlebars.HelperOptions): string {
+function isHandlebarsRuntime(value: unknown): value is HandlebarsRuntime {
+	return isObjectRecord(value) && typeof value.create === "function";
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function registerBuiltinHelpers(handlebars: HandlebarsInstance): void {
+	handlebars.registerHelper("arg", function (this: TemplateContext, index: number | string): string {
+		const args = this.args ?? [];
+		const parsedIndex = typeof index === "number" ? index : Number.parseInt(index, 10);
+		if (!Number.isFinite(parsedIndex)) return "";
+		const zeroBased = parsedIndex - 1;
+		if (zeroBased < 0) return "";
+		return args[zeroBased] ?? "";
+	});
+
+	/**
+	 * {{#list items prefix="- " suffix="" join="\n"}}{{this}}{{/list}}
+	 * Renders an array with customizable prefix, suffix, and join separator.
+	 * Note: Use \n in join for newlines (will be unescaped automatically).
+	 */
+	handlebars.registerHelper("list", function (this: unknown, context: unknown[], options: HelperOptions): string {
 		if (!Array.isArray(context) || context.length === 0) return "";
 		const prefix = (options.hash.prefix as string) ?? "";
 		const suffix = (options.hash.suffix as string) ?? "";
 		const rawSeparator = (options.hash.join as string) ?? "\n";
 		const separator = rawSeparator.replace(/\\n/g, "\n").replace(/\\t/g, "\t");
 		return context.map(item => `${prefix}${options.fn(item)}${suffix}`).join(separator);
-	},
-);
-
-/**
- * {{join array ", "}}
- * Joins an array with a separator (default: ", ").
- */
-handlebars.registerHelper("join", (context: unknown[], separator?: unknown): string => {
-	if (!Array.isArray(context)) return "";
-	const sep = typeof separator === "string" ? separator : ", ";
-	return context.join(sep);
-});
-
-/**
- * {{default value "fallback"}}
- * Returns the value if truthy, otherwise returns the fallback.
- */
-handlebars.registerHelper("default", (value: unknown, defaultValue: unknown): unknown => value || defaultValue);
-
-/**
- * {{pluralize count "item" "items"}}
- * Returns "1 item" or "5 items" based on count.
- */
-handlebars.registerHelper(
-	"pluralize",
-	(count: number, singular: string, plural: string): string => `${count} ${count === 1 ? singular : plural}`,
-);
+	});
 
-/**
- * {{#when value "==" compare}}...{{else}}...{{/when}}
- * Conditional block with comparison operators: ==, ===, !=, !==, >, <, >=, <=
- */
-handlebars.registerHelper(
-	"when",
-	function (this: unknown, lhs: unknown, operator: string, rhs: unknown, options: Handlebars.HelperOptions): string {
-		const ops: Record<string, (a: unknown, b: unknown) => boolean> = {
-			"==": (a, b) => a === b,
-			"===": (a, b) => a === b,
-			"!=": (a, b) => a !== b,
-			"!==": (a, b) => a !== b,
-			">": (a, b) => (a as number) > (b as number),
-			"<": (a, b) => (a as number) < (b as number),
-			">=": (a, b) => (a as number) >= (b as number),
-			"<=": (a, b) => (a as number) <= (b as number),
-		};
-		const fn = ops[operator];
-		if (!fn) return options.inverse(this);
-		return fn(lhs, rhs) ? options.fn(this) : options.inverse(this);
-	},
-);
+	/**
+	 * {{join array ", "}}
+	 * Joins an array with a separator (default: ", ").
+	 */
+	handlebars.registerHelper("join", (context: unknown[], separator?: unknown): string => {
+		if (!Array.isArray(context)) return "";
+		const sep = typeof separator === "string" ? separator : ", ";
+		return context.join(sep);
+	});
 
-/**
- * {{#ifAny a b c}}...{{else}}...{{/ifAny}}
- * True if any argument is truthy.
- */
-handlebars.registerHelper("ifAny", function (this: unknown, ...args: unknown[]): string {
-	const options = args.pop() as Handlebars.HelperOptions;
-	return args.some(Boolean) ? options.fn(this) : options.inverse(this);
-});
+	/**
+	 * {{default value "fallback"}}
+	 * Returns the value if truthy, otherwise returns the fallback.
+	 */
+	handlebars.registerHelper("default", (value: unknown, defaultValue: unknown): unknown => value || defaultValue);
+
+	/**
+	 * {{pluralize count "item" "items"}}
+	 * Returns "1 item" or "5 items" based on count.
+	 */
+	handlebars.registerHelper(
+		"pluralize",
+		(count: number, singular: string, plural: string): string => `${count} ${count === 1 ? singular : plural}`,
+	);
+
+	/**
+	 * {{#when value "==" compare}}...{{else}}...{{/when}}
+	 * Conditional block with comparison operators: ==, ===, !=, !==, >, <, >=, <=
+	 */
+	handlebars.registerHelper(
+		"when",
+		function (this: unknown, lhs: unknown, operator: string, rhs: unknown, options: HelperOptions): string {
+			const ops: Record<string, (a: unknown, b: unknown) => boolean> = {
+				"==": (a, b) => a === b,
+				"===": (a, b) => a === b,
+				"!=": (a, b) => a !== b,
+				"!==": (a, b) => a !== b,
+				">": (a, b) => (a as number) > (b as number),
+				"<": (a, b) => (a as number) < (b as number),
+				">=": (a, b) => (a as number) >= (b as number),
+				"<=": (a, b) => (a as number) <= (b as number),
+			};
+			const fn = ops[operator];
+			if (!fn) return options.inverse(this);
+			return fn(lhs, rhs) ? options.fn(this) : options.inverse(this);
+		},
+	);
+
+	/**
+	 * {{#ifAny a b c}}...{{else}}...{{/ifAny}}
+	 * True if any argument is truthy.
+	 */
+	handlebars.registerHelper("ifAny", function (this: unknown, ...args: unknown[]): string {
+		const options = args.pop() as HelperOptions;
+		return args.some(Boolean) ? options.fn(this) : options.inverse(this);
+	});
 
-/**
- * {{#ifAll a b c}}...{{else}}...{{/ifAll}}
- * True if all arguments are truthy.
- */
-handlebars.registerHelper("ifAll", function (this: unknown, ...args: unknown[]): string {
-	const options = args.pop() as Handlebars.HelperOptions;
-	return args.every(Boolean) ? options.fn(this) : options.inverse(this);
-});
+	/**
+	 * {{#ifAll a b c}}...{{else}}...{{/ifAll}}
+	 * True if all arguments are truthy.
+	 */
+	handlebars.registerHelper("ifAll", function (this: unknown, ...args: unknown[]): string {
+		const options = args.pop() as HelperOptions;
+		return args.every(Boolean) ? options.fn(this) : options.inverse(this);
+	});
 
-/**
- * {{#table rows headers="Col1|Col2"}}{{col1}}|{{col2}}{{/table}}
- * Generates a markdown table from an array of objects.
- */
-handlebars.registerHelper(
-	"table",
-	function (this: unknown, context: unknown[], options: Handlebars.HelperOptions): string {
+	/**
+	 * {{#table rows headers="Col1|Col2"}}{{col1}}|{{col2}}{{/table}}
+	 * Generates a markdown table from an array of objects.
+	 */
+	handlebars.registerHelper("table", function (this: unknown, context: unknown[], options: HelperOptions): string {
 		if (!Array.isArray(context) || context.length === 0) return "";
 		const headersStr = options.hash.headers as string | undefined;
 		const headers = headersStr?.split("|") ?? [];
@@ -331,108 +356,108 @@ handlebars.registerHelper(
 		const headerRow = headers.length > 0 ? `| ${headers.join(" | ")} |\n| ${separator} |\n` : "";
 		const rows = context.map(item => `| ${options.fn(item).trim()} |`).join("\n");
 		return headerRow + rows;
-	},
-);
-
-/**
- * {{#codeblock lang="diff"}}...{{/codeblock}}
- * Wraps content in a fenced code block.
- */
-handlebars.registerHelper("codeblock", function (this: unknown, options: Handlebars.HelperOptions): string {
-	const lang = (options.hash.lang as string) ?? "";
-	const content = options.fn(this).trim();
-	return `\`\`\`${lang}\n${content}\n\`\`\``;
-});
-
-/**
- * {{#xml "tag"}}content{{/xml}}
- * Wraps content in XML-style tags. Returns empty string if content is empty.
- */
-handlebars.registerHelper("xml", function (this: unknown, tag: string, options: Handlebars.HelperOptions): string {
-	const content = options.fn(this).trim();
-	if (!content) return "";
-	return `<${tag}>\n${content}\n</${tag}>`;
-});
+	});
 
-/**
- * {{escapeXml value}}
- * Escapes XML special characters: & < > "
- */
-handlebars.registerHelper("escapeXml", (value: unknown): string => {
-	if (value == null) return "";
-	return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-});
+	/**
+	 * {{#codeblock lang="diff"}}...{{/codeblock}}
+	 * Wraps content in a fenced code block.
+	 */
+	handlebars.registerHelper("codeblock", function (this: unknown, options: HelperOptions): string {
+		const lang = (options.hash.lang as string) ?? "";
+		const content = options.fn(this).trim();
+		return `\`\`\`${lang}\n${content}\n\`\`\``;
+	});
 
-/**
- * {{len array}}
- * Returns the length of an array or string.
- */
-handlebars.registerHelper("len", (value: unknown): number => {
-	if (Array.isArray(value)) return value.length;
-	if (typeof value === "string") return value.length;
-	return 0;
-});
+	/**
+	 * {{#xml "tag"}}content{{/xml}}
+	 * Wraps content in XML-style tags. Returns empty string if content is empty.
+	 */
+	handlebars.registerHelper("xml", function (this: unknown, tag: string, options: HelperOptions): string {
+		const content = options.fn(this).trim();
+		if (!content) return "";
+		return `<${tag}>\n${content}\n</${tag}>`;
+	});
 
-/**
- * {{add a b}}
- * Adds two numbers.
- */
-handlebars.registerHelper("add", (a: number, b: number): number => (a ?? 0) + (b ?? 0));
+	/**
+	 * {{escapeXml value}}
+	 * Escapes XML special characters: & < > "
+	 */
+	handlebars.registerHelper("escapeXml", (value: unknown): string => {
+		if (value == null) return "";
+		return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+	});
 
-/**
- * {{sub a b}}
- * Subtracts b from a.
- */
-handlebars.registerHelper("sub", (a: number, b: number): number => (a ?? 0) - (b ?? 0));
+	/**
+	 * {{len array}}
+	 * Returns the length of an array or string.
+	 */
+	handlebars.registerHelper("len", (value: unknown): number => {
+		if (Array.isArray(value)) return value.length;
+		if (typeof value === "string") return value.length;
+		return 0;
+	});
 
-/**
- * {{#has collection item}}...{{else}}...{{/has}}
- * Checks if an array includes an item or if a Set/Map has a key.
- */
-handlebars.registerHelper(
-	"has",
-	function (this: unknown, collection: unknown, item: unknown, options: Handlebars.HelperOptions): string {
-		let found = false;
-		if (Array.isArray(collection)) {
-			found = collection.includes(item);
-		} else if (collection instanceof Set) {
-			found = collection.has(item);
-		} else if (collection instanceof Map) {
-			found = collection.has(item);
-		} else if (collection && typeof collection === "object") {
-			if (typeof item === "string" || typeof item === "number" || typeof item === "symbol") {
-				found = item in collection;
+	/**
+	 * {{add a b}}
+	 * Adds two numbers.
+	 */
+	handlebars.registerHelper("add", (a: number, b: number): number => (a ?? 0) + (b ?? 0));
+
+	/**
+	 * {{sub a b}}
+	 * Subtracts b from a.
+	 */
+	handlebars.registerHelper("sub", (a: number, b: number): number => (a ?? 0) - (b ?? 0));
+
+	/**
+	 * {{#has collection item}}...{{else}}...{{/has}}
+	 * Checks if an array includes an item or if a Set/Map has a key.
+	 */
+	handlebars.registerHelper(
+		"has",
+		function (this: unknown, collection: unknown, item: unknown, options: HelperOptions): string {
+			let found = false;
+			if (Array.isArray(collection)) {
+				found = collection.includes(item);
+			} else if (collection instanceof Set) {
+				found = collection.has(item);
+			} else if (collection instanceof Map) {
+				found = collection.has(item);
+			} else if (collection && typeof collection === "object") {
+				if (typeof item === "string" || typeof item === "number" || typeof item === "symbol") {
+					found = item in collection;
+				}
 			}
-		}
-		return found ? options.fn(this) : options.inverse(this);
-	},
-);
+			return found ? options.fn(this) : options.inverse(this);
+		},
+	);
+
+	/**
+	 * {{includes array item}}
+	 * Returns true if array includes item. For use in other helpers.
+	 */
+	handlebars.registerHelper("includes", (collection: unknown, item: unknown): boolean => {
+		if (Array.isArray(collection)) return collection.includes(item);
+		if (collection instanceof Set) return collection.has(item);
+		if (collection instanceof Map) return collection.has(item);
+		return false;
+	});
 
-/**
- * {{includes array item}}
- * Returns true if array includes item. For use in other helpers.
- */
-handlebars.registerHelper("includes", (collection: unknown, item: unknown): boolean => {
-	if (Array.isArray(collection)) return collection.includes(item);
-	if (collection instanceof Set) return collection.has(item);
-	if (collection instanceof Map) return collection.has(item);
-	return false;
-});
+	/**
+	 * {{not value}}
+	 * Returns logical NOT of value. For use in subexpressions.
+	 */
+	handlebars.registerHelper("not", (value: unknown): boolean => !value);
 
-/**
- * {{not value}}
- * Returns logical NOT of value. For use in subexpressions.
- */
-handlebars.registerHelper("not", (value: unknown): boolean => !value);
-
-handlebars.registerHelper("jsonStringify", (value: unknown): string => JSON.stringify(value));
+	handlebars.registerHelper("jsonStringify", (value: unknown): string => JSON.stringify(value));
+}
 
 export function registerHelper(name: string, fn: HelperDelegate): void {
-	handlebars.registerHelper(name, fn);
+	getHandlebars().registerHelper(name, fn);
 }
 
 export function registerPartial(name: string, fn: Template): void {
-	handlebars.registerPartial(name, fn);
+	getHandlebars().registerPartial(name, fn);
 }
 
 /**
@@ -457,7 +482,7 @@ export function compile(template: string): (context: TemplateContext) => string
 	const disambiguated = disambiguateClosingBraces(template);
 	const cached = compiledTemplateCache.get(disambiguated);
 	if (cached) return cached;
-	const compiled = handlebars.compile(disambiguated, { noEscape: true, strict: false }) as (
+	const compiled = getHandlebars().compile(disambiguated, { noEscape: true, strict: false }) as (
 		context: TemplateContext,
 	) => string;
 	compiledTemplateCache.set(disambiguated, compiled);

package/dist/types/abortable.d.ts

@@ -1,27 +0,0 @@
-export declare class AbortError extends Error {
-    constructor(signal: AbortSignal);
-}
-/**
- * Creates an abortable stream from a given stream and signal.
- *
- * @param stream - The stream to make abortable
- * @param signal - The signal to abort the stream
- * @returns The abortable stream
- */
-export declare function createAbortableStream<T>(stream: ReadableStream<T>, signal?: AbortSignal): ReadableStream<T>;
-/**
- * Runs a promise-returning function (`pr`). If the given AbortSignal is aborted before or during
- * execution, the promise is rejected with a standard error.
- *
- * @param signal - Optional AbortSignal to cancel the operation
- * @param pr - Function returning a promise to run
- * @returns Promise resolving as `pr` would, or rejecting on abort
- */
-export declare function untilAborted<T>(signal: AbortSignal | undefined | null, pr: Promise<T> | (() => Promise<T>)): Promise<T>;
-/**
- * Memoizes a function with no arguments, calling it once and caching the result.
- *
- * @param fn - Function to be called once
- * @returns A function that returns the cached result of `fn`
- */
-export declare function once<T>(fn: () => T): () => T;

package/dist/types/async.d.ts

@@ -1,6 +0,0 @@
-/**
- * Wrap a promise with a timeout and optional abort signal.
- * Rejects with the given message if the timeout fires first.
- * Cleans up all listeners on settlement.
- */
-export declare function withTimeout<T>(promise: Promise<T>, ms: number, message: string, signal?: AbortSignal): Promise<T>;

package/dist/types/cli.d.ts

@@ -1,126 +0,0 @@
-export interface FlagDescriptor<K extends "string" | "boolean" | "integer" = "string" | "boolean" | "integer"> {
-    kind: K;
-    description?: string;
-    char?: string;
-    default?: unknown;
-    multiple?: boolean;
-    options?: readonly string[];
-    required?: boolean;
-}
-export interface ArgDescriptor {
-    kind: "string";
-    description?: string;
-    required?: boolean;
-    multiple?: boolean;
-    options?: readonly string[];
-}
-interface FlagInput {
-    description?: string;
-    char?: string;
-    default?: unknown;
-    multiple?: boolean;
-    options?: readonly string[];
-    required?: boolean;
-}
-interface ArgInput {
-    description?: string;
-    required?: boolean;
-    multiple?: boolean;
-    options?: readonly string[];
-}
-/** Builders that match the `Flags.*()` / `Args.*()` API from oclif. */
-export declare const Flags: {
-    string<T extends FlagInput>(opts?: T): FlagDescriptor<"string"> & T;
-    boolean<T_1 extends FlagInput>(opts?: T_1): FlagDescriptor<"boolean"> & T_1;
-    integer<T_2 extends FlagInput & {
-        default?: number;
-    }>(opts?: T_2): FlagDescriptor<"integer"> & T_2;
-};
-export declare const Args: {
-    string<T extends ArgInput>(opts?: T): ArgDescriptor & T;
-};
-/**
- * Thrown when CLI argument/flag parsing or validation fails (unknown flag,
- * bad option value, missing required arg, etc.). `run()` catches this to print
- * the message and render usage instead of crashing as an uncaught exception.
- */
-export declare class CliParseError extends Error {
-    constructor(message: string);
-}
-type FlagValue<D extends FlagDescriptor> = D["kind"] extends "boolean" ? D extends {
-    default: boolean;
-} ? boolean : boolean | undefined : D["kind"] extends "integer" ? D extends {
-    default: number;
-} ? number : number | undefined : D extends {
-    multiple: true;
-} ? string[] | undefined : string | undefined;
-type ArgValue<D extends ArgDescriptor> = D extends {
-    multiple: true;
-} ? string[] | undefined : string | undefined;
-type FlagValues<T extends Record<string, FlagDescriptor>> = {
-    [K in keyof T]: FlagValue<T[K]>;
-};
-type ArgValues<T extends Record<string, ArgDescriptor>> = {
-    [K in keyof T]: ArgValue<T[K]>;
-};
-export interface ParseOutput<F extends Record<string, FlagDescriptor> = Record<string, FlagDescriptor>, A extends Record<string, ArgDescriptor> = Record<string, ArgDescriptor>> {
-    flags: FlagValues<F>;
-    args: ArgValues<A>;
-    argv: string[];
-}
-export interface CommandCtor {
-    new (argv: string[], config: CliConfig): Command;
-    description?: string;
-    hidden?: boolean;
-    strict?: boolean;
-    aliases?: string[];
-    examples?: string[];
-    flags?: Record<string, FlagDescriptor>;
-    args?: Record<string, ArgDescriptor>;
-    delegateHelp?: boolean;
-}
-/** Configuration passed to every command instance and help renderers. */
-export interface CliConfig {
-    bin: string;
-    version: string;
-    /** All registered commands keyed by their canonical name. */
-    commands: Map<string, CommandCtor>;
-}
-/** Minimal Command base matching the oclif surface we use. */
-export declare abstract class Command {
-    argv: string[];
-    config: CliConfig;
-    constructor(argv: string[], config: CliConfig);
-    abstract run(): Promise<void>;
-    /**
-     * Parse argv against the static `flags` and `args` declared on the
-     * concrete command class. Returns a typed `{ flags, args, argv }` object.
-     */
-    parse<C extends CommandCtor>(_Cmd: C): Promise<ParseOutput<NonNullable<C["flags"]> extends Record<string, FlagDescriptor> ? NonNullable<C["flags"]> : Record<string, FlagDescriptor>, NonNullable<C["args"]> extends Record<string, ArgDescriptor> ? NonNullable<C["args"]> : Record<string, ArgDescriptor>>>;
-}
-/** Render full root help: header, default command details, subcommand list. */
-export declare function renderRootHelp(config: CliConfig): void;
-/** Render help for a single command. */
-export declare function renderCommandHelp(bin: string, id: string, Cmd: CommandCtor): void;
-/** A lazily-loaded command: canonical name, loader, and optional aliases. */
-export interface CommandEntry {
-    name: string;
-    load: () => Promise<CommandCtor>;
-    aliases?: string[];
-}
-export interface RunOptions {
-    bin: string;
-    version: string;
-    argv: string[];
-    commands: CommandEntry[];
-    /** Custom help renderer. Receives fully-populated config. */
-    help?: (config: CliConfig) => Promise<void> | void;
-}
-/**
- * Main entry point — replaces `run()` from @oclif/core.
- *
- * Each command is explicitly registered with a lazy loader.
- * No filesystem scanning, no plugin system, no package.json reading.
- */
-export declare function run(opts: RunOptions): Promise<void>;
-export {};