@unscientificjszhai/howto 1.0.0-alpha.2

package/LICENSE

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

package/dist/ai/errors.js

@@ -0,0 +1,30 @@
+export class AiProviderError extends Error {
+    constructor(provider, model, cause) {
+        super(formatProviderError(provider, model, cause));
+        this.name = "AiProviderError";
+        this.provider = provider;
+        this.model = model;
+    }
+}
+function formatProviderError(provider, model, cause) {
+    const summary = sanitizeErrorSummary(cause);
+    return `AI provider request failed (provider: ${provider}, model: ${model}): ${summary}`;
+}
+function sanitizeErrorSummary(cause) {
+    const rawMessage = getErrorMessage(cause);
+    const singleLine = rawMessage.replace(/\s+/g, " ").trim();
+    const redacted = singleLine
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]")
+        .replace(/(api[-_ ]?key["'\s:=]+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]")
+        .replace(/(authorization["'\s:=]+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]");
+    return redacted.length > 220 ? `${redacted.slice(0, 217)}...` : redacted;
+}
+function getErrorMessage(cause) {
+    if (cause instanceof Error && cause.message.trim() !== "") {
+        return cause.message;
+    }
+    if (typeof cause === "string" && cause.trim() !== "") {
+        return cause;
+    }
+    return "unknown error";
+}

package/dist/ai/gemini.js

@@ -0,0 +1,39 @@
+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 { GoogleGenAI } from "@google/genai";
+import { AiProviderError } from "./errors.js";
+export class GeminiCommandProvider {
+    constructor(config) {
+        this.model = config.model;
+        this.client = new GoogleGenAI({ apiKey: config.apiKey });
+    }
+    generateCommands(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.client.models.generateContent({
+                    model: this.model,
+                    contents: request.userPrompt,
+                    config: {
+                        systemInstruction: request.systemPrompt,
+                        responseMimeType: "application/json",
+                    },
+                });
+                const rawText = response.text;
+                if (rawText === undefined || rawText.trim() === "") {
+                    throw new Error("provider returned an empty response");
+                }
+                return { rawText };
+            }
+            catch (error) {
+                throw new AiProviderError("gemini", this.model, error);
+            }
+        });
+    }
+}

package/dist/ai/index.js

@@ -0,0 +1,15 @@
+import { GeminiCommandProvider } from "./gemini.js";
+import { OpenAiCommandProvider } from "./openai.js";
+export function createCommandProvider(config) {
+    switch (config.aiProvider) {
+        case "openai":
+            return new OpenAiCommandProvider(config.openai);
+        case "gemini":
+            return new GeminiCommandProvider(config.gemini);
+        default: {
+            const exhaustive = config.aiProvider;
+            return exhaustive;
+        }
+    }
+}
+export { AiProviderError } from "./errors.js";

package/dist/ai/openai.js

@@ -0,0 +1,43 @@
+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 OpenAI from "openai";
+import { AiProviderError } from "./errors.js";
+export class OpenAiCommandProvider {
+    constructor(config) {
+        this.model = config.model;
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl,
+        });
+    }
+    generateCommands(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const response = yield this.client.chat.completions.create({
+                    model: this.model,
+                    messages: [
+                        { role: "system", content: request.systemPrompt },
+                        { role: "user", content: request.userPrompt },
+                    ],
+                    response_format: { type: "json_object" },
+                });
+                const rawText = (_b = (_a = response.choices[0]) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.content;
+                if (rawText === undefined || rawText === null || rawText.trim() === "") {
+                    throw new Error("provider returned an empty response");
+                }
+                return { rawText };
+            }
+            catch (error) {
+                throw new AiProviderError("openai", this.model, error);
+            }
+        });
+    }
+}

