@unscientificjszhai/howto 1.0.0-alpha.2

package/dist/init/index.js

@@ -0,0 +1,146 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { input as promptInput, select } from "@inquirer/prompts";
+import { DEFAULT_GEMINI_MODEL, DEFAULT_OPENAI_MODEL, loadConfig } from "../config.js";
+import { getConfigFilePath, writeUserConfigFile } from "../config-file.js";
+import { InteractionCancelledError } from "../ui/tty.js";
+export function initializeConfig(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ cliOptions, env, input, output, }) {
+        try {
+            let initializationRows = 0;
+            const introduction = "howto needs an AI provider before it can call AI.\n\n";
+            output.write(introduction);
+            initializationRows += countTerminalRows(output, introduction);
+            const values = yield collectInitializationValues(input, output);
+            initializationRows += countInitializationPromptRows(output, values);
+            const fileConfig = createFileConfig(values);
+            const configFilePath = getConfigFilePath(env);
+            yield writeUserConfigFile(fileConfig, configFilePath);
+            const savedMessage = `\nSaved howto configuration to ${configFilePath}.\n`;
+            output.write(savedMessage);
+            initializationRows += countTerminalRows(output, savedMessage);
+            yield promptInput({ message: "Press Enter to start..." }, { input, output });
+            initializationRows += countTerminalRows(output, "✔ Press Enter to start...\n");
+            clearInitializationOutput(output, initializationRows);
+            return loadConfig(cliOptions, env, fileConfig);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                (error.name === "ExitPromptError" || error.message.includes("force closed"))) {
+                throw new InteractionCancelledError();
+            }
+            throw error;
+        }
+    });
+}
+export function clearInitializationOutput(output, rows) {
+    if (output.isTTY) {
+        output.write(erasePreviousTerminalRows(rows));
+    }
+}
+export function erasePreviousTerminalRows(rows) {
+    if (rows <= 0) {
+        return "";
+    }
+    let sequence = "\x1b[2K";
+    for (let row = 0; row < rows; row += 1) {
+        sequence += "\x1b[1A\x1b[2K";
+    }
+    return `${sequence}\x1b[G`;
+}
+export function countInitializationPromptRows(output, values) {
+    var _a;
+    const promptLines = values.provider === "gemini"
+        ? [
+            "✔ Choose AI provider: gemini",
+            `✔ Gemini API key: ${values.apiKey}`,
+            `✔ Gemini model: ${values.model}`,
+        ]
+        : [
+            "✔ Choose AI provider: openai",
+            `✔ OpenAI API key (optional): ${values.apiKey}`,
+            `✔ OpenAI model: ${values.model}`,
+            `✔ OpenAI base URL (optional, Enter for official default): ${(_a = values.openaiBaseUrl) !== null && _a !== void 0 ? _a : ""}`,
+        ];
+    return promptLines.reduce((rows, line) => rows + countTerminalRows(output, `${line}\n`), 0);
+}
+export function countTerminalRows(output, text) {
+    const columns = getOutputColumns(output);
+    const lines = text.split("\n");
+    let rows = 0;
+    lines.forEach((line, index) => {
+        const isFinalLine = index === lines.length - 1;
+        if (isFinalLine && line === "") {
+            return;
+        }
+        rows += Math.max(1, Math.ceil(line.length / columns));
+    });
+    return rows;
+}
+function getOutputColumns(output) {
+    const { columns } = output;
+    return typeof columns === "number" && columns > 0 ? columns : 80;
+}
+export function createFileConfig(values) {
+    if (values.provider === "gemini") {
+        return {
+            aiProvider: "gemini",
+            geminiApiKey: values.apiKey,
+            geminiModel: values.model,
+        };
+    }
+    const config = {
+        aiProvider: "openai",
+        openaiApiKey: values.apiKey,
+        openaiModel: values.model,
+    };
+    if (values.openaiBaseUrl !== undefined) {
+        config.openaiApiUrl = values.openaiBaseUrl;
+    }
+    return config;
+}
+function collectInitializationValues(input, output) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const provider = yield select({
+            message: "Choose AI provider:",
+            choices: [
+                { name: "openai", value: "openai" },
+                { name: "gemini", value: "gemini" },
+            ],
+        }, { input, output });
+        if (provider === "gemini") {
+            const apiKey = yield promptInput({
+                message: "Gemini API key:",
+                validate: (val) => (val.trim() !== "" ? true : "This value is required."),
+            }, { input, output });
+            const model = yield promptInput({
+                message: "Gemini model:",
+                default: DEFAULT_GEMINI_MODEL,
+            }, { input, output });
+            return { provider, apiKey, model };
+        }
+        const apiKey = yield promptInput({
+            message: "OpenAI API key (optional):",
+        }, { input, output });
+        const model = yield promptInput({
+            message: "OpenAI model:",
+            default: DEFAULT_OPENAI_MODEL,
+        }, { input, output });
+        const baseUrl = yield promptInput({
+            message: "OpenAI base URL (optional, Enter for official default):",
+        }, { input, output });
+        return {
+            provider,
+            apiKey,
+            model,
+            openaiBaseUrl: baseUrl.trim() === "" ? undefined : baseUrl,
+        };
+    });
+}

