gitpt 1.4.0 → 1.6.1

package/README.md

@@ -15,6 +15,7 @@ Git Prompt Tool is a CLI tool that helps you write commit messages using AI thro
 - Edit suggested messages before committing
 - Works with various AI models via OpenRouter
 - Support for local LLMs with OpenAI-compatible API
+- Support for Apple Foundation Models on-device (macOS 27+, no API key required)
 - [Commitlint](https://commitlint.js.org/) support - read directly from your repository
 
 ## Installation
@@ -114,6 +115,12 @@ GitPT works with any local LLM that provides an OpenAI-compatible API endpoint,
 - [LocalAI](https://localai.io/)
 - Custom setups with tools like llama.cpp
 
+#### Using Apple Foundation Models
+
+On macOS 27 and later, GitPT can use Apple's on-device Foundation Models through the built-in `fm` CLI — no API key or network connection required. Select **Apple Foundation Models** when running `gitpt setup` or `gitpt model`.
+
+> Note: the on-device model has a small context window (~4096 tokens), so very large diffs may not fit.
+
 ## GitHub Usage
 
 If you have GitHub CLI (`gh`) installed, you can use GitPT to interact with GitHub (e.g. generate full pull requests).

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

@@ -0,0 +1,4 @@
+export declare const buildCommitPrompt: (diff: string, validationErrors?: string) => {
+    system: string;
+    user: string;
+};

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

@@ -0,0 +1,13 @@
+import { getCommitlintRules, hasCommitlintConfig, } from "../../../utils/commitlint.js";
+import { systemPrompt } from "./systemPrompt.js";
+import { userPrompt } from "./userPrompt.js";
+export const buildCommitPrompt = (diff, validationErrors) => {
+    const baseRules = hasCommitlintConfig() ? getCommitlintRules() : "";
+    const errorInfo = validationErrors
+        ? `\n\nYOUR PREVIOUS MESSAGE FAILED VALIDATION WITH THESE ERRORS:\n${validationErrors}\n\nFIX THESE ISSUES IN YOUR NEW MESSAGE.`
+        : "";
+    return {
+        system: [systemPrompt, baseRules, errorInfo].join("\n\n"),
+        user: userPrompt(diff),
+    };
+};

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

@@ -0,0 +1,2 @@
+export declare const summarySystemPrompt = "\nYou are condensing a fragment of a git diff so a commit message can be written afterwards.\n\nOutput exactly one line per changed file, in this format:\n<path>: <what changed>\n\nRules:\n- One line per file \u2014 no more, no less.\n- Keep each description under ~12 words.\n- Describe the functional change (what was added, removed, refactored, or fixed), not file mechanics.\n- Output ONLY these lines. No preamble, no commentary, no code fences, no headings, no blank lines.\n";
+export declare const summaryUserPrompt: (diffChunk: string) => string;

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

@@ -0,0 +1,17 @@
+export const summarySystemPrompt = `
+You are condensing a fragment of a git diff so a commit message can be written afterwards.
+
+Output exactly one line per changed file, in this format:
+<path>: <what changed>
+
+Rules:
+- One line per file — no more, no less.
+- Keep each description under ~12 words.
+- Describe the functional change (what was added, removed, refactored, or fixed), not file mechanics.
+- Output ONLY these lines. No preamble, no commentary, no code fences, no headings, no blank lines.
+`;
+export const summaryUserPrompt = (diffChunk) => `
+Summarize the changes in this git diff fragment:
+
+${diffChunk}
+`;

package/dist/commands/commit/generateCommitMessage.js

@@ -1,37 +1,19 @@
 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";
+import { getProvider } from "../../llm/registry.js";
+import { buildCommitPrompt } from "./context/buildPrompt.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 { system, user } = buildCommitPrompt(diff, validationErrors);
+    const provider = getProvider();
+    const message = await provider.complete({
+        system,
+        user,
+        maxTokens: provider.maxOutputTokens,
     });
-    const message = response.choices[0].message.content;
     if (!message) {
         throw new Error("No message returned from LLM");
     }

package/dist/commands/commit/index.js

@@ -6,6 +6,7 @@ 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";
+import { prepareCommitContext } from "./summarizeDiff.js";
 export const commitCommand = async (options) => {
     capabilitiesMiddleware(["git"]);
     await setupMiddleware();
@@ -19,6 +20,7 @@ export const commitCommand = async (options) => {
         try {
             // Get staged changes
             const diff = git.getStagedChanges();
+            const context = await prepareCommitContext(diff);
             console.log(chalk.blue("Generating commit message..."));
             // Check if commitlint is configured
             let hasCommitlint = false;
@@ -32,7 +34,7 @@ export const commitCommand = async (options) => {
                 console.warn(chalk.yellow("Warning: Error detecting commitlint config, proceeding without commitlint validation."));
             }
             // Generate first commit message
-            commitMessage = await generateCommitMessage(diff);
+            commitMessage = await generateCommitMessage(context);
             // If commitlint is configured, try to validate and regenerate up to 3 times
             if (hasCommitlint) {
                 try {
@@ -61,7 +63,7 @@ export const commitCommand = async (options) => {
                             if (attempts < MAX_ATTEMPTS) {
                                 // Try regenerating with validation errors
                                 try {
-                                    commitMessage = await generateCommitMessage(diff, validationErrors);
+                                    commitMessage = await generateCommitMessage(context, validationErrors);
                                 }
                                 catch (error) {
                                     console.warn(chalk.yellow("Error regenerating message, breaking validation loop."));

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

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

package/dist/commands/commit/summarizeDiff.js

@@ -0,0 +1,172 @@
+import ora from "ora";
+import { getProvider } from "../../llm/registry.js";
+import { countTokens } from "../../llm/tokenCount.js";
+import { summarySystemPrompt, summaryUserPrompt } from "./context/summaryPrompt.js";
+import { systemPrompt } from "./context/systemPrompt.js";
+import { userPrompt } from "./context/userPrompt.js";
+const MARGIN = 0.9;
+const MAX_REDUCE_PASSES = 3;
+const LOW_SIGNAL_PATTERNS = [
+    { test: /(^|\/)package-lock\.json$/, note: "dependency lockfile updated" },
+    { test: /(^|\/)npm-shrinkwrap\.json$/, note: "dependency lockfile updated" },
+    { test: /(^|\/)yarn\.lock$/, note: "dependency lockfile updated" },
+    { test: /(^|\/)pnpm-lock\.yaml$/, note: "dependency lockfile updated" },
+    { test: /\.lock$/, note: "dependency lockfile updated" },
+    { test: /(^|\/)(dist|build|out|coverage)\//, note: "generated output updated" },
+    { test: /\.min\.(js|css)$/, note: "minified asset updated" },
+    { test: /\.(snap)$/, note: "test snapshot updated" },
+    { test: /(^|\/)snapshots?\//, note: "test snapshot updated" },
+    { test: /\.(patch|diff)$/, note: "patch file updated" },
+];
+const lowSignalNote = (file) => LOW_SIGNAL_PATTERNS.find((p) => p.test.test(file))?.note ?? null;
+const finalPromptTokens = (context) => countTokens(`${systemPrompt}\n\n${userPrompt(context)}`);
+const splitIntoFileBlocks = (diff) => diff.split(/(?=^diff --git )/m).filter((part) => part.trim().length > 0);
+const fileNameOf = (block) => {
+    const match = block.match(/^diff --git a\/(.+?) b\//m);
+    return match ? match[1] : "changes";
+};
+const truncateToBudget = (file, content, budget) => {
+    if (countTokens(content) <= budget)
+        return content;
+    const marker = `\n... [truncated ${file} to fit context] ...\n`;
+    let keep = content.length;
+    let truncated = content;
+    while (countTokens(truncated) > budget && keep > 200) {
+        keep = Math.floor(keep * 0.7);
+        truncated = content.slice(0, keep) + marker;
+    }
+    return truncated;
+};
+const splitBlockByHunks = (file, content, budget) => {
+    const firstHunk = content.search(/^@@ /m);
+    if (firstHunk < 0) {
+        return [{ files: [file], content: truncateToBudget(file, content, budget) }];
+    }
+    const header = content.slice(0, firstHunk);
+    const hunks = content
+        .slice(firstHunk)
+        .split(/(?=^@@ )/m)
+        .filter((h) => h.length > 0);
+    const chunks = [];
+    let current = "";
+    const flush = () => {
+        if (current) {
+            chunks.push({ files: [file], content: truncateToBudget(file, header + current, budget) });
+            current = "";
+        }
+    };
+    for (const hunk of hunks) {
+        if (current && countTokens(header + current + hunk) > budget)
+            flush();
+        current += hunk;
+    }
+    flush();
+    return chunks;
+};
+const packChunks = (blocks, budget) => {
+    const chunks = [];
+    let files = [];
+    let content = "";
+    let tokens = 0;
+    const flush = () => {
+        if (content) {
+            chunks.push({ files, content });
+            files = [];
+            content = "";
+            tokens = 0;
+        }
+    };
+    for (const block of blocks) {
+        if (block.tokens > budget) {
+            flush();
+            chunks.push(...splitBlockByHunks(block.file, block.content, budget));
+            continue;
+        }
+        if (content && tokens + block.tokens > budget)
+            flush();
+        files.push(block.file);
+        content += block.content;
+        tokens += block.tokens;
+    }
+    flush();
+    return chunks;
+};
+const summarizeChunk = async (content) => {
+    const provider = getProvider();
+    const message = await provider.complete({
+        system: summarySystemPrompt,
+        user: summaryUserPrompt(content),
+        maxTokens: provider.maxOutputTokens,
+    });
+    return message.trim();
+};
+export const prepareCommitContext = async (diff) => {
+    const reserved = getProvider().maxOutputTokens;
+    const window = await getProvider().getContextWindow();
+    if (!Number.isFinite(window))
+        return diff;
+    const fitBudget = Math.floor((window - reserved) * MARGIN);
+    if (finalPromptTokens(diff) <= fitBudget)
+        return diff;
+    const spinner = ora({ text: "Analyzing diff size..." }).start();
+    try {
+        const blocks = splitIntoFileBlocks(diff).map((content) => ({
+            file: fileNameOf(content),
+            content,
+            tokens: countTokens(content),
+        }));
+        const totalTokens = blocks.reduce((sum, b) => sum + b.tokens, 0);
+        const sourceBlocks = blocks.filter((b) => !lowSignalNote(b.file));
+        const lowSignalLines = blocks
+            .map((b) => {
+            const note = lowSignalNote(b.file);
+            return note ? `${b.file}: ${note}` : null;
+        })
+            .filter((line) => line !== null);
+        const summaryOverhead = countTokens(`${summarySystemPrompt}\n\n${summaryUserPrompt("")}`);
+        const chunkBudget = Math.floor((window - reserved - summaryOverhead) * MARGIN);
+        const chunks = packChunks(sourceBlocks, chunkBudget);
+        const condensedNote = lowSignalLines.length
+            ? `, ${lowSignalLines.length} generated file(s) condensed`
+            : "";
+        spinner.text = `Diff is large (~${totalTokens} tokens). Summarizing ${sourceBlocks.length} source file(s) in ${chunks.length} chunk(s)${condensedNote}...`;
+        const summaries = [];
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            spinner.text = `Summarizing chunk ${i + 1}/${chunks.length}: ${chunk.files.join(", ")}`;
+            summaries.push(await summarizeChunk(chunk.content));
+        }
+        const header = `The lines below are per-file summaries of a single commit. Treat them as one related change and write a commit message describing the overall change (not just one file):`;
+        let combined = [...summaries.filter(Boolean), ...lowSignalLines].join("\n");
+        const framed = () => `${header}\n${combined}`;
+        let pass = 0;
+        while (finalPromptTokens(framed()) > fitBudget && pass < MAX_REDUCE_PASSES) {
+            pass++;
+            const lineBlocks = combined
+                .split("\n")
+                .filter((line) => line.trim().length > 0)
+                .map((line) => ({
+                file: "summary",
+                content: `${line}\n`,
+                tokens: countTokens(line),
+            }));
+            const reduceChunks = packChunks(lineBlocks, chunkBudget);
+            const reduced = [];
+            for (let i = 0; i < reduceChunks.length; i++) {
+                spinner.text = `Condensing summary (pass ${pass}, ${i + 1}/${reduceChunks.length})...`;
+                reduced.push(await summarizeChunk(reduceChunks[i].content));
+            }
+            combined = reduced.filter(Boolean).join("\n");
+        }
+        if (finalPromptTokens(framed()) > fitBudget) {
+            const headerTokens = countTokens(`${systemPrompt}\n\n${userPrompt(`${header}\n`)}`);
+            combined = truncateToBudget("summary", combined, fitBudget - headerTokens);
+        }
+        spinner.succeed(`Summarized ${blocks.length} file(s): ~${totalTokens} → ~${countTokens(framed())} tokens`);
+        return framed();
+    }
+    catch (error) {
+        spinner.fail("Failed to summarize diff");
+        throw error;
+    }
+};

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

@@ -0,0 +1,8 @@
+import { GitPTConfig } from "../../../config.js";
+export interface DefaultModel {
+    id: string;
+    label: string;
+    isAvailable: () => boolean;
+    config: GitPTConfig;
+}
+export declare const resolveDefaultModel: () => DefaultModel | undefined;

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

@@ -0,0 +1,11 @@
+import { AppleProvider } from "../../../llm/providers/apple/index.js";
+import { isAppleModelAvailable } from "../../../llm/providers/apple/models.js";
+const DEFAULT_MODELS = [
+    {
+        id: "apple-foundation-models",
+        label: "Apple Foundation Models (on-device)",
+        isAvailable: () => AppleProvider.isAvailable() && isAppleModelAvailable("system"),
+        config: { provider: "apple", model: "system" },
+    },
+];
+export const resolveDefaultModel = () => DEFAULT_MODELS.find((model) => model.isAvailable());

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

@@ -1,40 +1,74 @@
+import chalk from "chalk";
 import inquirer from "inquirer";
-import { getConfig, validateConfig } from "../../../config.js";
-import { setupLocalLLM } from "./setupLocalLLM.js";
-import { setupOpenRouter } from "./setupOpenRouter.js";
+import { clearAcceptedDefault, getAcceptedDefault, getConfig, saveConfig, setAcceptedDefault, } from "../../../config.js";
+import { getProviderClass, PROVIDERS, validateConfig, } from "../../../llm/registry.js";
+import { resolveDefaultModel } from "./defaultModels.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
+    const defaultModel = resolveDefaultModel();
+    const acceptedDefault = getAcceptedDefault();
+    const interactive = Boolean(process.stdin.isTTY);
+    const applyDefault = (model) => {
+        saveConfig(model.config);
+        setAcceptedDefault(model.id);
+        return getConfig();
+    };
+    const confirmDefault = async (message) => {
+        const { useDefault } = await inquirer.prompt([
+            { type: "confirm", name: "useDefault", message, default: true },
+        ]);
+        return useDefault;
+    };
     if (context === "command") {
-        const isValidConfig = validateConfig();
-        if (isValidConfig.isValid) {
+        if (validateConfig().isValid) {
+            if (!acceptedDefault)
+                return getConfig();
+            if (!defaultModel || defaultModel.id === acceptedDefault) {
+                return getConfig();
+            }
+            if (!interactive ||
+                (await confirmDefault(`The recommended default changed to ${defaultModel.label}. Use it?`))) {
+                const result = applyDefault(defaultModel);
+                if (interactive) {
+                    console.log(chalk.green(`✓ Now using ${defaultModel.label}.`));
+                }
+                return result;
+            }
             return getConfig();
         }
+        if (!existingConfig.provider && defaultModel) {
+            if (!interactive)
+                return applyDefault(defaultModel);
+            if (await confirmDefault(`No model configured. Use ${defaultModel.label} by default?`)) {
+                const result = applyDefault(defaultModel);
+                console.log(chalk.green(`✓ Using ${defaultModel.label}. Run 'gitpt model' to change.`));
+                return result;
+            }
+        }
+        else if (!interactive) {
+            throw new Error("GitPT is not configured. Run 'gitpt setup' in an interactive terminal.");
+        }
     }
-    // For initial setup or model command, start by selecting the provider
-    const useLocalLLMAnswer = await inquirer.prompt([
+    clearAcceptedDefault();
+    const providerChoices = PROVIDERS.filter((p) => p.isAvailable()).map((p) => ({
+        name: p.label,
+        value: p.id,
+    }));
+    const providerAnswer = await inquirer.prompt([
         {
             type: "list",
-            name: "useLocalLLM",
+            name: "provider",
             message: "Select LLM provider:",
-            choices: [
-                { name: "OpenRouter (remote)", value: false },
-                { name: "Local LLM", value: true },
-            ],
-            default: existingConfig.provider === "local" ? 1 : 0,
+            choices: providerChoices,
+            default: Math.max(providerChoices.findIndex((c) => c.value === existingConfig.provider), 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);
+    existingConfig.provider = providerAnswer.provider;
+    const spec = getProviderClass(existingConfig.provider);
+    if (!spec) {
+        throw new Error(`Unknown provider: ${existingConfig.provider ?? "(none)"}.`);
     }
+    return spec.setup(existingConfig);
 };

package/dist/commands/pr/generatePRDetails.js

@@ -1,24 +1,17 @@
 import chalk from "chalk";
-import { getConfig } from "../../config.js";
-import { getLLMClient } from "../../llm/index.js";
+import { getProvider } from "../../llm/registry.js";
 import { systemPrompt } from "./context/systemPrompt.js";
 import { userPrompt } from "./context/userPrompt.js";
 import { getPRContext } from "./getPRContext.js";
 export const generatePRDetails = async () => {
-    const { model } = getConfig();
     const context = getPRContext().join("\n\n");
-    const userPromptWithContext = userPrompt(context);
-    const llmClient = getLLMClient();
     try {
-        const response = await llmClient.chat.completions.create({
-            model: model,
-            messages: [
-                { role: "system", content: systemPrompt },
-                { role: "user", content: userPromptWithContext },
-            ],
-            max_completion_tokens: 1000,
-        });
-        const result = response.choices[0].message?.content?.trim();
+        const provider = getProvider();
+        const result = (await provider.complete({
+            system: systemPrompt,
+            user: userPrompt(context),
+            maxTokens: provider.maxOutputTokens,
+        })).trim();
         if (!result) {
             throw new Error("No response from LLM");
         }

package/dist/commands/reset.d.ts

@@ -0,0 +1,3 @@
+export declare const resetCommand: (options?: {
+    yes?: boolean;
+}) => Promise<void>;

package/dist/commands/reset.js

@@ -0,0 +1,26 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { clearConfig, getConfig } from "../config.js";
+export const resetCommand = async (options = {}) => {
+    const hasConfig = Object.values(getConfig()).some((value) => value !== undefined);
+    if (!hasConfig) {
+        console.log(chalk.gray("GitPT has no saved configuration to reset."));
+        return;
+    }
+    if (!options.yes) {
+        const { confirm } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "Reset GitPT? This clears the saved provider, model, and API key.",
+                default: false,
+            },
+        ]);
+        if (!confirm) {
+            console.log(chalk.gray("Reset cancelled."));
+            return;
+        }
+    }
+    clearConfig();
+    console.log(chalk.green("✓ GitPT configuration reset. Run 'gitpt setup' to reconfigure."));
+};

package/dist/config.d.ts

@@ -1,18 +1,14 @@
 export interface GitPTConfig {
-    provider?: "openrouter" | "local";
+    provider?: "openrouter" | "local" | "apple" | "openai" | "anthropic";
     customLLMEndpoint?: string;
     model?: string;
     apiKey?: string;
+    apiKeys?: Record<string, string>;
+    contextWindow?: number;
 }
 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;
+export declare const getAcceptedDefault: () => string | undefined;
+export declare const setAcceptedDefault: (id: string) => void;
+export declare const clearAcceptedDefault: () => void;

package/dist/config.js

@@ -7,11 +7,15 @@ export const getConfig = () => {
         const customLLMEndpoint = config.get("customLLMEndpoint");
         const model = config.get("model");
         const apiKey = config.get("apiKey");
+        const apiKeys = config.get("apiKeys");
+        const contextWindow = config.get("contextWindow");
         return {
             provider,
             customLLMEndpoint,
             model,
             apiKey,
+            apiKeys,
+            contextWindow,
         };
     }
     catch (error) {
@@ -32,27 +36,28 @@ export const saveConfig = (newConfig) => {
     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 };
+    if (newConfig.apiKeys !== undefined) {
+        config.set("apiKeys", newConfig.apiKeys);
+    }
+    if (newConfig.contextWindow !== undefined) {
+        config.set("contextWindow", newConfig.contextWindow);
+    }
 };
 export const clearConfig = () => {
     config.clear();
 };
+const ACCEPTED_DEFAULT_KEY = "acceptedDefault";
+export const getAcceptedDefault = () => {
+    try {
+        return config.get(ACCEPTED_DEFAULT_KEY);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const setAcceptedDefault = (id) => {
+    config.set(ACCEPTED_DEFAULT_KEY, id);
+};
+export const clearAcceptedDefault = () => {
+    config.delete(ACCEPTED_DEFAULT_KEY);
+};

package/dist/index.js

@@ -7,6 +7,7 @@ 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 { resetCommand } from "./commands/reset.js";
 import { setupCommand } from "./commands/setup.js";
 const program = new Command();
 program
@@ -26,6 +27,11 @@ program
     .command("model")
     .description("Change the AI model used for generating commit messages")
     .action(modelCommand);
+program
+    .command("reset")
+    .description("Reset GitPT configuration (clears provider, model, and API key)")
+    .option("-y, --yes", "Skip the confirmation prompt")
+    .action(resetCommand);
 // Enhanced git commands
 program
     .command("commit")

package/dist/llm/client.d.ts

@@ -0,0 +1,24 @@
+import type OpenAI from "openai";
+export type ChatCompletionCreateParams = OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+export interface LLMChatCompletion {
+    choices: Array<{
+        message: {
+            content: string | null;
+        };
+    }>;
+}
+export interface LLMModelsPage {
+    data: OpenAI.Models.Model[];
+    hasNextPage(): boolean;
+    getNextPage(): Promise<LLMModelsPage>;
+}
+export interface LLMClient {
+    chat: {
+        completions: {
+            create(body: ChatCompletionCreateParams): Promise<LLMChatCompletion>;
+        };
+    };
+    models: {
+        list(): Promise<LLMModelsPage>;
+    };
+}

package/dist/llm/index.d.ts

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