commit-analyzer 1.0.1

package/src/csv-reader.ts

@@ -0,0 +1,180 @@
+import { readFileSync } from "fs"
+
+export interface ParsedCSVRow {
+  year: number
+  category: "tweak" | "feature" | "process"
+  summary: string
+  description: string
+}
+
+export class CSVReaderService {
+  static readCSV(filename: string): ParsedCSVRow[] {
+    try {
+      const content = readFileSync(filename, "utf8")
+      return this.parseCSV(content)
+    } catch (error) {
+      throw new Error(
+        `Failed to read CSV file ${filename}: ${error instanceof Error ? error.message : "Unknown error"}`,
+      )
+    }
+  }
+
+  private static parseCSV(content: string): ParsedCSVRow[] {
+    const lines = content.trim().split("\n")
+
+    if (lines.length === 0) {
+      throw new Error("CSV file is empty")
+    }
+
+    // Validate header
+    const header = lines[0].toLowerCase()
+    const expectedHeader = "year,category,summary,description"
+    if (header !== expectedHeader) {
+      throw new Error(
+        `Invalid CSV format. Expected header: "${expectedHeader}", got: "${header}"`,
+      )
+    }
+
+    const rows: ParsedCSVRow[] = []
+
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim()
+      if (line === "") continue // Skip empty lines
+
+      try {
+        const row = this.parseCSVLine(line, i + 1)
+        rows.push(row)
+      } catch (error) {
+        throw new Error(
+          `Error parsing CSV line ${i + 1}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        )
+      }
+    }
+
+    return rows
+  }
+
+  private static parseCSVLine(line: string, lineNumber: number): ParsedCSVRow {
+    const fields = this.parseCSVFields(line)
+
+    if (fields.length !== 4) {
+      throw new Error(
+        `Expected 4 fields (year,category,summary,description), got ${fields.length}`,
+      )
+    }
+
+    const [yearStr, category, summary, description] = fields
+
+    // Validate year
+    const year = parseInt(yearStr, 10)
+    if (isNaN(year) || year < 1900 || year > 2100) {
+      throw new Error(`Invalid year: ${yearStr}`)
+    }
+
+    // Validate category
+    if (!this.isValidCategory(category)) {
+      throw new Error(
+        `Invalid category: ${category}. Must be one of: tweak, feature, process`,
+      )
+    }
+
+    // Validate required fields
+    if (!summary.trim()) {
+      throw new Error("Summary field cannot be empty")
+    }
+
+    if (!description.trim()) {
+      throw new Error("Description field cannot be empty")
+    }
+
+    return {
+      year,
+      category: category as "tweak" | "feature" | "process",
+      summary: summary.trim(),
+      description: description.trim(),
+    }
+  }
+
+  /**
+   * Parse CSV fields handling quoted fields with commas and escaped quotes
+   */
+  private static parseCSVFields(line: string): string[] {
+    const fields: string[] = []
+    let currentField = ""
+    let inQuotes = false
+    let i = 0
+
+    while (i < line.length) {
+      const char = line[i]
+      const nextChar = line[i + 1]
+
+      if (char === '"') {
+        if (inQuotes && nextChar === '"') {
+          // Escaped quote inside quoted field
+          currentField += '"'
+          i += 2
+        } else {
+          // Start or end of quoted field
+          inQuotes = !inQuotes
+          i++
+        }
+      } else if (char === "," && !inQuotes) {
+        // Field separator outside quotes
+        fields.push(currentField)
+        currentField = ""
+        i++
+      } else {
+        // Regular character
+        currentField += char
+        i++
+      }
+    }
+
+    // Add the last field
+    fields.push(currentField)
+
+    return fields
+  }
+
+  private static isValidCategory(
+    category: string,
+  ): category is "tweak" | "feature" | "process" {
+    return ["tweak", "feature", "process"].includes(category)
+  }
+
+  /**
+   * Get summary statistics about the CSV data
+   */
+  static getStatistics(rows: ParsedCSVRow[]): {
+    totalRows: number
+    yearRange: { min: number; max: number }
+    categoryBreakdown: Record<string, number>
+  } {
+    if (rows.length === 0) {
+      return {
+        totalRows: 0,
+        yearRange: { min: 0, max: 0 },
+        categoryBreakdown: { tweak: 0, feature: 0, process: 0 },
+      }
+    }
+
+    const years = rows.map((row) => row.year)
+    const categoryBreakdown = rows.reduce(
+      (acc, row) => {
+        acc[row.category]++
+        return acc
+      },
+      { tweak: 0, feature: 0, process: 0 } as Record<string, number>,
+    )
+
+    return {
+      totalRows: rows.length,
+      yearRange: {
+        min: Math.min(...years),
+        max: Math.max(...years),
+      },
+      categoryBreakdown,
+    }
+  }
+}
+

package/src/csv.ts

@@ -0,0 +1,40 @@
+import { writeFileSync } from "fs"
+import { AnalyzedCommit, CSVRow } from "./types"
+
+export class CSVService {
+  static generateCSV(commits: AnalyzedCommit[]): string {
+    const headers = "year,category,summary,description"
+    const rows = commits.map((commit) => this.formatRow(commit))
+
+    return [headers, ...rows].join("\n")
+  }
+
+  static exportToFile(commits: AnalyzedCommit[], filename: string): void {
+    const csvContent = this.generateCSV(commits)
+    writeFileSync(filename, csvContent, "utf8")
+  }
+
+  private static formatRow(commit: AnalyzedCommit): string {
+    const row: CSVRow = {
+      year: commit.year,
+      category: commit.analysis.category,
+      summary: commit.analysis.summary,
+      description: commit.analysis.description,
+    }
+
+    return [
+      row.year,
+      this.escapeCsvField(row.category),
+      this.escapeCsvField(row.summary),
+      this.escapeCsvField(row.description),
+    ].join(",")
+  }
+
+  private static escapeCsvField(field: string): string {
+    if (field.includes(",") || field.includes('"') || field.includes("\n")) {
+      return `"${field.replace(/"/g, '""')}"`
+    }
+    return field
+  }
+}
+

