gitpt 1.2.0 → 1.4.0

package/README.md

@@ -1,6 +1,6 @@
 # GitPT
 
-Git Prompt Tool is a CLI tool that helps you write commit messages using AI through [OpenRouter](https://openrouter.ai/). It acts as a complete git wrapper, enhancing specific commands with AI while passing through all other git commands directly.
+Git Prompt Tool is a CLI tool that helps you write commit messages using AI through [OpenRouter](https://openrouter.ai/) or a local LLM. It acts as a complete git wrapper, enhancing specific commands with AI while passing through all other git commands directly.
 
 ## Features
 
@@ -14,6 +14,7 @@ Git Prompt Tool is a CLI tool that helps you write commit messages using AI thro
 - Compatible with all regular git options (flags, arguments, etc.)
 - Edit suggested messages before committing
 - Works with various AI models via OpenRouter
+- Support for local LLMs with OpenAI-compatible API
 - [Commitlint](https://commitlint.js.org/) support - read directly from your repository
 
 ## Installation
@@ -38,6 +39,9 @@ This will guide you through:
 1. Entering your OpenRouter API key
 2. Selecting an AI model from popular options or specifying a custom one
 
+_It's recommended using small models, such as `openai/gpt-4.1-mini` as your model choice. Mainly due to its large context window, fast response times & cost-effective pricing._
+
+
 You'll need an [OpenRouter](https://openrouter.ai/) account to get an API key.
 
 ## Usage
@@ -93,18 +97,22 @@ The tool will:
 
 ### Changing Models
 
-You can change the AI model at any time without re-entering your API key:
+You can change the AI model at any time:
 
 ```bash
-# Select model interactively (fetches available models from OpenRouter)
+# Select model interactively (either OpenRouter or a local LLM)
 gitpt model
+```
 
-# Specify model directly
-gitpt model openai/gpt-4o
+_It's recommended using small models, such as `openai/gpt-4.1-mini` as your model choice. Mainly due to its large context window, fast response times & cost-effective pricing._
 
-# Switch to a different Claude model
-gitpt model anthropic/claude-3-haiku
-```
+#### Using a Local LLM
+
+GitPT works with any local LLM that provides an OpenAI-compatible API endpoint, such as:
+- [Ollama](https://ollama.ai/)
+- [LM Studio](https://lmstudio.ai/)
+- [LocalAI](https://localai.io/)
+- Custom setups with tools like llama.cpp
 
 ## GitHub Usage
 
@@ -143,7 +151,7 @@ gitpt pr create --title "Your PR title here"
 
 ## How It Works
 
-GitPT leverages AI via OpenRouter to enhance your Git workflow while acting as a complete git wrapper:
+GitPT leverages AI to enhance your Git workflow while acting as a complete git wrapper:
 
 - **Command Handling:** GitPT intelligently routes commands - enhanced commands (commit, pr) use AI capabilities while all other git commands are passed directly to git.
 
@@ -155,6 +163,8 @@ GitPT leverages AI via OpenRouter to enhance your Git workflow while acting as a
 
 - **For other git commands:** Passes them through directly to git with all arguments and options preserved, ensuring complete compatibility with your existing git workflow.
 
+- **Local LLM Support:** Can use locally running LLM servers with OpenAI-compatible APIs instead of cloud-based services, providing privacy and offline capabilities.
+
 ## Development
 
 ```bash
@@ -188,4 +198,4 @@ This integration ensures that all AI-generated commit messages follow your team'
 
 ## License
 
-MIT
+MIT

package/dist/commands/commit/context/systemPrompt.d.ts

@@ -0,0 +1 @@
+export declare const systemPrompt = "\nYou are a helpful assistant that generates concise, informative Git commit messages.\n\nFollow these strict rules:\n1. Use conventional commit format: type: description\n2. Types are: feat, fix, docs, style, refactor, test, chore\n3. NO scopes in parentheses - do not use feat(scope)\n4. Keep the entire message under 100 characters\n5. Use present tense (e.g., \"add feature\" not \"added feature\")\n6. Be brief but descriptive about WHAT changed\n7. Do not include detailed explanations\n\nCritical Rules:\n- Return a SINGLE LINE commit message only, with no additional explanations or paragraphs\n- Do NOT include a detailed message body section, just the commit title line\n- Do NOT use multiple lines, even for a single message\n\nExamples of Good Commit Messages:\n- feat: add user authentication system\n- fix: resolve crash when opening settings menu\n- refactor: simplify data processing pipeline\n- docs: update installation instructions in README\n- chore: update npm dependencies to latest versions\n- style: fix indentation in CSS files\n- test: add unit tests for payment processing\n- perf: optimize database queries for faster loading\n- build: update webpack configuration\n- ci: fix GitHub Actions workflow\n\nExamples of Bad Commit Messages:\n- added login screen                    \u274C (missing type prefix)\n- feat(auth): implement OAuth login     \u274C (using scope parentheses)\n- This is a really long commit message that exceeds the limit and contains too much information \u274C (too long)\n- feat: Adding user auth\n  \n  This implements the login page...     \u274C (contains multiple lines)\n- \"fix: update styling\"                 \u274C (includes quotes)\n";

package/dist/commands/commit/context/systemPrompt.js

@@ -0,0 +1,38 @@
+export const systemPrompt = `
+You are a helpful assistant that generates concise, informative Git commit messages.
+
+Follow these strict rules:
+1. Use conventional commit format: type: description
+2. Types are: feat, fix, docs, style, refactor, test, chore
+3. NO scopes in parentheses - do not use feat(scope)
+4. Keep the entire message under 100 characters
+5. Use present tense (e.g., "add feature" not "added feature")
+6. Be brief but descriptive about WHAT changed
+7. Do not include detailed explanations
+
+Critical Rules:
+- Return a SINGLE LINE commit message only, with no additional explanations or paragraphs
+- Do NOT include a detailed message body section, just the commit title line
+- Do NOT use multiple lines, even for a single message
+
+Examples of Good Commit Messages:
+- feat: add user authentication system
+- fix: resolve crash when opening settings menu
+- refactor: simplify data processing pipeline
+- docs: update installation instructions in README
+- chore: update npm dependencies to latest versions
+- style: fix indentation in CSS files
+- test: add unit tests for payment processing
+- perf: optimize database queries for faster loading
+- build: update webpack configuration
+- ci: fix GitHub Actions workflow
+
+Examples of Bad Commit Messages:
+- added login screen                    ❌ (missing type prefix)
+- feat(auth): implement OAuth login     ❌ (using scope parentheses)
+- This is a really long commit message that exceeds the limit and contains too much information ❌ (too long)
+- feat: Adding user auth
+  
+  This implements the login page...     ❌ (contains multiple lines)
+- "fix: update styling"                 ❌ (includes quotes)
+`;

package/dist/commands/commit/context/userPrompt.d.ts

@@ -0,0 +1 @@
+export declare const userPrompt: (diff: string) => string;

package/dist/commands/commit/context/userPrompt.js

@@ -0,0 +1,5 @@
+export const userPrompt = (diff) => `
+Generate a single-line commit message for the following git diff:
+
+${diff}
+`;

package/dist/commands/commit/generateCommitMessage.d.ts

@@ -0,0 +1 @@
+export declare const generateCommitMessage: (diff: string, validationErrors?: string) => Promise<string>;

package/dist/commands/commit/generateCommitMessage.js

@@ -0,0 +1,39 @@
+import { getConfig } from "../../config.js";
+import { getLLMClient } from "../../llm/index.js";
+import { getCommitlintRules, hasCommitlintConfig, } from "../../utils/commitlint.js";
+import { systemPrompt } from "./context/systemPrompt.js";
+import { userPrompt } from "./context/userPrompt.js";
+export const generateCommitMessage = async (diff, validationErrors) => {
+    // Check if commitlint is configured
+    const hasCommitlint = hasCommitlintConfig();
+    const config = getConfig();
+    // Check if we have a configured model
+    if (!config.model) {
+        throw new Error('GitPT is not configured properly. Please run "gitpt setup" first.');
+    }
+    const { model } = config;
+    const baseRules = hasCommitlint ? getCommitlintRules() : "";
+    const errorInfo = validationErrors
+        ? `\n\nYOUR PREVIOUS MESSAGE FAILED VALIDATION WITH THESE ERRORS:\n${validationErrors}\n\nFIX THESE ISSUES IN YOUR NEW MESSAGE.`
+        : "";
+    const llmClient = getLLMClient();
+    const response = await llmClient.chat.completions.create({
+        model: model,
+        messages: [
+            {
+                role: "system",
+                content: [systemPrompt, baseRules, errorInfo].join("\n\n"),
+            },
+            {
+                role: "user",
+                content: userPrompt(diff),
+            },
+        ],
+        max_tokens: 300,
+    });
+    const message = response.choices[0].message.content;
+    if (!message) {
+        throw new Error("No message returned from LLM");
+    }
+    return message;
+};

package/dist/commands/{commit.d.ts → commit/index.d.ts}

@@ -3,5 +3,5 @@ interface CommitOptions {
     edit?: boolean;
     [key: string]: any;
 }
-export declare function commitCommand(options: CommitOptions): Promise<void>;
+export declare const commitCommand: (options: CommitOptions) => Promise<void>;
 export {};

package/dist/commands/commit/index.js

@@ -0,0 +1,183 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { capabilitiesMiddleware } from "../middleware/capabilitiesMiddleware/index.js";
+import { setupMiddleware } from "../middleware/setupMiddleware/index.js";
+import { git } from "../../services/git/index.js";
+import { hasCommitlintConfig, validateCommitMessage, } from "../../utils/commitlint.js";
+import { hasStagedChangesMiddleware } from "../middleware/hasStagedChangesMiddleware.js";
+import { generateCommitMessage } from "./generateCommitMessage.js";
+export const commitCommand = async (options) => {
+    capabilitiesMiddleware(["git"]);
+    await setupMiddleware();
+    hasStagedChangesMiddleware();
+    let commitMessage;
+    // If message is provided, use that
+    if (options.message) {
+        commitMessage = options.message;
+    }
+    else {
+        try {
+            // Get staged changes
+            const diff = git.getStagedChanges();
+            console.log(chalk.blue("Generating commit message..."));
+            // Check if commitlint is configured
+            let hasCommitlint = false;
+            try {
+                hasCommitlint = hasCommitlintConfig();
+                if (hasCommitlint) {
+                    console.log(chalk.blue("Commitlint configuration detected. Generating message according to rules..."));
+                }
+            }
+            catch (error) {
+                console.warn(chalk.yellow("Warning: Error detecting commitlint config, proceeding without commitlint validation."));
+            }
+            // Generate first commit message
+            commitMessage = await generateCommitMessage(diff);
+            // If commitlint is configured, try to validate and regenerate up to 3 times
+            if (hasCommitlint) {
+                try {
+                    console.log(chalk.blue("Validating commit message against commitlint rules..."));
+                    // Try up to 3 times to get a valid message
+                    let validMessage = false;
+                    let attempts = 0;
+                    const MAX_ATTEMPTS = 3;
+                    let validationErrors;
+                    while (!validMessage && attempts < MAX_ATTEMPTS) {
+                        const validation = await validateCommitMessage(commitMessage);
+                        if (validation.valid) {
+                            console.log(chalk.green("✓ Commit message passed validation"));
+                            validMessage = true;
+                            break;
+                        }
+                        else {
+                            attempts++;
+                            console.log(chalk.yellow(`Commit message failed validation. ${attempts < MAX_ATTEMPTS
+                                ? "Regenerating..."
+                                : "Max attempts reached."}`));
+                            if (validation.errors) {
+                                console.log(chalk.gray(validation.errors));
+                                validationErrors = validation.errors;
+                            }
+                            if (attempts < MAX_ATTEMPTS) {
+                                // Try regenerating with validation errors
+                                try {
+                                    commitMessage = await generateCommitMessage(diff, validationErrors);
+                                }
+                                catch (error) {
+                                    console.warn(chalk.yellow("Error regenerating message, breaking validation loop."));
+                                    break;
+                                }
+                            }
+                            else {
+                                // Ask user what to do after max attempts
+                                const { action } = await inquirer.prompt([
+                                    {
+                                        type: "list",
+                                        name: "action",
+                                        message: "Failed to generate a valid commit message after 3 attempts. What would you like to do?",
+                                        choices: [
+                                            {
+                                                name: "Proceed with invalid message",
+                                                value: "proceed",
+                                            },
+                                            { name: "Edit message manually", value: "edit" },
+                                            { name: "Abort commit", value: "abort" },
+                                        ],
+                                    },
+                                ]);
+                                if (action === "abort") {
+                                    console.log(chalk.red("Commit aborted due to validation failures."));
+                                    process.exit(1);
+                                }
+                                else if (action === "edit") {
+                                    options.edit = true; // Force editor to open
+                                }
+                                else {
+                                    console.log(chalk.yellow("Proceeding with invalid message..."));
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // If there's an error with commitlint validation, continue without it
+                    console.warn(chalk.yellow("Warning: Error during commitlint validation, proceeding without validation."));
+                    console.warn(chalk.gray("This may be due to an ESM module cycle conflict or missing commitlint dependencies."));
+                }
+            }
+            console.log(chalk.green("✓ Commit message generated"));
+            console.log("");
+            console.log(chalk.cyan("Generated message:"));
+            console.log(commitMessage);
+            console.log("");
+        }
+        catch (error) {
+            console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    // If edit is true or not specified, prompt user to edit the message
+    if (options.edit !== false) {
+        const answer = await inquirer.prompt([
+            {
+                type: "editor",
+                name: "message",
+                message: "Edit commit message:",
+                default: commitMessage,
+            },
+        ]);
+        commitMessage = answer.message;
+        // Validate the edited message once
+        try {
+            const hasCommitlint = hasCommitlintConfig();
+            if (hasCommitlint) {
+                console.log(chalk.blue("Validating edited commit message..."));
+                const validation = await validateCommitMessage(commitMessage);
+                if (!validation.valid) {
+                    console.log(chalk.yellow("Warning: Edited message still has validation issues."));
+                    if (validation.errors) {
+                        console.log(chalk.gray(validation.errors));
+                    }
+                    // Ask if user wants to proceed anyway
+                    const { proceed } = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "proceed",
+                            message: "Proceed with invalid commit message?",
+                            default: false,
+                        },
+                    ]);
+                    if (!proceed) {
+                        console.log(chalk.red("Commit aborted by user."));
+                        process.exit(1);
+                    }
+                }
+                else {
+                    console.log(chalk.green("✓ Edited message passed validation"));
+                }
+            }
+        }
+        catch (error) {
+            // If validation fails, just warn and continue
+            console.warn(chalk.yellow("Could not validate edited message, proceeding anyway."));
+        }
+    }
+    // Extract other git options to pass through
+    const gitOptions = Object.keys(options)
+        .filter((key) => !["message", "edit"].includes(key))
+        .map((key) => {
+        if (typeof options[key] === "boolean") {
+            return options[key] ? `--${key}` : `--no-${key}`;
+        }
+        return `--${key}=${options[key]}`;
+    });
+    try {
+        git.commit(commitMessage, gitOptions);
+        console.log(chalk.green("✓ Changes committed successfully"));
+    }
+    catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+};

package/dist/commands/config.d.ts

@@ -0,0 +1 @@
+export declare const configCommand: () => Promise<void>;

package/dist/commands/config.js

@@ -0,0 +1,11 @@
+import chalk from "chalk";
+import { getConfig } from "../config.js";
+import { maskApiKey } from "../utils/maskApiKey.js";
+export const configCommand = async () => {
+    console.log(chalk.blue("GitPT Configuration"));
+    const { apiKey, ...config } = getConfig();
+    console.log({
+        apiKey: apiKey ? maskApiKey(apiKey) : undefined,
+        ...config,
+    });
+};

package/dist/commands/middleware/capabilitiesMiddleware/ghCapability.d.ts

@@ -0,0 +1 @@
+export declare const ghCapability: () => void;

package/dist/commands/middleware/capabilitiesMiddleware/ghCapability.js

@@ -0,0 +1,23 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+import { gh } from "../../../services/gh/index.js";
+export const ghCapability = () => {
+    if (!gh.isAvailable()) {
+        console.error(chalk.red("GitHub CLI (gh) is not installed or available in PATH"));
+        console.log(chalk.yellow("Please install GitHub CLI from https://cli.github.com/"));
+        process.exit(1);
+    }
+    // Check if user is authenticated with GitHub CLI
+    try {
+        const authStatus = execSync("gh auth status -h github.com 2>&1 || true").toString();
+        if (authStatus.includes("not logged")) {
+            console.error(chalk.red("Error: You are not authenticated with GitHub CLI."));
+            console.log(chalk.yellow("Please run `gh auth login` to authenticate."));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.log(chalk.yellow("Warning: Could not verify GitHub CLI authentication."));
+        console.log(chalk.yellow("If PR creation fails, please run `gh auth login` first."));
+    }
+};

package/dist/commands/middleware/capabilitiesMiddleware/gitCapability.d.ts

@@ -0,0 +1 @@
+export declare const gitCapability: () => void;

package/dist/commands/middleware/capabilitiesMiddleware/gitCapability.js

@@ -0,0 +1,12 @@
+import chalk from "chalk";
+import { git } from "../../../services/git/index.js";
+export const gitCapability = () => {
+    if (!git.isAvailable()) {
+        console.error(chalk.red("Git command is not available, install it from https://git-scm.com/"));
+        process.exit(1);
+    }
+    if (!git.isGitRepository()) {
+        console.error(chalk.red("Not a git repository"));
+        process.exit(1);
+    }
+};

package/dist/commands/middleware/capabilitiesMiddleware/index.d.ts

@@ -0,0 +1,3 @@
+type Capability = "git" | "gh";
+export declare const capabilitiesMiddleware: (requiredCapabilities: Capability[]) => void;
+export {};

package/dist/commands/middleware/capabilitiesMiddleware/index.js

@@ -0,0 +1,15 @@
+import { ghCapability } from "./ghCapability.js";
+import { gitCapability } from "./gitCapability.js";
+const capabilities = {
+    git: gitCapability,
+    gh: ghCapability,
+};
+export const capabilitiesMiddleware = (requiredCapabilities) => {
+    requiredCapabilities.forEach((capabilityKey) => {
+        const resolver = capabilities[capabilityKey];
+        if (!resolver) {
+            throw new Error(`Capability ${capabilityKey} not found`);
+        }
+        resolver();
+    });
+};

package/dist/commands/middleware/hasStagedChangesMiddleware.d.ts

@@ -0,0 +1 @@
+export declare const hasStagedChangesMiddleware: () => void;

package/dist/commands/middleware/hasStagedChangesMiddleware.js

@@ -0,0 +1,8 @@
+import chalk from "chalk";
+import { git } from "../../services/git/index.js";
+export const hasStagedChangesMiddleware = () => {
+    if (!git.hasStagedChanges()) {
+        console.error(chalk.red("Error: No staged changes"));
+        process.exit(1);
+    }
+};

package/dist/commands/middleware/setupMiddleware/getAvailableModels.d.ts

@@ -0,0 +1,4 @@
+import { Model } from "openai/resources/models";
+export declare const getAvailableModels: (options?: {
+    baseURLOverride?: string;
+}) => Promise<Model[]>;

package/dist/commands/middleware/setupMiddleware/getAvailableModels.js

@@ -0,0 +1,11 @@
+import { getLLMClient } from "../../../llm/index.js";
+export const getAvailableModels = async (options) => {
+    const { baseURLOverride } = options || {};
+    let modelsList = await getLLMClient({ baseURLOverride }).models.list();
+    const modelsData = modelsList.data;
+    while (modelsList.hasNextPage()) {
+        modelsList = await modelsList.getNextPage();
+        modelsData.push(...modelsList.data);
+    }
+    return modelsData;
+};

package/dist/commands/middleware/setupMiddleware/getOrUpdateApiKey.d.ts

@@ -0,0 +1 @@
+export declare const getOrUpdateApiKey: (existingApiKey?: string) => Promise<string>;

package/dist/commands/middleware/setupMiddleware/getOrUpdateApiKey.js

@@ -0,0 +1,39 @@
+import inquirer from "inquirer";
+import { maskApiKey } from "../../../utils/maskApiKey.js";
+export const getOrUpdateApiKey = async (existingApiKey) => {
+    // For setup command, handle API key selection
+    if (existingApiKey) {
+        // If we have an existing API key, ask if the user wants to keep it or use a new one
+        const useExistingKeyAnswer = await inquirer.prompt([
+            {
+                type: "list",
+                name: "useExistingKey",
+                message: "OpenRouter API key:",
+                choices: [
+                    {
+                        name: `Use existing key (${maskApiKey(existingApiKey)})`,
+                        value: true,
+                    },
+                    { name: "Enter a new API key", value: false },
+                ],
+            },
+        ]);
+        if (useExistingKeyAnswer.useExistingKey) {
+            return existingApiKey;
+        }
+    }
+    // If no existing key or user wants a new one, prompt for a new API key
+    const apiKeyAnswer = await inquirer.prompt([
+        {
+            type: "input",
+            name: "apiKey",
+            message: "Enter your OpenRouter API key:",
+            validate: (input) => {
+                if (!input)
+                    return "API key is required";
+                return true;
+            },
+        },
+    ]);
+    return apiKeyAnswer.apiKey;
+};

package/dist/commands/middleware/setupMiddleware/index.d.ts

@@ -0,0 +1,4 @@
+import { GitPTConfig } from "../../../config.js";
+export declare const setupMiddleware: (options?: {
+    context?: "setup" | "model" | "command";
+}) => Promise<GitPTConfig>;

package/dist/commands/middleware/setupMiddleware/index.js

@@ -0,0 +1,40 @@
+import inquirer from "inquirer";
+import { getConfig, validateConfig } from "../../../config.js";
+import { setupLocalLLM } from "./setupLocalLLM.js";
+import { setupOpenRouter } from "./setupOpenRouter.js";
+export const setupMiddleware = async (options) => {
+    const context = options?.context || "command";
+    // Always get the current config, even if it's empty
+    const existingConfig = getConfig();
+    // If we're running a command, and the config is valid, continue with the command
+    if (context === "command") {
+        const isValidConfig = validateConfig();
+        if (isValidConfig.isValid) {
+            return getConfig();
+        }
+    }
+    // For initial setup or model command, start by selecting the provider
+    const useLocalLLMAnswer = await inquirer.prompt([
+        {
+            type: "list",
+            name: "useLocalLLM",
+            message: "Select LLM provider:",
+            choices: [
+                { name: "OpenRouter (remote)", value: false },
+                { name: "Local LLM", value: true },
+            ],
+            default: existingConfig.provider === "local" ? 1 : 0,
+        },
+    ]);
+    // Update config based on selected provider
+    existingConfig.provider = useLocalLLMAnswer.useLocalLLM
+        ? "local"
+        : "openrouter";
+    // Proceed based on selected provider
+    if (useLocalLLMAnswer.useLocalLLM) {
+        return await setupLocalLLM(existingConfig);
+    }
+    else {
+        return await setupOpenRouter(existingConfig);
+    }
+};

package/dist/commands/middleware/setupMiddleware/selectModel.d.ts

@@ -0,0 +1,5 @@
+import { Model } from "./types.js";
+/**
+ * Show a list of models to select from
+ */
+export declare const selectModel: (models: Model[], existingModel?: string) => Promise<string>;

package/dist/commands/middleware/setupMiddleware/selectModel.js

@@ -0,0 +1,38 @@
+import inquirer from "inquirer";
+/**
+ * Show a list of models to select from
+ */
+export const selectModel = async (models, existingModel) => {
+    const modelChoices = models.map((model) => ({
+        name: model.name
+            ? `${model.name} (Context: ${model.context_length})`
+            : model.id,
+        value: model.id,
+    }));
+    modelChoices.push({
+        name: "Other (specify model identifier)",
+        value: "custom",
+    });
+    const answers = await inquirer.prompt([
+        {
+            type: "list",
+            name: "modelChoice",
+            message: "Select an AI model:",
+            choices: modelChoices,
+            default: () => {
+                const currentIndex = modelChoices.findIndex((choice) => choice.value === existingModel);
+                return currentIndex >= 0 ? currentIndex : 0;
+            },
+        },
+        {
+            type: "input",
+            name: "customModel",
+            message: "Enter model identifier:",
+            when: (answers) => answers.modelChoice === "custom",
+            validate: (input) => input ? true : "Model identifier is required",
+        },
+    ]);
+    return answers.modelChoice === "custom"
+        ? answers.customModel
+        : answers.modelChoice;
+};

package/dist/commands/middleware/setupMiddleware/setupLocalLLM.d.ts

@@ -0,0 +1,5 @@
+import { GitPTConfig } from "../../../config.js";
+/**
+ * Set up a local LLM configuration
+ */
+export declare const setupLocalLLM: (existingConfig: GitPTConfig) => Promise<GitPTConfig>;