devlyn-cli 4.2.0 → 4.2.2

package/node_modules/@inquirer/core/dist/lib/screen-manager.js

@@ -0,0 +1,84 @@
+import { stripVTControlCharacters } from 'node:util';
+import { breakLines, readlineWidth } from "./utils.js";
+import { cursorDown, cursorLeft, cursorUp, cursorTo, cursorShow, eraseLines, } from '@inquirer/ansi';
+const height = (content) => content.split('\n').length;
+const lastLine = (content) => content.split('\n').pop() ?? '';
+export default class ScreenManager {
+    // These variables are keeping information to allow correct prompt re-rendering
+    height = 0;
+    extraLinesUnderPrompt = 0;
+    cursorPos;
+    rl;
+    constructor(rl) {
+        this.rl = rl;
+        this.cursorPos = rl.getCursorPos();
+    }
+    write(content) {
+        this.rl.output.unmute();
+        this.rl.output.write(content);
+        this.rl.output.mute();
+    }
+    render(content, bottomContent = '') {
+        // Write message to screen and setPrompt to control backspace
+        const promptLine = lastLine(content);
+        const rawPromptLine = stripVTControlCharacters(promptLine);
+        // Remove the rl.line from our prompt. We can't rely on the content of
+        // rl.line (mainly because of the password prompt), so just rely on it's
+        // length.
+        let prompt = rawPromptLine;
+        if (this.rl.line.length > 0) {
+            prompt = prompt.slice(0, -this.rl.line.length);
+        }
+        this.rl.setPrompt(prompt);
+        // SetPrompt will change cursor position, now we can get correct value
+        this.cursorPos = this.rl.getCursorPos();
+        const width = readlineWidth();
+        content = breakLines(content, width);
+        bottomContent = breakLines(bottomContent, width);
+        // Manually insert an extra line if we're at the end of the line.
+        // This prevent the cursor from appearing at the beginning of the
+        // current line.
+        if (rawPromptLine.length % width === 0) {
+            content += '\n';
+        }
+        let output = content + (bottomContent ? '\n' + bottomContent : '');
+        /**
+         * Re-adjust the cursor at the correct position.
+         */
+        // We need to consider parts of the prompt under the cursor as part of the bottom
+        // content in order to correctly cleanup and re-render.
+        const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+        const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+        // Return cursor to the input position (on top of the bottomContent)
+        if (bottomContentHeight > 0)
+            output += cursorUp(bottomContentHeight);
+        // Return cursor to the initial left offset.
+        output += cursorTo(this.cursorPos.cols);
+        /**
+         * Render and store state for future re-rendering
+         */
+        this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+        this.extraLinesUnderPrompt = bottomContentHeight;
+        this.height = height(output);
+    }
+    checkCursorPos() {
+        const cursorPos = this.rl.getCursorPos();
+        if (cursorPos.cols !== this.cursorPos.cols) {
+            this.write(cursorTo(cursorPos.cols));
+            this.cursorPos = cursorPos;
+        }
+    }
+    done({ clearContent }) {
+        this.rl.setPrompt('');
+        let output = cursorDown(this.extraLinesUnderPrompt);
+        output += clearContent ? eraseLines(this.height) : '\n';
+        // Reset cursor to column 0. On Windows terminals, \n moves the cursor
+        // down without resetting the column when the rendered prompt+answer
+        // wraps past the terminal width. Without this, all subsequent output
+        // starts at the wrong horizontal offset.
+        output += cursorLeft;
+        output += cursorShow;
+        this.write(output);
+        this.rl.close();
+    }
+}

package/node_modules/@inquirer/core/dist/lib/theme.d.ts

