commit-analyzer 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commit-analyzer",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Analyze git commits and generate categories, summaries, and descriptions for each commit. Optionally generate a yearly breakdown report of your commit history.",
   "main": "dist/index.js",
   "bin": {

package/src/cli.ts

@@ -1,8 +1,10 @@
-import { readFileSync } from "fs"
+import { readFileSync, mkdirSync } from "fs"
 import { Command } from "commander"
+import { join, dirname } from "path"
 
 export interface CLIOptions {
   output?: string
+  outputDir?: string
   file?: string
   commits: string[]
   author?: string
@@ -13,6 +15,7 @@ export interface CLIOptions {
   model?: string
   report?: boolean
   inputCsv?: string
+  verbose?: boolean
 }
 
 export class CLIService {
@@ -21,9 +24,15 @@ export class CLIService {
 
     program
       .name("commit-analyzer")
-      .description("Analyze git commits and generate categorized summaries")
-      .version("1.0.0")
-      .option("-o, --output <file>", "Output CSV file (default: output.csv)")
+      .description(
+        "Analyze user authored git commits and generate rich commit descriptions and stakeholder reports from them.",
+      )
+      .version("1.0.3")
+      .option("-o, --output <file>", "Output CSV file (default: commits.csv)")
+      .option(
+        "--output-dir <dir>",
+        "Output directory for CSV and report files (default: current directory)",
+      )
       .option(
         "-f, --file <file>",
         "Read commit hashes from file (one per line)",
@@ -37,18 +46,9 @@ export class CLIService {
         "Limit number of commits to analyze",
         parseInt,
       )
-      .option(
-        "-r, --resume",
-        "Resume from last checkpoint if available",
-      )
-      .option(
-        "-c, --clear",
-        "Clear any existing progress checkpoint",
-      )
-      .option(
-        "-m, --model <model>",
-        "LLM model to use (claude, gemini, codex)",
-      )
+      .option("-r, --resume", "Resume from last checkpoint if available")
+      .option("-c, --clear", "Clear any existing progress checkpoint")
+      .option("-m, --model <model>", "LLM model to use (claude, gemini, codex)")
       .option(
         "--report",
         "Generate condensed markdown report from existing CSV",
@@ -57,6 +57,10 @@ export class CLIService {
         "--input-csv <file>",
         "Input CSV file to read for report generation",
       )
+      .option(
+        "-v, --verbose",
+        "Enable verbose logging (shows detailed error information)",
+      )
       .argument(
         "[commits...]",
         "Commit hashes to analyze (if none provided, uses current user's commits)",
@@ -78,7 +82,10 @@ export class CLIService {
     }
 
     return {
-      output: options.output || "output.csv",
+      output:
+        options.output ||
+        CLIService.resolveOutputPath("commits.csv", options.outputDir),
+      outputDir: options.outputDir,
       file: options.file,
       commits,
       author: options.author,
@@ -89,6 +96,7 @@ export class CLIService {
       model: options.model,
       report: options.report,
       inputCsv: options.inputCsv,
+      verbose: options.verbose,
     }
   }
 
@@ -106,6 +114,24 @@ export class CLIService {
     }
   }
 
+  /**
+   * Resolve the full file path with optional output directory.
+   */
+  static resolveOutputPath(filename: string, outputDir?: string): string {
+    if (outputDir) {
+      // Ensure output directory exists
+      try {
+        mkdirSync(outputDir, { recursive: true })
+      } catch (error) {
+        throw new Error(
+          `Failed to create output directory ${outputDir}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        )
+      }
+      return join(outputDir, filename)
+    }
+    return filename
+  }
+
   static showHelp(): void {
     console.log(`
 Usage: commit-analyzer [options] [commits...]
@@ -114,14 +140,16 @@ Analyze git commits and generate categorized summaries using LLM.
 If no commits are specified, analyzes all commits authored by the current user.
 
 Options:
-  -o, --output <file>   Output file (default: output.csv for analysis, summary-report.md for reports)
-  -f, --file <file>     Read commit hashes from file (one per line)
+  -o, --output <file>     Output file (default: commits.csv for analysis, report.md for reports)
+  --output-dir <dir>      Output directory for CSV and report files (default: current directory)
+  -f, --file <file>       Read commit hashes from file (one per line)
   -a, --author <email>  Filter commits by author email (defaults to current user)
   -l, --limit <number>  Limit number of commits to analyze
   -r, --resume          Resume from last checkpoint if available
   -c, --clear           Clear any existing progress checkpoint
   --report              Generate condensed markdown report from existing CSV
   --input-csv <file>    Input CSV file to read for report generation
+  -v, --verbose         Enable verbose logging (shows detailed error information)
   -h, --help           Display help for command
   -V, --version        Display version number
 
@@ -140,4 +168,3 @@ Examples:
     `)
   }
 }
-

package/src/index.ts

@@ -17,10 +17,13 @@ async function promptResume(): Promise<boolean> {
   })
 
   return new Promise((resolve) => {
-    rl.question("\nDo you want to resume from the checkpoint? (y/n): ", (answer) => {
-      rl.close()
-      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes")
-    })
+    rl.question(
+      "\nDo you want to resume from the checkpoint? (y/n): ",
+      (answer) => {
+        rl.close()
+        resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes")
+      },
+    )
   })
 }
 
@@ -32,50 +35,76 @@ async function main(): Promise<void> {
 
     const options = CLIService.parseArguments()
 
+    // Resolve output file with output directory
+    if (options.output) {
+      options.output = CLIService.resolveOutputPath(
+        options.output,
+        options.outputDir,
+      )
+    }
+
     // Handle input CSV mode (skip commit analysis, just generate report)
     if (options.inputCsv) {
       console.log("Generating report from existing CSV...")
-      
+
       // Ensure --report flag is set when using --input-csv
       if (!options.report) {
         options.report = true
-        console.log("Note: --report flag automatically enabled when using --input-csv")
+        console.log(
+          "Note: --report flag automatically enabled when using --input-csv",
+        )
       }
-      
+
       // Determine output file name for report
-      let reportOutput = options.output || "summary-report.md"
-      if (reportOutput === "output.csv") {
-        reportOutput = "summary-report.md"
-      } else if (!reportOutput.endsWith('.md')) {
+      let reportOutput =
+        options.output ||
+        CLIService.resolveOutputPath("report.md", options.outputDir)
+      if (
+        reportOutput.endsWith("commits.csv") ||
+        reportOutput.endsWith("/commits.csv")
+      ) {
+        reportOutput = CLIService.resolveOutputPath(
+          "report.md",
+          options.outputDir,
+        )
+      } else if (!reportOutput.endsWith(".md")) {
         // If user specified output but it's not .md, append .md
-        reportOutput = reportOutput.replace(/\.[^.]+$/, '') + '.md'
+        reportOutput = reportOutput.replace(/\.[^.]+$/, "") + ".md"
       }
-      
-      await MarkdownReportGenerator.generateReport(options.inputCsv, reportOutput)
+
+      await MarkdownReportGenerator.generateReport(
+        options.inputCsv,
+        reportOutput,
+      )
       return
     }
 
     // Prompt to select LLM model if not provided
     const availableModels = LLMService.detectAvailableModels()
     if (availableModels.length === 0) {
-      throw new Error("No supported LLM models found. Please install claude, gemini, or codex.")
+      throw new Error(
+        "No supported LLM models found. Please install claude, gemini, or codex.",
+      )
     }
     const defaultModel = LLMService.detectDefaultModel()
     let selectedModel = options.model
     if (!selectedModel) {
-      const rlModel = readline.createInterface({ input: process.stdin, output: process.stdout })
+      const rlModel = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      })
       selectedModel = await new Promise<string>((resolve) =>
-        rlModel.question(`Select LLM model (${availableModels.join("/")}) [${defaultModel}]: `, (answer) => {
-          rlModel.close()
-          resolve(answer.trim() || defaultModel)
-        }),
+        rlModel.question(
+          `Select LLM model (${availableModels.join("/")}) [${defaultModel}]: `,
+          (answer) => {
+            rlModel.close()
+            resolve(answer.trim() || defaultModel)
+          },
+        ),
       )
     }
     LLMService.setModel(selectedModel)
-
-
-
-
+    LLMService.setVerbose(options.verbose || false)
 
     // Handle clear flag
     if (options.clear) {
@@ -100,17 +129,33 @@ async function main(): Promise<void> {
       if (progressState) {
         console.log("📂 Found previous session checkpoint")
         console.log(ProgressTracker.formatProgressSummary(progressState))
-        
+
         const resumeChoice = await promptResume()
         if (resumeChoice) {
           commitsToAnalyze = ProgressTracker.getRemainingCommits(progressState)
           analyzedCommits = progressState.analyzedCommits
           processedCommits = progressState.processedCommits
-          
+
           // Use the output file from the previous session
           options.output = progressState.outputFile
-          
-          console.log(`\n▶️  Resuming with ${commitsToAnalyze.length} remaining commits...`)
+
+          console.log(
+            `\n▶️  Resuming with ${commitsToAnalyze.length} remaining commits...`,
+          )
+          console.log(
+            `📊 Previous progress: ${processedCommits.length}/${progressState.totalCommits.length} commits processed`,
+          )
+          if (options.verbose) {
+            console.log(
+              `   Debug: analyzedCommits.length = ${analyzedCommits.length}`,
+            )
+            console.log(
+              `   Debug: processedCommits.length = ${processedCommits.length}`,
+            )
+            console.log(
+              `   Debug: commitsToAnalyze.length = ${commitsToAnalyze.length}`,
+            )
+          }
         } else {
           ProgressTracker.clearProgress()
           console.log("Starting fresh analysis...")
@@ -144,14 +189,17 @@ async function main(): Promise<void> {
       }
     }
 
-    const totalCommitsToProcess = processedCommits.length + commitsToAnalyze.length
-    console.log(`\nAnalyzing ${commitsToAnalyze.length} commits (${totalCommitsToProcess} total)...`)
+    const totalCommitsToProcess =
+      processedCommits.length + commitsToAnalyze.length
+    console.log(
+      `\nAnalyzing ${commitsToAnalyze.length} commits (${totalCommitsToProcess} total)...`,
+    )
 
     let failedCommits = 0
 
     // Keep track of all commits for checkpoint
     const allCommitsToAnalyze = [...processedCommits, ...commitsToAnalyze]
-    
+
     for (const [index, hash] of commitsToAnalyze.entries()) {
       const overallIndex = processedCommits.length + index + 1
       console.log(
@@ -178,25 +226,39 @@ async function main(): Promise<void> {
           ...commitInfo,
           analysis,
         })
-        
+
         processedCommits.push(hash)
-        
+
         // Save progress every 10 commits or on failure
-        if ((overallIndex % 10 === 0) || index === commitsToAnalyze.length - 1) {
+        if (overallIndex % 10 === 0 || index === commitsToAnalyze.length - 1) {
           ProgressTracker.saveProgress(
             allCommitsToAnalyze,
             processedCommits,
             analyzedCommits,
             options.output!,
           )
-          console.log(`  💾 Progress saved (${overallIndex}/${totalCommitsToProcess})`)
+          console.log(
+            `  💾 Progress saved (${overallIndex}/${totalCommitsToProcess})`,
+          )
+          if (options.verbose) {
+            console.log(
+              `     Debug: Saved ${processedCommits.length} processed, ${analyzedCommits.length} analyzed`,
+            )
+          }
         }
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error"
+        const errorMessage =
+          error instanceof Error ? error.message : "Unknown error"
         console.error(`  ❌ Failed: ${errorMessage}`)
         failedCommits++
         processedCommits.push(hash)
-        
+
+        // Check if this was a rate limit error and provide helpful messaging
+        const isRateLimitError =
+          errorMessage.includes("quota exceeded") ||
+          errorMessage.includes("rate limit") ||
+          errorMessage.includes("429")
+
         // Save progress on failure
         ProgressTracker.saveProgress(
           allCommitsToAnalyze,
@@ -205,18 +267,43 @@ async function main(): Promise<void> {
           options.output!,
         )
         console.log(`  💾 Progress saved after failure`)
-        
-        // Always stop on failure after max retries
-        console.error(`\n⛔ Stopping due to failure (after ${LLMService.getMaxRetries()} retry attempts)`)
-        console.log(`✅ Successfully analyzed ${analyzedCommits.length} commits before failure`)
-        console.log(`📁 Progress saved. Use --resume to continue from commit ${overallIndex + 1}`)
-        
+
+        // Provide specific guidance based on error type
+        if (isRateLimitError) {
+          console.error(`\n⛔ Stopping due to rate limit/quota exceeded`)
+          console.log(`💡 Suggestions:`)
+          console.log(
+            `   • Wait for quota to reset (daily limits typically reset at midnight Pacific Time)`,
+          )
+          console.log(
+            `   • Switch to a different model: --model claude or --model codex`,
+          )
+          console.log(`   • Resume later with: --resume`)
+        } else {
+          console.error(
+            `\n⛔ Stopping due to failure (after ${LLMService.getMaxRetries()} retry attempts)`,
+          )
+          console.log(`💡 Suggestions:`)
+          console.log(`   • Check your LLM model configuration and credentials`)
+          console.log(
+            `   • Run with --verbose flag for detailed error information`,
+          )
+          console.log(`   • Resume later with: --resume`)
+        }
+
+        console.log(
+          `✅ Successfully analyzed ${analyzedCommits.length} commits before failure`,
+        )
+        console.log(
+          `📁 Progress saved. Use --resume to continue from commit ${overallIndex + 1}`,
+        )
+
         // Export what we have so far
         if (analyzedCommits.length > 0) {
           CSVService.exportToFile(analyzedCommits, options.output!)
           console.log(`📊 Partial results exported to ${options.output}`)
         }
-        
+
         process.exit(1)
       }
     }
@@ -230,32 +317,58 @@ async function main(): Promise<void> {
     console.log(
       `Successfully analyzed ${analyzedCommits.length}/${totalCommitsToProcess} commits`,
     )
-    
+
     if (failedCommits > 0) {
-      console.log(`⚠️  Failed to analyze ${failedCommits} commits (see errors above)`)
+      console.log(
+        `⚠️  Failed to analyze ${failedCommits} commits (see errors above)`,
+      )
     }
-    
+
     // Generate report if --report flag is provided
     if (options.report) {
       console.log("\nGenerating condensed markdown report...")
-      
+
       // Determine report output filename
       let reportOutput: string
-      if (options.output!.endsWith('.csv')) {
-        reportOutput = options.output!.replace('.csv', '-report.md')
+      if (options.output!.endsWith(".csv")) {
+        reportOutput = options.output!.replace(".csv", ".md")
       } else {
-        reportOutput = options.output! + '-report.md'
+        reportOutput = options.output! + ".md"
+      }
+
+      // Handle default case - if output is commits.csv, make report report.md
+      if (reportOutput.endsWith("commits.md")) {
+        reportOutput = reportOutput.replace("commits.md", "report.md")
       }
-      
+
+      // If output directory is specified but report output is just a filename, use the output directory
+      if (
+        options.outputDir &&
+        !reportOutput.includes("/") &&
+        !reportOutput.includes("\\")
+      ) {
+        reportOutput = CLIService.resolveOutputPath(
+          reportOutput.split("/").pop() || reportOutput,
+          options.outputDir,
+        )
+      }
+
       try {
-        await MarkdownReportGenerator.generateReport(options.output!, reportOutput)
+        await MarkdownReportGenerator.generateReport(
+          options.output!,
+          reportOutput,
+        )
         console.log(`📊 Report generated: ${reportOutput}`)
       } catch (error) {
-        console.error(`⚠️  Failed to generate report: ${error instanceof Error ? error.message : "Unknown error"}`)
-        console.log("CSV analysis was successful, but report generation failed.")
+        console.error(
+          `⚠️  Failed to generate report: ${error instanceof Error ? error.message : "Unknown error"}`,
+        )
+        console.log(
+          "CSV analysis was successful, but report generation failed.",
+        )
       }
     }
-    
+
     // Clear checkpoint on successful completion
     ProgressTracker.clearProgress()
     console.log("✓ Progress checkpoint cleared (analysis complete)")
@@ -280,4 +393,3 @@ async function main(): Promise<void> {
 if (require.main === module) {
   main()
 }
-

package/src/llm.ts

@@ -3,6 +3,7 @@ import { CommitInfo, LLMAnalysis } from "./types"
 
 export class LLMService {
   private static model: string
+  private static verbose: boolean = false
 
   /**
    * Detect available LLM models by checking CLI commands.
@@ -43,6 +44,13 @@ export class LLMService {
     this.model = model
   }
 
+  /**
+   * Set verbose mode for detailed error logging.
+   */
+  static setVerbose(verbose: boolean): void {
+    this.verbose = verbose
+  }
+
   /**
    * Get the configured LLM model or detect default.
    */
@@ -52,6 +60,20 @@ export class LLMService {
     }
     return this.model
   }
+
+  /**
+   * Get the model command with appropriate flags.
+   */
+  static getModelCommand(): string {
+    const model = this.getModel()
+    
+    // Append -q flag for codex model
+    if (model === 'codex') {
+      return 'codex -q'
+    }
+    
+    return model
+  }
   private static readonly MAX_RETRIES = parseInt(
     process.env.LLM_MAX_RETRIES || "3",
     10,
@@ -79,6 +101,7 @@ export class LLMService {
 
   static async analyzeCommit(commit: CommitInfo): Promise<LLMAnalysis> {
     const currentModel = this.getModel()
+    const currentModelCommand = this.getModelCommand()
     const prompt = this.buildPrompt(commit.message, commit.diff, currentModel)
     
     // Log prompt length for debugging - only for Claude models
@@ -93,7 +116,7 @@ export class LLMService {
 
     for (let attempt = 1; attempt <= this.MAX_RETRIES; attempt++) {
       try {
-        const output = execSync(currentModel, {
+        const output = execSync(currentModelCommand, {
           input: prompt,
           encoding: "utf8",
           stdio: ["pipe", "pipe", "pipe"],
@@ -104,21 +127,62 @@ export class LLMService {
       } catch (error) {
         lastError = error instanceof Error ? error : new Error("Unknown error")
         
-        // Log detailed error information for debugging
-        console.log(`  - Error details for commit ${commit.hash.substring(0, 8)}:`)
-        console.log(`    Command: ${currentModel}`)
-        console.log(`    Error message: ${lastError.message}`)
-        if (this.isClaudeModel(currentModel)) {
-          console.log(`    Prompt length: ${prompt.length} characters`)
-        }
+        // Check if this is a rate limit error
+        const rateLimitInfo = this.isRateLimitError(error)
         
-        // If it's an exec error, log additional details
-        if (error && typeof error === 'object' && 'stderr' in error) {
-          const execError = error as any
-          console.log(`    Exit code: ${execError.status || 'unknown'}`)
-          console.log(`    Signal: ${execError.signal || 'none'}`)
-          console.log(`    Stderr: ${execError.stderr || 'none'}`)
-          console.log(`    Stdout: ${execError.stdout || 'none'}`)
+        if (rateLimitInfo.isRateLimit) {
+          // For rate limits, show user-friendly message immediately
+          const friendlyMessage = this.getRateLimitMessage(rateLimitInfo.service, rateLimitInfo.limitType)
+          console.log(`  - ${friendlyMessage}`)
+          
+          // Show detailed error info only in verbose mode
+          if (this.verbose) {
+            console.log(`  - Verbose error details for commit ${commit.hash.substring(0, 8)}:`)
+            console.log(`    Command: ${currentModelCommand}`)
+            console.log(`    Error message: ${lastError.message}`)
+            if (this.isClaudeModel(currentModel)) {
+              console.log(`    Prompt length: ${prompt.length} characters`)
+            }
+            
+            // If it's an exec error, log additional details
+            if (error && typeof error === 'object' && 'stderr' in error) {
+              const execError = error as any
+              console.log(`    Exit code: ${execError.status || 'unknown'}`)
+              console.log(`    Signal: ${execError.signal || 'none'}`)
+              if (execError.stderr) {
+                console.log(`    Stderr: ${execError.stderr.substring(0, 1000)}${execError.stderr.length > 1000 ? '...' : ''}`)
+              }
+            }
+          }
+          
+          // If it's a daily quota error, don't retry - fail immediately
+          if (rateLimitInfo.limitType === "daily quota") {
+            throw new Error(
+              `Daily quota exceeded for ${rateLimitInfo.service || 'LLM service'}. Retrying will not help until quota resets.`,
+            )
+          }
+        } else {
+          // For non-rate-limit errors, show detailed info based on verbose mode
+          if (this.verbose) {
+            console.log(`  - Error details for commit ${commit.hash.substring(0, 8)}:`)
+            console.log(`    Command: ${currentModelCommand}`)
+            console.log(`    Error message: ${lastError.message}`)
+            if (this.isClaudeModel(currentModel)) {
+              console.log(`    Prompt length: ${prompt.length} characters`)
+            }
+            
+            // If it's an exec error, log additional details
+            if (error && typeof error === 'object' && 'stderr' in error) {
+              const execError = error as any
+              console.log(`    Exit code: ${execError.status || 'unknown'}`)
+              console.log(`    Signal: ${execError.signal || 'none'}`)
+              console.log(`    Stderr: ${execError.stderr || 'none'}`)
+              console.log(`    Stdout: ${execError.stdout || 'none'}`)
+            }
+          } else {
+            // In non-verbose mode, show concise error message
+            console.log(`  - Analysis failed: ${lastError.message}`)
+          }
         }
 
         if (attempt < this.MAX_RETRIES) {
@@ -280,4 +344,68 @@ Format as JSON:
   ): category is "tweak" | "feature" | "process" {
     return ["tweak", "feature", "process"].includes(category)
   }
+
+  /**
+   * Check if an error is related to rate limiting or quota exceeded.
+   */
+  private static isRateLimitError(error: any): { isRateLimit: boolean; service?: string; limitType?: string } {
+    const errorMessage = error?.message?.toLowerCase() || ""
+    const stderr = error?.stderr?.toLowerCase() || ""
+    const stdout = error?.stdout?.toLowerCase() || ""
+    const combinedOutput = `${errorMessage} ${stderr} ${stdout}`
+
+    // Check for Gemini rate limit patterns
+    if (combinedOutput.includes("quota exceeded") && combinedOutput.includes("gemini")) {
+      if (combinedOutput.includes("requests per day")) {
+        return { isRateLimit: true, service: "Gemini", limitType: "daily quota" }
+      }
+      if (combinedOutput.includes("requests per minute")) {
+        return { isRateLimit: true, service: "Gemini", limitType: "per-minute rate limit" }
+      }
+      return { isRateLimit: true, service: "Gemini", limitType: "quota limit" }
+    }
+
+    // Check for Claude rate limit patterns
+    if (combinedOutput.includes("rate limit") && combinedOutput.includes("claude")) {
+      return { isRateLimit: true, service: "Claude", limitType: "rate limit" }
+    }
+
+    // Check for generic rate limit indicators
+    if (combinedOutput.includes("429") || 
+        combinedOutput.includes("too many requests") ||
+        combinedOutput.includes("rate limit") ||
+        combinedOutput.includes("quota exceeded")) {
+      // Try to determine service from model name
+      const currentModel = this.getModel().toLowerCase()
+      if (currentModel.includes("gemini")) {
+        return { isRateLimit: true, service: "Gemini", limitType: "rate/quota limit" }
+      }
+      if (currentModel.includes("claude")) {
+        return { isRateLimit: true, service: "Claude", limitType: "rate limit" }
+      }
+      return { isRateLimit: true, limitType: "rate/quota limit" }
+    }
+
+    return { isRateLimit: false }
+  }
+
+  /**
+   * Get user-friendly error message for rate limit errors.
+   */
+  private static getRateLimitMessage(service?: string, limitType?: string): string {
+    if (service === "Gemini" && limitType === "daily quota") {
+      return "⚠️  Gemini daily quota exceeded. The limit resets at midnight Pacific Time. Consider switching to a different model or resuming tomorrow."
+    }
+    
+    if (service === "Gemini" && limitType === "per-minute rate limit") {
+      return "⚠️  Gemini rate limit exceeded. Wait a minute before retrying, or consider switching to a different model."
+    }
+    
+    if (service === "Claude") {
+      return "⚠️  Claude rate limit exceeded. Wait a moment before retrying, or consider switching to a different model."
+    }
+    
+    const serviceMsg = service ? `${service} ` : ""
+    return `⚠️  ${serviceMsg}rate limit exceeded. Consider switching models or waiting before retrying.`
+  }
 }

package/src/progress.ts

@@ -19,12 +19,19 @@ export class ProgressTracker {
     analyzedCommits: AnalyzedCommit[],
     outputFile: string,
   ): void {
+    // Preserve the original start time if this is an update to existing progress
+    let startTime = new Date().toISOString()
+    const existingState = this.loadProgress()
+    if (existingState) {
+      startTime = existingState.startTime
+    }
+
     const state: ProgressState = {
       totalCommits,
       processedCommits,
       analyzedCommits,
       lastProcessedIndex: processedCommits.length - 1,
-      startTime: new Date().toISOString(),
+      startTime,
       outputFile,
     }