gitpt 1.1.0 → 1.3.0

package/dist/config.d.ts

@@ -0,0 +1,18 @@
+export interface GitPTConfig {
+    provider?: "openrouter" | "local";
+    customLLMEndpoint?: string;
+    model?: string;
+    apiKey?: string;
+}
+export declare const getConfig: () => GitPTConfig;
+export declare const saveConfig: (newConfig: GitPTConfig) => void;
+export declare enum ConfigErrors {
+    CustomLLMEndpointRequired = "Custom LLM endpoint is required for local LLM provider.",
+    APIKeyRequired = "API key is required for OpenRouter provider.",
+    ModelRequired = "Model is required."
+}
+export declare const validateConfig: () => {
+    isValid: boolean;
+    errors?: string[];
+};
+export declare const clearConfig: () => void;

package/dist/config.js

@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import Configstore from "configstore";
+const config = new Configstore("gitpt");
+export const getConfig = () => {
+    try {
+        const provider = config.get("provider");
+        const customLLMEndpoint = config.get("customLLMEndpoint");
+        const model = config.get("model");
+        const apiKey = config.get("apiKey");
+        return {
+            provider,
+            customLLMEndpoint,
+            model,
+            apiKey,
+        };
+    }
+    catch (error) {
+        console.error(chalk.red("Error reading configuration:"), error);
+        return {};
+    }
+};
+export const saveConfig = (newConfig) => {
+    if (newConfig.provider !== undefined) {
+        config.set("provider", newConfig.provider);
+    }
+    if (newConfig.customLLMEndpoint !== undefined) {
+        config.set("customLLMEndpoint", newConfig.customLLMEndpoint);
+    }
+    if (newConfig.model !== undefined) {
+        config.set("model", newConfig.model);
+    }
+    if (newConfig.apiKey !== undefined) {
+        config.set("apiKey", newConfig.apiKey);
+    }
+};
+export var ConfigErrors;
+(function (ConfigErrors) {
+    ConfigErrors["CustomLLMEndpointRequired"] = "Custom LLM endpoint is required for local LLM provider.";
+    ConfigErrors["APIKeyRequired"] = "API key is required for OpenRouter provider.";
+    ConfigErrors["ModelRequired"] = "Model is required.";
+})(ConfigErrors || (ConfigErrors = {}));
+export const validateConfig = () => {
+    const { provider, customLLMEndpoint, apiKey, model } = getConfig();
+    const errors = [];
+    if (provider === "local" && !customLLMEndpoint) {
+        errors.push(ConfigErrors.CustomLLMEndpointRequired);
+    }
+    if (provider === "openrouter" && !apiKey) {
+        errors.push(ConfigErrors.APIKeyRequired);
+    }
+    if (!model) {
+        errors.push(ConfigErrors.ModelRequired);
+    }
+    return { isValid: errors.length === 0, errors };
+};
+export const clearConfig = () => {
+    config.clear();
+};

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --experimental-specifier-resolution=node
 export {};

package/dist/index.js

@@ -1,70 +1,58 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { execSync } from 'child_process';
-import { setupCommand } from './commands/setup.js';
-import { commitCommand } from './commands/commit.js';
-import { addCommand } from './commands/add.js';
-import { modelCommand } from './commands/model.js';
-import { prCreateCommand } from './commands/pr.js';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { isGitRepository } from './utils/git.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
-const version = packageJson.version;
+#!/usr/bin/env node --experimental-specifier-resolution=node
+import chalk from "chalk";
+import { execSync } from "child_process";
+import { Command } from "commander";
+import packageJSON from "../package.json" with { type: "json" };
+import { commitCommand } from "./commands/commit/index.js";
+import { configCommand } from "./commands/config.js";
+import { modelCommand } from "./commands/model.js";
+import { prCreateCommand } from "./commands/pr/index.js";
+import { setupCommand } from "./commands/setup.js";
 const program = new Command();
 program
-    .name('gitpt')
-    .description('Git Prompt Tool helps you write commit messages using AI')
-    .version(version);
+    .name("gitpt")
+    .description("Git Prompt Tool helps you write commit messages using AI")
+    .version(packageJSON.version);
 // GitPT-specific commands
 program
-    .command('setup')
-    .description('Configure GitPT with your OpenRouter API key and model selection')
+    .command("setup")
+    .description("Configure GitPT with your OpenRouter API key and model selection")
     .action(setupCommand);
 program
