415 lines
12 KiB
TypeScript
415 lines
12 KiB
TypeScript
#!/usr/bin/env bun
|
|
|
|
import * as readline from "node:readline";
|
|
import { loadConfig, saveConfig } from "./src/config";
|
|
import {
|
|
isGitRepo,
|
|
getRepoRoot,
|
|
getStagedFiles,
|
|
getUnstagedFiles,
|
|
getStagedDiff,
|
|
getRecentCommits,
|
|
stageFiles,
|
|
commit,
|
|
} from "./src/git";
|
|
import { selectFiles } from "./src/selector";
|
|
import { collectProjectContext } from "./src/context";
|
|
import { buildPrompt, SYSTEM_PROMPT } from "./src/prompt";
|
|
import { generateCommitMessage } from "./src/ai";
|
|
import { copyToClipboard } from "./src/clipboard";
|
|
import { BOLD, GREEN, YELLOW, CYAN, RED, DIM, RESET } from "./src/terminal";
|
|
import type { Config } from "./src/types";
|
|
|
|
const args = process.argv.slice(2);
|
|
|
|
function showHelp() {
|
|
console.log(`
|
|
${BOLD}gai${RESET} — AI-powered git commit message generator
|
|
|
|
${BOLD}Usage:${RESET}
|
|
gai Generate commit message for staged/changed files
|
|
gai --auto Auto-stage all changed files
|
|
gai --dry-run Generate message without committing
|
|
gai config Configure API settings
|
|
gai --help Show this help message
|
|
gai --version Show version
|
|
|
|
${BOLD}Configuration:${RESET}
|
|
Set via ${CYAN}gai config${RESET} or environment variables:
|
|
GAI_API_KEY OpenAI-compatible API key
|
|
GAI_API_BASE API base URL (default: https://api.deepseek.com/v1)
|
|
GAI_MODEL Model name (default: deepseek-chat)
|
|
GAI_MAX_TOKENS Max tokens (default: 500)
|
|
GAI_TEMPERATURE Temperature (default: 0.7)
|
|
`);
|
|
}
|
|
|
|
function ask(question: string): Promise<string> {
|
|
const rl = readline.createInterface({
|
|
input: process.stdin,
|
|
output: process.stdout,
|
|
});
|
|
return new Promise((resolve) => {
|
|
rl.question(question, (answer) => {
|
|
rl.close();
|
|
resolve(answer.trim());
|
|
});
|
|
});
|
|
}
|
|
|
|
async function handleConfig() {
|
|
const config = await loadConfig();
|
|
|
|
console.log(`\n ${BOLD}Current configuration:${RESET}`);
|
|
console.log(
|
|
` API Key: ${config.apiKey ? "****" + config.apiKey.slice(-4) : `${YELLOW}(not set)${RESET}`}`,
|
|
);
|
|
console.log(` API Base: ${config.apiBase}`);
|
|
console.log(` Model: ${config.model}`);
|
|
console.log(` Max Tokens: ${config.maxTokens}`);
|
|
console.log(` Temperature: ${config.temperature}`);
|
|
|
|
console.log(
|
|
`\n ${BOLD}Enter new values (leave empty to keep current):${RESET}`,
|
|
);
|
|
|
|
const apiKey = await ask(" API Key: ");
|
|
const apiBase = await ask(` API Base [${config.apiBase}]: `);
|
|
const model = await ask(` Model [${config.model}]: `);
|
|
const maxTokens = await ask(` Max Tokens [${config.maxTokens}]: `);
|
|
const temperature = await ask(` Temperature [${config.temperature}]: `);
|
|
|
|
const updates: Partial<Config> = {};
|
|
if (apiKey) updates.apiKey = apiKey;
|
|
if (apiBase) updates.apiBase = apiBase;
|
|
if (model) updates.model = model;
|
|
if (maxTokens) updates.maxTokens = parseInt(maxTokens);
|
|
if (temperature) updates.temperature = parseFloat(temperature);
|
|
|
|
if (Object.keys(updates).length > 0) {
|
|
await saveConfig(updates);
|
|
console.log(`\n ${GREEN}Configuration saved!${RESET}`);
|
|
} else {
|
|
console.log("\n No changes.");
|
|
}
|
|
}
|
|
|
|
async function confirmCommit(message: string): Promise<"y" | "n" | "e"> {
|
|
console.log(`\n ${BOLD}Generated commit message:${RESET}`);
|
|
console.log(` ${GREEN}${message}${RESET}\n`);
|
|
const answer = await ask(` Use this message? [${GREEN}Y${RESET}/n/e] `);
|
|
const lower = answer.toLowerCase();
|
|
if (lower === "n") return "n";
|
|
if (lower === "e") return "e";
|
|
return "y";
|
|
}
|
|
|
|
async function editMessage(current: string): Promise<string | null> {
|
|
if (!process.stdin.isTTY) return null;
|
|
|
|
process.stdout.write(` ${DIM}Edit message (Enter to confirm, Esc to abort):${RESET}\n`);
|
|
|
|
const savedRaw = process.stdin.isRaw;
|
|
process.stdin.setRawMode(true);
|
|
process.stdin.resume();
|
|
|
|
let buffer = current;
|
|
let cursor = current.length;
|
|
const ESC = "\x1b";
|
|
const ENTER = "\r";
|
|
const CTRL_C = "\x03";
|
|
const BACKSPACE = "\x7f";
|
|
const DELETE = "\x1b[3~";
|
|
const LEFT = "\x1b[D";
|
|
const RIGHT = "\x1b[C";
|
|
const HOME = "\x1b[H" /* or \x01 */;
|
|
const END = "\x1b[F" /* or \x05 */;
|
|
|
|
function render() {
|
|
process.stdout.write("\x1b[2K\r > " + buffer);
|
|
if (cursor < buffer.length) {
|
|
process.stdout.write(`\x1b[${buffer.length - cursor}D`);
|
|
}
|
|
}
|
|
|
|
process.stdout.write(" > ");
|
|
process.stdout.write(buffer);
|
|
|
|
return new Promise((resolve) => {
|
|
let escapeBuf = "";
|
|
|
|
function handleSeq(seq: string) {
|
|
if (seq === "\x1b[D" || seq === "\x1bOD") {
|
|
if (cursor > 0) {
|
|
cursor--;
|
|
process.stdout.write("\x1b[D");
|
|
}
|
|
} else if (seq === "\x1b[C" || seq === "\x1bOC") {
|
|
if (cursor < buffer.length) {
|
|
cursor++;
|
|
process.stdout.write("\x1b[C");
|
|
}
|
|
} else if (seq === "\x1b[H" || seq === "\x1b[1~" || seq === "\x1bOH") {
|
|
if (cursor > 0) {
|
|
process.stdout.write(`\x1b[${cursor}D`);
|
|
cursor = 0;
|
|
}
|
|
} else if (seq === "\x1b[F" || seq === "\x1b[4~" || seq === "\x1bOF") {
|
|
if (cursor < buffer.length) {
|
|
process.stdout.write(`\x1b[${buffer.length - cursor}C`);
|
|
cursor = buffer.length;
|
|
}
|
|
} else if (seq === "\x1b[3~") {
|
|
if (cursor < buffer.length) {
|
|
buffer = buffer.slice(0, cursor) + buffer.slice(cursor + 1);
|
|
render();
|
|
}
|
|
}
|
|
}
|
|
|
|
process.stdin.on("data", (data: Buffer) => {
|
|
const key = data.toString();
|
|
|
|
if (key === CTRL_C) {
|
|
process.stdin.setRawMode(savedRaw === true);
|
|
process.stdin.pause();
|
|
process.stdin.removeAllListeners("data");
|
|
process.stdout.write("\n");
|
|
resolve(null);
|
|
return;
|
|
}
|
|
|
|
if (key === ESC || key.startsWith("\x1b[")) {
|
|
escapeBuf = key;
|
|
if (key.length >= 3) {
|
|
handleSeq(key);
|
|
escapeBuf = "";
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (escapeBuf) {
|
|
escapeBuf += key;
|
|
if (/^[A-Za-z~]$/.test(key)) {
|
|
handleSeq(escapeBuf);
|
|
escapeBuf = "";
|
|
} else if (escapeBuf.length > 8) {
|
|
escapeBuf = "";
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (key === ENTER) {
|
|
process.stdin.setRawMode(savedRaw === true);
|
|
process.stdin.pause();
|
|
process.stdin.removeAllListeners("data");
|
|
process.stdout.write("\n");
|
|
const result = buffer.trim();
|
|
resolve(result || null);
|
|
return;
|
|
}
|
|
|
|
if (key === BACKSPACE) {
|
|
if (cursor > 0) {
|
|
buffer = buffer.slice(0, cursor - 1) + buffer.slice(cursor);
|
|
cursor--;
|
|
render();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (key === "\x01") {
|
|
if (cursor > 0) {
|
|
process.stdout.write(`\x1b[${cursor}D`);
|
|
cursor = 0;
|
|
}
|
|
return;
|
|
}
|
|
if (key === "\x05") {
|
|
if (cursor < buffer.length) {
|
|
process.stdout.write(`\x1b[${buffer.length - cursor}C`);
|
|
cursor = buffer.length;
|
|
}
|
|
return;
|
|
}
|
|
if (key === "\x0b") {
|
|
buffer = buffer.slice(0, cursor);
|
|
render();
|
|
return;
|
|
}
|
|
if (key === "\x15") {
|
|
buffer = buffer.slice(cursor);
|
|
cursor = 0;
|
|
render();
|
|
return;
|
|
}
|
|
|
|
if (key.charCodeAt(0) >= 32 && key.charCodeAt(0) < 127) {
|
|
buffer = buffer.slice(0, cursor) + key + buffer.slice(cursor);
|
|
cursor++;
|
|
render();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
async function main() {
|
|
if (args.includes("--help") || args.includes("-h")) {
|
|
showHelp();
|
|
return;
|
|
}
|
|
|
|
if (args.includes("--version") || args.includes("-v")) {
|
|
console.log("gai v0.1.0");
|
|
return;
|
|
}
|
|
|
|
if (args[0] === "config") {
|
|
await handleConfig();
|
|
return;
|
|
}
|
|
|
|
const autoMode = args.includes("--auto") || args.includes("-a");
|
|
const dryRun = args.includes("--dry-run") || args.includes("-d");
|
|
|
|
const config = await loadConfig();
|
|
|
|
if (!config.apiKey) {
|
|
console.error(
|
|
` ${RED}Error: API key not set. Run ${BOLD}gai config${RESET}${RED} to configure.${RESET}`,
|
|
);
|
|
process.exit(1);
|
|
}
|
|
|
|
if (!(await isGitRepo())) {
|
|
console.error(` ${RED}Error: Not a git repository.${RESET}`);
|
|
process.exit(1);
|
|
}
|
|
|
|
const stagedFiles = await getStagedFiles();
|
|
const unstagedFiles = await getUnstagedFiles();
|
|
|
|
if (stagedFiles.length === 0 && unstagedFiles.length === 0) {
|
|
console.log(" Nothing to commit.");
|
|
return;
|
|
}
|
|
|
|
if (unstagedFiles.length > 0) {
|
|
if (autoMode) {
|
|
await stageFiles(unstagedFiles.map((f) => f.path));
|
|
console.log(
|
|
` ${GREEN}Auto-staged ${unstagedFiles.length} file(s).${RESET}`,
|
|
);
|
|
} else {
|
|
const selected = await selectFiles(stagedFiles, unstagedFiles);
|
|
if (selected.length > 0) {
|
|
await stageFiles(selected);
|
|
console.log(
|
|
` ${GREEN}Staged ${selected.length} file(s).${RESET}`,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
const diff = await getStagedDiff();
|
|
if (!diff) {
|
|
console.log(" No staged changes to commit.");
|
|
return;
|
|
}
|
|
|
|
const MAX_DIFF_SIZE = 15000;
|
|
const truncatedDiff =
|
|
diff.length > MAX_DIFF_SIZE
|
|
? diff.substring(0, MAX_DIFF_SIZE) + "\n... (truncated)"
|
|
: diff;
|
|
|
|
const repoRoot = await getRepoRoot();
|
|
const projectCtx = await collectProjectContext(repoRoot);
|
|
const recentCommits = await getRecentCommits(10);
|
|
|
|
const userPrompt = buildPrompt({
|
|
readme: projectCtx.readme,
|
|
packageDescription: projectCtx.packageDescription,
|
|
structure: projectCtx.structure,
|
|
recentCommits,
|
|
diff: truncatedDiff,
|
|
});
|
|
|
|
console.log("\n Generating commit message...");
|
|
|
|
let message: string;
|
|
try {
|
|
message = await generateCommitMessage(config, SYSTEM_PROMPT, userPrompt);
|
|
} catch (err) {
|
|
console.error(
|
|
` ${RED}AI request failed: ${err instanceof Error ? err.message : err}${RESET}`,
|
|
);
|
|
process.exit(1);
|
|
}
|
|
|
|
if (dryRun) {
|
|
console.log(`\n ${BOLD}Generated commit message:${RESET}`);
|
|
console.log(` ${GREEN}${message}${RESET}`);
|
|
await copyToClipboard(message);
|
|
console.log(`\n ${DIM}(dry-run, message copied to clipboard)${RESET}`);
|
|
return;
|
|
}
|
|
|
|
const action = await confirmCommit(message);
|
|
|
|
if (action === "y") {
|
|
try {
|
|
const result = await commit(message);
|
|
console.log(
|
|
`\n ${GREEN}${BOLD}✔ Committed successfully!${RESET}`,
|
|
);
|
|
if (result.hash) {
|
|
console.log(` ${YELLOW}${result.hash}${RESET} ${message}`);
|
|
}
|
|
if (result.summary) {
|
|
console.log(` ${DIM}${result.summary}${RESET}`);
|
|
}
|
|
} catch (err) {
|
|
console.error(
|
|
` ${RED}Commit failed: ${err instanceof Error ? err.message : err}${RESET}`,
|
|
);
|
|
process.exit(1);
|
|
}
|
|
} else if (action === "e") {
|
|
const edited = await editMessage(message);
|
|
if (edited) {
|
|
try {
|
|
const result = await commit(edited);
|
|
console.log(
|
|
`\n ${GREEN}${BOLD}✔ Committed successfully!${RESET}`,
|
|
);
|
|
if (result.hash) {
|
|
console.log(` ${YELLOW}${result.hash}${RESET} ${edited}`);
|
|
}
|
|
if (result.summary) {
|
|
console.log(` ${DIM}${result.summary}${RESET}`);
|
|
}
|
|
} catch (err) {
|
|
console.error(
|
|
` ${RED}Commit failed: ${err instanceof Error ? err.message : err}${RESET}`,
|
|
);
|
|
process.exit(1);
|
|
}
|
|
} else {
|
|
console.log(" Aborted.");
|
|
}
|
|
} else {
|
|
const copied = await copyToClipboard(message);
|
|
console.log(
|
|
copied
|
|
? ` Aborted. Message copied to clipboard.`
|
|
: ` Aborted. Message: ${message}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
main().catch((err) => {
|
|
console.error(` ${RED}Unexpected error: ${err}${RESET}`);
|
|
process.exit(1);
|
|
});
|