gitpt 1.4.0 → 1.7.2

package/dist/llm/providers/apple/client.js

@@ -0,0 +1,77 @@
+import { spawn } from "child_process";
+var clean = (text) => text.replace(/\x1b\[[0-9;]*m/g, "").replace(/[⠀-⣿]/g, "").trim();
+var messageText = (content) => {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((part) => part.type === "text" ? part.text : "").join("");
+	return "";
+};
+var runFm = (args, stdin) => new Promise((resolve, reject) => {
+	const child = spawn("fm", args, { stdio: [
+		"pipe",
+		"pipe",
+		"pipe"
+	] });
+	let stdout = "";
+	let stderr = "";
+	child.stdout.on("data", (chunk) => {
+		stdout += chunk.toString();
+	});
+	child.stderr.on("data", (chunk) => {
+		stderr += chunk.toString();
+	});
+	child.on("error", (error) => {
+		if (error.code === "ENOENT") {
+			reject(/* @__PURE__ */ new Error("The Apple Foundation Models CLI ('fm') was not found. It ships with macOS 27 and later."));
+			return;
+		}
+		reject(error);
+	});
+	child.on("close", (code) => {
+		const out = stdout.trim();
+		const err = clean(stderr);
+		if (code !== 0 || !out) {
+			reject(new Error(err || out || `'fm' exited with code ${code} and no output`));
+			return;
+		}
+		resolve(out);
+	});
+	child.stdin.on("error", () => {});
+	child.stdin.write(stdin);
+	child.stdin.end();
+});
+var getAppleFoundationClient = () => {
+	return {
+		chat: { completions: { create: async (params) => {
+			const model = params.model || "system";
+			const instructions = params.messages.filter((m) => m.role === "system").map((m) => messageText(m.content)).join("\n\n").trim();
+			const prompt = params.messages.filter((m) => m.role !== "system").map((m) => messageText(m.content)).join("\n\n").trim();
+			const args = [
+				"respond",
+				"--no-stream",
+				"--model",
+				model
+			];
+			if (instructions) args.push("--instructions", instructions);
+			return { choices: [{ message: { content: await runFm(args, prompt) } }] };
+		} } },
+		models: { list: async () => ({
+			data: [{
+				id: "system",
+				created: 0,
+				object: "model",
+				owned_by: "apple"
+			}, {
+				id: "pcc",
+				created: 0,
+				object: "model",
+				owned_by: "apple"
+			}],
+			hasNextPage: () => false,
+			getNextPage: async () => {
+				throw new Error("No more pages");
+			}
+		}) }
+	};
+};
+//#endregion
+export { getAppleFoundationClient };

package/dist/llm/providers/apple/index.js

@@ -0,0 +1,69 @@
+import { saveConfig } from "../../../config.js";
+import { selectModel } from "../../setup/selectModel.js";
+import { Provider } from "../base.js";
+import { getAppleFoundationClient } from "./client.js";
+import { CANDIDATE_MODELS, probeModel } from "./models.js";
+import chalk from "chalk";
+import { spawnSync } from "child_process";
+import { platform } from "os";
+//#region src/llm/providers/apple/index.ts
+var MIN_MACOS_MAJOR = 27;
+var AppleProvider = class extends Provider {
+	static id = "apple";
+	static label = "Apple Foundation Models (macOS 27+)";
+	static isAvailable() {
+		if (platform() !== "darwin") return false;
+		const result = spawnSync("sw_vers", ["-productVersion"], { encoding: "utf-8" });
+		if (result.error || !result.stdout) return false;
+		const major = parseInt(result.stdout.trim().split(".")[0], 10);
+		return Number.isFinite(major) && major >= MIN_MACOS_MAJOR;
+	}
+	static async setup(existingConfig) {
+		console.log(chalk.blue("Apple Foundation Models Setup"));
+		const probes = CANDIDATE_MODELS.map((model) => ({
+			model,
+			...probeModel(model.id)
+		}));
+		if (probes.every((p) => p.reason === "fm-missing")) {
+			console.error(chalk.red("The Apple Foundation Models CLI ('fm') was not found. It ships with macOS 27 and later."));
+			process.exit(1);
+		}
+		const availableModels = probes.filter((p) => p.available).map((p) => p.model);
+		if (availableModels.length === 0) {
+			console.error(chalk.red("No Apple Foundation Models are available in this context. Make sure Apple Intelligence is enabled in System Settings."));
+			process.exit(1);
+		}
+		const notes = probes.filter((p) => !p.available).map((p) => `Note: Apple doesn't allow ${p.model.name} access from command-line tools.`);
+		const selectedModel = await selectModel(availableModels, existingConfig.model, notes);
+		const updatedConfig = {
+			...existingConfig,
+			provider: "apple",
+			model: selectedModel
+		};
+		saveConfig(updatedConfig);
+		console.log(chalk.green(`✓ Model set to: ${chalk.yellow(selectedModel)}`));
+		return updatedConfig;
+	}
+	constructor(model) {
+		super(model || "system");
+	}
+	async getContextWindow() {
+		return 4096;
+	}
+	countTokens(text) {
+		const result = spawnSync("fm", ["token-count", "-q"], {
+			input: text,
+			encoding: "utf-8"
+		});
+		if (!result.error && result.stdout) {
+			const tokens = parseInt(result.stdout.replace(/[^0-9]/g, ""), 10);
+			if (Number.isFinite(tokens)) return tokens;
+		}
+		return super.countTokens(text);
+	}
+	getClient() {
+		return getAppleFoundationClient();
+	}
+};
+//#endregion
+export { AppleProvider };

package/dist/llm/providers/apple/models.js

@@ -0,0 +1,29 @@
+import { spawnSync } from "child_process";
+//#region src/llm/providers/apple/models.ts
+var CANDIDATE_MODELS = [{
+	id: "system",
+	name: "Apple On-Device Foundation Model",
+	context_length: 4096
+}, {
+	id: "pcc",
+	name: "Private Cloud Compute (PCC)"
+}];
+var probeModel = (modelId) => {
+	const result = spawnSync("fm", [
+		"available",
+		"--model",
+		modelId
+	], { encoding: "utf-8" });
+	if (result.error) return {
+		available: false,
+		reason: "fm-missing"
+	};
+	const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+	return {
+		available: /available/i.test(output) && !/not available|error/i.test(output),
+		reason: output.trim()
+	};
+};
+var isAppleModelAvailable = (modelId) => probeModel(modelId).available;
+//#endregion
+export { CANDIDATE_MODELS, isAppleModelAvailable, probeModel };

package/dist/llm/providers/base.js

@@ -0,0 +1,36 @@
+//#region src/llm/providers/base.ts
+var Provider = class {
+	model;
+	static requiresApiKey = false;
+	static requiresEndpoint = false;
+	static isAvailable() {
+		return true;
+	}
+	maxOutputTokens = 1024;
+	usesCompletionTokensParam = false;
+	constructor(model) {
+		this.model = model;
+	}
+	async getContextWindow() {
+		return Number.POSITIVE_INFINITY;
+	}
+	countTokens(text) {
+		return Math.ceil(text.length / 3);
+	}
+	async complete(req) {
+		const tokenLimit = this.usesCompletionTokensParam ? { max_completion_tokens: req.maxTokens } : { max_tokens: req.maxTokens };
+		return (await this.getClient().chat.completions.create({
+			model: this.model,
+			messages: [{
+				role: "system",
+				content: req.system
+			}, {
+				role: "user",
+				content: req.user
+			}],
+			...tokenLimit
+		})).choices[0].message.content ?? "";
+	}
+};
+//#endregion
+export { Provider };

package/dist/llm/providers/local/index.js

@@ -0,0 +1,84 @@
+import { getConfig, saveConfig } from "../../../config.js";
+import { getAvailableModels } from "../../setup/getAvailableModels.js";
+import { selectModel } from "../../setup/selectModel.js";
+import { OpenAICompatibleProvider } from "../openaiCompatible.js";
+import chalk from "chalk";
+import inquirer from "inquirer";
+//#region src/llm/providers/local/index.ts
+var DEFAULT_CONTEXT_WINDOW = 4096;
+var detectContextWindow = async (endpoint, modelId) => {
+	try {
+		const origin = new URL(endpoint).origin;
+		const response = await fetch(`${origin}/api/v0/models`);
+		if (!response.ok) return void 0;
+		const models = (await response.json())?.data ?? [];
+		const model = models.find((m) => m.id === modelId) ?? models.find((m) => m.state === "loaded");
+		const window = model?.loaded_context_length ?? model?.max_context_length;
+		return typeof window === "number" && window > 0 ? window : void 0;
+	} catch {
+		return;
+	}
+};
+var LocalProvider = class extends OpenAICompatibleProvider {
+	static id = "local";
+	static label = "Local LLM";
+	static requiresApiKey = false;
+	static requiresEndpoint = true;
+	static async setup(existingConfig) {
+		console.log(chalk.blue("Local LLM Setup"));
+		const endpoint = (await inquirer.prompt([{
+			type: "input",
+			name: "localLLMEndpoint",
+			message: "Enter local LLM API endpoint (e.g., http://127.0.0.1:1234):",
+			default: existingConfig.customLLMEndpoint || "http://127.0.0.1:1234",
+			validate: (input) => {
+				if (!input) return "API endpoint is required";
+				if (!input.startsWith("http://") && !input.startsWith("https://")) return "Must be a valid URL starting with http:// or https://";
+				return true;
+			}
+		}])).localLLMEndpoint;
+		console.log(chalk.gray("Trying to fetch available models from local LLM server..."));
+		const models = await getAvailableModels({ baseURLOverride: endpoint });
+		let selectedModel;
+		if (models.length > 0) {
+			console.log(chalk.green(`✓ Found ${models.length} models available on your local LLM server`));
+			selectedModel = await selectModel(models, existingConfig.model);
+		} else {
+			console.log(chalk.yellow("Could not fetch models from local LLM server, please enter model name manually"));
+			selectedModel = (await inquirer.prompt([{
+				type: "input",
+				name: "model",
+				message: "Enter model name to use with local endpoint:",
+				default: existingConfig.model,
+				validate: (input) => input ? true : "Model name is required"
+			}])).model;
+		}
+		const contextWindow = await detectContextWindow(endpoint, selectedModel) ?? DEFAULT_CONTEXT_WINDOW;
+		console.log(chalk.gray(`Using a context window of ${contextWindow} tokens.`));
+		const updatedConfig = {
+			...existingConfig,
+			provider: "local",
+			model: selectedModel,
+			customLLMEndpoint: endpoint,
+			contextWindow
+		};
+		saveConfig(updatedConfig);
+		console.log(chalk.green("✓ Local LLM configuration saved"));
+		return updatedConfig;
+	}
+	async getContextWindow() {
+		const { contextWindow, customLLMEndpoint, model } = getConfig();
+		if (contextWindow) return contextWindow;
+		const detected = await detectContextWindow(customLLMEndpoint ?? "", model ?? "");
+		if (detected) {
+			saveConfig({ contextWindow: detected });
+			return detected;
+		}
+		return DEFAULT_CONTEXT_WINDOW;
+	}
+	baseURL() {
+		return getConfig().customLLMEndpoint ?? "";
+	}
+};
+//#endregion
+export { LocalProvider };

package/dist/llm/providers/openai/index.js

@@ -0,0 +1,19 @@
+import { OpenAICompatibleProvider, setupApiKeyProvider } from "../openaiCompatible.js";
+//#region src/llm/providers/openai/index.ts
+var OpenAIProvider = class OpenAIProvider extends OpenAICompatibleProvider {
+	static id = "openai";
+	static label = "OpenAI";
+	static baseURL = "https://api.openai.com/v1";
+	usesCompletionTokensParam = true;
+	static setup(existingConfig) {
+		return setupApiKeyProvider(existingConfig, {
+			baseURL: OpenAIProvider.baseURL,
+			label: OpenAIProvider.label
+		});
+	}
+	baseURL() {
+		return OpenAIProvider.baseURL;
+	}
+};
+//#endregion
+export { OpenAIProvider };

package/dist/llm/providers/openaiCompatible.js

@@ -0,0 +1,66 @@
+import { saveConfig } from "../../config.js";
+import { getLLMClient } from "../index.js";
+import { getAvailableModels } from "../setup/getAvailableModels.js";
+import { selectModel } from "../setup/selectModel.js";
+import { getApiKey, promptApiKey, saveApiKey } from "./apiKey.js";
+import { Provider } from "./base.js";
+import chalk from "chalk";
+import inquirer from "inquirer";
+//#region src/llm/providers/openaiCompatible.ts
+var OpenAICompatibleProvider = class extends Provider {
+	static requiresApiKey = true;
+	maxOutputTokens = 2048;
+	getClient() {
+		return getLLMClient({
+			baseURLOverride: this.baseURL(),
+			apiKey: getApiKey()
+		});
+	}
+};
+var setupApiKeyProvider = async (existingConfig, opts) => {
+	const { baseURL, label } = opts;
+	const listModels = opts.listModels ?? ((key) => getAvailableModels({
+		baseURLOverride: baseURL,
+		apiKey: key
+	}));
+	const providerId = existingConfig.provider ?? "";
+	const apiKey = await promptApiKey(existingConfig.apiKeys?.[providerId] ?? existingConfig.apiKey, label);
+	if (!apiKey) {
+		console.error(chalk.red(`API key is required for ${label}.`));
+		process.exit(1);
+	}
+	if (existingConfig.model) {
+		console.log("Current model:", chalk.yellow(existingConfig.model));
+		console.log("");
+	}
+	let selectedModel;
+	try {
+		console.log(chalk.gray(`Fetching available models from ${label}...`));
+		const models = await listModels(apiKey);
+		if (models.length > 0) console.log(chalk.green(`✓ Found ${models.length} models available with your API key`));
+		else console.log(chalk.yellow(`No models found from ${label}. Please specify a model manually.`));
+		selectedModel = await selectModel(models, existingConfig.model);
+	} catch (error) {
+		console.error(chalk.yellow(`Error fetching models: ${error}`));
+		selectedModel = (await inquirer.prompt([{
+			type: "input",
+			name: "model",
+			message: "Enter model identifier:",
+			validate: (input) => input ? true : "Model identifier is required"
+		}])).model;
+	}
+	saveApiKey(providerId, apiKey);
+	const finalConfig = {
+		...existingConfig,
+		model: selectedModel,
+		apiKeys: {
+			...existingConfig.apiKeys,
+			[providerId]: apiKey
+		}
+	};
+	saveConfig(finalConfig);
+	console.log(chalk.green(`✓ Model set to: ${chalk.yellow(selectedModel)}`));
+	return finalConfig;
+};
+//#endregion
+export { OpenAICompatibleProvider, setupApiKeyProvider };

package/dist/llm/providers/openrouter/index.js

@@ -0,0 +1,19 @@
+import { OPENROUTER_API_URL } from "../../index.js";
+import { OpenAICompatibleProvider, setupApiKeyProvider } from "../openaiCompatible.js";
+//#region src/llm/providers/openrouter/index.ts
+var OpenRouterProvider = class OpenRouterProvider extends OpenAICompatibleProvider {
+	static id = "openrouter";
+	static label = "OpenRouter (remote)";
+	static baseURL = OPENROUTER_API_URL;
+	static setup(existingConfig) {
+		return setupApiKeyProvider(existingConfig, {
+			baseURL: OpenRouterProvider.baseURL,
+			label: OpenRouterProvider.label
+		});
+	}
+	baseURL() {
+		return OpenRouterProvider.baseURL;
+	}
+};
+//#endregion
+export { OpenRouterProvider };

package/dist/llm/registry.js

@@ -0,0 +1,39 @@
+import { getConfig } from "../config.js";
+import { getApiKey } from "./providers/apiKey.js";
+import { AnthropicProvider } from "./providers/anthropic/index.js";
+import { AppleProvider } from "./providers/apple/index.js";
+import { LocalProvider } from "./providers/local/index.js";
+import { OpenAIProvider } from "./providers/openai/index.js";
+import { OpenRouterProvider } from "./providers/openrouter/index.js";
+//#region src/llm/registry.ts
+var PROVIDERS = [
+	AppleProvider,
+	OpenRouterProvider,
+	OpenAIProvider,
+	AnthropicProvider,
+	LocalProvider
+];
+var getProviderClass = (id) => PROVIDERS.find((p) => p.id === id);
+var getProvider = () => {
+	const { provider, model } = getConfig();
+	const ProviderImpl = getProviderClass(provider);
+	if (!ProviderImpl) throw new Error(`Unknown provider: ${provider ?? "(none)"}. Run "gitpt setup".`);
+	return new ProviderImpl(model ?? "");
+};
+var validateConfig = () => {
+	const { provider, customLLMEndpoint, model } = getConfig();
+	const errors = [];
+	const spec = getProviderClass(provider);
+	if (!spec) errors.push("No provider configured. Run 'gitpt setup'.");
+	else {
+		if (spec.requiresApiKey && !getApiKey()) errors.push(`API key is required for ${spec.label}.`);
+		if (spec.requiresEndpoint && !customLLMEndpoint) errors.push(`Custom endpoint is required for ${spec.label}.`);
+	}
+	if (!model) errors.push("Model is required.");
+	return {
+		isValid: errors.length === 0,
+		errors
+	};
+};
+//#endregion
+export { PROVIDERS, getProvider, getProviderClass, validateConfig };

package/dist/llm/setup/getAvailableModels.js

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

package/dist/llm/setup/selectModel.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+//#region src/llm/setup/selectModel.ts
+/**
+* Show a list of models to select from
+*/
+var selectModel = async (models, existingModel, notes) => {
+	const modelChoices = models.map((model) => ({
+		name: model.name ? model.context_length ? `${model.name} (Context: ${model.context_length})` : model.name : model.id,
+		value: model.id
+	}));
+	modelChoices.push({
+		name: "Other (specify model identifier)",
+		value: "custom"
+	});
+	const choices = [...modelChoices];
+	if (notes && notes.length > 0) {
+		choices.push(new inquirer.Separator(" "));
+		for (const note of notes) choices.push(new inquirer.Separator(chalk.gray(note)));
+	}
+	const answers = await inquirer.prompt([{
+		type: "list",
+		name: "modelChoice",
+		message: "Select an AI model:",
+		choices,
+		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;
+};
+//#endregion
+export { selectModel };

package/dist/llm/tokenCount.js

@@ -0,0 +1,5 @@
+import { getProvider } from "./registry.js";
+//#region src/llm/tokenCount.ts
+var countTokens = (text) => getProvider().countTokens(text);
+//#endregion
+export { countTokens };

package/dist/package.js

@@ -0,0 +1,67 @@
+var package_default = {
+	name: "gitpt",
+	version: "1.7.2",
+	description: "CLI tool that helps you write commit messages & pull request descriptions using AI",
+	main: "dist/index.js",
+	type: "module",
+	bin: { "gitpt": "dist/index.js" },
+	files: [
+		"dist/**/*",
+		"README.md",
+		"LICENSE"
+	],
+	scripts: {
+		"typecheck": "tsc --noEmit",
+		"lint": "oxlint",
+		"build": "vite build",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:apple": "npm run build && node tests/apple-foundation-models/run.mjs",
+		"bench:apple": "npm run build && node tests/apple-foundation-models/benchmark.mjs",
+		"bench:local": "npm run build && node tests/local-model/run.mjs",
+		"bench:all": "npm run build && node tests/run-all.mjs",
+		"check:prompt": "npm run build && node tests/snapshots/check.mjs",
+		"build:demo": "node scripts/build-demo.mjs",
+		"prepublishOnly": "npm run build"
+	},
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/bartaxyz/GitPT.git"
+	},
+	keywords: [
+		"git",
+		"ai",
+		"prompt"
+	],
+	author: "@bartaxyz",
+	license: "MIT",
+	bugs: { "url": "https://github.com/bartaxyz/GitPT/issues" },
+	homepage: "https://github.com/bartaxyz/GitPT#readme",
+	devDependencies: {
+		"@types/configstore": "^6.0.2",
+		"@types/inquirer": "^9.0.7",
+		"@types/node": "^22.14.1",
+		"@types/node-fetch": "^2.6.12",
+		"ffmpeg-static": "^5.3.0",
+		"oxlint": "^1.71.0",
+		"pngjs": "^7.0.0",
+		"tsc-alias": "^1.8.16",
+		"typescript": "^5.8.3",
+		"vite": "^8.1.0",
+		"vitest": "^4.1.9"
+	},
+	dependencies: {
+		"@commitlint/cli": "^19.8.1",
+		"@commitlint/config-conventional": "^19.8.1",
+		"@commitlint/load": "^19.8.1",
+		"chalk": "^5.4.1",
+		"commander": "^13.1.0",
+		"configstore": "^7.0.0",
+		"inquirer": "^12.5.2",
+		"node-fetch": "^3.3.2",
+		"openai": "^4.100.0",
+		"ora": "^8.2.0"
+	}
+};
+//#endregion
+export { package_default as default };