@super-protocol/sp-cli 0.0.6 → 0.0.8

package/dist/utils/prompt-flags.js

@@ -0,0 +1,121 @@
+import { promptService } from './prompt.service.js';
+const getSampleValue = (definition) => {
+    if (typeof definition.min === 'number') {
+        return String(definition.min);
+    }
+    if (typeof definition.max === 'number' && definition.max < 1) {
+        return String(definition.max);
+    }
+    return '1';
+};
+const inferTypeFromDefinition = async (definition, allowNo) => {
+    if (definition && typeof definition === 'object') {
+        const typedDefinition = definition;
+        if (typedDefinition.type === 'boolean' || typedDefinition.type === 'flag') {
+            return 'boolean';
+        }
+        if (typedDefinition.type === 'integer' || typedDefinition.type === 'number') {
+            return 'integer';
+        }
+        if (allowNo && typeof typedDefinition.allowNo === 'boolean') {
+            return 'boolean';
+        }
+    }
+    const parse = definition?.parse;
+    if (typeof parse === 'function') {
+        const sample = getSampleValue(definition);
+        try {
+            const parsed = await parse(sample, {}, definition);
+            if (typeof parsed === 'number') {
+                return 'integer';
+            }
+            if (typeof parsed === 'boolean') {
+                return 'boolean';
+            }
+        }
+        catch {
+            // Ignore parsing errors for type inference.
+        }
+    }
+    return 'string';
+};
+const parseIntegerValue = (name, input, definition) => {
+    if (!/^-?\d+$/.test(input)) {
+        throw new Error(`${name} must be a number`);
+    }
+    const num = Number.parseInt(input, 10);
+    if (definition.min !== undefined && num < definition.min) {
+        throw new Error(`Expected an integer greater than or equal to ${definition.min} but received: ${input}`);
+    }
+    if (definition.max !== undefined && num > definition.max) {
+        throw new Error(`Expected an integer less than or equal to ${definition.max} but received: ${input}`);
+    }
+    return num;
+};
+const getFlagType = async (definition) => inferTypeFromDefinition(definition, true);
+export const findMissingRequiredFlags = async (flags, flagDefinitions) => {
+    if (!flagDefinitions) {
+        return [];
+    }
+    const missing = [];
+    for (const [name, definition] of Object.entries(flagDefinitions)) {
+        if (definition.required && (flags[name] === undefined || flags[name] === null)) {
+            missing.push({
+                name,
+                definition,
+                type: await getFlagType(definition),
+            });
+        }
+    }
+    return missing;
+};
+const getArgType = async (definition) => inferTypeFromDefinition(definition, false);
+export const findMissingRequiredArgs = async (args, argDefinitions) => {
+    if (!argDefinitions) {
+        return [];
+    }
+    const missing = [];
+    for (const [name, definition] of Object.entries(argDefinitions)) {
+        if (definition.required && (args[name] === undefined || args[name] === null)) {
+            missing.push({
+                name,
+                definition,
+                type: await getArgType(definition),
+            });
+        }
+    }
+    return missing;
+};
+export const promptForFlag = async (missingFlag) => {
+    const description = missingFlag.definition.description;
+    const optionValues = missingFlag.definition.options;
+    if (missingFlag.type === 'string' && Array.isArray(optionValues) && optionValues.length > 0) {
+        const message = description ? `Select ${description}` : `Select ${missingFlag.name}`;
+        return promptService.select({
+            message,
+            options: optionValues.map((value) => ({
+                label: value,
+                value,
+            })),
+        });
+    }
+    const parseValue = missingFlag.type === 'integer'
+        ? (input) => parseIntegerValue(missingFlag.name, input, missingFlag.definition)
+        : undefined;
+    return promptService.promptForValue(missingFlag.name, description, missingFlag.type, parseValue);
+};
+export const promptForArg = async (missingArg) => {
+    const description = missingArg.definition.description;
+    const parseValue = missingArg.type === 'integer'
+        ? (input) => parseIntegerValue(missingArg.name, input, missingArg.definition)
+        : undefined;
+    return promptService.promptForValue(missingArg.name, description, missingArg.type, parseValue);
+};
+export const formatMissingFlagsError = (missingFlags) => {
+    const flagNames = missingFlags.map((f) => `--${f.name}`).join(', ');
+    return `Missing required flags: ${flagNames}. Please provide them or run in interactive mode.`;
+};
+export const formatMissingArgsError = (missingArgs) => {
+    const argNames = missingArgs.map((a) => `<${a.name}>`).join(', ');
+    return `Missing required arguments: ${argNames}. Please provide them or run in interactive mode.`;
+};