package/dist/prompt.js

@@ -0,0 +1,55 @@
+export const OUTPUT_CONTRACT = `Return exactly one JSON object and no natural-language body, markdown, or code fences.
+The JSON object must match this schema:
+{
+  "commands": [
+    {
+      "title": "non-empty string",
+      "command": "non-empty shell command string",
+      "description": "non-empty string",
+      "placeholders": [
+        {
+          "name": "non-empty string using only letters, numbers, underscores, or hyphens",
+          "description": "non-empty string"
+        }
+      ]
+    }
+  ]
+}
+The commands array must contain 1 to 3 items. Do not return more than 3 candidate commands.
+Detect the primary natural language of the user's question. Return title, description, and placeholders[].description in that language. Keep placeholder name values English-compatible ASCII using only letters, numbers, underscores, or hyphens.
+Use placeholders in commands only as {{name}}, and declare every placeholder in the placeholders array. User may provide argument. If the user's intent is clear, try to use the provided arguments as parameters in the generated commands instead of placeholders. If the intent is unclear, do not fill them.`;
+export const SAFETY_CONSTRAINTS = `Prefer read-only, reversible, and low-risk commands.
+When a task could involve deletion, overwrite, privilege escalation, network download, or executing downloaded content, prefer a safer alternative or inspection command when possible.
+Do not include safety metadata or claim that a command is safe; the local CLI will perform its own validation and dangerous-command checks.`;
+export function createProviderPromptRequest(request) {
+    return {
+        question: request.question,
+        arguments: request.arguments,
+        useCommand: request.useCommand,
+        outputContract: OUTPUT_CONTRACT,
+        safetyConstraints: SAFETY_CONSTRAINTS,
+    };
+}
+export function buildCommandGenerationPrompt(request) {
+    const systemLines = [
+        "You are generating shell command candidates for a CLI named howto.",
+        "",
+        "Output contract:",
+        request.outputContract,
+        "",
+        "Safety constraints:",
+        request.safetyConstraints,
+    ];
+    const userLines = ["User request:", `question: ${JSON.stringify(request.question)}`];
+    if (request.useCommand !== undefined) {
+        userLines.push(`useCommand: ${JSON.stringify(request.useCommand)}`);
+        userLines.push(`The user specified use <command>: ${JSON.stringify(request.useCommand)}. Generate candidate commands only around this command-line tool. Each candidate command must clearly use ${JSON.stringify(request.useCommand)} as the requested tool.`);
+    }
+    if (request.arguments && request.arguments.length > 0) {
+        userLines.push(`argument: ${JSON.stringify(request.arguments)}`);
+    }
+    return {
+        systemPrompt: systemLines.join("\n"),
+        userPrompt: userLines.join("\n"),
+    };
+}