@@ -0,0 +1,166 @@
+import type { Prettify } from '@inquirer/type';
+import { type Keybinding } from './key.ts';
+/**
+ * Union type representing the possible statuses of a prompt.
+ *
+ * -   `'loading'`: The prompt is currently loading.
+ * -   `'idle'`: The prompt is loaded and currently waiting for the user to
+ *     submit an answer.
+ * -   `'done'`: The user has submitted an answer and the prompt is finished.
+ * -   `string`: Any other string: The prompt is in a custom state.
+ */
+export type Status = 'loading' | 'idle' | 'done' | (string & {});
+type DefaultTheme = {
+    /**
+     * Prefix to prepend to the message. If a function is provided, it will be
+     * called with the current status of the prompt, and the return value will be
+     * used as the prefix.
+     *
+     * @remarks
+     * If `status === 'loading'`, this property is ignored and the spinner (styled
+     * by the `spinner` property) will be displayed instead.
+     *
+     * @defaultValue
+     * ```ts
+     * // import { styleText } from 'node:util';
+     * (status) => status === 'done' ? styleText('green', '✔') : styleText('blue', '?')
+     * ```
+     */
+    prefix: string | Prettify<Omit<Record<Status, string>, 'loading'>>;
+    /**
+     * Configuration for the spinner that is displayed when the prompt is in the
+     * `'loading'` state.
+     *
+     * We recommend the use of {@link https://github.com/sindresorhus/cli-spinners|cli-spinners} for a list of available spinners.
+     */
+    spinner: {
+        /**
+         * The time interval between frames, in milliseconds.
+         *
+         * @defaultValue
+         * ```ts
+         * 80
+         * ```
+         */
+        interval: number;
+        /**
+         * A list of frames to show for the spinner.
+         *
+         * @defaultValue
+         * ```ts
+         * ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+         * ```
+         */
+        frames: string[];
+    };
+    /**
+     * Alternative keybindings enabled for prompt navigation.
+     *
+     * @defaultValue
+     * ```ts
+     * process.env['INQUIRER_KEYBINDINGS']
+     * ```
+     */
+    keybindings: ReadonlyArray<Keybinding>;
+    /**
+     * Object containing functions to style different parts of the prompt.
+     */
+    style: {
+        /**
+         * Style to apply to the user's answer once it has been submitted.
+         *
+         * @param text - The user's answer.
+         * @returns The styled answer.
+         *
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', text)
+         * ```
+         */
+        answer: (text: string) => string;
+        /**
+         * Style to apply to the message displayed to the user.
+         *
+         * @param text - The message to style.
+         * @param status - The current status of the prompt.
+         * @returns The styled message.
+         *
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text, status) => styleText('bold', text)
+         * ```
+         */
+        message: (text: string, status: Status) => string;
+        /**
+         * Style to apply to error messages.
+         *
+         * @param text - The error message.
+         * @returns The styled error message.
+         *
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('red', `> ${text}`)
+         * ```
+         */
+        error: (text: string) => string;
+        /**
+         * Style to apply to the default answer when one is provided.
+         *
+         * @param text - The default answer.
+         * @returns The styled default answer.
+         *
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('dim', `(${text})`)
+         * ```
+         */
+        defaultAnswer: (text: string) => string;
+        /**
+         * Style to apply to help text.
+         *
+         * @param text - The help text.
+         * @returns The styled help text.
+         *
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('dim', text)
+         * ```
+         */
+        help: (text: string) => string;
+        /**
+         * Style to apply to highlighted text.
+         *
+         * @param text - The text to highlight.
+         * @returns The highlighted text.
+         *
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', text)
+         * ```
+         */
+        highlight: (text: string) => string;
+        /**
+         * Style to apply to keyboard keys referred to in help texts.
+         *
+         * @param text - The key to style.
+         * @returns The styled key.
+         *
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', styleText('bold', `<${text}>`))
+         * ```
+         */
+        key: (text: string) => string;
+    };
+};
+export type Theme<Extension extends object = object> = Extension & DefaultTheme;
+export declare const defaultTheme: DefaultTheme;
+export declare function getDefaultTheme(): DefaultTheme;
+export {};

package/node_modules/@inquirer/core/dist/lib/theme.js

@@ -0,0 +1,29 @@
+import { styleText } from 'node:util';
+import figures from '@inquirer/figures';
+import { getDefaultKeybindings } from "./key.js";
+export const defaultTheme = {
+    prefix: {
+        idle: styleText('blue', '?'),
+        done: styleText('green', figures.tick),
+    },
+    spinner: {
+        interval: 80,
+        frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'].map((frame) => styleText('yellow', frame)),
+    },
+    keybindings: [],
+    style: {
+        answer: (text) => styleText('cyan', text),
+        message: (text) => styleText('bold', text),
+        error: (text) => styleText('red', `> ${text}`),
+        defaultAnswer: (text) => styleText('dim', `(${text})`),
+        help: (text) => styleText('dim', text),
+        highlight: (text) => styleText('cyan', text),
+        key: (text) => styleText('cyan', styleText('bold', `<${text}>`)),
+    },
+};
+export function getDefaultTheme() {
+    return {
+        ...defaultTheme,
+        keybindings: getDefaultKeybindings(),
+    };
+}

package/node_modules/@inquirer/core/dist/lib/use-effect.d.ts

@@ -0,0 +1,2 @@
+import type { InquirerReadline } from '@inquirer/type';
+export declare function useEffect(cb: (rl: InquirerReadline) => void | (() => void), depArray: ReadonlyArray<unknown>): void;

package/node_modules/@inquirer/core/dist/lib/use-effect.js