package/dist/ai/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,140 @@
+export class CliParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CliParseError";
+    }
+}
+const VALUE_OPTIONS = new Set([
+    "--ai-provider",
+    "--gemini-api-key",
+    "--gemini-model",
+    "--openai-api-url",
+    "--openai-api-key",
+    "--openai-model",
+]);
+const BOOLEAN_OPTIONS = new Set(["--print", "--init"]);
+export const USAGE = `Usage: howto [options] [use <command>] <question> [<argument>...]
+       howto --init
+
+Options:
+  --init
+  --print
+  --ai-provider <openai|gemini>
+  --gemini-api-key <key>
+  --gemini-model <model>
+  --openai-api-url <url>
+  --openai-api-key <key>
+  --openai-model <model>
+
+Try: howto "list files changed today"`;
+export function parseCliArgs(argv) {
+    const options = { print: false };
+    const positionals = [];
+    let parseOptions = true;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (parseOptions && token === "--") {
+            parseOptions = false;
+            continue;
+        }
+        if (parseOptions && token.startsWith("--")) {
+            const equalIndex = token.indexOf("=");
+            const optionName = equalIndex === -1 ? token : token.slice(0, equalIndex);
+            const inlineValue = equalIndex === -1 ? undefined : token.slice(equalIndex + 1);
+            if (BOOLEAN_OPTIONS.has(optionName)) {
+                if (inlineValue !== undefined) {
+                    throw new CliParseError(`${optionName} does not accept a value`);
+                }
+                assignBooleanOption(options, optionName);
+                continue;
+            }
+            if (VALUE_OPTIONS.has(optionName)) {
+                const value = inlineValue !== undefined ? inlineValue : readOptionValue(argv, index, optionName);
+                if (inlineValue === undefined) {
+                    index += 1;
+                }
+                assignOptionValue(options, optionName, value);
+                continue;
+            }
+            throw new CliParseError(`unknown option: ${optionName}`);
+        }
+        positionals.push(token);
+    }
+    return parsePositionals(options, positionals);
+}
+function readOptionValue(argv, optionIndex, optionName) {
+    const value = argv[optionIndex + 1];
+    if (value === undefined || value === "--" || value.startsWith("--")) {
+        throw new CliParseError(`missing value for ${optionName}`);
+    }
+    return value;
+}
+function assignOptionValue(options, optionName, value) {
+    switch (optionName) {
+        case "--ai-provider":
+            options.aiProvider = value;
+            return;
+        case "--gemini-api-key":
+            options.geminiApiKey = value;
+            return;
+        case "--gemini-model":
+            options.geminiModel = value;
+            return;
+        case "--openai-api-url":
+            options.openaiApiUrl = value;
+            return;
+        case "--openai-api-key":
+            options.openaiApiKey = value;
+            return;
+        case "--openai-model":
+            options.openaiModel = value;
+            return;
+        default:
+            throw new CliParseError(`unsupported option: ${optionName}`);
+    }
+}
+function assignBooleanOption(options, optionName) {
+    switch (optionName) {
+        case "--print":
+            options.print = true;
+            return;
+        case "--init":
+            options.init = true;
+            return;
+        default:
+            throw new CliParseError(`unsupported option: ${optionName}`);
+    }
+}
+function parsePositionals(options, positionals) {
+    if (options.init) {
+        if (options.print) {
+            throw new CliParseError("--init cannot be combined with --print");
+        }
+        if (positionals.length > 0) {
+            throw new CliParseError("--init cannot be combined with a question or use mode");
+        }
+        return { options, arguments: [] };
+    }
+    if (positionals.length === 0) {
+        throw new CliParseError("missing question");
+    }
+    if (positionals[0] === "use") {
+        if (positionals.length === 1) {
+            throw new CliParseError("use mode requires <command> and <question>");
+        }
+        if (positionals.length === 2) {
+            throw new CliParseError("use mode requires <question>");
+        }
+        return {
+            options,
+            useCommand: positionals[1],
+            question: positionals[2],
+            arguments: positionals.slice(3),
+        };
+    }
+    return {
+        options,
+        question: positionals[0],
+        arguments: positionals.slice(1),
+    };
+}

package/dist/config-file.js