package/dist/utils/prompt.service.d.ts

@@ -0,0 +1,16 @@
+import { type ConfirmOptions as ClackConfirmOptions, type PasswordOptions as ClackPasswordOptions, type SelectOptions as ClackSelectOptions, type TextOptions as ClackTextOptions } from '@clack/prompts';
+export type TextOptions = ClackTextOptions;
+export type ConfirmOptions = ClackConfirmOptions;
+export type SelectOptions<T> = ClackSelectOptions<T>;
+export type PasswordOptions = ClackPasswordOptions;
+type ParseValue = (input: string) => string | number | boolean;
+export declare class PromptService {
+    text(options: ClackTextOptions): Promise<string>;
+    confirm(options: ClackConfirmOptions): Promise<boolean>;
+    select<T>(options: ClackSelectOptions<T>): Promise<T>;
+    password(options: ClackPasswordOptions): Promise<string>;
+    ensureValue<T>(value: symbol | T, errorMessage?: string): T;
+    promptForValue(name: string, description: string | undefined, type: 'string' | 'integer' | 'boolean', parseValue?: ParseValue): Promise<string | number | boolean>;
+}
+export declare const promptService: PromptService;
+export {};

package/dist/utils/prompt.service.js

@@ -0,0 +1,75 @@
+import { confirm as clackConfirm, password as clackPassword, select as clackSelect, text as clackText, isCancel, } from '@clack/prompts';
+export class PromptService {
+    async text(options) {
+        const result = await clackText(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async confirm(options) {
+        const result = await clackConfirm(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async select(options) {
+        const result = await clackSelect(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async password(options) {
+        const result = await clackPassword(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    ensureValue(value, errorMessage = 'Operation cancelled.') {
+        if (isCancel(value)) {
+            throw new Error(errorMessage);
+        }
+        return value;
+    }
+    async promptForValue(name, description, type, parseValue) {
+        const fullDescription = description ? ` (${description})` : '';
+        if (type === 'boolean') {
+            const message = `Enable ${name}${fullDescription}?`;
+            return await this.confirm({ message });
+        }
+        const message = `Please provide ${name}${fullDescription}:`;
+        const parseInput = (value) => {
+            if (parseValue) {
+                return parseValue(value);
+            }
+            if (type === 'integer') {
+                const num = Number.parseInt(value, 10);
+                if (Number.isNaN(num)) {
+                    throw new Error(`${name} must be a number`);
+                }
+                return num;
+            }
+            return value;
+        };
+        const result = await this.text({
+            message,
+            validate: (value) => {
+                if (!value || value.trim() === '') {
+                    return `${name} is required`;
+                }
+                try {
+                    parseInput(value);
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : String(error);
+                }
+                return;
+            },
+        });
+        return parseInput(result);
+    }
+}
+export const promptService = new PromptService();

package/dist/utils/tty.d.ts

@@ -0,0 +1 @@
+export declare const isInteractiveMode: (ttyFlag?: boolean) => boolean;

package/dist/utils/tty.js

@@ -0,0 +1,3 @@
+export const isInteractiveMode = (ttyFlag) => {
+    return ttyFlag ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+};