@@ -0,0 +1,11 @@
+import { withPointer, effectScheduler } from "./hook-engine.js";
+export function useEffect(cb, depArray) {
+    withPointer((pointer) => {
+        const oldDeps = pointer.get();
+        const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+        if (hasChanged) {
+            effectScheduler.queue(cb);
+        }
+        pointer.set(depArray);
+    });
+}

package/node_modules/@inquirer/core/dist/lib/use-keypress.d.ts

@@ -0,0 +1,3 @@
+import { type InquirerReadline } from '@inquirer/type';
+import { type KeypressEvent } from './key.ts';
+export declare function useKeypress(userHandler: (event: KeypressEvent, rl: InquirerReadline) => void | Promise<void>): void;

package/node_modules/@inquirer/core/dist/lib/use-keypress.js

@@ -0,0 +1,20 @@
+import { useRef } from "./use-ref.js";
+import { useEffect } from "./use-effect.js";
+import { withUpdates } from "./hook-engine.js";
+export function useKeypress(userHandler) {
+    const signal = useRef(userHandler);
+    signal.current = userHandler;
+    useEffect((rl) => {
+        let ignore = false;
+        const handler = withUpdates((_input, event) => {
+            if (ignore)
+                return;
+            void signal.current(event, rl);
+        });
+        rl.input.on('keypress', handler);
+        return () => {
+            ignore = true;
+            rl.input.removeListener('keypress', handler);
+        };
+    }, []);
+}

package/node_modules/@inquirer/core/dist/lib/use-memo.d.ts

@@ -0,0 +1 @@
+export declare function useMemo<Value>(fn: () => Value, dependencies: ReadonlyArray<unknown>): Value;

package/node_modules/@inquirer/core/dist/lib/use-memo.js

@@ -0,0 +1,14 @@
+import { withPointer } from "./hook-engine.js";
+export function useMemo(fn, dependencies) {
+    return withPointer((pointer) => {
+        const prev = pointer.get();
+        if (!pointer.initialized ||
+            prev.dependencies.length !== dependencies.length ||
+            prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+            const value = fn();
+            pointer.set({ value, dependencies });
+            return value;
+        }
+        return prev.value;
+    });
+}

package/node_modules/@inquirer/core/dist/lib/use-prefix.d.ts

@@ -0,0 +1,5 @@
+import type { Theme, Status } from './theme.ts';
+export declare function usePrefix({ status, theme, }: {
+    status?: Status;
+    theme?: Theme;
+}): string;

package/node_modules/@inquirer/core/dist/lib/use-prefix.js

@@ -0,0 +1,35 @@
+import { useState } from "./use-state.js";
+import { useEffect } from "./use-effect.js";
+import { makeTheme } from "./make-theme.js";
+export function usePrefix({ status = 'idle', theme, }) {
+    const [showLoader, setShowLoader] = useState(false);
+    const [tick, setTick] = useState(0);
+    const { prefix, spinner } = makeTheme(theme);
+    useEffect(() => {
+        if (status === 'loading') {
+            let tickInterval;
+            let inc = -1;
+            // Delay displaying spinner by 300ms, to avoid flickering
+            const delayTimeout = setTimeout(() => {
+                setShowLoader(true);
+                tickInterval = setInterval(() => {
+                    inc = inc + 1;
+                    setTick(inc % spinner.frames.length);
+                }, spinner.interval);
+            }, 300);
+            return () => {
+                clearTimeout(delayTimeout);
+                clearInterval(tickInterval);
+            };
+        }
+        else {
+            setShowLoader(false);
+        }
+    }, [status]);
+    if (showLoader) {
+        return spinner.frames[tick];
+    }
+    // There's a delay before we show the loader. So we want to ignore `loading` here, and pass idle instead.
+    const iconName = status === 'loading' ? 'idle' : status;
+    return typeof prefix === 'string' ? prefix : (prefix[iconName] ?? prefix['idle']);
+}

package/node_modules/@inquirer/core/dist/lib/use-ref.d.ts

@@ -0,0 +1,6 @@
+export declare function useRef<Value>(val: Value): {
+    current: Value;
+};
+export declare function useRef<Value>(val?: Value): {
+    current: Value | undefined;
+};

package/node_modules/@inquirer/core/dist/lib/use-ref.js

@@ -0,0 +1,4 @@
+import { useState } from "./use-state.js";
+export function useRef(val) {
+    return useState({ current: val })[0];
+}

package/node_modules/@inquirer/core/dist/lib/use-state.d.ts

