@unscientificjszhai/howto 1.0.0-alpha.2 → 1.0.0

package/dist/ui/ResolvePlaceholdersView.js

@@ -1,80 +1,59 @@
-import React, { useState, useMemo } from "react";
+import React, { useState } 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]);
+import { applyPlaceholderResolutionInput, createPlaceholderResolution, getPlaceholderResolutionView, } from "./placeholder-logic.js";
+export const ResolvePlaceholdersView = ({ candidate, onResolve, onBack, onCancel, }) => {
+    const [resolutionState, setResolutionState] = useState(() => createPlaceholderResolution(candidate));
+    const { currentPlaceholder, currentBuffer, resolvedValues } = getPlaceholderResolutionView(resolutionState);
     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]);
-            }
+        const resolutionInput = toPlaceholderResolutionInput(input, key);
+        if (!resolutionInput) {
             return;
         }
-        if (key.backspace || key.delete) {
-            setBuffer((prev) => prev.slice(0, -1));
-            return;
-        }
-        if (input && !Object.values(key).some(Boolean)) {
-            setBuffer((prev) => prev + input);
+        const transition = applyPlaceholderResolutionInput(resolutionState, resolutionInput);
+        switch (transition.type) {
+            case "editing":
+                setResolutionState(transition.state);
+                return;
+            case "back-to-selection":
+                onBack();
+                return;
+            case "complete":
+                onResolve(transition.resolved);
+                return;
         }
-        // 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(SelectedCommandDisplay, { candidate: candidate, resolvedValues: resolvedValues, 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,
+                    currentPlaceholder.name,
                     ": ",
-                    placeholders[activeIndex].description),
+                    currentPlaceholder.description),
                 React.createElement(Box, null,
                     React.createElement(Text, { color: "cyan" }, "> "),
-                    React.createElement(Text, null, buffer),
+                    React.createElement(Text, null, currentBuffer.value),
                     React.createElement(Text, { backgroundColor: "white" }, " ")))),
         React.createElement(Text, { dimColor: true }, "Press Enter for next value, Esc to go back, Ctrl+C to cancel.")));
 };
+function toPlaceholderResolutionInput(input, key) {
+    if (key.escape) {
+        return { type: "escape" };
+    }
+    if (key.return) {
+        return { type: "commit" };
+    }
+    if (key.backspace || key.delete) {
+        return { type: "delete" };
+    }
+    if (input && !Object.values(key).some(Boolean)) {
+        return { type: "append", value: input };
+    }
+    return undefined;
+}

package/dist/ui/placeholder-logic.js

@@ -5,6 +5,64 @@ export class PlaceholderResolutionError extends Error {
         this.name = "PlaceholderResolutionError";
     }
 }