package/dist/safety/dangerous-command.js

@@ -0,0 +1,104 @@
+const SHELL_COMMAND_PREFIX = String.raw `(?:^|[;&|]\s*|\|\s*)`;
+const SUDO_PREFIX = String.raw `(?:sudo\s+)?`;
+const COMMAND_PREFIX = `${SHELL_COMMAND_PREFIX}${SUDO_PREFIX}`;
+const RISKY_TARGET_PATTERN = /(^|\s)(?:\/|~(?:\/|\s|$)|\*|\.\.\/|\.\/\*|\/(?:bin|boot|dev|etc|home|lib|opt|private|sbin|System|usr|var)(?:\/|\s|$))/;
+const RULES = [
+    {
+        name: "destructive-rm",
+        reason: "recursive or forced rm against a high-risk target",
+        matches(command) {
+            return findCommandSegments(command, "rm").some((segment) => {
+                const hasDangerousFlag = /(^|\s)(?:-[A-Za-z]*[rRfF][A-Za-z]*|--recursive|--force)(\s|$)/.test(segment);
+                return hasDangerousFlag && RISKY_TARGET_PATTERN.test(segment);
+            });
+        },
+    },
+    {
+        name: "disk-filesystem-operation",
+        reason: "disk, partition, filesystem, or raw block-device operation",
+        matches(command) {
+            return (new RegExp(`${COMMAND_PREFIX}(?:mkfs(?:\\.[\\w-]+)?|fdisk|parted)(?:\\s|$)`).test(command) ||
+                new RegExp(`${COMMAND_PREFIX}diskutil\\s+erase\\w*\\b`).test(command) ||
+                new RegExp(`${COMMAND_PREFIX}dd\\s+[^;&|]*\\bif=\\S+\\s+[^;&|]*\\bof=/dev/\\S*`).test(command));
+        },
+    },
+    {
+        name: "recursive-permission-ownership-change",
+        reason: "recursive chmod or chown against a high-risk target",
+        matches(command) {
+            return findCommandSegments(command, "(?:chmod|chown)").some((segment) => {
+                const hasRecursiveFlag = /(^|\s)(?:-[A-Za-z]*R[A-Za-z]*|--recursive)(\s|$)/.test(segment);
+                return hasRecursiveFlag && RISKY_TARGET_PATTERN.test(segment);
+            });
+        },
+    },
+    {
+        name: "download-and-execute",
+        reason: "network download piped or redirected directly into a shell",
+        matches(command) {
+            return (/\b(?:curl|wget)\b[^|;&]*\|\s*(?:sudo\s+)?(?:sh|bash|zsh)\b/.test(command) ||
+                /\b(?:sh|bash|zsh)\s+<\(\s*(?:curl|wget)\b/.test(command) ||
+                /\bwget\b[^|;&]*\s+-O-\s*\|\s*(?:sudo\s+)?(?:sh|bash|zsh)\b/.test(command));
+        },
+    },
+    {
+        name: "package-manager-high-impact-operation",
+        reason: "package manager upgrade, uninstall, or global install operation",
+        matches(command) {
+            return (new RegExp(`${COMMAND_PREFIX}(?:apt|apt-get|yum|dnf)\\s+(?:dist-upgrade|full-upgrade|upgrade|remove|purge|autoremove)\\b`).test(command) ||
+                new RegExp(`${COMMAND_PREFIX}brew\\s+(?:upgrade|uninstall|remove)\\b`).test(command) ||
+                new RegExp(`${COMMAND_PREFIX}npm\\s+(?:install|uninstall|remove|rm)\\b[^;&|]*(?:^|\\s)(?:-g|--global)(?:\\s|$)`).test(command) ||
+                new RegExp(`${COMMAND_PREFIX}(?:pip|pip3)\\s+(?:install|uninstall)\\b[^;&|]*(?:^|\\s)(?:-g|--user|--break-system-packages)(?:\\s|$)`).test(command));
+        },
+    },
+    {
+        name: "system-service-high-impact-operation",
+        reason: "system service stop, disable, restart, or configuration operation",
+        matches(command) {
+            return new RegExp(`${COMMAND_PREFIX}(?:systemctl|service|launchctl)\\s+(?:stop|disable|restart|reload|unload|bootout|remove)\\b`).test(command);
+        },
+    },
+];
+export function detectDangerousCommand(command) {
+    const normalizedCommand = normalizeCommand(command);
+    const commandsToCheck = [normalizedCommand, ...extractSudoShellCommands(normalizedCommand)];
+    for (const commandToCheck of commandsToCheck) {
+        for (const rule of RULES) {
+            if (rule.matches(commandToCheck)) {
+                return {
+                    rule: rule.name,
+                    reason: rule.reason,
+                };
+            }
+        }
+    }
+    return undefined;
+}
+export function isDangerousCommand(command) {
+    return detectDangerousCommand(command) !== undefined;
+}
+function normalizeCommand(command) {
+    return command.replace(/\s+/g, " ").trim();
+}
+function extractSudoShellCommands(command) {
+    var _a, _b;
+    const matcher = /\bsudo\s+(?:sh|bash|zsh)\s+-c\s+(?:"([^"]*)"|'([^']*)'|(\S+))/g;
+    const commands = [];
+    let match;
+    while ((match = matcher.exec(command)) !== null) {
+        const shellCommand = (_b = (_a = match[1]) !== null && _a !== void 0 ? _a : match[2]) !== null && _b !== void 0 ? _b : match[3];
+        if (shellCommand !== undefined) {
+            commands.push(normalizeCommand(shellCommand));
+        }
+    }
+    return commands;
+}
+function findCommandSegments(command, commandNamePattern) {
+    const matcher = new RegExp(`${COMMAND_PREFIX}${commandNamePattern}\\b([^;&|]*)`, "g");
+    const segments = [];
+    let match;
+    while ((match = matcher.exec(command)) !== null) {
+        segments.push(match[0]);
+    }
+    return segments;
+}

