terminal-pilot 0.0.30 → 0.0.31

package/node_modules/toolcraft-design/dist/internal/theme-state.d.ts

@@ -0,0 +1,12 @@
+export interface ThemeConfig {
+    brand: string;
+    label: string;
+}
+export declare function configureTheme(patch: {
+    brand?: string;
+    label?: string;
+}): void;
+export declare function getThemeConfig(): ThemeConfig;
+export declare function getThemeRevision(): number;
+export declare function isThemeBrandConfigured(): boolean;
+export declare function resetTheme(): void;

package/node_modules/toolcraft-design/dist/internal/theme-state.js

@@ -0,0 +1,35 @@
+import { brands } from "../tokens/brand.js";
+const defaults = {
+    brand: "purple",
+    label: "Poe"
+};
+let config = { ...defaults };
+let revision = 0;
+let brandConfigured = false;
+export function configureTheme(patch) {
+    if (patch.brand !== undefined && !Object.hasOwn(brands, patch.brand)) {
+        throw new Error(`Unknown brand: ${patch.brand}`);
+    }
+    config = {
+        brand: patch.brand ?? config.brand,
+        label: patch.label ?? config.label
+    };
+    if (patch.brand !== undefined) {
+        brandConfigured = true;
+    }
+    revision += 1;
+}
+export function getThemeConfig() {
+    return { ...config };
+}
+export function getThemeRevision() {
+    return revision;
+}
+export function isThemeBrandConfigured() {
+    return brandConfigured;
+}
+export function resetTheme() {
+    config = { ...defaults };
+    brandConfigured = false;
+    revision += 1;
+}

package/node_modules/toolcraft-design/dist/prompts/index.d.ts