+export function createPlaceholderResolution(candidate) {
+    if (candidate.placeholders.length === 0) {
+        throw new PlaceholderResolutionError("cannot resolve command without placeholders");
+    }
+    return {
+        candidate,
+        activeIndex: 0,
+        values: candidate.placeholders.map(() => ""),
+        buffer: "",
+    };
+}
+export function getPlaceholderResolutionView(state) {
+    const currentPlaceholder = state.candidate.placeholders[state.activeIndex];
+    if (!currentPlaceholder) {
+        throw new PlaceholderResolutionError("placeholder resolution state is out of bounds");
+    }
+    const resolvedValues = new Map();
+    state.candidate.placeholders.forEach((placeholder, index) => {
+        if (index < state.activeIndex) {
+            resolvedValues.set(placeholder.name, state.values[index]);
+        }
+    });
+    return {
+        currentPlaceholder,
+        currentBuffer: {
+            name: currentPlaceholder.name,
+            value: state.buffer,
+        },
+        resolvedValues,
+    };
+}
+export function applyPlaceholderResolutionInput(state, input) {
+    switch (input.type) {
+        case "append":
+            return {
+                type: "editing",
+                state: Object.assign(Object.assign({}, state), { buffer: state.buffer + input.value }),
+            };
+        case "delete":
+            return {
+                type: "editing",
+                state: Object.assign(Object.assign({}, state), { buffer: state.buffer.slice(0, -1) }),
+            };
+        case "escape":
+            return applyEscape(state);
+        case "commit":
+            return applyCommit(state);
+    }
+}
+export function resolveCandidatePlaceholders(candidate, values) {
+    const command = replaceCommandPlaceholders(candidate.command, values);
+    assertNoUnresolvedPlaceholders(command);
+    return {
+        candidate,
+        values,
+        command,
+    };
+}
 export function replaceCommandPlaceholders(command, values) {
     let resolvedCommand = command;
     for (const [name, value] of values) {
@@ -17,3 +75,34 @@ export function assertNoUnresolvedPlaceholders(command) {
         throw new PlaceholderResolutionError("final command contains unresolved placeholders");
     }
 }
+function applyEscape(state) {
+    if (state.activeIndex === 0) {
+        return { type: "back-to-selection" };
+    }
+    const previousIndex = state.activeIndex - 1;
+    const values = [...state.values];
+    values[state.activeIndex] = "";
+    return {
+        type: "editing",
+        state: Object.assign(Object.assign({}, state), { activeIndex: previousIndex, values, buffer: values[previousIndex] }),
+    };
+}
+function applyCommit(state) {
+    const values = [...state.values];
+    values[state.activeIndex] = state.buffer;
+    if (state.activeIndex === state.candidate.placeholders.length - 1) {
+        const resolvedValues = new Map();
+        state.candidate.placeholders.forEach((placeholder, index) => {
+            resolvedValues.set(placeholder.name, values[index]);
+        });
+        return {
+            type: "complete",
+            resolved: resolveCandidatePlaceholders(state.candidate, resolvedValues),
+        };
+    }
+    const nextIndex = state.activeIndex + 1;
+    return {
+        type: "editing",
+        state: Object.assign(Object.assign({}, state), { activeIndex: nextIndex, values, buffer: values[nextIndex] }),
+    };
+}

package/dist/validation/generated-commands.js

@@ -0,0 +1,19 @@
+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 { parseAndValidateAiResponse } from "./ai-response.js";
+import { validateUseCommandCandidates } from "./command-tool.js";
+export function generateValidatedCommandCandidates(provider, request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield provider.generateCommands(request);
+        const response = parseAndValidateAiResponse(result.rawText);
+        validateUseCommandCandidates(response, request.useCommand);
+        return response.commands;
+    });
+}

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@unscientificjszhai/howto",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0",
   "type": "module",
   "description": "Use AI to quickly find commands within the terminal.",