package/dist/ui/App.js

@@ -0,0 +1,93 @@
+import React, { useState, useEffect } from "react";
+import { Box, Text, useWindowSize } from "ink";
+import { LoadingView } from "./LoadingView.js";
+import { SelectCommandView } from "./SelectCommandView.js";
+import { ResolvePlaceholdersView } from "./ResolvePlaceholdersView.js";
+import { ConfirmView } from "./ConfirmView.js";
+import { parseAndValidateAiResponse } from "../validation/ai-response.js";
+import { validateUseCommandCandidates } from "../validation/command-tool.js";
+import { detectDangerousCommand } from "../safety/dangerous-command.js";
+import { replaceCommandPlaceholders } from "./placeholder-logic.js";
+import { InteractionCancelledError } from "./tty.js";
+export const App = ({ provider, request, useCommand, onSuccess, onError }) => {
+    const { rows } = useWindowSize();
+    const [status, setStatus] = useState("loading");
+    const [candidates, setCandidates] = useState([]);
+    const [selectedCandidate, setSelectedCandidate] = useState(null);
+    const [resolvedValues, setResolvedValues] = useState(new Map());
+    const [finalCommand, setFinalCommand] = useState("");
+    const [danger, setDanger] = useState(undefined);
+    const [errorMessage, setErrorMessage] = useState("");
+    useEffect(() => {
+        if (status === "loading") {
+            provider
+                .generateCommands(request)
+                .then((result) => {
+                const aiResponse = parseAndValidateAiResponse(result.rawText);
+                validateUseCommandCandidates(aiResponse, useCommand);
+                setCandidates(aiResponse.commands);
+                setStatus("selecting");
+            })
+                .catch((error) => {
+                const appError = normalizeError(error);
+                setErrorMessage(appError.message);
+                setStatus("error");
+                onError(appError);
+            });
+        }
+    }, [status, provider, request, useCommand, onError]);
+    const handleSelect = (candidate) => {
+        setSelectedCandidate(candidate);
+        setResolvedValues(new Map());
+        if (candidate.placeholders.length > 0) {
+            setStatus("resolving");
+        }
+        else {
+            const command = candidate.command;
+            setFinalCommand(command);
+            setDanger(detectDangerousCommand(command));
+            setStatus("confirming");
+        }
+    };
+    const handleResolve = (values) => {
+        if (!selectedCandidate)
+            return;
+        setResolvedValues(values);
+        const command = replaceCommandPlaceholders(selectedCandidate.command, values);
+        setFinalCommand(command);
+        setDanger(detectDangerousCommand(command));
+        setStatus("confirming");
+    };
+    useEffect(() => {
+        if (status === "done") {
+            onSuccess(finalCommand);
+        }
+    }, [status, finalCommand, onSuccess]);
+    const handleConfirm = () => {
+        setStatus("done");
+    };
+    const handleCancel = () => {
+        onError(new InteractionCancelledError());
+    };
+    const handleBackToSelection = () => {
+        setStatus("selecting");
+    };
+    const maxFrameRows = Math.max(1, rows - 1);
+    return (React.createElement(Box, { flexDirection: "column", maxHeight: maxFrameRows, overflowY: "hidden" },
+        status === "loading" && React.createElement(LoadingView, null),
+        status === "selecting" && (React.createElement(SelectCommandView, { candidates: candidates, onSelect: handleSelect, onCancel: handleCancel })),
+        status === "resolving" && selectedCandidate && (React.createElement(ResolvePlaceholdersView, { candidate: selectedCandidate, placeholders: selectedCandidate.placeholders, onResolve: handleResolve, onBack: handleBackToSelection, onCancel: handleCancel })),
+        (status === "confirming" || status === "done") && selectedCandidate && (React.createElement(ConfirmView, { candidate: selectedCandidate, resolvedValues: resolvedValues, danger: danger, onConfirm: handleConfirm, onCancel: handleCancel, isDone: status === "done" })),
+        status === "error" && React.createElement(Text, { color: "red" },
+            "Error: ",
+            errorMessage)));
+};
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    if (typeof error === "string" && error.trim() !== "") {
+        return new Error(error);
+    }
+    return new Error("unknown error");
+}