@@ -0,0 +1,66 @@
+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 { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { ConfigError } from "./config.js";
+const CONFIG_FILE_FIELDS = new Set([
+    "aiProvider",
+    "geminiApiKey",
+    "geminiModel",
+    "openaiApiUrl",
+    "openaiApiKey",
+    "openaiModel",
+]);
+export function getConfigFilePath(env = process.env) {
+    var _a;
+    return join((_a = env.HOME) !== null && _a !== void 0 ? _a : homedir(), ".howto", "config.json");
+}
+export function readUserConfigFile() {
+    return __awaiter(this, arguments, void 0, function* (path = getConfigFilePath()) {
+        if (!existsSync(path)) {
+            return {};
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(yield readFile(path, "utf8"));
+        }
+        catch (error) {
+            throw new ConfigError(`failed to read config file ${path}: ${getParseErrorMessage(error)}`);
+        }
+        if (!isPlainObject(parsed)) {
+            throw new ConfigError(`config file ${path} must contain a JSON object`);
+        }
+        const config = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!CONFIG_FILE_FIELDS.has(key)) {
+                continue;
+            }
+            if (typeof value !== "string") {
+                throw new ConfigError(`config file field ${key} must be a string`);
+            }
+            config[key] = value;
+        }
+        return config;
+    });
+}
+export function writeUserConfigFile(config_1) {
+    return __awaiter(this, arguments, void 0, function* (config, path = getConfigFilePath()) {
+        yield mkdir(dirname(path), { recursive: true });
+        yield writeFile(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    });
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getParseErrorMessage(error) {
+    return error instanceof Error ? error.message : "invalid JSON";
+}

package/dist/config.js

@@ -0,0 +1,49 @@
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+    }
+}
+const DEFAULT_OPENAI_MODEL = "gpt-5.4-mini";
+const DEFAULT_GEMINI_MODEL = "gemini-3.1-flash-lite";
+export { DEFAULT_GEMINI_MODEL, DEFAULT_OPENAI_MODEL };
+export function hasExplicitAiProvider(options, env, fileConfig = {}) {
+    return (pickConfigValue(options.aiProvider, env.HOWTO_AI_PROVIDER, fileConfig.aiProvider) !== undefined);
+}
+export function loadConfig(options, env, fileConfig = {}) {
+    var _a, _b, _c;
+    const aiProviderValue = pickConfigValue(options.aiProvider, env.HOWTO_AI_PROVIDER, fileConfig.aiProvider);
+    if (aiProviderValue === undefined) {
+        throw new ConfigError("AI provider is not configured. Set --ai-provider or HOWTO_AI_PROVIDER, or run howto in an interactive terminal to initialize it.");
+    }
+    const aiProvider = parseAiProvider(aiProviderValue);
+    const config = {
+        aiProvider,
+        gemini: {
+            apiKey: pickConfigValue(options.geminiApiKey, env.HOWTO_GEMINI_API_KEY, fileConfig.geminiApiKey),
+            model: (_a = pickConfigValue(options.geminiModel, env.HOWTO_GEMINI_MODEL, fileConfig.geminiModel)) !== null && _a !== void 0 ? _a : DEFAULT_GEMINI_MODEL,
+        },
+        openai: {
+            apiKey: (_b = pickConfigValue(options.openaiApiKey, env.HOWTO_OPENAI_API_KEY, fileConfig.openaiApiKey)) !== null && _b !== void 0 ? _b : "",
+            model: (_c = pickConfigValue(options.openaiModel, env.HOWTO_OPENAI_MODEL, fileConfig.openaiModel)) !== null && _c !== void 0 ? _c : DEFAULT_OPENAI_MODEL,
+            baseUrl: pickConfigValue(options.openaiApiUrl, env.HOWTO_OPENAI_API_URL, fileConfig.openaiApiUrl),
+        },
+    };
+    if (config.aiProvider === "gemini" && isBlank(config.gemini.apiKey)) {
+        throw new ConfigError("Gemini provider requires --gemini-api-key or HOWTO_GEMINI_API_KEY");
+    }
+    return config;
+}
+function pickConfigValue(cliValue, envValue, fileValue) {
+    var _a;
+    return (_a = cliValue !== null && cliValue !== void 0 ? cliValue : envValue) !== null && _a !== void 0 ? _a : fileValue;
+}
+function parseAiProvider(value) {
+    if (value === "openai" || value === "gemini") {
+        return value;
+    }
+    throw new ConfigError("invalid AI provider; expected openai or gemini");
+}
+function isBlank(value) {
+    return value === undefined || value.trim() === "";
+}

