@unscientificjszhai/howto 1.0.0-alpha.2 → 1.0.0

package/dist/index.js

@@ -17,8 +17,8 @@ import { ConfigError, hasExplicitAiProvider, loadConfig } from "./config.js";
 import { readUserConfigFile } from "./config-file.js";
 import { createCommandProvider } from "./ai/index.js";
 import { buildCommandGenerationPrompt, createProviderPromptRequest } from "./prompt.js";
-import { parseAndValidateAiResponse } from "./validation/ai-response.js";
 import { checkCommandInPath } from "./validation/command-tool.js";
+import { generateValidatedCommandCandidates } from "./validation/generated-commands.js";
 import { ensureInteractiveTty } from "./ui/tty.js";
 import { executeCommand } from "./execute.js";
 import { toAppError } from "./errors.js";
@@ -66,14 +66,14 @@ function run(argv) {
                 question: parsedCli.question,
                 arguments: parsedCli.arguments,
                 useCommand: parsedCli.useCommand,
+                structuredOutput: config.structuredOutput,
             });
             const { systemPrompt, userPrompt } = buildCommandGenerationPrompt(promptRequest);
             const provider = createCommandProvider(config);
             if (parsedCli.options.print) {
-                const aiResult = yield provider.generateCommands(Object.assign(Object.assign({}, promptRequest), { systemPrompt,
+                const candidates = yield generateValidatedCommandCandidates(provider, Object.assign(Object.assign({}, promptRequest), { systemPrompt,
                     userPrompt }));
-                const aiResponse = parseAndValidateAiResponse(aiResult.rawText);
-                aiResponse.commands.forEach((candidate) => {
+                candidates.forEach((candidate) => {
                     console.log(candidate.command);
                 });
                 return { exitCode: 0 };
@@ -83,7 +83,7 @@ function run(argv) {
             }
             let finalCommand;
             let appError;
-            const { waitUntilExit, unmount, clear } = render(React.createElement(App, { provider: provider, request: Object.assign(Object.assign({}, promptRequest), { systemPrompt, userPrompt }), useCommand: parsedCli.useCommand, onSuccess: (command) => {
+            const { waitUntilExit, unmount, clear } = render(React.createElement(App, { provider: provider, request: Object.assign(Object.assign({}, promptRequest), { systemPrompt, userPrompt }), onSuccess: (command) => {
                     finalCommand = command;
                     clear();
                     unmount();

package/dist/init/InitializationApp.js

@@ -0,0 +1,97 @@
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { applyInitializationInput, createInitialInitializationState, getProviderOptions, } from "./state.js";
+export const InitializationApp = ({ onSubmit, onComplete, onCancel, onError }) => {
+    const [state, setState] = useState(createInitialInitializationState);
+    const [submitStatus, setSubmitStatus] = useState("editing");
+    const [errorMessage, setErrorMessage] = useState("");
+    useInput((input, key) => {
+        const update = applyInitializationInput(state, { input, key });
+        setState(update.state);
+        if (update.cancelled) {
+            setSubmitStatus("cancelled");
+            onCancel();
+            return;
+        }
+        if (update.completedValues !== undefined) {
+            setSubmitStatus("saving");
+            onSubmit(update.completedValues)
+                .then((config) => {
+                onComplete(config);
+            })
+                .catch((error) => {
+                const appError = normalizeError(error);
+                setErrorMessage(appError.message);
+                setSubmitStatus("error");
+                onError(appError);
+            });
+        }
+    }, { isActive: submitStatus === "editing" });
+    if (submitStatus === "saving") {
+        return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+            React.createElement(Text, { color: "green" }, "Saving howto configuration...")));
+    }
+    if (submitStatus === "error") {
+        return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+            React.createElement(Text, { color: "red" },
+                "Error: ",
+                errorMessage)));
+    }
+    if (submitStatus === "cancelled") {
+        return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+            React.createElement(Text, { dimColor: true }, "Initialization cancelled.")));
+    }
+    if (state.step === "provider") {
+        return React.createElement(ProviderStep, { selectedIndex: state.selectedIndex });
+    }
+    return React.createElement(InputStep, { state: state });
+};
+const ProviderStep = ({ selectedIndex }) => {
+    const providers = getProviderOptions();
+    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+        React.createElement(Text, null, "howto needs an AI provider before it can call AI."),
+        React.createElement(Box, { height: 1 },
+            React.createElement(Text, null, " ")),
+        React.createElement(Text, { color: "green" }, "? Choose AI provider"),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, providers.map((provider, index) => {
+            const isSelected = selectedIndex === index;
+            return (React.createElement(Box, { key: provider },
+                React.createElement(Text, { color: isSelected ? "cyan" : undefined }, isSelected ? "> " : "  "),
+                React.createElement(Text, { inverse: isSelected, bold: isSelected },
+                    index + 1,
+                    ". ",
+                    provider)));
+        })),
+        React.createElement(Box, { flexShrink: 0, marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Use Up/Down or 1/2 to choose, Enter to continue, Esc or Ctrl+C to cancel."))));
+};
+const InputStep = ({ state, }) => {
+    const currentField = state.fields[state.fieldIndex];
+    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+        React.createElement(Text, { color: "green" },
+            "? Configure ",
+            state.provider),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, state.fields.map((field, index) => (React.createElement(FieldRow, { key: field.name, field: field, isActive: index === state.fieldIndex })))),
+        currentField.defaultValue !== undefined && currentField.value === "" && (React.createElement(Text, { dimColor: true },
+            "Default: ",
+            currentField.defaultValue)),
+        state.errorMessage !== undefined && React.createElement(Text, { color: "red" }, state.errorMessage),
+        React.createElement(Box, { flexShrink: 0, marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press Enter for next value, Esc to go back, Ctrl+C to cancel."))));
+};
+const FieldRow = ({ field, isActive, }) => (React.createElement(Box, null,
+    React.createElement(Text, { color: isActive ? "cyan" : undefined }, isActive ? "> " : "  "),
+    React.createElement(Text, null,
+        field.label,
+        ": "),
+    React.createElement(Text, null, field.value),
+    isActive && React.createElement(Text, { backgroundColor: "white" }, " ")));
+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/init/index.js

@@ -7,37 +7,48 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 React from "react";
+import { render } from "ink";
+import { loadConfig } from "../config.js";
 import { getConfigFilePath, writeUserConfigFile } from "../config-file.js";
 import { InteractionCancelledError } from "../ui/tty.js";
+import { InitializationApp } from "./InitializationApp.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;
-        }
+        return yield new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                instance.clear();
+                instance.unmount();
+                void instance.waitUntilExit().then(result, result);
+            };
+            const instance = render(React.createElement(InitializationApp, { onSubmit: (values) => __awaiter(this, void 0, void 0, function* () {
+                    const fileConfig = createFileConfig(values);
+                    const configFilePath = getConfigFilePath(env);
+                    yield writeUserConfigFile(fileConfig, configFilePath);
+                    return loadConfig(cliOptions, env, fileConfig);
+                }), onComplete: (config) => {
+                    settle(() => {
+                        resolve(config);
+                    });
+                }, onCancel: () => {
+                    settle(() => {
+                        reject(new InteractionCancelledError());
+                    });
+                }, onError: (error) => {
+                    settle(() => {
+                        reject(error);
+                    });
+                } }), {
+                stdin: input,
+                stdout: output,
+                exitOnCtrlC: false,
+            });
+        });
     });
 }
 export function clearInitializationOutput(output, rows) {
@@ -55,22 +66,6 @@ export function erasePreviousTerminalRows(rows) {
     }
     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");
@@ -101,46 +96,8 @@ export function createFileConfig(values) {
         openaiApiKey: values.apiKey,
         openaiModel: values.model,
     };
-    if (values.openaiBaseUrl !== undefined) {
+    if (values.openaiBaseUrl !== undefined && values.openaiBaseUrl.trim() !== "") {
         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/init/state.js

@@ -0,0 +1,172 @@
+import { DEFAULT_GEMINI_MODEL, DEFAULT_OPENAI_MODEL } from "../config.js";
+const PROVIDERS = ["openai", "gemini"];
+export function createInitialInitializationState() {
+    return {
+        step: "provider",
+        selectedIndex: null,
+    };
+}
+export function getProviderOptions() {
+    return PROVIDERS;
+}
+export function applyInitializationInput(state, event) {
+    if (event.key.ctrl && event.input === "c") {
+        return { state, cancelled: true };
+    }
+    if (state.step === "provider") {
+        return applyProviderInput(state, event);
+    }
+    return applyFieldInput(state, event);
+}
+function applyProviderInput(state, event) {
+    if (event.key.escape) {
+        return { state, cancelled: true };
+    }
+    const numericSelection = getNumericProviderSelection(event.input);
+    if (numericSelection !== null) {
+        return {
+            state: createInputState(PROVIDERS[numericSelection]),
+        };
+    }
+    if (event.key.upArrow) {
+        return {
+            state: Object.assign(Object.assign({}, state), { selectedIndex: state.selectedIndex === null
+                    ? PROVIDERS.length - 1
+                    : (state.selectedIndex - 1 + PROVIDERS.length) % PROVIDERS.length }),
+        };
+    }
+    if (event.key.downArrow) {
+        return {
+            state: Object.assign(Object.assign({}, state), { selectedIndex: state.selectedIndex === null ? 0 : (state.selectedIndex + 1) % PROVIDERS.length }),
+        };
+    }
+    if (event.key.return && state.selectedIndex !== null) {
+        return {
+            state: createInputState(PROVIDERS[state.selectedIndex]),
+        };
+    }
+    return { state };
+}
+function getNumericProviderSelection(input) {
+    if (input === "1") {
+        return 0;
+    }
+    if (input === "2") {
+        return 1;
+    }
+    return null;
+}
+function applyFieldInput(state, event) {
+    if (event.key.escape) {
+        return { state: createInitialInitializationState() };
+    }
+    if (event.key.return) {
+        const validationError = validateCurrentField(state);
+        if (validationError !== undefined) {
+            return {
+                state: Object.assign(Object.assign({}, state), { errorMessage: validationError }),
+            };
+        }
+        if (state.fieldIndex === state.fields.length - 1) {
+            return {
+                state,
+                completedValues: createInitializationValues(state),
+            };
+        }
+        return {
+            state: Object.assign(Object.assign({}, state), { fieldIndex: state.fieldIndex + 1, errorMessage: undefined }),
+        };
+    }
+    if (event.key.backspace || event.key.delete) {
+        return updateCurrentField(state, (value) => value.slice(0, -1));
+    }
+    if (event.input !== "" && !hasControlKey(event)) {
+        return updateCurrentField(state, (value) => value + event.input);
+    }
+    return { state };
+}
+function hasControlKey(event) {
+    return (event.key.upArrow ||
+        event.key.downArrow ||
+        event.key.return ||
+        event.key.escape ||
+        event.key.ctrl ||
+        event.key.backspace ||
+        event.key.delete);
+}
+function createInputState(provider) {
+    return {
+        step: "input",
+        provider,
+        fieldIndex: 0,
+        fields: provider === "gemini"
+            ? [
+                {
+                    name: "apiKey",
+                    label: "Gemini API key",
+                    value: "",
+                    required: true,
+                },
+                {
+                    name: "model",
+                    label: "Gemini model",
+                    value: "",
+                    defaultValue: DEFAULT_GEMINI_MODEL,
+                    required: false,
+                },
+            ]
+            : [
+                {
+                    name: "apiKey",
+                    label: "OpenAI API key (optional)",
+                    value: "",
+                    required: false,
+                },
+                {
+                    name: "model",
+                    label: "OpenAI model",
+                    value: "",
+                    defaultValue: DEFAULT_OPENAI_MODEL,
+                    required: false,
+                },
+                {
+                    name: "openaiBaseUrl",
+                    label: "OpenAI base URL (optional, Enter for official default)",
+                    value: "",
+                    required: false,
+                },
+            ],
+    };
+}
+function updateCurrentField(state, updateValue) {
+    return {
+        state: Object.assign(Object.assign({}, state), { fields: state.fields.map((field, index) => index === state.fieldIndex
+                ? Object.assign(Object.assign({}, field), { value: updateValue(field.value) }) : field), errorMessage: undefined }),
+    };
+}
+function validateCurrentField(state) {
+    const field = state.fields[state.fieldIndex];
+    if (field.required && field.value.trim() === "") {
+        return "This value is required.";
+    }
+    return undefined;
+}
+function createInitializationValues(state) {
+    var _a, _b, _c;
+    const fieldValues = new Map(state.fields.map((field) => [field.name, field.value]));
+    const modelValue = (_a = fieldValues.get("model")) === null || _a === void 0 ? void 0 : _a.trim();
+    if (state.provider === "gemini") {
+        return {
+            provider: "gemini",
+            apiKey: (_b = fieldValues.get("apiKey")) !== null && _b !== void 0 ? _b : "",
+            model: modelValue === "" || modelValue === undefined ? DEFAULT_GEMINI_MODEL : modelValue,
+        };
+    }
+    const baseUrl = fieldValues.get("openaiBaseUrl");
+    return {
+        provider: "openai",
+        apiKey: (_c = fieldValues.get("apiKey")) !== null && _c !== void 0 ? _c : "",
+        model: modelValue === "" || modelValue === undefined ? DEFAULT_OPENAI_MODEL : modelValue,
+        openaiBaseUrl: baseUrl === undefined || baseUrl.trim() === "" ? undefined : baseUrl,
+    };
+}

package/dist/prompt.js

@@ -18,6 +18,10 @@ The JSON object must match this schema:
 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 STRUCTURED_OUTPUT_CONTRACT = `Return only the JSON object requested by the response schema. Do not include a natural-language body, markdown, or code fences.
+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.`;
@@ -26,7 +30,8 @@ export function createProviderPromptRequest(request) {
         question: request.question,
         arguments: request.arguments,
         useCommand: request.useCommand,
-        outputContract: OUTPUT_CONTRACT,
+        structuredOutput: request.structuredOutput,
+        outputContract: request.structuredOutput ? STRUCTURED_OUTPUT_CONTRACT : OUTPUT_CONTRACT,
         safetyConstraints: SAFETY_CONSTRAINTS,
     };
 }

package/dist/ui/App.js

@@ -4,12 +4,11 @@ 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 { generateValidatedCommandCandidates } from "../validation/generated-commands.js";
 import { detectDangerousCommand } from "../safety/dangerous-command.js";
-import { replaceCommandPlaceholders } from "./placeholder-logic.js";
+import { resolveCandidatePlaceholders } from "./placeholder-logic.js";
 import { InteractionCancelledError } from "./tty.js";
-export const App = ({ provider, request, useCommand, onSuccess, onError }) => {
+export const App = ({ provider, request, onSuccess, onError }) => {
     const { rows } = useWindowSize();
     const [status, setStatus] = useState("loading");
     const [candidates, setCandidates] = useState([]);
@@ -20,12 +19,9 @@ export const App = ({ provider, request, useCommand, onSuccess, onError }) => {
     const [errorMessage, setErrorMessage] = useState("");
     useEffect(() => {
         if (status === "loading") {
-            provider
-                .generateCommands(request)
-                .then((result) => {
-                const aiResponse = parseAndValidateAiResponse(result.rawText);
-                validateUseCommandCandidates(aiResponse, useCommand);
-                setCandidates(aiResponse.commands);
+            generateValidatedCommandCandidates(provider, request)
+                .then((generatedCandidates) => {
+                setCandidates(generatedCandidates);
                 setStatus("selecting");
             })
                 .catch((error) => {
@@ -35,7 +31,7 @@ export const App = ({ provider, request, useCommand, onSuccess, onError }) => {
                 onError(appError);
             });
         }
-    }, [status, provider, request, useCommand, onError]);
+    }, [status, provider, request, onError]);
     const handleSelect = (candidate) => {
         setSelectedCandidate(candidate);
         setResolvedValues(new Map());
@@ -43,19 +39,27 @@ export const App = ({ provider, request, useCommand, onSuccess, onError }) => {
             setStatus("resolving");
         }
         else {
-            const command = candidate.command;
-            setFinalCommand(command);
-            setDanger(detectDangerousCommand(command));
-            setStatus("confirming");
+            try {
+                const resolved = resolveCandidatePlaceholders(candidate, new Map());
+                setFinalCommand(resolved.command);
+                setResolvedValues(resolved.values);
+                setDanger(detectDangerousCommand(resolved.command));
+                setStatus("confirming");
+            }
+            catch (error) {
+                const appError = normalizeError(error);
+                setErrorMessage(appError.message);
+                setStatus("error");
+                onError(appError);
+            }
         }
     };
-    const handleResolve = (values) => {
+    const handleResolve = (resolved) => {
         if (!selectedCandidate)
             return;
-        setResolvedValues(values);
-        const command = replaceCommandPlaceholders(selectedCandidate.command, values);
-        setFinalCommand(command);
-        setDanger(detectDangerousCommand(command));
+        setResolvedValues(resolved.values);
+        setFinalCommand(resolved.command);
+        setDanger(detectDangerousCommand(resolved.command));
         setStatus("confirming");
     };
     useEffect(() => {
@@ -76,8 +80,8 @@ export const App = ({ provider, request, useCommand, onSuccess, onError }) => {
     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 === "resolving" && selectedCandidate && (React.createElement(ResolvePlaceholdersView, { candidate: selectedCandidate, onResolve: handleResolve, onBack: handleBackToSelection, onCancel: handleCancel })),
+        (status === "confirming" || status === "done") && selectedCandidate && (React.createElement(ConfirmView, { candidate: selectedCandidate, command: finalCommand, resolvedValues: resolvedValues, danger: danger, onConfirm: handleConfirm, onCancel: handleCancel, isDone: status === "done" })),
         status === "error" && React.createElement(Text, { color: "red" },
             "Error: ",
             errorMessage)));

package/dist/ui/ConfirmView.js

@@ -1,7 +1,10 @@
 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, }) => {
+export function isDangerConfirmationInput(input) {
+    return input.toUpperCase() === "EXECUTE";
+}
+export const ConfirmView = ({ candidate, command, resolvedValues, danger, onConfirm, onCancel, isDone = false, }) => {
     const [buffer, setBuffer] = useState("");
     useInput((input, key) => {
         if (isDone)
@@ -16,7 +19,7 @@ export const ConfirmView = ({ candidate, resolvedValues, danger, onConfirm, onCa
         }
         if (danger) {
             if (key.return) {
-                if (buffer === "EXECUTE") {
+                if (isDangerConfirmationInput(buffer)) {
                     onConfirm();
                 }
                 else {
@@ -48,7 +51,10 @@ export const ConfirmView = ({ candidate, resolvedValues, danger, onConfirm, onCa
                 "Risk: ",
                 danger.reason),
             React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(SelectedCommandDisplay, { candidate: candidate, resolvedValues: resolvedValues })),
+                React.createElement(SelectedCommandDisplay, { candidate: candidate, resolvedValues: resolvedValues }),
+                React.createElement(Text, null,
+                    "Final command: ",
+                    React.createElement(Text, { color: "yellow" }, command))),
             !isDone && (React.createElement(React.Fragment, null,
                 React.createElement(Box, { marginTop: 1 },
                     React.createElement(Text, null,
@@ -62,6 +68,9 @@ export const ConfirmView = ({ candidate, resolvedValues, danger, onConfirm, onCa
     }
     return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
         React.createElement(SelectedCommandDisplay, { candidate: candidate, resolvedValues: resolvedValues }),
+        React.createElement(Text, null,
+            "Final command: ",
+            React.createElement(Text, { color: "yellow" }, command)),
         !isDone && (React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, null,
                 "Press ",