package/dist/ui/ConfirmView.js

@@ -0,0 +1,75 @@
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { SelectedCommandDisplay } from "./SelectedCommandDisplay.js";
+export const ConfirmView = ({ candidate, resolvedValues, danger, onConfirm, onCancel, isDone = false, }) => {
+    const [buffer, setBuffer] = useState("");
+    useInput((input, key) => {
+        if (isDone)
+            return;
+        if (key.ctrl && input === "c") {
+            onCancel();
+            return;
+        }
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (danger) {
+            if (key.return) {
+                if (buffer === "EXECUTE") {
+                    onConfirm();
+                }
+                else {
+                    onCancel();
+                }
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setBuffer((prev) => prev.slice(0, -1));
+                return;
+            }
+            if (input && !Object.values(key).some(Boolean)) {
+                setBuffer((prev) => prev + input);
+            }
+        }
+        else {
+            if (key.return) {
+                onConfirm();
+            }
+        }
+    });
+    if (danger) {
+        return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+            React.createElement(Text, { color: "red", bold: true }, "Dangerous command detected."),
+            React.createElement(Text, null,
+                "Rule: ",
+                danger.rule),
+            React.createElement(Text, null,
+                "Risk: ",
+                danger.reason),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(SelectedCommandDisplay, { candidate: candidate, resolvedValues: resolvedValues })),
+            !isDone && (React.createElement(React.Fragment, null,
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, null,
+                        "Type ",
+                        React.createElement(Text, { color: "yellow" }, "EXECUTE"),
+                        " to continue, or anything else to cancel.")),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: "cyan" }, "> "),
+                    React.createElement(Text, null, buffer),
+                    React.createElement(Text, { backgroundColor: "white" }, " "))))));
+    }
+    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+        React.createElement(SelectedCommandDisplay, { candidate: candidate, resolvedValues: resolvedValues }),
+        !isDone && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, null,
+                "Press ",
+                React.createElement(Text, { color: "green" }, "Enter"),
+                " to execute, ",
+                React.createElement(Text, { color: "gray" }, "Esc"),
+                " or",
+                " ",
+                React.createElement(Text, { color: "gray" }, "Ctrl+C"),
+                " to cancel.")))));
+};