@@ -0,0 +1,91 @@
+import type { CANCEL } from "./interactive/cancel-symbol.js";
+import { type SelectOption } from "./interactive/select.js";
+import { cancel, isCancel } from "./primitives/cancel.js";
+import { intro } from "./primitives/intro.js";
+import { log } from "./primitives/log.js";
+import { note } from "./primitives/note.js";
+import { outro } from "./primitives/outro.js";
+import { spinner } from "./primitives/spinner.js";
+export { isCancel, cancel, log };
+export { intro, outro, note, spinner };
+export declare function introPlain(title: string): void;
+export interface SelectOptions<Value> {
+    message: string;
+    options: Array<SelectOption<Value>>;
+    initialValue?: Value;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function select<Value>(opts: SelectOptions<Value>): Promise<Value | typeof CANCEL>;
+export interface MultiselectOptions<Value> {
+    message: string;
+    options: Array<SelectOption<Value>>;
+    initialValues?: Value[];
+    required?: boolean;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+/**
+ * Prompts the user to select one or more values from a list.
+ *
+ * Returns the selected values as an array, or a cancellation symbol if the
+ * user cancels. Use `isCancel` to check for cancellation.
+ *
+ * @example
+ * const result = await multiselect({
+ *   message: "Pick workflows to run",
+ *   options: [{ label: "Fix Vulnerabilities", value: "fix-vulnerabilities" }],
+ *   required: true
+ * });
+ * if (!isCancel(result)) {
+ *   // result is Value[]
+ * }
+ */
+export declare function multiselect<Value>(opts: MultiselectOptions<Value>): Promise<Value[] | typeof CANCEL>;
+export interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function text(opts: TextOptions): Promise<string | typeof CANCEL>;
+export interface ConfirmOptions {
+    message: string;
+    initialValue?: boolean;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function confirm(opts: ConfirmOptions): Promise<boolean | typeof CANCEL>;
+export declare class PromptCancelledError extends Error {
+    constructor(message?: string);
+}
+export declare function confirmOrCancel(opts: ConfirmOptions): Promise<boolean>;
+export interface PasswordOptions {
+    message: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function password(opts: PasswordOptions): Promise<string | typeof CANCEL>;
+export type SpinnerOptions = {
+    start: (message?: string) => void;
+    stop: (message?: string, code?: number) => void;
+    message: (message?: string) => void;
+};
+export interface WithSpinnerOptions<T> {
+    message: string | (() => string);
+    fn: () => Promise<T>;
+    stopMessage?: (result: T) => string;
+    subtext?: (result: T) => string | undefined;
+}
+export declare function withSpinner<T>(options: WithSpinnerOptions<T>): Promise<T>;

package/node_modules/toolcraft-design/dist/prompts/index.js

@@ -0,0 +1,137 @@
+import { color } from "../components/color.js";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { stripAnsi } from "../internal/strip-ansi.js";
+import { confirmPrompt } from "./interactive/confirm.js";
+import { multiselectPrompt } from "./interactive/multiselect.js";
+import { passwordPrompt } from "./interactive/password.js";
+import { selectPrompt } from "./interactive/select.js";
+import { textPrompt } from "./interactive/text.js";
+import { cancel, isCancel } from "./primitives/cancel.js";
+import { intro } from "./primitives/intro.js";
+import { log } from "./primitives/log.js";
+import { note } from "./primitives/note.js";
+import { outro } from "./primitives/outro.js";
+import { spinner } from "./primitives/spinner.js";
+export { isCancel, cancel, log };
+export { intro, outro, note, spinner };
+export function introPlain(title) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`# ${stripAnsi(title)}\n\n`);
+        return;
+    }
+    if (format === "json") {
+        return;
+    }
+    process.stdout.write(`${color.gray("┌")}  ${title}\n`);
+}
+export async function select(opts) {
+    return selectPrompt(opts);
+}
+/**
+ * Prompts the user to select one or more values from a list.
+ *
+ * Returns the selected values as an array, or a cancellation symbol if the
+ * user cancels. Use `isCancel` to check for cancellation.
+ *
+ * @example
+ * const result = await multiselect({
+ *   message: "Pick workflows to run",
+ *   options: [{ label: "Fix Vulnerabilities", value: "fix-vulnerabilities" }],
+ *   required: true
+ * });
+ * if (!isCancel(result)) {
+ *   // result is Value[]
+ * }
+ */
+export async function multiselect(opts) {
+    return multiselectPrompt(opts);
+}
+export async function text(opts) {
+    return textPrompt(opts);
+}
+export async function confirm(opts) {
+    return confirmPrompt(opts);
+}
+export class PromptCancelledError extends Error {
+    constructor(message = "Operation cancelled.") {
+        super(message);
+        this.name = "PromptCancelledError";
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+export async function confirmOrCancel(opts) {
+    const result = await confirm(opts);
+    if (isCancel(result)) {
+        cancel("Operation cancelled.");
+        throw new PromptCancelledError();
+    }
+    return result === true;
+}
+export async function password(opts) {
+    return passwordPrompt(opts);
+}
+function formatElapsed(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s`;
+    }
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes}m ${seconds}s`;
+}
+export async function withSpinner(options) {
+    const { message, fn, stopMessage, subtext } = options;
+    const readMessage = () => (typeof message === "function" ? message() : message);
+    if (resolveOutputFormat() === "json") {
+        const result = await fn();
+        const sub = subtext ? subtext(result) : undefined;
+        if (sub) {
+            process.stdout.write(sub + "\n");
+        }
+        return result;
+    }
+    const noSpinner = process.env.POE_NO_SPINNER === "1";
+    const isTTY = process.stdout.isTTY;
+    if (noSpinner || !isTTY) {
+        const result = await fn();
+        const msg = stopMessage ? stopMessage(result) : undefined;
+        if (msg) {
+            process.stdout.write(`${color.green("◆")}  ${msg}\n`);
+        }
+        const sub = subtext ? subtext(result) : undefined;
+        if (sub) {
+            for (const line of sub.split("\n")) {
+                process.stdout.write(`${color.gray("│")}     ${line}\n`);
+            }
+        }
+        return result;
+    }
+    const s = spinner();
+    const start = Date.now();
+    s.start(readMessage());
+    const timer = setInterval(() => {
+        s.message(`${readMessage()} [${formatElapsed(Date.now() - start)}]`);
+    }, 1000);
+    try {
+        const result = await fn();
+        clearInterval(timer);
+        const elapsed = formatElapsed(Date.now() - start);
+        const msg = stopMessage ? stopMessage(result) : undefined;
+        s.stop(msg ? `${msg} [${elapsed}]` : `Done [${elapsed}]`);
+        const sub = subtext ? subtext(result) : undefined;
+        if (sub) {
+            for (const line of sub.split("\n")) {
+                process.stdout.write(`${color.gray("│")}     ${line}\n`);
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        clearInterval(timer);
+        s.stop("", 1);
+        throw error;
+    }
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/cancel-symbol.d.ts

@@ -0,0 +1,2 @@
+export declare const CANCEL: unique symbol;
+export declare function isCancel(value: unknown): value is typeof CANCEL;

package/node_modules/toolcraft-design/dist/prompts/interactive/cancel-symbol.js

@@ -0,0 +1,4 @@
+export const CANCEL = Symbol.for("poe.cancel");
+export function isCancel(value) {
+    return value === CANCEL;
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/confirm.d.ts

@@ -0,0 +1,9 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface ConfirmOptions {
+    message: string;
+    initialValue?: boolean;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function confirmPrompt(opts: ConfirmOptions): Promise<boolean | typeof CANCEL>;

package/node_modules/toolcraft-design/dist/prompts/interactive/confirm.js

@@ -0,0 +1,47 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol, symbolBar } from "./glyphs.js";
+import { Prompt } from "./core.js";
+class ConfirmPrompt extends Prompt {
+    constructor(opts) {
+        super({
+            ...opts,
+            initialValue: opts.initialValue ?? true,
+            render: (prompt) => renderConfirmPrompt(prompt, opts)
+        }, false);
+        this.on("confirm", (value) => {
+            this.setValue(value);
+            this.state = "submit";
+            this.emit("finalize");
+            this.render();
+            this.close();
+        });
+        this.on("cursor", (action) => {
+            if (action === "up" || action === "down" || action === "left" || action === "right") {
+                this.setValue(!this.value);
+            }
+        });
+    }
+    promptNonTty() {
+        if (process.env.POE_NO_PROMPT === "1") {
+            return Promise.resolve(this.value ?? true);
+        }
+        return super.promptNonTty();
+    }
+}
+function choices(value) {
+    const yes = value ? `${color.green(GLYPHS.radioActive)} ${color.bold("Yes")}` : `${color.dim(GLYPHS.radioInactive)} ${color.dim("Yes")}`;
+    const no = value ? `${color.dim(GLYPHS.radioInactive)} ${color.dim("No")}` : `${color.green(GLYPHS.radioActive)} ${color.bold("No")}`;
+    return `${yes} ${color.dim("/")} ${no}`;
+}
+function renderConfirmPrompt(prompt, opts) {
+    if (prompt.state === "submit") {
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${color.dim(prompt.value ? "Yes" : "No")}\n${color.green(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "cancel") {
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(prompt.value ? "Yes" : "No")}\n${color.red(GLYPHS.barEnd)}`;
+    }
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${symbolBar(prompt.state)}  ${choices(prompt.value)}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function confirmPrompt(opts) {
+    return new ConfirmPrompt(opts).prompt();
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/core.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter } from "node:events";
+import { CANCEL } from "./cancel-symbol.js";
+export type PromptStateName = "initial" | "active" | "submit" | "cancel" | "error";
+export interface PromptState<Value> {
+    state: PromptStateName;
+    value: Value | undefined;
+    error: string;
+    cursor: number;
+    userInput: string;
+}
+export interface PromptOptions<Value> {
+    render: (state: Prompt<Value>) => string;
+    initialValue?: Value;
+    initialUserInput?: string;
+    validate?: (value: Value | undefined) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+type InputStream = NodeJS.ReadableStream & {
+    isTTY?: boolean;
+    setRawMode?: (enabled: boolean) => void;
+    unpipe?: () => void;
+};
+export declare class Prompt<Value> extends EventEmitter {
+    state: PromptStateName;
+    value: Value | undefined;
+    error: string;
+    userInput: string;
+    protected _cursor: number;
+    protected input: InputStream;
+    protected output: NodeJS.WritableStream;
+    private readonly renderFrame;
+    private readonly validate?;
+    private readonly signal?;
+    private readonly trackValue;
+    private previousFrame;
+    private readlineInterface?;
+    private abortListener?;
+    private closed;
+    constructor(opts: PromptOptions<Value>, trackValue?: boolean);
+    get cursor(): number;
+    prompt(): Promise<Value | typeof CANCEL>;
+    protected promptNonTty(): Promise<Value | typeof CANCEL>;
+    protected readNonTtyLine(): Promise<string>;
+    protected setValue(value: Value | undefined): void;
+    protected setError(message: string): void;
+    protected setUserInput(value: string): void;
+    protected clearUserInput(): void;
+    private readonly onKeypress;
+    private updateTrackedInput;
+    protected readonly render: () => void;
+    protected close(): void;
+}
+export {};

package/node_modules/toolcraft-design/dist/prompts/interactive/core.js

@@ -0,0 +1,274 @@
+import { EventEmitter } from "node:events";
+import * as readline from "node:readline";
+import { CANCEL } from "./cancel-symbol.js";
+import { mapKey } from "./keys.js";
+import { wrapFrame } from "./wrap.js";
+const cursor = {
+    hide: "\x1b[?25l",
+    show: "\x1b[?25h",
+    move: (x, y) => {
+        let output = "";
+        if (x < 0)
+            output += `\x1b[${-x}D`;
+        if (x > 0)
+            output += `\x1b[${x}C`;
+        if (y < 0)
+            output += `\x1b[${-y}A`;
+        if (y > 0)
+            output += `\x1b[${y}B`;
+        return output;
+    }
+};
+const erase = {
+    down: "\x1b[J"
+};
+export class Prompt extends EventEmitter {
+    state = "initial";
+    value;
+    error = "";
+    userInput = "";
+    _cursor = 0;
+    input;
+    output;
+    renderFrame;
+    validate;
+    signal;
+    trackValue;
+    previousFrame = "";
+    readlineInterface;
+    abortListener;
+    closed = false;
+    constructor(opts, trackValue = true) {
+        super();
+        this.input = (opts.input ?? process.stdin);
+        this.output = opts.output ?? process.stdout;
+        this.renderFrame = opts.render;
+        this.validate = opts.validate;
+        this.signal = opts.signal;
+        this.value = opts.initialValue;
+        this.trackValue = trackValue;
+        this.userInput = opts.initialUserInput ?? "";
+        this._cursor = this.userInput.length;
+    }
+    get cursor() {
+        return this._cursor;
+    }
+    prompt() {
+        if (this.signal?.aborted) {
+            this.state = "cancel";
+            return Promise.resolve(CANCEL);
+        }
+        if (this.input.isTTY !== true) {
+            return this.promptNonTty();
+        }
+        return new Promise((resolve) => {
+            const onSubmit = (value) => resolve(value);
+            const onCancel = () => resolve(CANCEL);
+            this.once("submit", onSubmit);
+            this.once("cancel", onCancel);
+            this.abortListener = () => {
+                this.state = "cancel";
+                this.emit("finalize");
+                this.render();
+                this.close();
+            };
+            this.signal?.addEventListener("abort", this.abortListener, { once: true });
+            this.readlineInterface = readline.createInterface({
+                input: this.input,
+                output: undefined,
+                tabSize: 2,
+                prompt: "",
+                escapeCodeTimeout: 50,
+                terminal: true
+            });
+            readline.emitKeypressEvents(this.input, this.readlineInterface);
+            this.readlineInterface.prompt();
+            this.input.on("keypress", this.onKeypress);
+            if (this.input.setRawMode) {
+                this.input.setRawMode(true);
+            }
+            this.output.on("resize", this.render);
+            this.render();
+        });
+    }
+    promptNonTty() {
+        return Promise.reject(new Error("Interactive prompt requires a TTY. Set POE_NO_PROMPT=1 to accept defaults non-interactively."));
+    }
+    readNonTtyLine() {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({ input: this.input, terminal: false });
+            let settled = false;
+            const settle = (value) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                rl.close();
+                resolve(value);
+            };
+            rl.once("line", settle);
+            rl.once("close", () => settle(rl.line));
+        });
+    }
+    setValue(value) {
+        this.value = value;
+        this.emit("value", value);
+    }
+    setError(message) {
+        this.error = message;
+    }
+    setUserInput(value) {
+        this.userInput = value;
+        this._cursor = Math.min(this._cursor, this.userInput.length);
+        this.emit("userInput", this.userInput);
+    }
+    clearUserInput() {
+        this.userInput = "";
+        this._cursor = 0;
+        this.emit("userInput", this.userInput);
+    }
+    onKeypress = (char, key = {}) => {
+        let action = mapKey(key.name, char);
+        if (this.trackValue && char && char >= " " && key.name !== "return" && key.name !== "enter" && key.name !== "escape") {
+            action = undefined;
+        }
+        if (this.trackValue && action !== "enter") {
+            this.updateTrackedInput(char, key, action);
+        }
+        if (this.state === "error") {
+            this.state = "active";
+            this.error = "";
+        }
+        if (!this.trackValue && action) {
+            this.emit("cursor", action);
+        }
+        else if (this.trackValue && action && action !== "enter") {
+            this.emit("cursor", action);
+        }
+        if (char && /^[yn]$/i.test(char)) {
+            this.emit("confirm", char.toLowerCase() === "y");
+        }
+        if (char) {
+            this.emit("key", char.toLowerCase(), key);
+        }
+        if (action === "enter") {
+            const error = this.validate?.(this.value);
+            if (error) {
+                this.error = error instanceof Error ? error.message : error;
+                this.state = "error";
+            }
+            else {
+                this.state = "submit";
+            }
+        }
+        if (action === "cancel") {
+            this.state = "cancel";
+        }
+        if (this.state === "submit" || this.state === "cancel") {
+            this.emit("finalize");
+        }
+        this.render();
+        if (this.state === "submit" || this.state === "cancel") {
+            this.close();
+        }
+    };
+    updateTrackedInput(char, key, action) {
+        if (key.ctrl) {
+            if (key.name === "a") {
+                this._cursor = 0;
+                return;
+            }
+            if (key.name === "e") {
+                this._cursor = this.userInput.length;
+                return;
+            }
+            if (key.name === "u") {
+                this.userInput = this.userInput.slice(this._cursor);
+                this._cursor = 0;
+                this.emit("userInput", this.userInput);
+                return;
+            }
+            if (key.name === "k") {
+                this.userInput = this.userInput.slice(0, this._cursor);
+                this.emit("userInput", this.userInput);
+                return;
+            }
+        }
+        if (action === "left") {
+            this._cursor = Math.max(0, this._cursor - 1);
+            return;
+        }
+        if (action === "right") {
+            this._cursor = Math.min(this.userInput.length, this._cursor + 1);
+            return;
+        }
+        if (action === "cancel" || action === "up" || action === "down" || action === "space") {
+            return;
+        }
+        if (key.name === "backspace" || char === "\b" || char === "\x7f") {
+            if (this._cursor > 0) {
+                this.userInput = `${this.userInput.slice(0, this._cursor - 1)}${this.userInput.slice(this._cursor)}`;
+                this._cursor -= 1;
+                this.emit("userInput", this.userInput);
+            }
+            return;
+        }
+        if (key.name === "delete") {
+            if (this._cursor < this.userInput.length) {
+                this.userInput = `${this.userInput.slice(0, this._cursor)}${this.userInput.slice(this._cursor + 1)}`;
+                this.emit("userInput", this.userInput);
+            }
+            return;
+        }
+        if (!char || char < " " || key.ctrl) {
+            return;
+        }
+        this.userInput = `${this.userInput.slice(0, this._cursor)}${char}${this.userInput.slice(this._cursor)}`;
+        this._cursor += char.length;
+        this.emit("userInput", this.userInput);
+    }
+    render = () => {
+        if (this.closed) {
+            return;
+        }
+        const frame = wrapFrame(this.output, this.renderFrame(this) ?? "");
+        if (frame === this.previousFrame) {
+            return;
+        }
+        if (!this.previousFrame) {
+            this.output.write(`${cursor.hide}${frame}`);
+            this.previousFrame = frame;
+            if (this.state === "initial") {
+                this.state = "active";
+            }
+            return;
+        }
+        const previousLineCount = this.previousFrame.split("\n").length - 1;
+        this.output.write(`${cursor.move(-999, -previousLineCount)}${erase.down}${frame}`);
+        this.previousFrame = frame;
+    };
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.input.removeListener("keypress", this.onKeypress);
+        this.output.removeListener("resize", this.render);
+        if (this.abortListener) {
+            this.signal?.removeEventListener("abort", this.abortListener);
+        }
+        this.output.write(`${cursor.show}\n`);
+        if (!process.platform.startsWith("win") && this.input.setRawMode) {
+            this.input.setRawMode(false);
+        }
+        this.readlineInterface?.close();
+        this.input.unpipe?.();
+        if (this.state === "cancel") {
+            this.emit("cancel");
+        }
+        else {
+            this.emit("submit", this.value);
+        }
+        this.removeAllListeners();
+    }
+}