package/dist/env.js

@@ -0,0 +1,10 @@
+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/errors.js

@@ -0,0 +1,57 @@
+import { AiProviderError } from "./ai/index.js";
+import { CliParseError, USAGE } from "./cli.js";
+import { ConfigError } from "./config.js";
+import { AiResponseValidationError } from "./validation/ai-response.js";
+import { InteractionCancelledError, InteractiveTtyError } from "./ui/tty.js";
+import { PlaceholderResolutionError } from "./ui/placeholder-logic.js";
+export class AppError extends Error {
+    constructor(message, exitCode) {
+        super(message);
+        this.name = "AppError";
+        this.exitCode = exitCode;
+    }
+}
+export function toAppError(error) {
+    if (error instanceof AppError) {
+        return error;
+    }
+    if (error instanceof CliParseError) {
+        return new AppError(`Error: ${error.message}\n${USAGE}`, 2);
+    }
+    if (error instanceof ConfigError) {
+        return new AppError(`Configuration error: ${error.message}`, 2);
+    }
+    if (error instanceof AiProviderError) {
+        return new AppError(error.message, 1);
+    }
+    if (error instanceof AiResponseValidationError) {
+        return new AppError(`AI response format error: ${error.message}`, 2);
+    }
+    if (error instanceof InteractiveTtyError) {
+        return new AppError(`Error: ${error.message}`, 2);
+    }
+    if (error instanceof PlaceholderResolutionError) {
+        return new AppError(`Error: ${error.message}`, 2);
+    }
+    if (error instanceof InteractionCancelledError) {
+        return new AppError("", 130);
+    }
+    return new AppError(`Error: ${sanitizeErrorMessage(getErrorMessage(error))}`, 1);
+}
+function getErrorMessage(error) {
+    if (error instanceof Error && error.message.trim() !== "") {
+        return error.message;
+    }
+    if (typeof error === "string" && error.trim() !== "") {
+        return error;
+    }
+    return "unknown error";
+}
+function sanitizeErrorMessage(message) {
+    const singleLine = message.replace(/\s+/g, " ").trim();
+    const redacted = singleLine
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]")
+        .replace(/(api[-_ ]?key["'\s:=]+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]")
+        .replace(/(authorization["'\s:=]+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]");
+    return redacted.length > 220 ? `${redacted.slice(0, 217)}...` : redacted;
+}

package/dist/execute.js

@@ -0,0 +1,47 @@
+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 { spawn } from "child_process";
+import { constants as osConstants } from "os";
+export function executeCommand(command_1) {
+    return __awaiter(this, arguments, void 0, function* (command, options = {}) {
+        var _a, _b, _c;
+        const env = (_a = options.env) !== null && _a !== void 0 ? _a : process.env;
+        const platform = (_b = options.platform) !== null && _b !== void 0 ? _b : process.platform;
+        const spawnCommand = (_c = options.spawnCommand) !== null && _c !== void 0 ? _c : spawnCommandWithNodeSpawn;
+        const child = platform === "win32"
+            ? spawnCommand(command, { shell: env.SHELL || true, stdio: "inherit" }, { stdio: "inherit" })
+            : spawnCommand(resolveShell(env), ["-lc", `exec ${command}`], { stdio: "inherit" });
+        return new Promise((resolve, reject) => {
+            child.once("error", reject);
+            child.once("close", (code, signal) => {
+                resolve(resolveProcessExitCode(code, signal));
+            });
+        });
+    });
+}
+export function resolveProcessExitCode(code, signal) {
+    var _a;
+    if (typeof code === "number") {
+        return code;
+    }
+    if (signal !== null) {
+        return 128 + ((_a = osConstants.signals[signal]) !== null && _a !== void 0 ? _a : 1);
+    }
+    return 1;
+}
+function resolveShell(env) {
+    return env.SHELL && env.SHELL.trim() !== "" ? env.SHELL : "/bin/sh";
+}
+const spawnCommandWithNodeSpawn = (command, args, options) => {
+    if (Array.isArray(args)) {
+        return options === undefined ? spawn(command, args) : spawn(command, args, options);
+    }
+    return spawn(command, args);
+};

package/dist/index.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+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 React from "react";
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { render } from "ink";
+import { CliParseError, parseCliArgs } from "./cli.js";
+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 { ensureInteractiveTty } from "./ui/tty.js";
+import { executeCommand } from "./execute.js";
+import { toAppError } from "./errors.js";
+import { App } from "./ui/App.js";
+import { initializeConfig } from "./init/index.js";
+function run(argv) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const parsedCli = parseCliArgs(argv);
+            if (parsedCli.options.init) {
+                ensureInteractiveTty(process.stdin, process.stdout);
+                yield initializeConfig({
+                    cliOptions: parsedCli.options,
+                    env: process.env,
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                return { exitCode: 0 };
+            }
+            const fileConfig = yield readUserConfigFile();
+            if (parsedCli.question === undefined) {
+                throw new CliParseError("missing question");
+            }
+            if (!hasExplicitAiProvider(parsedCli.options, process.env, fileConfig)) {
+                if (parsedCli.options.print) {
+                    throw new ConfigError("AI provider is not configured. --print cannot run initialization; run howto --init or set --ai-provider, HOWTO_AI_PROVIDER, or ~/.howto/config.json.");
+                }
+                ensureInteractiveTty(process.stdin, process.stdout);
+            }
+            const config = hasExplicitAiProvider(parsedCli.options, process.env, fileConfig)
+                ? loadConfig(parsedCli.options, process.env, fileConfig)
+                : yield initializeConfig({
+                    cliOptions: parsedCli.options,
+                    env: process.env,
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+            const useCommandPathCheck = parsedCli.useCommand === undefined
+                ? undefined
+                : checkCommandInPath(parsedCli.useCommand, process.env);
+            if (!parsedCli.options.print) {
+                ensureInteractiveTty(process.stdin, process.stdout);
+            }
+            const promptRequest = createProviderPromptRequest({
+                question: parsedCli.question,
+                arguments: parsedCli.arguments,
+                useCommand: parsedCli.useCommand,
+            });
+            const { systemPrompt, userPrompt } = buildCommandGenerationPrompt(promptRequest);
+            const provider = createCommandProvider(config);
+            if (parsedCli.options.print) {
+                const aiResult = yield provider.generateCommands(Object.assign(Object.assign({}, promptRequest), { systemPrompt,
+                    userPrompt }));
+                const aiResponse = parseAndValidateAiResponse(aiResult.rawText);
+                aiResponse.commands.forEach((candidate) => {
+                    console.log(candidate.command);
+                });
+                return { exitCode: 0 };
+            }
+            if (useCommandPathCheck !== undefined && !useCommandPathCheck.found) {
+                console.error(`Warning: requested command "${useCommandPathCheck.command}" was not found in PATH. Review before executing any generated command.`);
+            }
+            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) => {
+                    finalCommand = command;
+                    clear();
+                    unmount();
+                }, onError: (error) => {
+                    appError = error;
+                    clear();
+                    unmount();
+                } }));
+            yield waitUntilExit();
+            if (appError) {
+                throw appError;
+            }
+            if (finalCommand === undefined) {
+                return { exitCode: 1 };
+            }
+            const exitCode = yield executeCommand(finalCommand);
+            return { exitCode };
+        }
+        catch (error) {
+            const appError = toAppError(error);
+            if (appError.message !== "") {
+                console.error(appError.message);
+            }
+            return { exitCode: appError.exitCode };
+        }
+    });
+}
+function resolveEntrypointPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch (_a) {
+        return path;
+    }
+}
+const isMain = process.argv[1] !== undefined &&
+    fileURLToPath(import.meta.url) === resolveEntrypointPath(process.argv[1]);
+if (isMain) {
+    run(process.argv.slice(2))
+        .then((result) => {
+        process.exitCode = result.exitCode;
+    })
+        .catch((error) => {
+        const appError = toAppError(error);
+        if (appError.message !== "") {
+            console.error(appError.message);
+        }
+        process.exitCode = appError.exitCode;
+    });
+}
+export { run };