package/dist/ui/LoadingView.js

@@ -0,0 +1,17 @@
+import React, { useState, useEffect } from "react";
+import { Text } from "ink";
+const FRAMES = ["|", "/", "-", "\\"];
+export const LoadingView = () => {
+    const [frameIndex, setFrameIndex] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrameIndex((prev) => (prev + 1) % FRAMES.length);
+        }, 120);
+        return () => clearInterval(timer);
+    }, []);
+    return (React.createElement(Text, null,
+        React.createElement(Text, { color: "cyan" },
+            FRAMES[frameIndex],
+            " "),
+        "Thinking..."));
+};

package/dist/ui/ResolvePlaceholdersView.js

@@ -0,0 +1,80 @@
+import React, { useState, useMemo } from "react";
+import { Box, Text, useInput } from "ink";
+import { SelectedCommandDisplay } from "./SelectedCommandDisplay.js";
+export const ResolvePlaceholdersView = ({ candidate, placeholders, onResolve, onBack, onCancel, }) => {
+    const [activeIndex, setActiveIndex] = useState(0);
+    const [values, setValues] = useState(placeholders.map(() => ""));
+    const [buffer, setBuffer] = useState("");
+    const resolvedValuesMap = useMemo(() => {
+        const map = new Map();
+        placeholders.forEach((p, i) => {
+            if (i < activeIndex) {
+                map.set(p.name, values[i]);
+            }
+        });
+        return map;
+    }, [placeholders, activeIndex, values]);
+    const currentBuffer = useMemo(() => ({
+        name: placeholders[activeIndex].name,
+        value: buffer,
+    }), [placeholders, activeIndex, buffer]);
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            onCancel();
+            return;
+        }
+        if (key.escape) {
+            if (activeIndex === 0) {
+                onBack();
+            }
+            else {
+                const newValues = [...values];
+                newValues[activeIndex] = "";
+                setValues(newValues);
+                setActiveIndex((prev) => prev - 1);
+                setBuffer(values[activeIndex - 1]);
+            }
+            return;
+        }
+        if (key.return) {
+            const newValues = [...values];
+            newValues[activeIndex] = buffer;
+            setValues(newValues);
+            if (activeIndex === placeholders.length - 1) {
+                const resultMap = new Map();
+                placeholders.forEach((p, i) => {
+                    resultMap.set(p.name, newValues[i]);
+                });
+                onResolve(resultMap);
+            }
+            else {
+                setActiveIndex((prev) => prev + 1);
+                setBuffer(values[activeIndex + 1]);
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setBuffer((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (input && !Object.values(key).some(Boolean)) {
+            setBuffer((prev) => prev + input);
+        }
+        // Handle space and other printable characters that might be in key but not in input if needed
+        // However ink's useInput input is usually the string.
+    });
+    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+        React.createElement(SelectedCommandDisplay, { candidate: candidate, resolvedValues: resolvedValuesMap, currentBuffer: currentBuffer }),
+        React.createElement(Text, { color: "green" }, "? Fill command placeholders"),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                React.createElement(Text, null,
+                    placeholders[activeIndex].name,
+                    ": ",
+                    placeholders[activeIndex].description),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: "cyan" }, "> "),
+                    React.createElement(Text, null, buffer),
+                    React.createElement(Text, { backgroundColor: "white" }, " ")))),
+        React.createElement(Text, { dimColor: true }, "Press Enter for next value, Esc to go back, Ctrl+C to cancel.")));
+};