+  "license": "MIT",
   "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UnscientificJsZhai/HowTo.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "bin": {
     "howto": "dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "THIRD_PARTY_NOTICES.md"
   ],
   "scripts": {
     "build": "tsc",
@@ -22,10 +32,9 @@
     "test:unit": "tsc -p tsconfig.test.json && node --test dist-test/tests/unit/*.test.js dist-test/tests/unit/**/*.test.js"
   },
   "dependencies": {
-    "@google/genai": "^1.0.0",
-    "@inquirer/prompts": "^7.0.0",
-    "ink": "^7.0.3",
-    "openai": "^4.0.0",
+    "@google/genai": "^2.6.0",
+    "ink": "^7.0.4",
+    "openai": "^6.39.0",
     "react": "^19.2.6"
   },
   "devDependencies": {

package/dist/env.js

@@ -1,10 +0,0 @@
-import os from "os";
-export function getTerminalEnv(env = process.env) {
-    return {
-        os: os.platform(),
-        shell: env.SHELL || (os.platform() === "win32" ? "cmd.exe" : "sh"),
-    };
-}
-export function isZsh(shell) {
-    return shell.toLowerCase().endsWith("zsh");
-}

package/dist/ui/confirm.js

@@ -1,117 +0,0 @@
-"use strict";
-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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.confirmFinalCommand = confirmFinalCommand;
-exports.confirmDangerousCommand = confirmDangerousCommand;
-exports.formatFinalCommandConfirmation = formatFinalCommandConfirmation;
-exports.formatDangerousCommandConfirmation = formatDangerousCommandConfirmation;
-const readline_1 = __importDefault(require("readline"));
-const interactive_1 = require("./interactive");
-const key_input_1 = require("./key-input");
-function confirmFinalCommand(command_1) {
-    return __awaiter(this, arguments, void 0, function* (command, streams = {}) {
-        var _a, _b;
-        const input = (_a = streams.input) !== null && _a !== void 0 ? _a : process.stdin;
-        const output = (_b = streams.output) !== null && _b !== void 0 ? _b : process.stdout;
-        (0, interactive_1.ensureInteractiveTty)(input, output);
-        return new Promise((resolve, reject) => {
-            let cleanupKeypressSession;
-            const cleanup = () => {
-                cleanupKeypressSession === null || cleanupKeypressSession === void 0 ? void 0 : cleanupKeypressSession();
-                cleanupKeypressSession = undefined;
-            };
-            const finish = () => {
-                cleanup();
-                resolve();
-            };
-            const cancel = () => {
-                cleanup();
-                reject(new interactive_1.InteractionCancelledError("Final command confirmation cancelled"));
-            };
-            const onKeypress = (_inputText, key = {}) => {
-                if (key.ctrl === true && key.name === "c") {
-                    cancel();
-                    return;
-                }
-                if (key.name === "escape") {
-                    cancel();
-                    return;
-                }
-                if (key.name === "return" || key.name === "enter") {
-                    finish();
-                }
-            };
-            output.write(formatFinalCommandConfirmation(command));
-            cleanupKeypressSession = (0, key_input_1.beginKeypressSession)(input, onKeypress);
-        });
-    });
-}
-function confirmDangerousCommand(command_1, match_1) {
-    return __awaiter(this, arguments, void 0, function* (command, match, streams = {}) {
-        var _a, _b;
-        const input = (_a = streams.input) !== null && _a !== void 0 ? _a : process.stdin;
-        const output = (_b = streams.output) !== null && _b !== void 0 ? _b : process.stdout;
-        (0, interactive_1.ensureInteractiveTty)(input, output);
-        const rl = readline_1.default.createInterface({
-            input,
-            output,
-            terminal: input.isTTY === true && output.isTTY === true,
-        });
-        try {
-            output.write(formatDangerousCommandConfirmation(command, match));
-            const answer = yield readConfirmationLine(rl, input);
-            if (answer !== "EXECUTE") {
-                throw new interactive_1.InteractionCancelledError("Dangerous command confirmation cancelled");
-            }
-        }
-        finally {
-            rl.close();
-        }
-    });
-}
-function formatFinalCommandConfirmation(command) {
-    return `\nFinal command:\n${command}\n\nPress Enter to execute, Esc or Ctrl+C to cancel.\n`;
-}
-function formatDangerousCommandConfirmation(command, match) {
-    return [
-        "\nDangerous command detected.",
-        `Rule: ${match.rule}`,
-        `Risk: ${match.reason}`,
-        "",
-        "Final command:",
-        command,
-        "",
-        'Type EXECUTE to continue, or anything else to cancel.',
-        "> ",
-    ].join("\n");
-}
-function readConfirmationLine(rl, input) {
-    input.resume();
-    return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            rl.off("line", onLine);
-            rl.off("SIGINT", onSigint);
-        };
-        const onLine = (line) => {
-            cleanup();
-            resolve(line);
-        };
-        const onSigint = () => {
-            cleanup();
-            reject(new interactive_1.InteractionCancelledError("Dangerous command confirmation cancelled"));
-        };
-        rl.on("line", onLine);
-        rl.on("SIGINT", onSigint);
-    });
-}

package/dist/ui/interactive.js

