gitpt 1.1.0 → 1.3.0

package/README.md

@@ -1,15 +1,21 @@
 # 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
 
 - Acts as a complete git replacement - all git commands are supported
 - Generate commit messages with AI based on your code changes
+
+  `gitpt commit`
 - Create pull requests with AI-generated titles and descriptions
+
+  `gitpt pr create`
 - 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
 
@@ -33,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
@@ -59,14 +68,8 @@ gitpt merge --no-ff feature-branch
 Add files to the staging area just like you would with git:
 
 ```bash
-# Same as git add .
+# Same as git add . (supports all the regular git add options)
 gitpt add .
-
-# Same as git add -p
-gitpt add -p
-
-# Same as git add src/*.ts
-gitpt add src/*.ts
 ```
 
 ### Creating Commits
@@ -75,44 +78,45 @@ Generate an AI-powered commit message based on your staged changes:
 
 ```bash
 gitpt commit
+
+# Or supply -m argument, if you want to avoid gitpt generating the message
+gitpt commit -m "feat: file hash validation"
+
+# Pass any other git commit options
+gitpt commit --amend
 ```
 
 The tool will:
 1. Analyze your staged changes
 2. Generate a commit message using the configured AI model
-3. Show you the suggested message
-4. Let you edit the message before committing
-5. Create the commit with your approved message
+3. Validate against commitlint rules (if configured)
+4. Regenerate the message if it fails validation
+5. Show you the suggested message
+6. Let you edit the message before committing
+7. Create the commit with your approved message
 
 ### 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
-
-# Switch to a different Claude model
-gitpt model anthropic/claude-3-haiku
 ```
 
-### Commit Options
+_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 can use any standard git commit options with the `gitpt commit` command:
+#### Using a Local LLM
 
-```bash
-# Skip editing the message
-gitpt commit --no-edit
+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
 
-# Provide your own message instead of generating one
-gitpt commit -m "Your message here"
+## GitHub Usage
 
-# Pass any other git commit options
-gitpt commit --amend
-```
+If you have GitHub CLI (`gh`) installed, you can use GitPT to interact with GitHub (e.g. generate full pull requests).
 
 ### Creating Pull Requests
 
@@ -145,20 +149,22 @@ gitpt pr create --no-edit
 gitpt pr create --title "Your PR title here"
 ```
 
-> **Note:** This command requires GitHub CLI (`gh`) to be installed and authenticated.
-
 ## 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.
 
 - **For commits:** Sends a diff of your staged changes to the AI, which generates a contextual commit message following best practices.
 
+- **Commitlint Integration:** Automatically detects commitlint configuration files and validates generated commit messages against your project's commit conventions. If validation fails, it regenerates a compliant message.
+
 - **For pull requests:** Analyzes the commits and file changes between your branch and the base branch, then generates a suitable title and detailed description for your PR.
 
 - **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
@@ -176,6 +182,20 @@ npm run build
 npm link
 ```
 
+## Commitlint Integration
+
+GitPT automatically detects and integrates with [commitlint](https://commitlint.js.org/) if it's configured in your repository:
+
+- **Automatic Detection:** GitPT checks for common commitlint configuration files (commitlint.config.js, .commitlintrc.*, etc.)
+
+- **Rule-Aware Generation:** When commitlint is detected, GitPT instructs the AI to generate messages that follow your specific commit conventions
+
+- **Validation & Regeneration:** Generated messages are validated against your commitlint rules before committing. If validation fails, GitPT automatically regenerates a compliant message
+
+- **Error Feedback:** Validation errors are sent to the AI to help it understand how to fix the message
+
+This integration ensures that all AI-generated commit messages follow your team's established commit conventions without requiring manual corrections.
+
 ## License
 
 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);
+    }
+};