-    .command('model [model-id]')
-    .description('Change the AI model used for generating commit messages')
+    .command("config")
+    .description("Configure GitPT with your OpenRouter API key and model selection")
+    .action(configCommand);
+program
+    .command("model")
+    .description("Change the AI model used for generating commit messages")
     .action(modelCommand);
 // Enhanced git commands
 program
-    .command('add [files...]')
-    .description('Add files to git staging area (pass-through to git add)')
-    .allowUnknownOption(true) // Pass through other git add options
-    .action(addCommand);
-program
-    .command('commit')
-    .description('Generate AI-powered commit message based on staged changes')
-    .option('-m, --message <message>', 'use provided message instead of generating one')
-    .option('-e, --edit', 'edit the message after generation')
-    .option('--no-edit', 'do not edit the message after generation')
+    .command("commit")
+    .description("Generate AI-powered commit message based on staged changes")
+    .option("-m, --message <message>", "use provided message instead of generating one")
+    .option("-e, --edit", "edit the message after generation")
+    .option("--no-edit", "do not edit the message after generation")
     .allowUnknownOption(true) // Pass through other git commit options
     .action(commitCommand);
 program
-    .command('pr create')
-    .description('Create a pull request with AI-generated title and description')
-    .option('-t, --title <title>', 'Custom pull request title')
-    .option('-b, --body <body>', 'Custom pull request description')
-    .option('-d, --draft', 'Create as draft pull request')
-    .option('-B, --base <branch>', 'Base branch to create PR against')
-    .option('-e, --edit', 'Edit PR details before submission', true)
-    .option('--no-edit', 'Skip editing PR details')
+    .command("pr create")
+    .description("Create a pull request with AI-generated title and description")
+    .option("-t, --title <title>", "Custom pull request title")
+    .option("-b, --body <body>", "Custom pull request description")
+    .option("-d, --draft", "Create as draft pull request")
+    .option("-B, --base <branch>", "Base branch to create PR against")
+    .option("-e, --edit", "Edit PR details before submission", true)
+    .option("--no-edit", "Skip editing PR details")
     .allowUnknownOption(true)
     .action(prCreateCommand);
 // Handle unknown commands by passing them to git