@@ -0,0 +1,7 @@
+type NotFunction<T> = T extends (...args: never) => unknown ? never : T;
+type Reducer<Value> = (currentValue: Value) => Value;
+type SetState<Value> = (newValue: NotFunction<Value> | Reducer<Value>) => void;
+type OptionalSetState<Value> = (newValue?: NotFunction<Value> | Reducer<Value>) => void;
+export declare function useState<Value>(defaultValue: NotFunction<Value> | (() => Value)): [Value, SetState<Value>];
+export declare function useState<Value>(defaultValue?: NotFunction<Value> | (() => Value)): [Value | undefined, OptionalSetState<Value | undefined>];
+export {};

package/node_modules/@inquirer/core/dist/lib/use-state.js

@@ -0,0 +1,28 @@
+import { AsyncResource } from 'node:async_hooks';
+import { withPointer, handleChange } from "./hook-engine.js";
+function isFactory(value) {
+    return typeof value === 'function';
+}
+function isReducer(value) {
+    return typeof value === 'function';
+}
+export function useState(defaultValue) {
+    return withPointer((pointer) => {
+        const setState = AsyncResource.bind(function setState(newValue) {
+            const currentValue = pointer.get();
+            const nextValue = isReducer(newValue) ? newValue(currentValue) : newValue;
+            // Noop if the value is still the same.
+            if (!Object.is(currentValue, nextValue)) {
+                pointer.set(nextValue);
+                // Trigger re-render
+                handleChange();
+            }
+        });
+        if (pointer.initialized) {
+            return [pointer.get(), setState];
+        }
+        const value = isFactory(defaultValue) ? defaultValue() : defaultValue;
+        pointer.set(value);
+        return [value, setState];
+    });
+}

package/node_modules/@inquirer/core/dist/lib/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Force line returns at specific width. This function is ANSI code friendly and it'll
+ * ignore invisible codes during width calculation.
+ * @param {string} content
+ * @param {number} width
+ * @return {string}
+ */
+export declare function breakLines(content: string, width: number): string;
+/**
+ * Returns the width of the active readline, or 80 as default value.
+ * @returns {number}
+ */
+export declare function readlineWidth(): number;

package/node_modules/@inquirer/core/dist/lib/utils.js

@@ -0,0 +1,25 @@
+import cliWidth from 'cli-width';
+import { wrapAnsi } from 'fast-wrap-ansi';
+import { readline } from "./hook-engine.js";
+/**
+ * Force line returns at specific width. This function is ANSI code friendly and it'll
+ * ignore invisible codes during width calculation.
+ * @param {string} content
+ * @param {number} width
+ * @return {string}
+ */
+export function breakLines(content, width) {
+    return content
+        .split('\n')
+        .flatMap((line) => wrapAnsi(line, width, { trim: false, wordWrap: false })
+        .split('\n')
+        .map((str) => str.trimEnd()))
+        .join('\n');
+}
+/**
+ * Returns the width of the active readline, or 80 as default value.
+ * @returns {number}
+ */
+export function readlineWidth() {
+    return cliWidth({ defaultWidth: 80, output: readline().output });
+}

package/node_modules/@inquirer/core/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@inquirer/core",
+  "version": "12.0.4",
+  "description": "Core Inquirer prompt API",
+  "keywords": [
+    "answer",
+    "answers",
+    "ask",
+    "base",
+    "cli",
+    "command",
+    "command-line",
+    "confirm",
+    "enquirer",
+    "generate",
+    "generator",
+    "hyper",
+    "input",
+    "inquire",
+    "inquirer",
+    "interface",
+    "iterm",
+    "javascript",
+    "menu",
+    "node",
+    "nodejs",
+    "prompt",
+    "promptly",
+    "prompts",
+    "question",
+    "readline",
+    "scaffold",
+    "scaffolder",
+    "scaffolding",
+    "stdin",
+    "stdout",
+    "terminal",
+    "tty",
+    "ui",
+    "yeoman",
+    "yo",
+    "zsh"
+  ],
+  "homepage": "https://github.com/SBoudrias/Inquirer.js/blob/main/packages/core/README.md",
+  "license": "MIT",
+  "author": "Simon Boudrias <admin@simonboudrias.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SBoudrias/Inquirer.js.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "tsc": "tsc"
+  },
+  "dependencies": {
+    "@inquirer/ansi": "^2.0.9",
+    "@inquirer/figures": "^2.0.9",
+    "@inquirer/type": "4.2.0",
+    "cli-width": "^4.1.0",
+    "fast-wrap-ansi": "^0.2.0",
+    "mute-stream": "^3.0.0",
+    "signal-exit": "^4.1.0"
+  },
+  "devDependencies": {
+    "@repo/tsconfig": "0.0.0",
+    "@types/mute-stream": "^0.0.4",
+    "@types/node": "^26.1.1",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "@types/node": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "gitHead": "a9436bd94d55a439df308f50e77a7cd0b2078e98"
+}

package/node_modules/@inquirer/figures/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2025 Simon Boudrias
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.