1006 lines
28 KiB
TypeScript
1006 lines
28 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 { BACK, selectOne } from "./src/menu";
|
||
import type { PromptBack } from "./src/menu";
|
||
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";
|
||
import {
|
||
getDefaultBranch,
|
||
getBranchName,
|
||
getBranchPushStatus,
|
||
pushCurrentBranch,
|
||
getBranchCommits,
|
||
getBranchDiff,
|
||
detectPlatform,
|
||
getRemoteHostname,
|
||
createPR,
|
||
} from "./src/pr";
|
||
import type { Platform } from "./src/pr";
|
||
import { PR_SYSTEM_PROMPT, buildPRPrompt } from "./src/prompt";
|
||
import { generatePRMessage } from "./src/ai";
|
||
|
||
const args = process.argv.slice(2);
|
||
|
||
function showHelp() {
|
||
console.log(`
|
||
${BOLD}gai${RESET} — AI-powered git commit message generator
|
||
|
||
${BOLD}Usage:${RESET}
|
||
gai Open interactive menu
|
||
gai commit Generate commit message for staged/changed files
|
||
gai commit --auto Auto-stage all changed files
|
||
gai commit -d Generate message without committing
|
||
gai pr Create a PR with AI-generated title and body
|
||
gai pr --draft Create a draft PR
|
||
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());
|
||
});
|
||
});
|
||
}
|
||
|
||
type ConfigKey = keyof Config;
|
||
|
||
interface ConfigField {
|
||
key: ConfigKey;
|
||
label: string;
|
||
format: (config: Config) => string;
|
||
initialEditValue: (config: Config) => string;
|
||
parse: (value: string) => { value: Config[ConfigKey] } | { error: string };
|
||
}
|
||
|
||
const CONFIG_FIELDS: ConfigField[] = [
|
||
{
|
||
key: "apiKey",
|
||
label: "API Key",
|
||
format: (config) =>
|
||
config.apiKey ? `****${config.apiKey.slice(-4)}` : `${YELLOW}(not set)${RESET}`,
|
||
initialEditValue: () => "",
|
||
parse: (value) => ({ value }),
|
||
},
|
||
{
|
||
key: "apiBase",
|
||
label: "API Base",
|
||
format: (config) => config.apiBase,
|
||
initialEditValue: (config) => config.apiBase,
|
||
parse: (value) => ({ value }),
|
||
},
|
||
{
|
||
key: "model",
|
||
label: "Model",
|
||
format: (config) => config.model,
|
||
initialEditValue: (config) => config.model,
|
||
parse: (value) => ({ value }),
|
||
},
|
||
{
|
||
key: "maxTokens",
|
||
label: "Max Tokens",
|
||
format: (config) => String(config.maxTokens),
|
||
initialEditValue: (config) => String(config.maxTokens),
|
||
parse: (value) => {
|
||
const parsed = Number(value);
|
||
if (!Number.isInteger(parsed) || parsed <= 0) {
|
||
return { error: "Max Tokens must be a positive integer." };
|
||
}
|
||
return { value: parsed };
|
||
},
|
||
},
|
||
{
|
||
key: "temperature",
|
||
label: "Temperature",
|
||
format: (config) => String(config.temperature),
|
||
initialEditValue: (config) => String(config.temperature),
|
||
parse: (value) => {
|
||
const parsed = Number(value);
|
||
if (!Number.isFinite(parsed)) {
|
||
return { error: "Temperature must be a finite number." };
|
||
}
|
||
return { value: parsed };
|
||
},
|
||
},
|
||
];
|
||
|
||
function visibleLength(value: string) {
|
||
return value.replace(/\x1b\[[0-9;]*m/g, "").length;
|
||
}
|
||
|
||
function clearLine() {
|
||
process.stdout.write("\r\x1b[2K");
|
||
}
|
||
|
||
function moveUp(lines: number) {
|
||
if (lines > 0) process.stdout.write(`\x1b[${lines}A`);
|
||
}
|
||
|
||
function renderConfigPage(
|
||
config: Config,
|
||
cursor: number,
|
||
previousLines: number,
|
||
status: string | null,
|
||
editState: { buffer: string; cursor: number } | null,
|
||
) {
|
||
if (previousLines > 0) {
|
||
for (let i = 0; i < previousLines; i++) {
|
||
clearLine();
|
||
process.stdout.write("\n");
|
||
}
|
||
moveUp(previousLines);
|
||
}
|
||
|
||
const labelWidth = Math.max(...CONFIG_FIELDS.map((field) => field.label.length)) + 2;
|
||
const lines = [
|
||
"",
|
||
` ${BOLD}Configuration${RESET}`,
|
||
editState
|
||
? ` ${DIM}editing · enter save · esc cancel · ctrl+c cancel${RESET}`
|
||
: ` ${DIM}↑/↓ navigate · space edit · ←/backspace back · ctrl+c cancel${RESET}`,
|
||
"",
|
||
];
|
||
|
||
let activeValueOffset = 0;
|
||
for (let i = 0; i < CONFIG_FIELDS.length; i++) {
|
||
const field = CONFIG_FIELDS[i]!;
|
||
const active = i === cursor;
|
||
const pointer = active ? `${CYAN}❯${RESET}` : " ";
|
||
const marker = active ? `${GREEN}●${RESET}` : `${DIM}○${RESET}`;
|
||
const label = active ? `${BOLD}${field.label}${RESET}` : field.label;
|
||
const padding = " ".repeat(Math.max(1, labelWidth - visibleLength(field.label)));
|
||
const value = active && editState ? editState.buffer : field.format(config);
|
||
if (active && editState) {
|
||
activeValueOffset = visibleLength(` ${pointer} ${marker} ${label}${padding}`);
|
||
}
|
||
lines.push(` ${pointer} ${marker} ${label}${padding}${value}`);
|
||
}
|
||
|
||
if (status) {
|
||
lines.push("", ` ${status}`);
|
||
}
|
||
|
||
for (const line of lines) {
|
||
process.stdout.write(`${line}\n`);
|
||
}
|
||
if (editState) {
|
||
moveUp(lines.length - (4 + cursor));
|
||
const column = activeValueOffset + editState.cursor;
|
||
process.stdout.write(`\r${column > 0 ? `\x1b[${column}C` : ""}`);
|
||
} else {
|
||
moveUp(lines.length);
|
||
}
|
||
return lines.length;
|
||
}
|
||
|
||
async function handleConfig(): Promise<"done" | "back"> {
|
||
if (process.stdin.isTTY !== true) {
|
||
console.error(` ${RED}Error: Configuration requires a TTY.${RESET}`);
|
||
process.exit(1);
|
||
}
|
||
|
||
let config = await loadConfig();
|
||
let cursor = 0;
|
||
let renderedLines = 0;
|
||
let escapeBuf = "";
|
||
let status: string | null = null;
|
||
let editState: { buffer: string; cursor: number } | null = null;
|
||
let renderedCursorRow = 0;
|
||
const wasRaw = process.stdin.isRaw;
|
||
|
||
if (wasRaw !== true) process.stdin.setRawMode(true);
|
||
process.stdin.resume();
|
||
process.stdout.write("\x1b[?25l");
|
||
|
||
const render = () => {
|
||
moveUp(renderedCursorRow);
|
||
renderedLines = renderConfigPage(config, cursor, renderedLines, status, editState);
|
||
renderedCursorRow = editState ? 4 + cursor : 0;
|
||
process.stdout.write(editState ? "\x1b[?25h" : "\x1b[?25l");
|
||
};
|
||
|
||
render();
|
||
|
||
return new Promise((resolve) => {
|
||
const finish = (value: "done" | "back") => {
|
||
process.stdin.setRawMode(wasRaw === true);
|
||
process.stdin.pause();
|
||
process.stdin.removeListener("data", onData);
|
||
moveUp(renderedCursorRow);
|
||
for (let i = 0; i < renderedLines; i++) {
|
||
clearLine();
|
||
process.stdout.write("\n");
|
||
}
|
||
moveUp(renderedLines);
|
||
process.stdout.write("\x1b[?25h");
|
||
resolve(value);
|
||
};
|
||
|
||
const saveEdit = async () => {
|
||
if (!editState) return;
|
||
const field = CONFIG_FIELDS[cursor]!;
|
||
const value = editState.buffer.trim();
|
||
editState = null;
|
||
|
||
if (value === "") {
|
||
status = `${DIM}No changes.${RESET}`;
|
||
} else {
|
||
const parsed = field.parse(value);
|
||
if ("error" in parsed) {
|
||
status = `${RED}${parsed.error}${RESET}`;
|
||
} else {
|
||
await saveConfig({ [field.key]: parsed.value } as Partial<Config>);
|
||
config = await loadConfig();
|
||
status = `${GREEN}${field.label} saved.${RESET}`;
|
||
}
|
||
}
|
||
|
||
render();
|
||
};
|
||
|
||
const onData = (data: Buffer) => {
|
||
const key = data.toString();
|
||
const UP = "\x1b[A";
|
||
const DOWN = "\x1b[B";
|
||
const LEFT = "\x1b[D";
|
||
const ALT_UP = "\x1bOA";
|
||
const ALT_DOWN = "\x1bOB";
|
||
const ALT_LEFT = "\x1bOD";
|
||
const SPACE = " ";
|
||
const ENTER = "\r";
|
||
const ESC = "\x1b";
|
||
const RIGHT = "\x1b[C";
|
||
const ALT_RIGHT = "\x1bOC";
|
||
const CTRL_C = "\x03";
|
||
const BACKSPACE = "\x7f";
|
||
|
||
if (editState) {
|
||
if (key === CTRL_C || key === ESC) {
|
||
editState = null;
|
||
status = `${DIM}No changes.${RESET}`;
|
||
render();
|
||
return;
|
||
}
|
||
if (key === ENTER) {
|
||
void saveEdit();
|
||
return;
|
||
}
|
||
if (key === "\x01") {
|
||
editState.cursor = 0;
|
||
render();
|
||
return;
|
||
}
|
||
if (key === "\x05") {
|
||
editState.cursor = editState.buffer.length;
|
||
render();
|
||
return;
|
||
}
|
||
if (key === "\x0b") {
|
||
editState.buffer = editState.buffer.slice(0, editState.cursor);
|
||
render();
|
||
return;
|
||
}
|
||
if (key === "\x15") {
|
||
editState.buffer = editState.buffer.slice(editState.cursor);
|
||
editState.cursor = 0;
|
||
render();
|
||
return;
|
||
}
|
||
if (key === BACKSPACE) {
|
||
if (editState.cursor > 0) {
|
||
editState.buffer =
|
||
editState.buffer.slice(0, editState.cursor - 1) +
|
||
editState.buffer.slice(editState.cursor);
|
||
editState.cursor--;
|
||
render();
|
||
}
|
||
return;
|
||
}
|
||
if (key === LEFT || key === ALT_LEFT) {
|
||
if (editState.cursor > 0) editState.cursor--;
|
||
render();
|
||
return;
|
||
}
|
||
if (key === RIGHT || key === ALT_RIGHT) {
|
||
if (editState.cursor < editState.buffer.length) editState.cursor++;
|
||
render();
|
||
return;
|
||
}
|
||
if (key.startsWith("\x1b[")) {
|
||
if (key === "\x1b[H" || key === "\x1b[1~") {
|
||
editState.cursor = 0;
|
||
} else if (key === "\x1b[F" || key === "\x1b[4~") {
|
||
editState.cursor = editState.buffer.length;
|
||
} else if (key === "\x1b[3~" && editState.cursor < editState.buffer.length) {
|
||
editState.buffer =
|
||
editState.buffer.slice(0, editState.cursor) +
|
||
editState.buffer.slice(editState.cursor + 1);
|
||
}
|
||
render();
|
||
return;
|
||
}
|
||
if (key >= " " && key !== "\x7f") {
|
||
editState.buffer =
|
||
editState.buffer.slice(0, editState.cursor) +
|
||
key +
|
||
editState.buffer.slice(editState.cursor);
|
||
editState.cursor += key.length;
|
||
render();
|
||
}
|
||
return;
|
||
}
|
||
|
||
const action = (() => {
|
||
if (key === UP || key === ALT_UP) return "up";
|
||
if (key === DOWN || key === ALT_DOWN) return "down";
|
||
if (key === LEFT || key === ALT_LEFT || key === BACKSPACE) return "back";
|
||
if (key === SPACE) return "edit";
|
||
if (key === CTRL_C) return "cancel";
|
||
if (key === "\x1b" || key.startsWith("\x1b[")) {
|
||
escapeBuf = key;
|
||
return null;
|
||
}
|
||
if (escapeBuf) {
|
||
const next = escapeBuf + key;
|
||
escapeBuf = /^[A-Za-z~]$/.test(key) || next.length > 8 ? "" : next;
|
||
if (next === UP || next === ALT_UP) return "up";
|
||
if (next === DOWN || next === ALT_DOWN) return "down";
|
||
if (next === LEFT || next === ALT_LEFT) return "back";
|
||
}
|
||
return null;
|
||
})();
|
||
|
||
if (action === "cancel") return finish("done");
|
||
if (action === "back") return finish("back");
|
||
if (action === "up" && cursor > 0) {
|
||
cursor--;
|
||
status = null;
|
||
render();
|
||
} else if (action === "down" && cursor < CONFIG_FIELDS.length - 1) {
|
||
cursor++;
|
||
status = null;
|
||
render();
|
||
} else if (action === "edit") {
|
||
const value = CONFIG_FIELDS[cursor]!.initialEditValue(config);
|
||
editState = { buffer: value, cursor: value.length };
|
||
status = null;
|
||
render();
|
||
}
|
||
};
|
||
|
||
process.stdin.on("data", onData);
|
||
});
|
||
}
|
||
|
||
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";
|
||
|
||
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();
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
function printCommitResult(
|
||
result: { branch: string; hash: string; files: number; insertions: number; deletions: number },
|
||
msg: string,
|
||
) {
|
||
console.log(`\n ${GREEN}${BOLD}✔ Committed successfully!${RESET}`);
|
||
|
||
const id = result.branch && result.hash
|
||
? `${YELLOW}[${result.branch} ${result.hash}]${RESET}`
|
||
: result.hash
|
||
? `${YELLOW}${result.hash}${RESET}`
|
||
: "";
|
||
console.log(` ${id} ${msg}`);
|
||
|
||
const parts: string[] = [];
|
||
if (result.files > 0) parts.push(`${YELLOW}${result.files} file${result.files > 1 ? "s" : ""} changed${RESET}`);
|
||
if (result.insertions > 0) parts.push(`${GREEN}${result.insertions} insertion${result.insertions > 1 ? "s" : ""}(+)${RESET}`);
|
||
if (result.deletions > 0) parts.push(`${RED}${result.deletions} deletion${result.deletions > 1 ? "s" : ""}(-)${RESET}`);
|
||
if (parts.length > 0) console.log(` ${parts.join(", ")}`);
|
||
}
|
||
|
||
interface MenuAction {
|
||
key: "commit" | "pr" | "config";
|
||
label: string;
|
||
description: string;
|
||
}
|
||
|
||
const MENU_ACTIONS: MenuAction[] = [
|
||
{ key: "commit", label: "commit", description: "Generate AI commit message" },
|
||
{ key: "pr", label: "pr", description: "Create a PR with AI-generated title" },
|
||
{ key: "config", label: "config", description: "Configure API settings" },
|
||
];
|
||
|
||
async function showMenu(): Promise<void> {
|
||
if (!process.stdin.isTTY) {
|
||
console.error(` ${RED}Error: Interactive menu requires a TTY.${RESET}`);
|
||
process.exit(1);
|
||
}
|
||
|
||
while (true) {
|
||
const selected = await selectOne({
|
||
title: "gai",
|
||
subtitle: "Choose a workflow",
|
||
allowBack: false,
|
||
items: MENU_ACTIONS.map((action) => ({
|
||
label: action.label,
|
||
value: action.key,
|
||
description: action.description,
|
||
})),
|
||
});
|
||
|
||
if (selected === null || selected === BACK) return;
|
||
|
||
const result =
|
||
selected === "commit"
|
||
? await handleCommit(false, false)
|
||
: selected === "pr"
|
||
? await handlePR(false)
|
||
: await handleConfig();
|
||
|
||
if (result !== "back") return;
|
||
}
|
||
}
|
||
|
||
async function selectPlatform(
|
||
hostname: string,
|
||
): Promise<Platform | null | PromptBack> {
|
||
if (!process.stdin.isTTY) {
|
||
console.error(` ${RED}Error: Platform selection requires a TTY.${RESET}`);
|
||
process.exit(1);
|
||
}
|
||
|
||
return selectOne({
|
||
title: "Select remote platform",
|
||
subtitle: `Remote ${hostname} could not be auto-detected`,
|
||
items: [
|
||
{ label: "GitHub", value: "github" as Platform, description: "Use gh CLI" },
|
||
{ label: "Gitea", value: "gitea" as Platform, description: "Use tea CLI" },
|
||
{ label: "GitLab", value: "gitlab" as Platform, description: "Use glab CLI" },
|
||
],
|
||
});
|
||
}
|
||
|
||
async function handleCommit(
|
||
autoMode: boolean,
|
||
dryRun: boolean,
|
||
): Promise<"done" | "back"> {
|
||
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) {
|
||
const choice = await selectOne({
|
||
title: "Nothing to commit",
|
||
subtitle: "No staged or unstaged changes.",
|
||
items: [{ label: "Back", value: "back" as const }],
|
||
});
|
||
if (choice === null) process.exit(0);
|
||
return "done";
|
||
}
|
||
|
||
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 === BACK) return "back";
|
||
if (selected.length > 0) {
|
||
await stageFiles(selected);
|
||
console.log(
|
||
` ${GREEN}Staged ${selected.length} file(s).${RESET}`,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
const diff = await getStagedDiff();
|
||
if (!diff) {
|
||
const choice = await selectOne({
|
||
title: "Nothing to commit",
|
||
subtitle: "No staged changes to commit.",
|
||
items: [{ label: "Back", value: "back" as const }],
|
||
});
|
||
if (choice === null) process.exit(0);
|
||
return "done";
|
||
}
|
||
|
||
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 "done";
|
||
}
|
||
|
||
const action = await confirmCommit(message);
|
||
|
||
if (action === "y") {
|
||
try {
|
||
const result = await commit(message);
|
||
printCommitResult(result, message);
|
||
} 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);
|
||
printCommitResult(result, edited);
|
||
} 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}`,
|
||
);
|
||
}
|
||
|
||
return "done";
|
||
}
|
||
|
||
async function handlePR(draft: boolean): Promise<"done" | "back"> {
|
||
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);
|
||
}
|
||
|
||
let platform = await detectPlatform();
|
||
if (!platform) {
|
||
const hostname = (await getRemoteHostname()) || "unknown";
|
||
const chosen = await selectPlatform(hostname);
|
||
if (chosen === BACK) return "back";
|
||
if (!chosen) {
|
||
console.log(" Aborted.");
|
||
process.exit(0);
|
||
}
|
||
platform = chosen;
|
||
}
|
||
|
||
const platformLabel =
|
||
platform === "github" ? "GitHub" : platform === "gitlab" ? "GitLab" : "Gitea";
|
||
console.log(` Using: ${CYAN}${platformLabel}${RESET}`);
|
||
|
||
const baseBranch = await getDefaultBranch();
|
||
const branchName = await getBranchName();
|
||
|
||
if (branchName === baseBranch) {
|
||
console.error(
|
||
` ${RED}Error: You are on the default branch (${baseBranch}). Switch to a feature branch first.${RESET}`,
|
||
);
|
||
process.exit(1);
|
||
}
|
||
|
||
console.log(
|
||
` Branch: ${CYAN}${branchName}${RESET} → base: ${CYAN}${baseBranch}${RESET}`,
|
||
);
|
||
|
||
const commits = await getBranchCommits(baseBranch);
|
||
|
||
if (commits.length === 0) {
|
||
const choice = await selectOne({
|
||
title: "No commits to compare",
|
||
subtitle: `No commits on ${branchName} compared to ${baseBranch}. Commit something first.`,
|
||
items: [{ label: "Back", value: "back" as const }],
|
||
});
|
||
if (choice === null) process.exit(0);
|
||
return "done";
|
||
}
|
||
|
||
console.log(
|
||
` ${commits.length} commit${commits.length > 1 ? "s" : ""} on this branch`,
|
||
);
|
||
|
||
const pushStatus = await getBranchPushStatus();
|
||
if (!pushStatus.pushed) {
|
||
const target = pushStatus.upstream ?? `origin/${branchName}`;
|
||
const answer = await ask(
|
||
` Branch is not pushed to ${CYAN}${target}${RESET}. Push now? [${GREEN}Y${RESET}/n] `,
|
||
);
|
||
|
||
if (answer.toLowerCase() === "n") {
|
||
console.log(" Aborted.");
|
||
return "done";
|
||
}
|
||
|
||
console.log(` Pushing ${CYAN}${branchName}${RESET}...`);
|
||
try {
|
||
await pushCurrentBranch(branchName, pushStatus.upstream);
|
||
console.log(` ${GREEN}Pushed ${branchName}.${RESET}`);
|
||
} catch (err) {
|
||
console.error(
|
||
` ${RED}Push failed: ${err instanceof Error ? err.message : err}${RESET}`,
|
||
);
|
||
process.exit(1);
|
||
}
|
||
}
|
||
|
||
const diff = await getBranchDiff(baseBranch);
|
||
if (!diff) {
|
||
console.error(` ${RED}Error: No diff from base branch.${RESET}`);
|
||
process.exit(1);
|
||
}
|
||
|
||
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 userPrompt = buildPRPrompt({
|
||
readme: projectCtx.readme,
|
||
packageDescription: projectCtx.packageDescription,
|
||
structure: projectCtx.structure,
|
||
branchName,
|
||
baseBranch,
|
||
branchCommits: commits,
|
||
diff: truncatedDiff,
|
||
});
|
||
|
||
console.log("\n Generating PR title...");
|
||
|
||
let title: string;
|
||
let body: string;
|
||
try {
|
||
const result = await generatePRMessage(config, PR_SYSTEM_PROMPT, userPrompt);
|
||
title = result.title;
|
||
body = result.body;
|
||
} catch (err) {
|
||
console.error(
|
||
` ${RED}AI request failed: ${err instanceof Error ? err.message : err}${RESET}`,
|
||
);
|
||
process.exit(1);
|
||
}
|
||
|
||
console.log(`\n ${BOLD}Generated PR:${RESET}`);
|
||
console.log(` Title: ${GREEN}${title}${RESET}`);
|
||
if (body) {
|
||
console.log(
|
||
` Body: ${DIM}${body.replace(/\n/g, "\n ")}${RESET}`,
|
||
);
|
||
}
|
||
console.log("");
|
||
|
||
const answer = await ask(` Create this PR? [${GREEN}Y${RESET}/n/e] `);
|
||
const lower = answer.toLowerCase();
|
||
|
||
if (lower === "n") {
|
||
console.log(" Aborted.");
|
||
return "done";
|
||
}
|
||
|
||
if (lower === "e") {
|
||
const newTitle = await ask(" Title: ");
|
||
const newBody = await ask(" Body (optional): ");
|
||
if (!newTitle.trim()) {
|
||
console.log(" Aborted.");
|
||
return "done";
|
||
}
|
||
title = newTitle;
|
||
body = newBody;
|
||
}
|
||
|
||
console.log(`\n Creating PR...`);
|
||
|
||
try {
|
||
const url = await createPR(platform, title, body, baseBranch, draft);
|
||
console.log(` ${GREEN}${BOLD}✔ PR created!${RESET}`);
|
||
console.log(` ${CYAN}${url}${RESET}`);
|
||
} catch (err) {
|
||
console.error(
|
||
` ${RED}PR creation failed: ${err instanceof Error ? err.message : err}${RESET}`,
|
||
);
|
||
process.exit(1);
|
||
}
|
||
|
||
return "done";
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
const subcommand = args[0];
|
||
|
||
if (subcommand === "config") {
|
||
await handleConfig();
|
||
return;
|
||
}
|
||
|
||
if (subcommand === "help") {
|
||
showHelp();
|
||
return;
|
||
}
|
||
|
||
if (subcommand === "commit") {
|
||
const autoMode = args.includes("--auto") || args.includes("-a");
|
||
const dryRun = args.includes("--dry-run") || args.includes("-d");
|
||
await handleCommit(autoMode, dryRun);
|
||
return;
|
||
}
|
||
|
||
if (subcommand === "pr") {
|
||
const draft = args.includes("--draft");
|
||
await handlePR(draft);
|
||
return;
|
||
}
|
||
|
||
if (!subcommand) {
|
||
await showMenu();
|
||
return;
|
||
}
|
||
|
||
console.error(` ${RED}Unknown command: ${subcommand}${RESET}`);
|
||
showHelp();
|
||
process.exit(1);
|
||
}
|
||
|
||
process.on("SIGINT", () => {
|
||
process.stdout.write("\x1b[?25h");
|
||
process.stdout.write("\n");
|
||
process.exit(130);
|
||
});
|
||
|
||
main().catch((err) => {
|
||
console.error(` ${RED}Unexpected error: ${err}${RESET}`);
|
||
process.exit(1);
|
||
});
|