@ksw8954/git-ai-commit 1.0.5 → 1.0.7

package/src/__tests__/tagCommand.test.ts

@@ -8,7 +8,12 @@ jest.mock('../commands/git', () => ({
     getLatestTag: jest.fn(),
     getCommitSummariesSince: jest.fn(),
     createAnnotatedTag: jest.fn(),
-    pushTag: jest.fn()
+    pushTag: jest.fn(),
+    tagExists: jest.fn(),
+    remoteTagExists: jest.fn(),
+    deleteLocalTag: jest.fn(),
+    deleteRemoteTag: jest.fn(),
+    forcePushTag: jest.fn()
   }
 }));
 
@@ -44,6 +49,10 @@ describe('TagCommand', () => {
 
     (ConfigService.validateConfig as jest.Mock).mockReturnValue(undefined);
 
+    // Tag doesn't exist by default
+    (GitService.tagExists as jest.Mock).mockResolvedValue(false);
+    (GitService.remoteTagExists as jest.Mock).mockResolvedValue(false);
+
     // Confirm creation by default
     jest
       .spyOn(TagCommand.prototype as any, 'confirmTagCreate')
@@ -194,4 +203,176 @@ describe('TagCommand', () => {
     expect(GitService.pushTag).toHaveBeenCalledWith('v3.0.0');
     expect(exitSpy).toHaveBeenCalledWith(1);
   });
+
+  it('should cancel when user declines to replace existing local tag', async () => {
+    (GitService.tagExists as jest.Mock).mockResolvedValueOnce(true);
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagDelete')
+      .mockResolvedValueOnce(false);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.0.0', { message: 'Release notes' });
+
+    expect(GitService.tagExists).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.createAnnotatedTag).not.toHaveBeenCalled();
+    expect(GitService.pushTag).not.toHaveBeenCalled();
+  });
+
+  it('should delete local tag and create new one when user confirms', async () => {
+    (GitService.tagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.remoteTagExists as jest.Mock).mockResolvedValueOnce(false);
+    (GitService.deleteLocalTag as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValueOnce(true);
+
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagDelete')
+      .mockResolvedValueOnce(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.0.0', { message: 'Release notes' });
+
+    expect(GitService.tagExists).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.deleteLocalTag).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v1.0.0', 'Release notes');
+  });
+
+  it('should delete both local and remote tag when user confirms', async () => {
+    (GitService.tagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.remoteTagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.deleteLocalTag as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.deleteRemoteTag as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValueOnce(true);
+
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagDelete')
+      .mockResolvedValueOnce(true);
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmRemoteTagDelete')
+      .mockResolvedValueOnce(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.0.0', { message: 'Release notes' });
+
+    expect(GitService.remoteTagExists).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.deleteRemoteTag).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.deleteLocalTag).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v1.0.0', 'Release notes');
+  });
+
+  it('should exit when local tag deletion fails', async () => {
+    (GitService.tagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.remoteTagExists as jest.Mock).mockResolvedValueOnce(false);
+    (GitService.deleteLocalTag as jest.Mock).mockResolvedValueOnce(false);
+
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagDelete')
+      .mockResolvedValueOnce(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.0.0', { message: 'Release notes' });
+
+    expect(GitService.deleteLocalTag).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.createAnnotatedTag).not.toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('should exit when remote tag deletion fails', async () => {
+    (GitService.tagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.remoteTagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.deleteRemoteTag as jest.Mock).mockResolvedValueOnce(false);
+
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagDelete')
+      .mockResolvedValueOnce(true);
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmRemoteTagDelete')
+      .mockResolvedValueOnce(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.0.0', { message: 'Release notes' });
+
+    expect(GitService.deleteRemoteTag).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.deleteLocalTag).not.toHaveBeenCalled();
+    expect(GitService.createAnnotatedTag).not.toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('should force push when tag was replaced and user confirms', async () => {
+    (GitService.tagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.remoteTagExists as jest.Mock).mockResolvedValueOnce(false);
+    (GitService.deleteLocalTag as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.forcePushTag as jest.Mock).mockResolvedValueOnce(true);
+
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagDelete')
+      .mockResolvedValueOnce(true);
+    confirmSpy.mockResolvedValueOnce(true);
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmForcePush')
+      .mockResolvedValueOnce(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.0.0', { message: 'Release notes' });
+
+    expect(GitService.deleteLocalTag).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v1.0.0', 'Release notes');
+    expect(GitService.forcePushTag).toHaveBeenCalledWith('v1.0.0');
+  });
+
+  it('should cancel push when user declines force push', async () => {
+    (GitService.tagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.remoteTagExists as jest.Mock).mockResolvedValueOnce(false);
+    (GitService.deleteLocalTag as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValueOnce(true);
+
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagDelete')
+      .mockResolvedValueOnce(true);
+    confirmSpy.mockResolvedValueOnce(true);
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmForcePush')
+      .mockResolvedValueOnce(false);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.0.0', { message: 'Release notes' });
+
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v1.0.0', 'Release notes');
+    expect(GitService.forcePushTag).not.toHaveBeenCalled();
+    expect(GitService.pushTag).not.toHaveBeenCalled();
+  });
+
+  it('should force push when remote tag exists and user confirms', async () => {
+    (GitService.tagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.remoteTagExists as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.deleteRemoteTag as jest.Mock).mockResolvedValueOnce(false); // User declined remote deletion
+    (GitService.deleteLocalTag as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValueOnce(true);
+    (GitService.forcePushTag as jest.Mock).mockResolvedValueOnce(true);
+
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagDelete')
+      .mockResolvedValueOnce(true);
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmRemoteTagDelete')
+      .mockResolvedValueOnce(false); // Decline remote deletion
+    confirmSpy.mockResolvedValueOnce(true);
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmForcePush')
+      .mockResolvedValueOnce(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.0.0', { message: 'Release notes' });
+
+    expect(GitService.forcePushTag).toHaveBeenCalledWith('v1.0.0');
+    expect(GitService.pushTag).not.toHaveBeenCalled();
+  });
 });

package/src/commands/ai.ts

@@ -72,6 +72,11 @@ export class AIService {
     // Remove any remaining XML/HTML-like tags
     cleaned = cleaned.replace(/<[^>]+>/g, '');
 
+    // Strip common Markdown emphasis so headers remain plain text
+    cleaned = cleaned.replace(/\*\*(.*?)\*\*/g, '$1');
+    cleaned = cleaned.replace(/__(.*?)__/g, '$1');
+    cleaned = cleaned.replace(/`([^`]+)`/g, '$1');
+
     // Normalize whitespace
     cleaned = cleaned.replace(/[\t\r]+/g, '');
     cleaned = cleaned.replace(/\n{3,}/g, '\n\n').trim();
@@ -217,6 +222,14 @@ export class AIService {
         }
       }
 
+      // Drop additional commit headers to enforce a single conventional commit
+      if (lines.length > 0) {
+        const nextHeaderIdx = lines.slice(1).findIndex(l => headerPattern.test(l));
+        if (nextHeaderIdx >= 0) {
+          lines = lines.slice(0, nextHeaderIdx + 1);
+        }
+      }
+
       finalMessage = lines.join('\n').trim();
 
       return {

package/src/commands/commit.ts

@@ -1,9 +1,12 @@
-import { Command } from 'commander';
-import readline from 'readline';
-import { GitService, GitDiffResult } from './git';
-import { AIService, AIServiceConfig } from './ai';
-import { ConfigService } from './config';
-import { LogService } from './log';
+import { Command } from "commander";
+import readline from "readline";
+import fs from "fs";
+import path from "path";
+import { spawn } from "child_process";
+import { GitService, GitDiffResult } from "./git";
+import { AIService, AIServiceConfig } from "./ai";
+import { ConfigService } from "./config";
+import { LogService } from "./log";
 
 export interface CommitOptions {
   apiKey?: string;
@@ -18,24 +21,117 @@ export class CommitCommand {
   private program: Command;
 
   constructor() {
-    this.program = new Command('commit')
-      .description('Generate AI-powered commit message')
-      .option('-k, --api-key <key>', 'OpenAI API key (overrides env var)')
-      .option('-b, --base-url <url>', 'Custom API base URL (overrides env var)')
-      .option('--model <model>', 'Model to use (overrides env var)')
-      .option('-m, --message-only', 'Output only the generated commit message and skip git actions')
-      .option('-p, --push', 'Push current branch after creating the commit (implies --commit)')
-      .option('--prompt <text>', 'Additional instructions to append to the AI prompt for this commit')
+    this.program = new Command("commit")
+      .description("Generate AI-powered commit message")
+      .option("-k, --api-key <key>", "OpenAI API key (overrides env var)")
+      .option("-b, --base-url <url>", "Custom API base URL (overrides env var)")
+      .option("--model <model>", "Model to use (overrides env var)")
+      .option(
+        "-m, --message-only",
+        "Output only the generated commit message and skip git actions"
+      )
+      .option(
+        "-p, --push",
+        "Push current branch after creating the commit (implies --commit)"
+      )
+      .option(
+        "--prompt <text>",
+        "Additional instructions to append to the AI prompt for this commit"
+      )
       .action(this.handleCommit.bind(this));
   }
 
+  private async runPreCommitHook(): Promise<void> {
+    // 1. Check for npm pre-commit script
+    const packageJsonPath = path.resolve(process.cwd(), "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const raw = fs.readFileSync(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(raw);
+
+        if (pkg.scripts && pkg.scripts["pre-commit"]) {
+          console.log("Running npm pre-commit script...");
+
+          await new Promise<void>((resolve, reject) => {
+            const child = spawn("npm", ["run", "pre-commit"], {
+              stdio: "inherit",
+              shell: true,
+            });
+
+            child.on("close", (code) => {
+              if (code === 0) {
+                console.log("✅ npm pre-commit script passed");
+                resolve();
+              } else {
+                console.error(`❌ npm pre-commit script failed with code ${code}`);
+                reject(new Error(`npm pre-commit script failed with code ${code}`));
+              }
+            });
+
+            child.on("error", (err) => {
+              reject(err);
+            });
+          });
+        }
+      } catch (error) {
+        if (!(error instanceof SyntaxError)) {
+          throw error;
+        }
+      }
+    }
+
+    // 2. Check for .pre-commit-config.yaml (Python/General pre-commit)
+    const preCommitConfigPath = path.resolve(process.cwd(), ".pre-commit-config.yaml");
+    if (fs.existsSync(preCommitConfigPath)) {
+      console.log("Found .pre-commit-config.yaml, running pre-commit hooks...");
+      
+      try {
+        await new Promise<void>((resolve, reject) => {
+          const child = spawn("pre-commit", ["run"], {
+            stdio: "inherit",
+            shell: true,
+          });
+
+          child.on("close", (code) => {
+            if (code === 0) {
+              console.log("✅ pre-commit hooks passed");
+              resolve();
+            } else {
+              console.error(`❌ pre-commit hooks failed with code ${code}`);
+              reject(new Error(`pre-commit hooks failed with code ${code}`));
+            }
+          });
+
+          child.on("error", (err) => {
+            // If pre-commit is not installed/found, we might want to warn instead of fail?
+            // But usually 'error' event on spawn (with shell:true) is rare for command not found (it usually exits with 127).
+            // However, if it fails to spawn, we reject.
+            reject(err);
+          });
+        });
+      } catch (error) {
+        // If the error suggests command not found, we might warn.
+        // But since we use shell:true, 'command not found' usually results in exit code 127, which goes to 'close' event.
+        // So we catch the error from the promise rejection above.
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("code 127") || msg.includes("ENOENT")) {
+           console.warn("⚠️ 'pre-commit' command not found, skipping hooks despite configuration file presence.");
+           return;
+        }
+        throw error;
+      }
+    }
+  }
+
   private async handleCommit(options: CommitOptions) {
     const start = Date.now();
     const safeArgs = {
       ...options,
-      apiKey: options.apiKey ? '***' : undefined
+      apiKey: options.apiKey ? "***" : undefined,
     } as Record<string, unknown>;
     try {
+      await this.runPreCommitHook();
+
       const existingConfig = ConfigService.getConfig();
 
       const mergedApiKey = options.apiKey || existingConfig.apiKey;
@@ -51,7 +147,7 @@ export class CommitCommand {
 
       ConfigService.validateConfig({
         apiKey: mergedApiKey,
-        language: existingConfig.language
+        language: existingConfig.language,
       });
 
       const aiConfig: AIServiceConfig = {
@@ -59,81 +155,84 @@ export class CommitCommand {
         baseURL: mergedBaseURL,
         model: mergedModel,
         language: existingConfig.language,
-        verbose: !messageOnly
+        verbose: !messageOnly,
       };
 
-      log('Getting staged changes...');
-      
+      log("Getting staged changes...");
+
       const diffResult: GitDiffResult = await GitService.getStagedDiff();
-      
+
       if (!diffResult.success) {
-        console.error('Error:', diffResult.error);
+        console.error("Error:", diffResult.error);
         await LogService.append({
-          command: 'commit',
+          command: "commit",
           args: safeArgs,
-          status: 'failure',
+          status: "failure",
           details: diffResult.error,
-          durationMs: Date.now() - start
+          durationMs: Date.now() - start,
         });
         process.exit(1);
       }
 
-      log('Generating commit message...');
-      
+      log("Generating commit message...");
+
       const aiService = new AIService(aiConfig);
-      const aiResult = await aiService.generateCommitMessage(diffResult.diff!, options.prompt);
+      const aiResult = await aiService.generateCommitMessage(
+        diffResult.diff!,
+        options.prompt
+      );
 
       if (!aiResult.success) {
-        console.error('Error:', aiResult.error);
+        console.error("Error:", aiResult.error);
         await LogService.append({
-          command: 'commit',
+          command: "commit",
           args: safeArgs,
-          status: 'failure',
+          status: "failure",
           details: aiResult.error,
-          durationMs: Date.now() - start
+          durationMs: Date.now() - start,
         });
         process.exit(1);
       }
 
-      if (typeof aiResult.message !== 'string') {
-        console.error('Error: Failed to generate commit message');
+      if (typeof aiResult.message !== "string") {
+        console.error("Error: Failed to generate commit message");
         process.exit(1);
       }
 
       if (messageOnly) {
         console.log(aiResult.message);
         await LogService.append({
-          command: 'commit',
+          command: "commit",
           args: { ...safeArgs, messageOnly: true },
-          status: 'success',
-          details: 'message-only output',
-          durationMs: Date.now() - start
+          status: "success",
+          details: "message-only output",
+          durationMs: Date.now() - start,
         });
         return;
       }
 
-      console.log('\nGenerated commit message:');
+      console.log("\nGenerated commit message:");
       console.log(aiResult.message);
 
       const confirmed = await this.confirmCommit();
 
       if (!confirmed) {
-        console.log('Commit cancelled by user.');
+        console.log("Commit cancelled by user.");
         await LogService.append({
-          command: 'commit',
+          command: "commit",
           args: safeArgs,
-          status: 'cancelled',
-          details: 'user declined commit',
-          durationMs: Date.now() - start
+          status: "cancelled",
+          details: "user declined commit",
+          durationMs: Date.now() - start,
         });
         return;
       }
 
-      console.log('\nCreating commit...');
+      console.log("\nCreating commit...");
       const commitSuccess = await GitService.createCommit(aiResult.message!);
 
       if (commitSuccess) {
-        console.log('✅ Commit created successfully!');
+        console.log("✅ Commit created successfully!");
 
         const pushRequested = Boolean(options.push);
         const pushFromConfig = !pushRequested && existingConfig.autoPush;
@@ -141,53 +240,53 @@ export class CommitCommand {
 
         if (shouldPush) {
           if (pushFromConfig) {
-            console.log('Auto push enabled in config; pushing to remote...');
+            console.log("Auto push enabled in config; pushing to remote...");
           } else {
-            console.log('Pushing to remote...');
+            console.log("Pushing to remote...");
           }
 
           const pushSuccess = await GitService.push();
 
           if (pushSuccess) {
-            console.log('✅ Push completed successfully!');
+            console.log("✅ Push completed successfully!");
           } else {
-            console.error('❌ Failed to push to remote');
+            console.error("❌ Failed to push to remote");
             await LogService.append({
-              command: 'commit',
+              command: "commit",
               args: { ...safeArgs, push: true },
-              status: 'failure',
-              details: 'push failed',
-              durationMs: Date.now() - start
+              status: "failure",
+              details: "push failed",
+              durationMs: Date.now() - start,
             });
             process.exit(1);
           }
         }
       } else {
-        console.error('❌ Failed to create commit');
+        console.error("❌ Failed to create commit");
         await LogService.append({
-          command: 'commit',
+          command: "commit",
           args: safeArgs,
-          status: 'failure',
-          details: 'git commit failed',
-          durationMs: Date.now() - start
+          status: "failure",
+          details: "git commit failed",
+          durationMs: Date.now() - start,
         });
         process.exit(1);
       }
       await LogService.append({
-        command: 'commit',
+        command: "commit",
         args: safeArgs,
-        status: 'success',
-        durationMs: Date.now() - start
+        status: "success",
+        durationMs: Date.now() - start,
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error('Error:', message);
+      console.error("Error:", message);
       await LogService.append({
-        command: 'commit',
+        command: "commit",
         args: safeArgs,
-        status: 'failure',
+        status: "failure",
         details: message,
-        durationMs: Date.now() - start
+        durationMs: Date.now() - start,
       });
       process.exit(1);
     }
@@ -196,17 +295,17 @@ export class CommitCommand {
   private async confirmCommit(): Promise<boolean> {
     const rl = readline.createInterface({
       input: process.stdin,
-      output: process.stdout
+      output: process.stdout,
     });
 
-    const answer: string = await new Promise(resolve => {
-      rl.question('Proceed with git commit? (y/n): ', resolve);
+    const answer: string = await new Promise((resolve) => {
+      rl.question("Proceed with git commit? (y/n): ", resolve);
     });
 
     rl.close();
 
     const normalized = answer.trim().toLowerCase();
-    return normalized === 'y' || normalized === 'yes';
+    return normalized === "y" || normalized === "yes";
   }
 
   getCommand(): Command {

package/src/commands/git.ts

@@ -171,4 +171,52 @@ export class GitService {
       return false;
     }
   }
+
+  static async tagExists(tagName: string): Promise<boolean> {
+    try {
+      await execFileAsync('git', ['rev-parse', `refs/tags/${tagName}`]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static async remoteTagExists(tagName: string): Promise<boolean> {
+    try {
+      const { stdout } = await execAsync(`git ls-remote --tags origin refs/tags/${tagName}`);
+      return stdout.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  static async deleteLocalTag(tagName: string): Promise<boolean> {
+    try {
+      await execFileAsync('git', ['tag', '-d', tagName]);
+      return true;
+    } catch (error) {
+      console.error('Failed to delete local tag:', error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
+
+  static async deleteRemoteTag(tagName: string): Promise<boolean> {
+    try {
+      await execFileAsync('git', ['push', 'origin', '--delete', tagName]);
+      return true;
+    } catch (error) {
+      console.error('Failed to delete remote tag:', error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
+
+  static async forcePushTag(tagName: string): Promise<boolean> {
+    try {
+      await execFileAsync('git', ['push', 'origin', tagName, '--force']);
+      return true;
+    } catch (error) {
+      console.error('Failed to force push tag to remote:', error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
 }