package/dist/ui/SelectCommandView.js

@@ -0,0 +1,39 @@
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+export const SelectCommandView = ({ candidates, onSelect, onCancel }) => {
+    const [activeIndex, setActiveIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === "c")) {
+            onCancel();
+            return;
+        }
+        if (key.upArrow) {
+            setActiveIndex((prev) => (prev - 1 + candidates.length) % candidates.length);
+        }
+        if (key.downArrow) {
+            setActiveIndex((prev) => (prev + 1) % candidates.length);
+        }
+        if (key.return) {
+            onSelect(candidates[activeIndex]);
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+        React.createElement(Text, { color: "green" }, "? Select a command"),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, candidates.map((candidate, index) => {
+            const isSelected = index === activeIndex;
+            const isLast = index === candidates.length - 1;
+            return (React.createElement(React.Fragment, { key: index },
+                React.createElement(Box, { flexDirection: "column", flexShrink: 0 },
+                    React.createElement(Box, null,
+                        React.createElement(Text, { color: isSelected ? "cyan" : undefined }, isSelected ? "> " : "  "),
+                        React.createElement(Text, { inverse: isSelected, bold: isSelected }, candidate.title)),
+                    React.createElement(Box, { paddingLeft: 4 },
+                        React.createElement(Text, { color: "gray" }, candidate.command)),
+                    React.createElement(Box, { paddingLeft: 4 },
+                        React.createElement(Text, { italic: true, color: "dim" }, candidate.description))),
+                !isLast && (React.createElement(Box, { height: 1, flexShrink: 0 },
+                    React.createElement(Text, null, " ")))));
+        })),
+        React.createElement(Box, { flexShrink: 0, marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Use Up/Down to move, Enter to select, Esc or Ctrl+C to cancel."))));
+};

package/dist/ui/SelectedCommandDisplay.js

@@ -0,0 +1,31 @@
+import React from "react";
+import { Box, Text } from "ink";
+export const SelectedCommandDisplay = ({ candidate, resolvedValues, currentBuffer, }) => {
+    // Split command by {{placeholder}} pattern, keeping the delimiters
+    const parts = candidate.command.split(/({{.*?}})/);
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1 },
+        React.createElement(Box, null,
+            React.createElement(Text, { color: "cyan", bold: true }, "> "),
+            React.createElement(Text, { bold: true }, candidate.title)),
+        React.createElement(Box, { marginLeft: 2 },
+            React.createElement(Text, null, parts.map((part, index) => {
+                const match = part.match(/^{{(.*)}}$/);
+                if (match) {
+                    const placeholderName = match[1];
+                    // If it's the current buffer, show the buffer in yellow
+                    if (currentBuffer && currentBuffer.name === placeholderName) {
+                        return (React.createElement(Text, { key: index, color: "yellow" }, currentBuffer.value || part));
+                    }
+                    // If it's already resolved, show the value in yellow
+                    if (resolvedValues.has(placeholderName)) {
+                        return (React.createElement(Text, { key: index, color: "yellow" }, resolvedValues.get(placeholderName)));
+                    }
+                    // Otherwise show the original {{placeholder}} in default gray
+                    return (React.createElement(Text, { key: index, color: "gray" }, part));
+                }
+                // Normal text
+                return React.createElement(Text, { key: index }, part);
+            }))),
+        React.createElement(Box, { marginLeft: 2 },
+            React.createElement(Text, { italic: true, color: "dim" }, candidate.description))));
+};