-program.on('command:*', (operands) => {
-    if (!isGitRepository()) {
-        console.error(chalk.red('Error: Not a git repository'));
-        process.exit(1);
-    }
+program.on("command:*", () => {
     try {
         // Get all arguments passed to the original command
         const args = process.argv.slice(2);
         // Execute git with all arguments
-        execSync(`git ${args.join(' ')}`, { stdio: 'inherit' });
+        execSync(`git ${args.join(" ")}`, { stdio: "inherit" });
     }
     catch (error) {
         // Git will handle its own error output through stdio: 'inherit'
@@ -77,7 +65,7 @@ async function main() {
         await program.parseAsync();
     }
     catch (error) {
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
         process.exit(1);
     }
 }

package/dist/llm/index.d.ts

@@ -0,0 +1,5 @@
+import openai from "openai";
+export declare const OPENROUTER_API_URL = "https://openrouter.ai/api/v1";
+export declare const getLLMClient: (options?: {
+    baseURLOverride?: string;
+}) => openai;

package/dist/llm/index.js

@@ -0,0 +1,14 @@
+import openai from "openai";
+import { getConfig } from "../config.js";
+import { formatBaseURL } from "../utils/formatBaseURL.js";
+export const OPENROUTER_API_URL = "https://openrouter.ai/api/v1";
+export const getLLMClient = (options) => {
+    const { baseURLOverride } = options || {};
+    const { apiKey, customLLMEndpoint } = getConfig();
+    const baseURL = formatBaseURL(baseURLOverride ?? customLLMEndpoint ?? OPENROUTER_API_URL);
+    console.log({ baseURL });
+    return new openai.OpenAI({
+        apiKey,
+        baseURL,
+    });
+};

package/dist/services/gh/createPullRequest.d.ts

@@ -0,0 +1 @@
+export declare const createPullRequest: (title: string, body: string, baseBranch: string, draft: boolean) => void;

package/dist/services/gh/createPullRequest.js

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const createPullRequest = (title, body, baseBranch, draft) => {
+    const draftFlag = draft ? "--draft" : "";
+    try {
+        console.log(chalk.blue(`Creating pull request to ${baseBranch}...`));
+        // Create a temporary file for the PR body to avoid issues with escaping
+        const tempFilePath = `/tmp/gitpt-pr-body-${Date.now()}.md`;
+        try {
+            // Write the body to a temporary file
+            execSync(`cat > "${tempFilePath}" << 'GITPT_EOF'
+  ${body}
+  GITPT_EOF`);
+            // Try to get the remote repo URL if available
+            let repoUrlArg = "";
+            try {
+                const repoUrl = execSync("git config --get remote.origin.url")
+                    .toString()
+                    .trim();
+                if (repoUrl) {
+                    repoUrlArg = `--repo "${repoUrl}"`;
+                }
+            }
+            catch (e) {
+                // Proceed without repo URL
+            }
+            // Use the file for the body
+            const command = `gh pr create --title "${title.replace(/"/g, '\\"')}" --body-file "${tempFilePath}" --base "${baseBranch}" ${draftFlag} ${repoUrlArg}`;
+            // Set a timeout to avoid hanging indefinitely
+            console.log(chalk.gray("Running GitHub PR creation command..."));
+            console.log(chalk.gray(`Using base branch: ${baseBranch}`));
+            // Add debugging output
+            console.log(chalk.gray("Executing command with 60s timeout:"));
+            // Execute the command with a timeout
+            const result = execSync(command, {
+                stdio: "pipe",
+                timeout: 60000, // 60-second timeout
+            }).toString();
+            console.log(result);
+            console.log(chalk.green("✓ Pull request created successfully"));
+        }
+        finally {
+            // Clean up temporary file
+            try {
+                execSync(`rm -f "${tempFilePath}"`);
+            }
+            catch (e) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("timeout")) {
+            console.error(chalk.red("Error: GitHub CLI command timed out after 60 seconds."));
+            console.log(chalk.yellow("You may need to create the PR manually using:"));
+            console.log(chalk.yellow(`gh pr create --title "${title}" --base "${baseBranch}" ${draftFlag}`));
+        }
+        else {
+            console.error(chalk.red("Error creating pull request:"), error);
+        }
+        throw new Error("Failed to create pull request");
+    }
+};

package/dist/services/gh/index.d.ts

@@ -0,0 +1,4 @@
+export declare const gh: {
+    createPullRequest: (title: string, body: string, baseBranch: string, draft: boolean) => void;
+    isAvailable: () => boolean;
+};

package/dist/services/gh/index.js

@@ -0,0 +1,6 @@
+import { createPullRequest } from "./createPullRequest.js";
+import { isAvailable } from "./isAvailable.js";
+export const gh = {
+    createPullRequest,
+    isAvailable,
+};

package/dist/services/gh/isAvailable.d.ts

@@ -0,0 +1 @@
+export declare const isAvailable: () => boolean;

package/dist/services/gh/isAvailable.js

@@ -0,0 +1,10 @@
+import { execSync } from "child_process";
+export const isAvailable = () => {
+    try {
+        execSync("gh --version", { stdio: "ignore" });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};

package/dist/services/git/executeGitAdd.d.ts

@@ -0,0 +1 @@
+export declare const executeGitAdd: (files: string[]) => void;

package/dist/services/git/executeGitAdd.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const executeGitAdd = (files) => {
+    try {
+        if (files.length === 0) {
+            throw new Error("No files specified");
+        }
+        const fileArgs = files.join(" ");
+        execSync(`git add ${fileArgs}`, { stdio: "inherit" });
+    }
+    catch (error) {
+        console.error(chalk.red("Error adding files:"), error);
+        throw new Error("Failed to add files to git");
+    }
+};

package/dist/services/git/executeGitCommit.d.ts

@@ -0,0 +1 @@
+export declare const executeGitCommit: (message: string, additionalArgs?: string[]) => void;

package/dist/services/git/executeGitCommit.js

@@ -0,0 +1,12 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const executeGitCommit = (message, additionalArgs = []) => {
+    try {
+        const args = additionalArgs.join(" ");
+        execSync(`git commit -m "${message}" ${args}`, { stdio: "inherit" });
+    }
+    catch (error) {
+        console.error(chalk.red("Error committing changes:"), error);
+        throw new Error("Failed to commit changes");
+    }
+};

package/dist/services/git/getChangedFiles.d.ts

@@ -0,0 +1 @@
+export declare const getChangedFiles: (baseBranch: string) => string[];

package/dist/services/git/getChangedFiles.js

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const getChangedFiles = (baseBranch) => {
+    // Try several methods to get changed files
+    // Method 1: Compare with origin/baseBranch using three dots
+    try {
+        const changedFiles = execSync(`git diff --name-only origin/${baseBranch}...HEAD`)
+            .toString()
+            .trim();
+        if (changedFiles) {
+            return changedFiles.split("\n").filter(Boolean);
+        }
+    }
+    catch (error) {
+        // Continue to next method
+    }
+    // Method 2: Compare with local baseBranch using three dots
+    try {
+        const changedFiles = execSync(`git diff --name-only ${baseBranch}...HEAD`)
+            .toString()
+            .trim();
+        if (changedFiles) {
+            return changedFiles.split("\n").filter(Boolean);
+        }
+    }
+    catch (error) {
+        // Continue to next method
+    }
+    // Method 3: Direct comparison with two dots
+    try {
+        const changedFiles = execSync(`git diff --name-only ${baseBranch}..HEAD`)
+            .toString()
+            .trim();
+        if (changedFiles) {
+            return changedFiles.split("\n").filter(Boolean);
+        }
+    }
+    catch (error) {
+        // Continue to next method
+    }
+    // Method 4: Get recently modified files
+    try {
+        console.log(chalk.yellow(`Could not determine changed files relative to ${baseBranch}, using recently modified files...`));
+        const changedFiles = execSync("git ls-files --modified --others --exclude-standard")
+            .toString()
+            .trim();
+        if (changedFiles) {
+            return changedFiles.split("\n").filter(Boolean);
+        }
+    }
+    catch (error) {
+        // Last resort
+    }
+    // Method 5: List all files in the repo as a last resort
+    try {
+        console.log(chalk.yellow("Using all tracked files as fallback..."));
+        const allFiles = execSync("git ls-files").toString().trim();
+        return allFiles.split("\n").filter(Boolean).slice(0, 50); // Limit to first 50 files
+    }
+    catch (error) {
+        console.error(chalk.red("Could not determine changed files."));
+        return [];
+    }
+};

package/dist/services/git/getCommitsSinceBaseBranch.d.ts

@@ -0,0 +1 @@
+export declare const getCommitsSinceBaseBranch: (baseBranch: string) => string[];

package/dist/services/git/getCommitsSinceBaseBranch.js

@@ -0,0 +1,59 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const getCommitsSinceBaseBranch = (baseBranch) => {
+    try {
+        // Try first with origin/baseBranch
+        try {
+            const mergeBase = execSync(`git merge-base HEAD origin/${baseBranch}`)
+                .toString()
+                .trim();
+            const commitMessages = execSync(`git log --pretty=format:"%s" ${mergeBase}..HEAD`)
+                .toString()
+                .trim();
+            if (commitMessages) {
+                return commitMessages.split("\n").filter(Boolean);
+            }
+        }
+        catch (error) {
+            // If origin/baseBranch doesn't exist, try with just baseBranch
+            console.log(chalk.yellow(`No origin/${baseBranch} found, trying with local ${baseBranch} branch...`));
+        }
+        // Try with local branch
+        try {
+            const mergeBase = execSync(`git merge-base HEAD ${baseBranch}`)
+                .toString()
+                .trim();
+            const commitMessages = execSync(`git log --pretty=format:"%s" ${mergeBase}..HEAD`)
+                .toString()
+                .trim();
+            if (commitMessages) {
+                return commitMessages.split("\n").filter(Boolean);
+            }
+        }
+        catch (error) {
+            // If that fails too, fallback to simple branch comparison
+            console.log(chalk.yellow(`Merge base with ${baseBranch} not found, comparing branches directly...`));
+        }
+        // Direct branch comparison
+        try {
+            const commitMessages = execSync(`git log --pretty=format:"%s" ${baseBranch}..HEAD`)
+                .toString()
+                .trim();
+            if (commitMessages) {
+                return commitMessages.split("\n").filter(Boolean);
+            }
+        }
+        catch (error) {
+            console.log(chalk.yellow(`Could not compare with ${baseBranch}, using recent commits...`));
+        }
+        // Last resort: get most recent commits
+        const commitMessages = execSync('git log --pretty=format:"%s" -n 10')
+            .toString()
+            .trim();
+        return commitMessages.split("\n").filter(Boolean);
+    }
+    catch (error) {
+        console.error(chalk.yellow("Could not get commits. Using empty list."));
+        return [];
+    }
+};

package/dist/services/git/getCurrentBranch.d.ts

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

package/dist/services/git/getCurrentBranch.js

@@ -0,0 +1,11 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const getCurrentBranch = () => {
+    try {
+        return execSync("git rev-parse --abbrev-ref HEAD").toString().trim();
+    }
+    catch (error) {
+        console.error(chalk.red("Error getting current branch:"), error);
+        throw new Error("Failed to get current branch");
+    }
+};

package/dist/services/git/getDefaultBranch.d.ts

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

package/dist/services/git/getDefaultBranch.js

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const getDefaultBranch = () => {
+    try {
+        // First check for a default branch set in git config
+        try {
+            const defaultBranch = execSync("git config init.defaultBranch")
+                .toString()
+                .trim();
+            if (defaultBranch) {
+                return defaultBranch;
+            }
+        }
+        catch (error) {
+            // Continue if git config doesn't have default branch
+        }
+        // Next, check if GitHub CLI can tell us the default branch
+        try {
+            const repoInfo = execSync("gh repo view --json defaultBranchRef --jq .defaultBranchRef.name")
+                .toString()
+                .trim();
+            if (repoInfo) {
+                return repoInfo;
+            }
+        }
+        catch (error) {
+            // Continue if gh command fails
+        }
+        // Try to find default branch in remote branches list
+        const branches = execSync("git branch -r").toString().trim().split("\n");
+        // Common default branch names, in order of likelihood
+        const mainPatterns = [
+            /origin\/main$/,
+            /origin\/master$/,
+            /origin\/develop$/,
+            /origin\/dev$/,
+            /origin\/trunk$/,
+        ];
+        // Try each pattern in order
+        for (const pattern of mainPatterns) {
+            const defaultBranch = branches.find((b) => pattern.test(b.trim()));
+            if (defaultBranch) {
+                return defaultBranch.trim().replace(/^origin\//, "");
+            }
+        }
+        // Check for a branch that has 'HEAD -> origin/' in it, indicating the default branch
+        const headBranch = branches.find((b) => b.includes("HEAD -> origin/"));
+        if (headBranch) {
+            const match = headBranch.match(/HEAD -> origin\/([^,\s]+)/);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        // Fallback to 'main' as most GitHub repos use this now
+        console.log(chalk.yellow('Could not determine default branch, using "main"'));
+        return "main";
+    }
+    catch (error) {
+        // If we can't determine, default to main
+        console.log(chalk.yellow('Error detecting default branch, using "main"'));
+        return "main";
+    }
+};

package/dist/services/git/getStagedChanges.d.ts

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

package/dist/services/git/getStagedChanges.js

@@ -0,0 +1,11 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const getStagedChanges = () => {
+    try {
+        return execSync("git diff --staged").toString();
+    }
+    catch (error) {
+        console.error(chalk.red("Error getting staged changes:"), error);
+        throw new Error("Failed to get staged changes");
+    }
+};

package/dist/services/git/getStagedFiles.d.ts

@@ -0,0 +1 @@
+export declare const getStagedFiles: () => string[];

package/dist/services/git/getStagedFiles.js

@@ -0,0 +1,12 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+export const getStagedFiles = () => {
+    try {
+        const result = execSync("git diff --staged --name-only").toString();
+        return result.split("\n").filter(Boolean);
+    }
+    catch (error) {
+        console.error(chalk.red("Error getting staged files:"), error);
+        throw new Error("Failed to get staged files");
+    }
+};

package/dist/services/git/hasStagedChanges.d.ts

@@ -0,0 +1 @@
+export declare const hasStagedChanges: () => boolean;

package/dist/services/git/hasStagedChanges.js

@@ -0,0 +1,10 @@
+import { execSync } from "child_process";
+export const hasStagedChanges = () => {
+    try {
+        const output = execSync('git diff --staged --quiet || echo "has-changes"').toString();
+        return output.includes("has-changes");
+    }
+    catch (error) {
+        return true; // Assume there are changes if we can't check
+    }
+};

package/dist/services/git/index.d.ts

@@ -0,0 +1,13 @@
+export declare const git: {
+    add: (files: string[]) => void;
+    commit: (message: string, additionalArgs?: string[]) => void;
+    getChangedFiles: (baseBranch: string) => string[];
+    getCommitsSinceBaseBranch: (baseBranch: string) => string[];
+    getCurrentBranch: () => string;
+    getDefaultBranch: () => string;
+    hasStagedChanges: () => boolean;
+    getStagedChanges: () => string;
+    getStagedFiles: () => string[];
+    isAvailable: () => boolean;
+    isGitRepository: () => boolean;
+};