@@ -1,115 +0,0 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InteractionCancelledError = exports.InteractiveTtyError = void 0;
-exports.selectCommandCandidate = selectCommandCandidate;
-exports.ensureInteractiveTty = ensureInteractiveTty;
-exports.formatCandidateSelection = formatCandidateSelection;
-const key_input_1 = require("./key-input");
-class InteractiveTtyError extends Error {
-    constructor(message = "Interactive mode requires a TTY. Run howto in an interactive terminal or use --print.") {
-        super(message);
-        this.name = "InteractiveTtyError";
-    }
-}
-exports.InteractiveTtyError = InteractiveTtyError;
-class InteractionCancelledError extends Error {
-    constructor(message = "Interactive selection cancelled") {
-        super(message);
-        this.name = "InteractionCancelledError";
-    }
-}
-exports.InteractionCancelledError = InteractionCancelledError;
-function selectCommandCandidate(candidates_1) {
-    return __awaiter(this, arguments, void 0, function* (candidates, streams = {}) {
-        var _a, _b;
-        const input = (_a = streams.input) !== null && _a !== void 0 ? _a : process.stdin;
-        const output = (_b = streams.output) !== null && _b !== void 0 ? _b : process.stdout;
-        ensureInteractiveTty(input, output);
-        return new Promise((resolve, reject) => {
-            let activeIndex = 0;
-            let renderedLineCount = 0;
-            let cleanupKeypressSession;
-            const clearRenderedSelection = () => {
-                if (renderedLineCount > 0) {
-                    output.write(`\x1B[${renderedLineCount}A\x1B[J`);
-                    renderedLineCount = 0;
-                }
-            };
-            const cleanup = () => {
-                cleanupKeypressSession === null || cleanupKeypressSession === void 0 ? void 0 : cleanupKeypressSession();
-                cleanupKeypressSession = undefined;
-                clearRenderedSelection();
-                output.write("\x1B[?25h");
-            };
-            const finish = (candidate) => {
-                cleanup();
-                resolve(candidate);
-            };
-            const cancel = () => {
-                cleanup();
-                reject(new InteractionCancelledError());
-            };
-            const render = () => {
-                const text = formatCandidateSelection(candidates, activeIndex);
-                clearRenderedSelection();
-                output.write(`\x1B[?25l${text}\n`);
-                renderedLineCount = text.split("\n").length + 1;
-            };
-            const onKeypress = (_inputText, key = {}) => {
-                if (key.ctrl === true && key.name === "c") {
-                    cancel();
-                    return;
-                }
-                if (key.name === "escape") {
-                    cancel();
-                    return;
-                }
-                if (key.name === "return" || key.name === "enter") {
-                    finish(candidates[activeIndex]);
-                    return;
-                }
-                if (key.name === "up") {
-                    activeIndex = (activeIndex - 1 + candidates.length) % candidates.length;
-                    render();
-                    return;
-                }
-                if (key.name === "down") {
-                    activeIndex = (activeIndex + 1) % candidates.length;
-                    render();
-                }
-            };
-            cleanupKeypressSession = (0, key_input_1.beginKeypressSession)(input, onKeypress);
-            render();
-        });
-    });
-}
-function ensureInteractiveTty(input, output) {
-    if (input.isTTY !== true || output.isTTY !== true) {
-        throw new InteractiveTtyError();
-    }
-}
-function formatCandidateSelection(candidates, activeIndex) {
-    const lines = ["? Select a command", ""];
-    candidates.forEach((candidate, index) => {
-        const prefix = index === activeIndex ? ">" : " ";
-        const titleLine = `${prefix} ${candidate.title}`;
-        lines.push(index === activeIndex ? `\x1B[7m${titleLine}\x1B[0m` : titleLine);
-        lines.push(`  ${candidate.command}`);
-        lines.push(`  ${candidate.description}`);
-        if (index < candidates.length - 1) {
-            lines.push("");
-        }
-    });
-    lines.push("");
-    lines.push("Use Up/Down to move, Enter to select, Esc or Ctrl+C to cancel.");
-    return lines.join("\n");
-}

package/dist/ui/key-input.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.beginKeypressSession = beginKeypressSession;
-const readline_1 = __importDefault(require("readline"));
-function beginKeypressSession(input, onKeypress) {
-    const wasRaw = input.isRaw === true;
-    readline_1.default.emitKeypressEvents(input);
-    input.on("keypress", onKeypress);
-    if (typeof input.setRawMode === "function") {
-        input.setRawMode(true);
-    }
-    input.resume();
-    return () => {
-        input.off("keypress", onKeypress);
-        if (typeof input.setRawMode === "function" && !wasRaw) {
-            input.setRawMode(false);
-        }
-        input.pause();
-    };
-}

package/dist/ui/loading.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAiLoadingIndicator = createAiLoadingIndicator;
-const FRAMES = ["|", "/", "-", "\\"];
-const MESSAGE = "Waiting for AI response...";
-function createAiLoadingIndicator(options) {
-    var _a, _b;
-    const output = (_a = options.output) !== null && _a !== void 0 ? _a : process.stdout;
-    const intervalMs = (_b = options.intervalMs) !== null && _b !== void 0 ? _b : 120;
-    let timer;
-    let frameIndex = 0;
-    let running = false;
-    const shouldRender = () => options.enabled && output.isTTY === true;
-    const render = () => {
-        const frame = FRAMES[frameIndex % FRAMES.length];
-        frameIndex += 1;
-        output.write(`\r${frame} ${MESSAGE}`);
-    };
-    return {
-        start() {
-            if (!shouldRender() || running) {
-                return;
-            }
-            running = true;
-            render();
-            timer = setInterval(render, intervalMs);
-        },
-        stop() {
-            if (!running) {
-                return;
-            }
-            if (timer !== undefined) {
-                clearInterval(timer);
-                timer = undefined;
-            }
-            running = false;
-            output.write("\r\x1B[2K");
-        },
-    };
-}