@ksw8954/git-ai-commit 1.0.0

package/src/commands/configCommand.ts

@@ -0,0 +1,139 @@
+import { Command } from 'commander';
+import { ConfigService, SupportedLanguage } from './config';
+
+export interface ConfigOptions {
+  show?: boolean;
+  language?: string;
+  autoPush?: boolean;
+  apiKey?: string;
+  baseUrl?: string;
+  model?: string;
+  mode?: 'custom' | 'openai';
+}
+
+export class ConfigCommand {
+  private program: Command;
+
+  constructor() {
+    this.program = new Command('config')
+      .description('Manage git-ai-commit configuration')
+      .option('-s, --show', 'Show current configuration values')
+      .option('-l, --language <language>', 'Set default language for AI output (ko | en)')
+      .option('--auto-push', 'Enable automatic git push after successful commits created with --commit')
+      .option('--no-auto-push', 'Disable automatic git push after successful commits created with --commit')
+      .option('-k, --api-key <key>', 'Persist API key for AI requests (overrides environment variables)')
+      .option('-b, --base-url <url>', 'Persist API base URL (overrides environment variables)')
+      .option('-m, --model <model>', 'Persist default AI model')
+      .option('--mode <mode>', 'Persist AI mode (custom | openai)')
+      .action(this.handleConfig.bind(this));
+  }
+
+  private validateLanguage(language: string): SupportedLanguage {
+    const normalized = language?.toLowerCase();
+    if (normalized !== 'ko' && normalized !== 'en') {
+      console.error('Language must be either "ko" or "en".');
+      process.exit(1);
+    }
+
+    return normalized;
+  }
+
+  private validateMode(mode: string): 'custom' | 'openai' {
+    const normalized = mode?.toLowerCase();
+    if (normalized !== 'custom' && normalized !== 'openai') {
+      console.error('Mode must be either "custom" or "openai".');
+      process.exit(1);
+    }
+
+    return normalized;
+  }
+
+  private sanitizeStringValue(value?: string): string | undefined {
+    if (value === undefined) {
+      return undefined;
+    }
+
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  }
+
+  private async handleConfig(options: ConfigOptions) {
+    const updates: {
+      apiKey?: string;
+      baseURL?: string;
+      model?: string;
+      mode?: 'custom' | 'openai';
+      language?: SupportedLanguage;
+      autoPush?: boolean;
+    } = {};
+
+    if (options.language) {
+      updates.language = this.validateLanguage(options.language);
+    }
+
+    if (typeof options.autoPush === 'boolean') {
+      updates.autoPush = options.autoPush;
+    }
+
+    if (options.apiKey !== undefined) {
+      updates.apiKey = this.sanitizeStringValue(options.apiKey);
+    }
+
+    if (options.baseUrl !== undefined) {
+      updates.baseURL = this.sanitizeStringValue(options.baseUrl);
+    }
+
+    if (options.model !== undefined) {
+      updates.model = this.sanitizeStringValue(options.model);
+    }
+
+    if (options.mode) {
+      updates.mode = this.validateMode(options.mode);
+    }
+
+    const hasUpdates = Object.keys(updates).length > 0;
+
+    if (!options.show && !hasUpdates) {
+      console.log('Usage examples:');
+      console.log('  git-ai-commit config --show                 # Display merged configuration');
+      console.log('  git-ai-commit config --language en          # Use English prompts and output');
+      console.log('  git-ai-commit config --auto-push            # Push after commits created with --commit');
+      console.log('  git-ai-commit config -k sk-xxx              # Persist API key securely on disk');
+      console.log('  git-ai-commit config -b https://api.test    # Persist custom API base URL');
+      console.log('  git-ai-commit config --mode openai          # Use OpenAI-compatible environment defaults');
+      console.log('  git-ai-commit config --model gpt-4o-mini    # Persist preferred AI model');
+      return;
+    }
+
+    if (hasUpdates) {
+      try {
+        await ConfigService.updateConfig(updates);
+        console.log('Configuration updated successfully.');
+      } catch (error) {
+        console.error('Error updating configuration:', error instanceof Error ? error.message : error);
+        process.exit(1);
+        return;
+      }
+    }
+
+    if (options.show) {
+      try {
+        const config = ConfigService.getConfig();
+        console.log('Current configuration:');
+        console.log(`Language: ${config.language}`);
+        console.log(`Auto push: ${config.autoPush ? 'enabled' : 'disabled'}`);
+        console.log(`API Key: ${config.apiKey ? '***' + config.apiKey.slice(-4) : 'Not set'}`);
+        console.log(`Base URL: ${config.baseURL || 'Not set (using provider default)'}`);
+        console.log(`Model: ${config.model || 'zai-org/GLM-4.5-FP8 (default)'}`);
+        console.log(`Mode: ${config.mode || 'custom (default)'}`);
+      } catch (error) {
+        console.error('Error reading configuration:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    }
+  }
+
+  getCommand(): Command {
+    return this.program;
+  }
+}

package/src/commands/git.ts

@@ -0,0 +1,174 @@
+import { exec, execFile } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+
+export interface GitDiffResult {
+  success: boolean;
+  diff?: string;
+  error?: string;
+}
+
+export interface GitTagResult {
+  success: boolean;
+  tag?: string;
+  error?: string;
+}
+
+export interface GitLogResult {
+  success: boolean;
+  log?: string;
+  error?: string;
+}
+
+export class GitService {
+  static async getStagedDiff(): Promise<GitDiffResult> {
+    try {
+      const { stdout } = await execAsync('git diff --staged');
+      
+      if (!stdout.trim()) {
+        return {
+          success: false,
+          error: 'No staged changes found. Please stage your changes first.'
+        };
+      }
+      
+      return {
+        success: true,
+        diff: stdout
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to get git diff'
+      };
+    }
+  }
+
+  static async getBranchDiff(base: string, compare: string): Promise<GitDiffResult> {
+    try {
+      const command = `git diff ${base}...${compare}`;
+      const { stdout } = await execAsync(command);
+
+      if (!stdout.trim()) {
+        return {
+          success: false,
+          error: `No differences found between ${base} and ${compare}.`
+        };
+      }
+
+      return {
+        success: true,
+        diff: stdout
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Failed to get branch diff';
+      return {
+        success: false,
+        error: message.includes('unknown revision')
+          ? `Unable to resolve one of the branches: ${base} or ${compare}.`
+          : message
+      };
+    }
+  }
+  
+  static async createCommit(message: string): Promise<boolean> {
+    try {
+      await execFileAsync('git', ['commit', '-m', message]);
+      return true;
+    } catch (error) {
+      console.error('Failed to create commit:', error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
+
+  static async push(): Promise<boolean> {
+    try {
+      await execFileAsync('git', ['push']);
+      return true;
+    } catch (error) {
+      console.error('Failed to push to remote:', error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
+
+  static async pushTag(tagName: string): Promise<boolean> {
+    try {
+      await execFileAsync('git', ['push', 'origin', tagName]);
+      return true;
+    } catch (error) {
+      console.error('Failed to push tag to remote:', error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
+
+  static async getLatestTag(): Promise<GitTagResult> {
+    try {
+      const { stdout } = await execAsync('git describe --tags --abbrev=0');
+      const tag = stdout.trim();
+
+      if (!tag) {
+        return {
+          success: false,
+          error: 'No tags found in the repository.'
+        };
+      }
+
+      return {
+        success: true,
+        tag
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Failed to determine the latest tag. Provide a base tag explicitly using --base-tag.'
+      };
+    }
+  }
+
+  static async getCommitSummariesSince(tag?: string): Promise<GitLogResult> {
+    try {
+      const logCommand = tag
+        ? `git log ${tag}..HEAD --pretty=format:%s`
+        : 'git log --pretty=format:%s';
+
+      const { stdout } = await execAsync(logCommand);
+      const trimmed = stdout
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line.length > 0);
+
+      if (trimmed.length === 0) {
+        return {
+          success: false,
+          error: tag
+            ? `No commits found since tag ${tag}.`
+            : 'No commits found in the repository.'
+        };
+      }
+
+      const formattedLog = trimmed.map(entry => `- ${entry}`).join('\n');
+
+      return {
+        success: true,
+        log: formattedLog
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to read commit history.'
+      };
+    }
+  }
+
+  static async createAnnotatedTag(tagName: string, message: string): Promise<boolean> {
+    try {
+      await execFileAsync('git', ['tag', '-a', tagName, '-m', message]);
+      return true;
+    } catch (error) {
+      console.error('Failed to create tag:', error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
+}

package/src/commands/history.ts

@@ -0,0 +1,82 @@
+import { Command } from 'commander';
+import readline from 'readline';
+import { LogService } from './log';
+
+export interface HistoryOptions {
+  limit?: string;
+  json?: boolean;
+  clear?: boolean;
+}
+
+export class HistoryCommand {
+  private program: Command;
+
+  constructor() {
+    this.program = new Command('history')
+      .description('Manage git-ai-commit command history')
+      .option('-l, --limit <n>', 'Limit number of entries to show (most recent first)')
+      .option('--json', 'Output in JSON format')
+      .option('--clear', 'Clear all stored history (requires confirmation)')
+      .action(this.handleHistory.bind(this));
+  }
+
+  private async confirmClear(): Promise<boolean> {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer: string = await new Promise(resolve => {
+      rl.question('This will remove all stored history. Continue? (y/n): ', resolve);
+    });
+    rl.close();
+    const normalized = answer.trim().toLowerCase();
+    return normalized === 'y' || normalized === 'yes';
+  }
+
+  private parseLimit(value?: string): number | undefined {
+    if (!value) return undefined;
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : undefined;
+  }
+
+  private formatLine(e: any): string {
+    const ts = new Date(e.timestamp).toISOString();
+    const args = Object.entries(e.args || {})
+      .filter(([k, v]) => v !== undefined && v !== null && v !== '')
+      .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+      .join(' ');
+    return `${ts}  ${e.command}  ${e.status}${e.durationMs ? ` (${e.durationMs}ms)` : ''}${args ? `  -- ${args}` : ''}${e.details ? `\n  > ${e.details}` : ''}`;
+  }
+
+  private async handleHistory(options: HistoryOptions) {
+    if (options.clear) {
+      const confirmed = await this.confirmClear();
+      if (!confirmed) {
+        console.log('History clear cancelled.');
+        return;
+      }
+      await LogService.clear();
+      console.log('History cleared.');
+      return;
+    }
+
+    const limit = this.parseLimit(options.limit);
+    const entries = await LogService.read(limit);
+
+    if (options.json) {
+      const output = limit ? entries.slice(-limit) : entries;
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+
+    if (entries.length === 0) {
+      console.log('No history entries.');
+      return;
+    }
+
+    for (const e of entries) {
+      console.log(this.formatLine(e));
+    }
+  }
+
+  getCommand(): Command {
+    return this.program;
+  }
+}

package/src/commands/loadEnv.ts

@@ -0,0 +1,5 @@
+import dotenv from 'dotenv';
+
+export function loadEnv() {
+  dotenv.config();
+}

package/src/commands/log.ts

@@ -0,0 +1,71 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+export type LogStatus = 'success' | 'failure' | 'cancelled';
+
+export interface HistoryEntry {
+  id: string;
+  timestamp: string; // ISO
+  command: string;
+  args: Record<string, unknown>;
+  status: LogStatus;
+  details?: string;
+  durationMs?: number;
+}
+
+function getStorageDir(): string {
+  const override = process.env.GIT_AI_COMMIT_CONFIG_PATH;
+  return override ? path.dirname(path.resolve(override)) : path.join(os.homedir(), '.git-ai-commit');
+}
+
+function getHistoryPath(): string {
+  return path.join(getStorageDir(), 'history.jsonl');
+}
+
+function genId(): string {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export class LogService {
+  static async append(entry: Omit<HistoryEntry, 'id' | 'timestamp'> & { timestamp?: string; id?: string }): Promise<void> {
+    const file = getHistoryPath();
+    const dir = path.dirname(file);
+    await fs.mkdir(dir, { recursive: true });
+
+    const finalized: HistoryEntry = {
+      id: entry.id || genId(),
+      timestamp: entry.timestamp || new Date().toISOString(),
+      command: entry.command,
+      args: entry.args,
+      status: entry.status,
+      details: entry.details,
+      durationMs: entry.durationMs
+    };
+
+    const line = JSON.stringify(finalized) + '\n';
+    await fs.appendFile(file, line, 'utf-8');
+  }
+
+  static async read(limit?: number): Promise<HistoryEntry[]> {
+    const file = getHistoryPath();
+    try {
+      const raw = await fs.readFile(file, 'utf-8');
+      const lines = raw.split('\n').filter(Boolean);
+      const parsed = lines.map(l => {
+        try { return JSON.parse(l) as HistoryEntry; } catch { return undefined; }
+      }).filter((e): e is HistoryEntry => Boolean(e));
+      const result = limit && limit > 0 ? parsed.slice(-limit) : parsed;
+      return result;
+    } catch (e) {
+      return [];
+    }
+  }
+
+  static async clear(): Promise<void> {
+    const file = getHistoryPath();
+    const dir = path.dirname(file);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(file, '', 'utf-8');
+  }
+}

package/src/commands/prCommand.ts

@@ -0,0 +1,108 @@
+import { Command } from 'commander';
+import { GitService } from './git';
+import { AIService } from './ai';
+import { ConfigService } from './config';
+import { LogService } from './log';
+
+export interface PullRequestOptions {
+  base: string;
+  compare: string;
+  apiKey?: string;
+  baseURL?: string;
+  baseUrl?: string;
+  model?: string;
+}
+
+export class PullRequestCommand {
+  private program: Command;
+
+  constructor() {
+    this.program = new Command('pr')
+      .description('Generate a pull request title and summary from branch differences')
+      .requiredOption('--base <branch>', 'Base branch to diff against (e.g. main)')
+      .requiredOption('--compare <branch>', 'Compare branch to describe (e.g. feature/my-change)')
+      .option('-k, --api-key <key>', 'Override API key for this run')
+      .option('-b, --base-url <url>', 'Override API base URL')
+      .option('--model <model>', 'Override AI model for this run')
+      .action(this.handlePullRequest.bind(this));
+  }
+
+  private async handlePullRequest(options: PullRequestOptions) {
+    try {
+      const existingConfig = ConfigService.getConfig();
+
+      const mergedApiKey = options.apiKey || existingConfig.apiKey;
+      const baseURLOverride = options.baseURL ?? options.baseUrl;
+      const mergedBaseURL = baseURLOverride || existingConfig.baseURL;
+      const mergedModel = options.model || existingConfig.model;
+
+      ConfigService.validateConfig({
+        apiKey: mergedApiKey,
+        language: existingConfig.language
+      });
+
+      const diffResult = await GitService.getBranchDiff(options.base, options.compare);
+
+      if (!diffResult.success || !diffResult.diff) {
+        const err = diffResult.error || 'Unable to determine differences between branches.';
+        console.error('Error:', err);
+        await LogService.append({
+          command: 'pr',
+          args: { ...options, apiKey: options.apiKey ? '***' : undefined },
+          status: 'failure',
+          details: err
+        });
+        process.exit(1);
+        return;
+      }
+
+      const aiService = new AIService({
+        apiKey: mergedApiKey!,
+        baseURL: mergedBaseURL,
+        model: mergedModel,
+        language: existingConfig.language,
+        verbose: false
+      });
+
+      const aiResult = await aiService.generatePullRequestMessage(
+        options.base,
+        options.compare,
+        diffResult.diff
+      );
+
+      if (!aiResult.success || !aiResult.message) {
+        const err = aiResult.error || 'Failed to generate pull request message.';
+        console.error('Error:', err);
+        await LogService.append({
+          command: 'pr',
+          args: { ...options, apiKey: options.apiKey ? '***' : undefined },
+          status: 'failure',
+          details: err
+        });
+        process.exit(1);
+        return;
+      }
+
+      console.log(aiResult.message);
+      await LogService.append({
+        command: 'pr',
+        args: { ...options, apiKey: options.apiKey ? '***' : undefined },
+        status: 'success'
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error('Error:', message);
+      await LogService.append({
+        command: 'pr',
+        args: { ...options, apiKey: options.apiKey ? '***' : undefined },
+        status: 'failure',
+        details: message
+      });
+      process.exit(1);
+    }
+  }
+
+  getCommand(): Command {
+    return this.program;
+  }
+}