craftcommit-cli 0.3.0

package/src/ai.ts

@@ -0,0 +1,268 @@
+import OpenAI from 'openai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import type { Provider, Language } from './config.js';
+
+export interface CommitMessage {
+  type: string;
+  scope?: string;
+  subject: string;
+}
+
+const SYSTEM_PROMPT_EN = `You are a commit message generator. Analyze the git diff and generate 3 different commit message suggestions following Conventional Commits format.
+
+Output JSON only: { "candidates": [{ "type": "...", "scope": "...", "subject": "..." }, ...] }
+
+Rules:
+- type: one of feat, fix, docs, style, refactor, perf, test, build, ci, chore
+- scope: optional, short identifier for affected area (e.g., "auth", "api", "ui"). Omit if changes span multiple areas
+- subject: imperative mood (e.g., "add", "fix", "update"), max 72 chars, no period at end, lowercase first letter
+- Provide 3 different variations with different wording or focus
+
+Example output:
+{ "candidates": [
+  { "type": "feat", "scope": "auth", "subject": "add OAuth2 login support" },
+  { "type": "feat", "scope": "auth", "subject": "implement OAuth2 authentication flow" },
+  { "type": "feat", "subject": "add social login via OAuth2" }
+]}`;
+
+const SYSTEM_PROMPT_KO = `You are a commit message generator. Analyze the git diff and generate 3 different commit message suggestions following Conventional Commits format.
+
+Output JSON only: { "candidates": [{ "type": "...", "scope": "...", "subject": "..." }, ...] }
+
+Rules:
+- type: one of feat, fix, docs, style, refactor, perf, test, build, ci, chore (MUST be in English)
+- scope: optional, short identifier for affected area (MUST be in English)
+- subject: MUST be written in Korean, max 72 chars, no period at end
+- Provide 3 different variations with different wording or focus
+
+Example output:
+{ "candidates": [
+  { "type": "feat", "scope": "auth", "subject": "OAuth2 로그인 지원 추가" },
+  { "type": "feat", "scope": "auth", "subject": "OAuth2 인증 흐름 구현" },
+  { "type": "feat", "subject": "OAuth2를 통한 소셜 로그인 추가" }
+]}`;
+
+function getSystemPrompt(language: Language, issueReference?: string): string {
+  let prompt = language === 'korean' ? SYSTEM_PROMPT_KO : SYSTEM_PROMPT_EN;
+
+  if (issueReference) {
+    prompt += `\n\nIMPORTANT: Include "${issueReference}" at the end of each subject.`;
+  }
+
+  return prompt;
+}
+
+function buildUserPrompt(diff: string, fileSummary: string): string {
+  return `Generate 3 commit message candidates for the following changes:
+
+## Files Changed:
+${fileSummary || 'No files changed'}
+
+## Diff:
+${diff || 'No diff available'}`;
+}
+
+function parseJsonFromText(text: string): unknown {
+  const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) ||
+                    text.match(/(\{[\s\S]*\})/);
+
+  if (jsonMatch) {
+    return JSON.parse(jsonMatch[1].trim());
+  }
+
+  return JSON.parse(text);
+}
+
+function validateCandidates(data: unknown): CommitMessage[] {
+  if (typeof data !== 'object' || data === null) {
+    throw new Error('Response is not an object');
+  }
+
+  const obj = data as Record<string, unknown>;
+
+  if (!Array.isArray(obj.candidates)) {
+    throw new Error('Missing candidates array');
+  }
+
+  return obj.candidates.slice(0, 3).map((candidate) => {
+    const c = candidate as Record<string, unknown>;
+    let subject = String(c.subject || '').trim();
+
+    if (subject.endsWith('.')) {
+      subject = subject.slice(0, -1);
+    }
+
+    if (subject.length > 72) {
+      subject = subject.substring(0, 69) + '...';
+    }
+
+    return {
+      type: String(c.type || 'chore'),
+      scope: c.scope ? String(c.scope).trim() : undefined,
+      subject
+    };
+  });
+}
+
+async function callOpenAI(
+  apiKey: string,
+  model: string,
+  diff: string,
+  fileSummary: string,
+  language: Language,
+  issueReference?: string
+): Promise<CommitMessage[]> {
+  const client = new OpenAI({ apiKey });
+
+  const response = await client.chat.completions.create({
+    model,
+    messages: [
+      { role: 'system', content: getSystemPrompt(language, issueReference) },
+      { role: 'user', content: buildUserPrompt(diff, fileSummary) }
+    ],
+    response_format: { type: 'json_object' },
+    temperature: 0.7,
+    max_tokens: 500
+  });
+
+  const content = response.choices[0]?.message?.content;
+  if (!content) {
+    throw new Error('Empty response from OpenAI');
+  }
+
+  return validateCandidates(JSON.parse(content));
+}
+
+async function callGroq(
+  apiKey: string,
+  model: string,
+  diff: string,
+  fileSummary: string,
+  language: Language,
+  issueReference?: string
+): Promise<CommitMessage[]> {
+  const client = new OpenAI({
+    apiKey,
+    baseURL: 'https://api.groq.com/openai/v1'
+  });
+
+  const response = await client.chat.completions.create({
+    model,
+    messages: [
+      { role: 'system', content: getSystemPrompt(language, issueReference) },
+      { role: 'user', content: buildUserPrompt(diff, fileSummary) }
+    ],
+    response_format: { type: 'json_object' },
+    temperature: 0.7,
+    max_tokens: 500
+  });
+
+  const content = response.choices[0]?.message?.content;
+  if (!content) {
+    throw new Error('Empty response from Groq');
+  }
+
+  return validateCandidates(JSON.parse(content));
+}
+
+async function callGemini(
+  apiKey: string,
+  model: string,
+  diff: string,
+  fileSummary: string,
+  language: Language,
+  issueReference?: string
+): Promise<CommitMessage[]> {
+  const genAI = new GoogleGenerativeAI(apiKey);
+  const geminiModel = genAI.getGenerativeModel({
+    model,
+    generationConfig: {
+      temperature: 0.7,
+      maxOutputTokens: 500,
+      responseMimeType: 'application/json'
+    }
+  });
+
+  const prompt = `${getSystemPrompt(language, issueReference)}
+
+${buildUserPrompt(diff, fileSummary)}`;
+
+  const result = await geminiModel.generateContent(prompt);
+  const text = result.response.text();
+
+  if (!text) {
+    throw new Error('Empty response from Gemini');
+  }
+
+  return validateCandidates(parseJsonFromText(text));
+}
+
+async function callOllama(
+  ollamaUrl: string,
+  model: string,
+  diff: string,
+  fileSummary: string,
+  language: Language,
+  issueReference?: string
+): Promise<CommitMessage[]> {
+  const response = await fetch(`${ollamaUrl}/api/chat`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: getSystemPrompt(language, issueReference) },
+        { role: 'user', content: buildUserPrompt(diff, fileSummary) }
+      ],
+      format: 'json',
+      stream: false
+    })
+  });
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Model "${model}" not found. Run: ollama pull ${model}`);
+    }
+    throw new Error(`Ollama request failed: ${response.status}`);
+  }
+
+  const data = await response.json() as { message?: { content?: string } };
+  const content = data.message?.content;
+
+  if (!content) {
+    throw new Error('Empty response from Ollama');
+  }
+
+  return validateCandidates(parseJsonFromText(content));
+}
+
+export async function generateCommitMessages(
+  provider: Provider,
+  apiKey: string,
+  diff: string,
+  fileSummary: string,
+  model: string,
+  language: Language,
+  ollamaUrl?: string,
+  issueReference?: string
+): Promise<CommitMessage[]> {
+  switch (provider) {
+    case 'openai':
+      return callOpenAI(apiKey, model, diff, fileSummary, language, issueReference);
+    case 'groq':
+      return callGroq(apiKey, model, diff, fileSummary, language, issueReference);
+    case 'gemini':
+      return callGemini(apiKey, model, diff, fileSummary, language, issueReference);
+    case 'ollama':
+      return callOllama(ollamaUrl || 'http://localhost:11434', model, diff, fileSummary, language, issueReference);
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+
+export function formatCommitMessage(commit: CommitMessage): string {
+  if (commit.scope) {
+    return `${commit.type}(${commit.scope}): ${commit.subject}`;
+  }
+  return `${commit.type}: ${commit.subject}`;
+}

package/src/cli.ts

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import clipboardy from 'clipboardy';
+import { simpleGit, SimpleGit } from 'simple-git';
+import { loadConfig, saveConfig, getApiKey, getDefaultModel, type Provider, type Language } from './config.js';
+import { generateCommitMessages, formatCommitMessage, type CommitMessage } from './ai.js';
+
+const VERSION = '0.3.0';
+
+const git: SimpleGit = simpleGit();
+
+async function getStagedDiff(): Promise<{ diff: string; fileSummary: string }> {
+  const [diff, fileSummary] = await Promise.all([
+    git.diff(['--cached']),
+    git.diff(['--cached', '--name-status'])
+  ]);
+
+  return { diff, fileSummary };
+}
+
+async function hasStagedChanges(): Promise<boolean> {
+  const diff = await git.diff(['--cached', '--name-only']);
+  return diff.trim().length > 0;
+}
+
+async function getCurrentBranch(): Promise<string> {
+  const branchSummary = await git.branch();
+  return branchSummary.current;
+}
+
+function extractIssueFromBranch(branchName: string, pattern?: string): string | null {
+  if (!pattern) return null;
+
+  try {
+    const regex = new RegExp(pattern);
+    const match = branchName.match(regex);
+    return match?.[1] || match?.[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+async function generateCommand(options: {
+  provider?: Provider;
+  model?: string;
+  language?: Language;
+  commit?: boolean;
+  issuePattern?: string;
+  issuePrefix?: string;
+}) {
+  const config = loadConfig();
+
+  // Override config with CLI options
+  const provider = options.provider || config.provider;
+  const model = options.model || config.model || getDefaultModel(provider);
+  const language = options.language || config.language;
+
+  // Check for API key
+  const apiKey = getApiKey({ ...config, provider });
+  if (!apiKey) {
+    console.error(chalk.red(`\nNo API key found for ${provider}.`));
+    console.log(chalk.yellow(`\nSet your API key:`));
+    console.log(chalk.gray(`  Environment: OPENAI_API_KEY, GROQ_API_KEY, or GEMINI_API_KEY`));
+    console.log(chalk.gray(`  Config file: ~/.commitcraftrc`));
+    console.log(chalk.gray(`  Or run: commitcraft config\n`));
+    process.exit(1);
+  }
+
+  // Check for staged changes
+  const hasChanges = await hasStagedChanges();
+  if (!hasChanges) {
+    console.log(chalk.yellow('\nNo staged changes found.'));
+    console.log(chalk.gray('Stage files with: git add <files>\n'));
+    process.exit(1);
+  }
+
+  // Get diff
+  const spinner = ora('Getting staged changes...').start();
+  let diff: string;
+  let fileSummary: string;
+
+  try {
+    const result = await getStagedDiff();
+    diff = result.diff;
+    fileSummary = result.fileSummary;
+
+    if (!diff.trim()) {
+      spinner.fail('No diff content found');
+      process.exit(1);
+    }
+
+    // Truncate large diffs
+    const MAX_CHARS = 12000;
+    if (diff.length > MAX_CHARS) {
+      diff = diff.substring(0, MAX_CHARS) + '\n... [truncated]';
+    }
+
+    spinner.succeed('Got staged changes');
+  } catch (error) {
+    spinner.fail('Failed to get staged changes');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+
+  // Extract issue from branch if pattern is configured
+  let issueReference: string | undefined;
+  if (options.issuePattern) {
+    try {
+      const branchName = await getCurrentBranch();
+      const issue = extractIssueFromBranch(branchName, options.issuePattern);
+      if (issue) {
+        issueReference = (options.issuePrefix || '') + issue;
+        console.log(chalk.blue(`\nDetected issue: ${issueReference}`));
+      }
+    } catch {
+      // Ignore branch detection errors
+    }
+  }
+
+  // Generate commit messages
+  const generateSpinner = ora(`Generating commit messages via ${provider}...`).start();
+  let candidates: CommitMessage[];
+
+  try {
+    candidates = await generateCommitMessages(
+      provider,
+      apiKey,
+      diff,
+      fileSummary,
+      model,
+      language,
+      config.ollamaUrl,
+      issueReference
+    );
+    generateSpinner.succeed('Generated commit messages');
+  } catch (error) {
+    generateSpinner.fail('Failed to generate commit messages');
+    const message = error instanceof Error ? error.message : String(error);
+
+    if (message.includes('401') || message.includes('Unauthorized')) {
+      console.error(chalk.red(`\nInvalid ${provider} API key.`));
+    } else if (message.includes('ECONNREFUSED')) {
+      console.error(chalk.red(`\nCannot connect to Ollama at ${config.ollamaUrl}`));
+    } else {
+      console.error(chalk.red(`\n${message}`));
+    }
+    process.exit(1);
+  }
+
+  // Format choices for inquirer
+  const choices = candidates.map((commit, index) => ({
+    name: `${index + 1}. ${formatCommitMessage(commit)}`,
+    value: commit
+  }));
+
+  choices.push({
+    name: chalk.gray('Cancel'),
+    value: null as unknown as CommitMessage
+  });
+
+  // Let user select a message
+  console.log();
+  const { selected } = await inquirer.prompt<{ selected: CommitMessage | null }>([
+    {
+      type: 'list',
+      name: 'selected',
+      message: 'Select a commit message:',
+      choices
+    }
+  ]);
+
+  if (!selected) {
+    console.log(chalk.yellow('\nCancelled.'));
+    process.exit(0);
+  }
+
+  const commitMessage = formatCommitMessage(selected);
+
+  if (options.commit) {
+    // Auto-commit
+    const commitSpinner = ora('Committing...').start();
+    try {
+      await git.commit(commitMessage);
+      commitSpinner.succeed(chalk.green(`Committed: ${commitMessage}`));
+    } catch (error) {
+      commitSpinner.fail('Failed to commit');
+      console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  } else {
+    // Copy to clipboard
+    try {
+      await clipboardy.write(commitMessage);
+      console.log(chalk.green(`\n✓ Copied to clipboard: ${commitMessage}`));
+    } catch {
+      // Clipboard might not work in all environments
+      console.log(chalk.green(`\n✓ Selected: ${commitMessage}`));
+      console.log(chalk.gray('(Copy manually if clipboard is not available)'));
+    }
+  }
+}
+
+async function configCommand() {
+  console.log(chalk.bold('\nCommitCraft CLI Configuration\n'));
+
+  const { provider } = await inquirer.prompt<{ provider: Provider }>([
+    {
+      type: 'list',
+      name: 'provider',
+      message: 'Select AI provider:',
+      choices: [
+        { name: 'OpenAI', value: 'openai' },
+        { name: 'Groq', value: 'groq' },
+        { name: 'Gemini', value: 'gemini' },
+        { name: 'Ollama (local)', value: 'ollama' }
+      ]
+    }
+  ]);
+
+  let apiKey: string | undefined;
+
+  if (provider !== 'ollama') {
+    const { key } = await inquirer.prompt<{ key: string }>([
+      {
+        type: 'password',
+        name: 'key',
+        message: `Enter your ${provider} API key:`,
+        mask: '*'
+      }
+    ]);
+    apiKey = key;
+  }
+
+  const { language } = await inquirer.prompt<{ language: Language }>([
+    {
+      type: 'list',
+      name: 'language',
+      message: 'Select language for commit messages:',
+      choices: [
+        { name: 'English', value: 'english' },
+        { name: 'Korean', value: 'korean' }
+      ]
+    }
+  ]);
+
+  const { model } = await inquirer.prompt<{ model: string }>([
+    {
+      type: 'input',
+      name: 'model',
+      message: 'Model (leave empty for default):',
+      default: getDefaultModel(provider)
+    }
+  ]);
+
+  const configToSave: Record<string, string> = {
+    provider,
+    language,
+    model
+  };
+
+  if (apiKey) {
+    const keyName = `${provider}ApiKey`;
+    configToSave[keyName] = apiKey;
+  }
+
+  if (provider === 'ollama') {
+    const { ollamaUrl } = await inquirer.prompt<{ ollamaUrl: string }>([
+      {
+        type: 'input',
+        name: 'ollamaUrl',
+        message: 'Ollama URL:',
+        default: 'http://localhost:11434'
+      }
+    ]);
+    configToSave.ollamaUrl = ollamaUrl;
+  }
+
+  saveConfig(configToSave);
+  console.log(chalk.green('\n✓ Configuration saved to ~/.commitcraftrc\n'));
+}
+
+// Main CLI
+const program = new Command();
+
+program
+  .name('commitcraft')
+  .description('Generate AI-powered commit messages')
+  .version(VERSION);
+
+program
+  .command('generate', { isDefault: true })
+  .description('Generate commit message from staged changes')
+  .option('-p, --provider <provider>', 'AI provider (openai, groq, gemini, ollama)')
+  .option('-m, --model <model>', 'Model to use')
+  .option('-l, --language <language>', 'Language (english, korean)')
+  .option('-c, --commit', 'Auto-commit with selected message')
+  .option('--issue-pattern <pattern>', 'Regex to extract issue from branch name')
+  .option('--issue-prefix <prefix>', 'Prefix for issue reference (e.g., #)')
+  .action(generateCommand);
+
+program
+  .command('config')
+  .description('Configure API keys and preferences')
+  .action(configCommand);
+
+program.parse();

package/src/config.ts

@@ -0,0 +1,118 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import dotenv from 'dotenv';
+
+export type Provider = 'openai' | 'groq' | 'gemini' | 'ollama';
+export type Language = 'english' | 'korean';
+
+export interface Config {
+  provider: Provider;
+  model: string;
+  language: Language;
+  ollamaUrl: string;
+  openaiApiKey?: string;
+  groqApiKey?: string;
+  geminiApiKey?: string;
+}
+
+const CONFIG_FILE = '.commitcraftrc';
+const CONFIG_PATH = path.join(os.homedir(), CONFIG_FILE);
+
+const DEFAULT_MODELS: Record<Provider, string> = {
+  openai: 'gpt-4o-mini',
+  groq: 'llama-3.1-8b-instant',
+  gemini: 'gemini-1.5-flash',
+  ollama: 'llama3.2'
+};
+
+function loadEnvFile(): void {
+  // Load from current directory .env first
+  const localEnv = path.join(process.cwd(), '.env');
+  if (fs.existsSync(localEnv)) {
+    dotenv.config({ path: localEnv });
+  }
+
+  // Then load from home directory
+  const homeEnv = path.join(os.homedir(), '.env');
+  if (fs.existsSync(homeEnv)) {
+    dotenv.config({ path: homeEnv });
+  }
+}
+
+function loadConfigFile(): Partial<Config> {
+  // Check local config first
+  const localConfig = path.join(process.cwd(), CONFIG_FILE);
+  if (fs.existsSync(localConfig)) {
+    try {
+      const content = fs.readFileSync(localConfig, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  // Then check home directory
+  if (fs.existsSync(CONFIG_PATH)) {
+    try {
+      const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  return {};
+}
+
+export function loadConfig(): Config {
+  loadEnvFile();
+  const fileConfig = loadConfigFile();
+
+  const provider = (process.env.COMMITCRAFT_PROVIDER || fileConfig.provider || 'openai') as Provider;
+
+  return {
+    provider,
+    model: process.env.COMMITCRAFT_MODEL || fileConfig.model || DEFAULT_MODELS[provider],
+    language: (process.env.COMMITCRAFT_LANGUAGE || fileConfig.language || 'english') as Language,
+    ollamaUrl: process.env.OLLAMA_URL || fileConfig.ollamaUrl || 'http://localhost:11434',
+    openaiApiKey: process.env.OPENAI_API_KEY || fileConfig.openaiApiKey,
+    groqApiKey: process.env.GROQ_API_KEY || fileConfig.groqApiKey,
+    geminiApiKey: process.env.GEMINI_API_KEY || fileConfig.geminiApiKey
+  };
+}
+
+export function saveConfig(config: Partial<Config>): void {
+  let existingConfig: Partial<Config> = {};
+
+  if (fs.existsSync(CONFIG_PATH)) {
+    try {
+      const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+      existingConfig = JSON.parse(content);
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  const newConfig = { ...existingConfig, ...config };
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(newConfig, null, 2));
+}
+
+export function getApiKey(config: Config): string | undefined {
+  switch (config.provider) {
+    case 'openai':
+      return config.openaiApiKey;
+    case 'groq':
+      return config.groqApiKey;
+    case 'gemini':
+      return config.geminiApiKey;
+    case 'ollama':
+      return 'ollama-no-key-needed';
+    default:
+      return undefined;
+  }
+}
+
+export function getDefaultModel(provider: Provider): string {
+  return DEFAULT_MODELS[provider];
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}