package/src/errors.ts

@@ -0,0 +1,49 @@
+export class CommitAnalyzerError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+  ) {
+    super(message)
+    this.name = "CommitAnalyzerError"
+  }
+}
+
+export class GitError extends CommitAnalyzerError {
+  constructor(message: string) {
+    super(message, "GIT_ERROR")
+  }
+}
+
+export class LLMError extends CommitAnalyzerError {
+  constructor(message: string) {
+    super(message, "LLM_ERROR")
+  }
+}
+
+export class ValidationError extends CommitAnalyzerError {
+  constructor(message: string) {
+    super(message, "VALIDATION_ERROR")
+  }
+}
+
+export class FileError extends CommitAnalyzerError {
+  constructor(message: string) {
+    super(message, "FILE_ERROR")
+  }
+}
+
+export function handleError(error: unknown): never {
+  if (error instanceof CommitAnalyzerError) {
+    console.error(`Error [${error.code}]: ${error.message}`)
+    process.exit(1)
+  }
+
+  if (error instanceof Error) {
+    console.error(`Unexpected error: ${error.message}`)
+    process.exit(1)
+  }
+
+  console.error("Unknown error occurred")
+  process.exit(1)
+}
+

package/src/git.ts

@@ -0,0 +1,112 @@
+import { execSync } from "child_process"
+import { CommitInfo } from "./types"
+
+export class GitService {
+  static async getCommitInfo(hash: string): Promise<CommitInfo> {
+    try {
+      const showOutput = execSync(
+        `git show --format="%H|%s|%ci" --no-patch "${hash}"`,
+        {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "pipe"],
+        },
+      ).trim()
+
+      const [fullHash, message, dateStr] = showOutput.split("|")
+      const date = new Date(dateStr)
+      const year = date.getFullYear()
+
+      const diff = execSync(`git show "${hash}"`, {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large diffs
+      })
+
+      return {
+        hash: fullHash,
+        message,
+        date,
+        diff,
+        year,
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to get commit info for ${hash}: ${error instanceof Error ? error.message : "Unknown error"}`,
+      )
+    }
+  }
+
+  static validateCommitHash(hash: string): boolean {
+    try {
+      execSync(`git rev-parse --verify "${hash}"`, {
+        stdio: ["pipe", "pipe", "pipe"],
+      })
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  static isGitRepository(): boolean {
+    try {
+      execSync("git rev-parse --git-dir", {
+        stdio: ["pipe", "pipe", "pipe"],
+      })
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  static getCurrentUserEmail(): string {
+    try {
+      return execSync("git config user.email", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim()
+    } catch (error) {
+      throw new Error(
+        `Failed to get current user email: ${error instanceof Error ? error.message : "Unknown error"}`,
+      )
+    }
+  }
+
+  static getCurrentUserName(): string {
+    try {
+      return execSync("git config user.name", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim()
+    } catch (error) {
+      throw new Error(
+        `Failed to get current user name: ${error instanceof Error ? error.message : "Unknown error"}`,
+      )
+    }
+  }
+
+  static getUserAuthoredCommits(author?: string, limit?: number): string[] {
+    try {
+      const authorFilter = author || this.getCurrentUserEmail()
+      const limitFlag = limit ? `--max-count=${limit}` : ""
+
+      const output = execSync(
+        `git log --author="${authorFilter}" --format="%H" --no-merges ${limitFlag}`,
+        {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "pipe"],
+        },
+      ).trim()
+
+      if (!output) {
+        return []
+      }
+
+      return output.split("\n").filter((hash) => hash.length > 0)
+    } catch (error) {
+      throw new Error(
+        `Failed to get user authored commits: ${error instanceof Error ? error.message : "Unknown error"}`,
+      )
+    }
+  }
+}
+

package/src/index.ts

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+
+import { GitService } from "./git"
+import { LLMService } from "./llm"
+import { CSVService } from "./csv"
+import { CLIService } from "./cli"
+import { ProgressTracker } from "./progress"
+import { MarkdownReportGenerator } from "./report-generator"
+import { handleError, GitError, ValidationError } from "./errors"
+import { AnalyzedCommit } from "./types"
+import * as readline from "readline"
+
+async function promptResume(): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+
+  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")
+    })
+  })
+}
+
+async function main(): Promise<void> {
+  try {
+    if (!GitService.isGitRepository()) {
+      throw new GitError("Current directory is not a git repository")
+    }
+
+    const options = CLIService.parseArguments()
+
+    // 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")
+      }
+      
+      // 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')) {
+        // If user specified output but it's not .md, append .md
+        reportOutput = reportOutput.replace(/\.[^.]+$/, '') + '.md'
+      }
+      
+      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.")
+    }
+    const defaultModel = LLMService.detectDefaultModel()
+    let selectedModel = options.model
+    if (!selectedModel) {
+      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)
+        }),
+      )
+    }
+    LLMService.setModel(selectedModel)
+
+
+
+
+
+    // Handle clear flag
+    if (options.clear) {
+      if (ProgressTracker.hasProgress()) {
+        ProgressTracker.clearProgress()
+        console.log("✓ Progress checkpoint cleared")
+      } else {
+        console.log("No progress checkpoint to clear")
+      }
+      if (!options.resume) {
+        return
+      }
+    }
+
+    let commitsToAnalyze: string[] = options.commits
+    let analyzedCommits: AnalyzedCommit[] = []
+    let processedCommits: string[] = []
+
+    // Handle resume flag
+    if (options.resume && ProgressTracker.hasProgress()) {
+      const progressState = ProgressTracker.loadProgress()
+      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...`)
+        } else {
+          ProgressTracker.clearProgress()
+          console.log("Starting fresh analysis...")
+        }
+      }
+    } else if (options.resume && !ProgressTracker.hasProgress()) {
+      console.log("No previous checkpoint found. Starting fresh...")
+    }
+
+    // Only get new commits if not resuming
+    if (commitsToAnalyze.length === 0 || (!options.resume && !options.clear)) {
+      if (options.useDefaults) {
+        console.log("No commits specified, analyzing your authored commits...")
+        const userEmail = GitService.getCurrentUserEmail()
+        const userName = GitService.getCurrentUserName()
+        console.log(`Finding commits by ${userName} (${userEmail})`)
+
+        commitsToAnalyze = GitService.getUserAuthoredCommits(
+          options.author,
+          options.limit,
+        )
+
+        if (commitsToAnalyze.length === 0) {
+          throw new ValidationError(
+            "No commits found for the current user. Make sure you have commits in this repository.",
+          )
+        }
+
+        const limitText = options.limit ? ` (limited to ${options.limit})` : ""
+        console.log(`Found ${commitsToAnalyze.length} commits${limitText}`)
+      }
+    }
+
+    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(
+        `\n[${overallIndex}/${totalCommitsToProcess}] Processing commit: ${hash.substring(0, 8)}`,
+      )
+
+      if (!GitService.validateCommitHash(hash)) {
+        console.error(`  ❌ Invalid commit hash: ${hash}`)
+        failedCommits++
+        processedCommits.push(hash)
+        continue
+      }
+
+      try {
+        const commitInfo = await GitService.getCommitInfo(hash)
+        console.log(`  ✓ Extracted commit info`)
+
+        const analysis = await LLMService.analyzeCommit(commitInfo)
+        console.log(
+          `  ✓ Analyzed as "${analysis.category}": ${analysis.summary}`,
+        )
+
+        analyzedCommits.push({
+          ...commitInfo,
+          analysis,
+        })
+        
+        processedCommits.push(hash)
+        
+        // Save progress every 10 commits or on failure
+        if ((overallIndex % 10 === 0) || index === commitsToAnalyze.length - 1) {
+          ProgressTracker.saveProgress(
+            allCommitsToAnalyze,
+            processedCommits,
+            analyzedCommits,
+            options.output!,
+          )
+          console.log(`  💾 Progress saved (${overallIndex}/${totalCommitsToProcess})`)
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error"
+        console.error(`  ❌ Failed: ${errorMessage}`)
+        failedCommits++
+        processedCommits.push(hash)
+        
+        // Save progress on failure
+        ProgressTracker.saveProgress(
+          allCommitsToAnalyze,
+          processedCommits,
+          analyzedCommits,
+          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}`)
+        
+        // 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)
+      }
+    }
+
+    if (analyzedCommits.length === 0) {
+      throw new ValidationError("No commits were successfully analyzed")
+    }
+
+    CSVService.exportToFile(analyzedCommits, options.output!)
+    console.log(`\n✅ Analysis complete! Results exported to ${options.output}`)
+    console.log(
+      `Successfully analyzed ${analyzedCommits.length}/${totalCommitsToProcess} commits`,
+    )
+    
+    if (failedCommits > 0) {
+      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')
+      } else {
+        reportOutput = options.output! + '-report.md'
+      }
+      
+      try {
+        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.")
+      }
+    }
+    
+    // Clear checkpoint on successful completion
+    ProgressTracker.clearProgress()
+    console.log("✓ Progress checkpoint cleared (analysis complete)")
+
+    const summary = analyzedCommits.reduce(
+      (acc, commit) => {
+        acc[commit.analysis.category] = (acc[commit.analysis.category] || 0) + 1
+        return acc
+      },
+      {} as Record<string, number>,
+    )
+
+    console.log("\nSummary by category:")
+    Object.entries(summary).forEach(([category, count]) => {
+      console.log(`  ${category}: ${count} commits`)
+    })
+  } catch (error) {
+    handleError(error)
+  }
+}
+
+if (require.main === module) {
+  main()
+}
+