commit-analyzer 1.0.2 → 1.1.0

package/src/2.application/analyze-commits.usecase.ts

@@ -0,0 +1,307 @@
+import { AnalyzedCommit } from "@domain/analyzed-commit"
+import { CommitAnalysisService } from "@domain/commit-analysis-service"
+import { CommitHash } from "@domain/commit-hash"
+
+import { ICommandHandler } from "@presentation/command-handler.interface"
+import { ConsoleFormatter } from "@presentation/console-formatter"
+import { IProgressRepository } from "@presentation/progress-repository.interface"
+import { IStorageRepository } from "@presentation/storage-repository.interface"
+
+import { ConcurrencyManager } from "../utils/concurrency"
+
+export interface AnalyzeCommitsCommand {
+  commitHashes: string[]
+  outputFile: string
+  verbose?: boolean
+  saveProgressInterval?: number
+  batchSize?: number
+}
+
+export interface AnalyzeCommitsResult {
+  analyzedCommits: AnalyzedCommit[]
+  failedCommits: number
+  totalProcessed: number
+}
+
+export class AnalyzeCommitsUseCase
+  implements ICommandHandler<AnalyzeCommitsCommand, AnalyzeCommitsResult>
+{
+  private static readonly DEFAULT_PROGRESS_INTERVAL = 10
+  private static readonly DEFAULT_BATCH_SIZE = 1
+  private static readonly DEFAULT_MAX_CONCURRENCY = 3
+
+  constructor(
+    private readonly commitAnalysisService: CommitAnalysisService,
+    private readonly progressRepository: IProgressRepository,
+    private readonly storageRepository: IStorageRepository,
+  ) {}
+
+  async handle(command: AnalyzeCommitsCommand): Promise<AnalyzeCommitsResult> {
+    const {
+      commitHashes,
+      outputFile,
+      verbose = false,
+      saveProgressInterval = AnalyzeCommitsUseCase.DEFAULT_PROGRESS_INTERVAL,
+      batchSize = AnalyzeCommitsUseCase.DEFAULT_BATCH_SIZE,
+    } = command
+
+    if (commitHashes.length === 0) {
+      throw new Error("No commits provided for analysis")
+    }
+
+    // Convert string hashes to domain objects
+    const hashes = commitHashes.map((hash) => CommitHash.create(hash))
+
+    // Validate commits exist
+    const { valid, invalid } =
+      await this.commitAnalysisService.validateCommits(hashes)
+
+    if (invalid.length > 0) {
+      ConsoleFormatter.logWarning(
+        `Warning: ${invalid.length} invalid commit hashes found`,
+      )
+      for (const invalidHash of invalid) {
+        ConsoleFormatter.logWarning(`  - ${invalidHash.getShortHash()}`)
+      }
+    }
+
+    if (valid.length === 0) {
+      throw new Error("No valid commits found for analysis")
+    }
+
+    const analyzedCommits: AnalyzedCommit[] = []
+    const processedCommits: CommitHash[] = []
+    let failedCommits = 0
+
+    ConsoleFormatter.logInfo(`Analyzing ${valid.length} commits...`)
+
+    if (batchSize === 1) {
+      // Sequential processing for batch size 1
+      for (let i = 0; i < valid.length; i++) {
+        const hash = valid[i]
+        const currentIndex = i + 1
+
+        if (verbose) {
+          ConsoleFormatter.logInfo(
+            `[${currentIndex}/${valid.length}] Processing: ${hash.getShortHash()}`,
+          )
+        } else {
+          ConsoleFormatter.updateProgress(currentIndex, valid.length, `Processing commits`)
+        }
+
+        try {
+          const analyzedCommit =
+            await this.commitAnalysisService.analyzeCommit(hash)
+          analyzedCommits.push(analyzedCommit)
+          processedCommits.push(hash)
+
+          const analysis = analyzedCommit.getAnalysis()
+          
+          if (verbose) {
+            ConsoleFormatter.logSuccess(
+              `✓ [${currentIndex}/${valid.length}] Analyzed as "${analysis.getCategory().getValue()}": ${analysis.getSummary()}`,
+            )
+          }
+
+          // Save progress periodically
+          if (
+            currentIndex % saveProgressInterval === 0 ||
+            currentIndex === valid.length
+          ) {
+            await this.saveProgress(
+              hashes,
+              processedCommits,
+              analyzedCommits,
+              outputFile,
+            )
+            if (verbose) {
+              ConsoleFormatter.logInfo(
+                `Progress saved (${currentIndex}/${valid.length})`,
+              )
+            }
+          }
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : "Unknown error"
+          
+          if (verbose) {
+            ConsoleFormatter.logError(`❌ [${currentIndex}/${valid.length}] Failed: ${errorMessage}`)
+          }
+          
+          failedCommits++
+          processedCommits.push(hash)
+
+          // Save progress on failure
+          await this.saveProgress(
+            hashes,
+            processedCommits,
+            analyzedCommits,
+            outputFile,
+          )
+
+          if (verbose) {
+            ConsoleFormatter.logError(`    Detailed error: ${errorMessage}`)
+          }
+        }
+      }
+      
+      if (!verbose) {
+        ConsoleFormatter.completeProgress()
+      }
+    } else {
+      // Batch processing for batch size > 1
+      const results = await this.processBatches(
+        valid,
+        batchSize,
+        saveProgressInterval,
+        hashes,
+        outputFile,
+        verbose
+      )
+      
+      analyzedCommits.push(...results.analyzedCommits)
+      processedCommits.push(...results.processedCommits)
+      failedCommits = results.failedCommits
+    }
+
+    // Export results
+    if (analyzedCommits.length > 0) {
+      await this.storageRepository.exportToCSV(analyzedCommits, outputFile)
+    }
+
+    return {
+      analyzedCommits,
+      failedCommits,
+      totalProcessed: processedCommits.length,
+    }
+  }
+
+  private async saveProgress(
+    totalCommits: CommitHash[],
+    processedCommits: CommitHash[],
+    analyzedCommits: AnalyzedCommit[],
+    outputFile: string,
+  ): Promise<void> {
+    const progressState = {
+      totalCommits,
+      processedCommits,
+      analyzedCommits,
+      lastProcessedIndex: processedCommits.length - 1,
+      startTime: new Date(),
+      outputFile,
+    }
+
+    await this.progressRepository.saveProgress(progressState)
+  }
+
+  private async processBatches(
+    commitHashes: CommitHash[],
+    batchSize: number,
+    saveProgressInterval: number,
+    allHashes: CommitHash[],
+    outputFile: string,
+    verbose: boolean
+  ): Promise<{
+    analyzedCommits: AnalyzedCommit[]
+    processedCommits: CommitHash[]
+    failedCommits: number
+  }> {
+    const analyzedCommits: AnalyzedCommit[] = []
+    const processedCommits: CommitHash[] = []
+    let failedCommits = 0
+
+    // Process commits in batches
+    for (let i = 0; i < commitHashes.length; i += batchSize) {
+      const batch = commitHashes.slice(i, i + batchSize)
+      const batchStart = i + 1
+      const batchEnd = Math.min(i + batchSize, commitHashes.length)
+      
+      if (verbose) {
+        ConsoleFormatter.logInfo(
+          `Processing batch ${batchStart}-${batchEnd}/${commitHashes.length} (${batch.length} commits)`,
+        )
+      } else {
+        ConsoleFormatter.updateProgress(batchStart, commitHashes.length, `Processing batch ${batchStart}-${batchEnd}`)
+      }
+
+      // Process all commits in this batch with controlled concurrency
+      const concurrencyManager = new ConcurrencyManager(AnalyzeCommitsUseCase.DEFAULT_MAX_CONCURRENCY)
+      
+      const batchPromises = batch.map(async (hash, index) => {
+        const globalIndex = i + index + 1
+        
+        return concurrencyManager.execute(async () => {
+          try {
+            if (verbose) {
+              ConsoleFormatter.logInfo(
+                `  [${globalIndex}/${commitHashes.length}] Processing: ${hash.getShortHash()}`,
+              )
+            }
+            
+            const analyzedCommit = await this.commitAnalysisService.analyzeCommit(hash)
+            const analysis = analyzedCommit.getAnalysis()
+            
+            if (verbose) {
+              ConsoleFormatter.logSuccess(
+                `✓ [${globalIndex}/${commitHashes.length}] Analyzed as "${analysis.getCategory().getValue()}": ${analysis.getSummary()}`,
+              )
+            }
+            
+            return { success: true, commit: analyzedCommit, hash }
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error"
+            
+            if (verbose) {
+              ConsoleFormatter.logError(`❌ [${globalIndex}/${commitHashes.length}] Failed: ${errorMessage}`)
+              ConsoleFormatter.logError(`    Detailed error: ${errorMessage}`)
+            }
+            
+            return { success: false, hash, error: errorMessage }
+          }
+        })
+      })
+
+      // Wait for all commits in this batch to complete
+      const batchResults = await Promise.all(batchPromises)
+      
+      // Process results
+      for (const result of batchResults) {
+        processedCommits.push(result.hash)
+        
+        if (result.success && 'commit' in result && result.commit) {
+          analyzedCommits.push(result.commit)
+        } else {
+          failedCommits++
+        }
+      }
+
+      // Save progress periodically or after each batch
+      if (
+        (i + batchSize) % (saveProgressInterval * batchSize) === 0 ||
+        (i + batchSize) >= commitHashes.length
+      ) {
+        await this.saveProgress(
+          allHashes,
+          processedCommits,
+          analyzedCommits,
+          outputFile,
+        )
+        if (verbose) {
+          ConsoleFormatter.logInfo(
+            `Progress saved (${processedCommits.length}/${commitHashes.length})`,
+          )
+        }
+      }
+    }
+
+    if (!verbose) {
+      ConsoleFormatter.completeProgress()
+    }
+
+    return {
+      analyzedCommits,
+      processedCommits,
+      failedCommits
+    }
+  }
+}

package/src/2.application/generate-report.usecase.ts

@@ -0,0 +1,204 @@
+import { AnalyzedCommit } from "@domain/analyzed-commit"
+import { DateFormattingService } from "@domain/date-formatting-service"
+import {
+  CommitStatistics,
+  ReportGenerationService,
+} from "@domain/report-generation-service"
+
+import { ICommandHandler } from "@presentation/command-handler.interface"
+import { IStorageRepository } from "@presentation/storage-repository.interface"
+
+import { ILLMService } from "./llm-service"
+
+export interface GenerateReportCommand {
+  inputCsvPath?: string
+  analyzedCommits?: AnalyzedCommit[]
+  outputPath: string
+  includeStatistics?: boolean
+  sourceInfo?: {
+    type: 'author' | 'commits' | 'csv'
+    value: string // email address, commit hashes, or csv file path
+  }
+}
+
+export interface GenerateReportResult {
+  reportPath: string
+  statistics: CommitStatistics
+  commitsProcessed: number
+}
+
+export class GenerateReportUseCase
+  implements ICommandHandler<GenerateReportCommand, GenerateReportResult>
+{
+  constructor(
+    private readonly reportGenerationService: ReportGenerationService,
+    private readonly storageRepository: IStorageRepository,
+    private readonly llmService: ILLMService,
+    private readonly dateFormattingService: DateFormattingService,
+  ) {}
+
+  async handle(command: GenerateReportCommand): Promise<GenerateReportResult> {
+    const {
+      inputCsvPath,
+      analyzedCommits,
+      outputPath,
+      includeStatistics = true,
+    } = command
+
+    let commits: AnalyzedCommit[]
+
+    // Get commits from either CSV file or provided commits
+    if (inputCsvPath) {
+      console.log(`Reading CSV data from ${inputCsvPath}...`)
+      commits = await this.storageRepository.importFromCSV(inputCsvPath)
+    } else if (analyzedCommits) {
+      commits = analyzedCommits
+    } else {
+      throw new Error("Either inputCsvPath or analyzedCommits must be provided")
+    }
+
+    if (commits.length === 0) {
+      throw new Error("No commits found for report generation")
+    }
+
+    // Generate statistics
+    const statistics = this.reportGenerationService.generateStatistics(commits)
+
+    // Format date range based on commit span
+    const dateRange = this.dateFormattingService.formatDateRange(commits)
+
+    console.log(
+      `Found ${statistics.totalCommits} commits spanning ${dateRange}`,
+    )
+    console.log(
+      `Categories: ${statistics.categoryBreakdown.feature} features, ${statistics.categoryBreakdown.process} process, ${statistics.categoryBreakdown.tweak} tweaks`,
+    )
+
+    // Generate and save the report
+    console.log("Generating condensed report...")
+    await this.generateMarkdownReportWithLLM({
+      commits,
+      statistics,
+      outputPath,
+      includeStatistics,
+      sourceInfo: command.sourceInfo,
+    })
+
+    return {
+      reportPath: outputPath,
+      statistics,
+      commitsProcessed: commits.length,
+    }
+  }
+
+  private async generateMarkdownReportWithLLM(params: {
+    commits: AnalyzedCommit[]
+    statistics: CommitStatistics
+    outputPath: string
+    includeStatistics: boolean
+    sourceInfo?: { type: 'author' | 'commits' | 'csv'; value: string }
+  }): Promise<void> {
+    const { commits, statistics, outputPath, includeStatistics, sourceInfo } = params
+    let reportContent = "# Development Summary Report\n\n"
+
+    if (includeStatistics) {
+      reportContent += this.generateAnalysisSection(commits, statistics, sourceInfo)
+      reportContent += "\n\n"
+    }
+
+    // Generate sophisticated yearly summaries using LLM
+    reportContent += await this.generateYearlySummariesWithLLM(commits)
+
+    // Write the final report using the storage repository
+    await this.storageRepository.writeFile(outputPath, reportContent)
+  }
+
+  /**
+   * Generate commit analysis section with accurate counts (like the original)
+   */
+  private generateAnalysisSection(
+    commits: AnalyzedCommit[],
+    statistics: CommitStatistics,
+    sourceInfo?: { type: 'author' | 'commits' | 'csv'; value: string }
+  ): string {
+    // Get formatted date range using the date formatting service
+    const dateRange = this.dateFormattingService.formatDateRange(commits)
+    // Group data by year for detailed breakdown
+    const yearlyStats = commits.reduce(
+      (acc, commit) => {
+        const year = commit.getYear()
+        const category = commit.getAnalysis().getCategory().getValue()
+        
+        if (!acc[year]) {
+          acc[year] = { tweak: 0, feature: 0, process: 0, total: 0 }
+        }
+        acc[year][category]++
+        acc[year].total++
+        return acc
+      },
+      {} as Record<
+        number,
+        { tweak: number; feature: number; process: number; total: number }
+      >,
+    )
+
+    // Sort years in descending order
+    const sortedYears = Object.keys(yearlyStats)
+      .map(Number)
+      .sort((a, b) => b - a)
+
+    let analysisContent = `## Commit Analysis\n`
+    analysisContent += `- **Total Commits**: ${statistics.totalCommits} commits spanning ${dateRange}\n`
+    
+    // Add source information
+    if (sourceInfo) {
+      switch (sourceInfo.type) {
+        case 'author':
+          analysisContent += `- **Source**: Commits by author ${sourceInfo.value}\n`
+          break
+        case 'commits': {
+          const commitCount = sourceInfo.value.split(',').length
+          analysisContent += `- **Source**: ${commitCount} specific commit${commitCount > 1 ? 's' : ''}\n`
+          break
+        }
+        case 'csv':
+          analysisContent += `- **Source**: Imported from ${sourceInfo.value}\n`
+          break
+      }
+    }
+
+    // Add year-by-year breakdown
+    for (const year of sortedYears) {
+      const yearData = yearlyStats[year]
+      analysisContent += `- **${year}**: ${yearData.total} commits (${yearData.feature} features, ${yearData.process} process, ${yearData.tweak} tweaks)\n`
+    }
+
+    return analysisContent
+  }
+
+  /**
+   * Generate sophisticated time-period-based summaries using LLM service
+   */
+  private async generateYearlySummariesWithLLM(
+    commits: AnalyzedCommit[],
+  ): Promise<string> {
+    // Determine the appropriate time period for the report
+    const timePeriod = this.reportGenerationService.determineTimePeriod(commits)
+    
+    // Group commits by the determined time period
+    const groupedCommits = this.reportGenerationService.groupByTimePeriod(commits, timePeriod)
+    
+    // Convert grouped commits to CSV format for LLM consumption
+    const csvContent = this.reportGenerationService.convertGroupedToCSV(groupedCommits, timePeriod)
+
+    try {
+      // Use the LLM service to generate sophisticated time-period-based summaries
+      const summaryContent = await this.llmService.generateTimePeriodSummariesFromCSV(csvContent, timePeriod)
+      return summaryContent
+    } catch (error) {
+      throw new Error(
+        `Failed to generate ${timePeriod} summaries: ${error instanceof Error ? error.message : "Unknown error"}`,
+      )
+    }
+  }
+}

package/src/2.application/llm-service.ts

@@ -0,0 +1,54 @@
+import { CategoryType } from "@domain/category"
+
+/**
+ * Output port for LLM analysis operations
+ */
+export interface ILLMService {
+  /**
+   * Detects available LLM models on the system
+   */
+  detectAvailableModels(): Promise<string[]>
+
+  /**
+   * Sets the LLM model to use
+   */
+  setModel(model: string): void
+
+  /**
+   * Sets verbose mode for detailed logging
+   */
+  setVerbose(verbose: boolean): void
+
+  /**
+   * Analyzes commit content and returns structured analysis
+   */
+  analyzeCommit(
+    message: string,
+    diff: string,
+  ): Promise<{
+    category: CategoryType
+    summary: string
+    description: string
+  }>
+
+  /**
+   * Gets the maximum number of retry attempts
+   */
+  getMaxRetries(): number
+
+  /**
+   * Generates sophisticated yearly summaries from CSV data using LLM
+   * with consolidation, categorization, and stakeholder-friendly language
+   */
+  generateYearlySummariesFromCSV(csvContent: string): Promise<string>
+
+  /**
+   * Generates time-period-based summaries from CSV data using LLM
+   */
+  generateTimePeriodSummariesFromCSV(csvContent: string, period: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly'): Promise<string>
+
+  /**
+   * Checks if the service is available and configured
+   */
+  isAvailable(): Promise<boolean>
+}

package/src/2.application/resume-analysis.usecase.ts

@@ -0,0 +1,123 @@
+import { ICommandHandler } from "@presentation/command-handler.interface"
+import { ConsoleFormatter } from "@presentation/console-formatter"
+import { IProgressRepository } from "@presentation/progress-repository.interface"
+
+import { createPromiseReadline } from "../utils"
+
+import {
+  AnalyzeCommitsResult,
+  AnalyzeCommitsUseCase,
+} from "./analyze-commits.usecase"
+
+export interface ResumeAnalysisCommand {
+  verbose?: boolean
+}
+
+export class ResumeAnalysisUseCase
+  implements ICommandHandler<ResumeAnalysisCommand, AnalyzeCommitsResult | null>
+{
+  constructor(
+    private readonly progressRepository: IProgressRepository,
+    private readonly analyzeCommitsUseCase: AnalyzeCommitsUseCase,
+  ) {}
+
+  async handle(
+    command: ResumeAnalysisCommand,
+  ): Promise<AnalyzeCommitsResult | null> {
+    const { verbose = false } = command
+
+    // Check if there's saved progress
+    const hasProgress = await this.progressRepository.hasProgress()
+    if (!hasProgress) {
+      ConsoleFormatter.logInfo(
+        "No previous checkpoint found. Starting fresh...",
+      )
+      return null
+    }
+
+    // Load progress state
+    const progressState = await this.progressRepository.loadProgress()
+    if (!progressState) {
+      ConsoleFormatter.logError("Failed to load progress state.")
+      return null
+    }
+
+    ConsoleFormatter.logInfo("Found previous session checkpoint")
+    ConsoleFormatter.logInfo(
+      this.progressRepository.formatProgressSummary(progressState),
+    )
+
+    // Ask user if they want to resume
+    const shouldResume = await this.promptUserForResume()
+    if (!shouldResume) {
+      await this.progressRepository.clearProgress()
+      ConsoleFormatter.logInfo("Starting fresh analysis...")
+      return null
+    }
+
+    // Get remaining commits
+    const remainingCommits =
+      this.progressRepository.getRemainingCommits(progressState)
+
+    if (remainingCommits.length === 0) {
+      ConsoleFormatter.logSuccess("All commits have already been processed!")
+      await this.progressRepository.clearProgress()
+      return {
+        analyzedCommits: progressState.analyzedCommits,
+        failedCommits: 0,
+        totalProcessed: progressState.processedCommits.length,
+      }
+    }
+
+    ConsoleFormatter.logInfo(
+      `Resuming with ${remainingCommits.length} remaining commits...`,
+    )
+    ConsoleFormatter.logInfo(
+      `Previous progress: ${progressState.processedCommits.length}/${progressState.totalCommits.length} commits processed`,
+    )
+
+    if (verbose) {
+      ConsoleFormatter.logDebug(
+        `analyzedCommits.length = ${progressState.analyzedCommits.length}`,
+      )
+      ConsoleFormatter.logDebug(
+        `processedCommits.length = ${progressState.processedCommits.length}`,
+      )
+      ConsoleFormatter.logDebug(
+        `remainingCommits.length = ${remainingCommits.length}`,
+      )
+    }
+
+    // Continue analysis with remaining commits
+    const remainingHashStrings = remainingCommits.map((hash) => hash.getValue())
+    const result = await this.analyzeCommitsUseCase.handle({
+      commitHashes: remainingHashStrings,
+      outputFile: progressState.outputFile,
+      verbose,
+    })
+
+    // Combine with previous results
+    const totalAnalyzedCommits = [
+      ...progressState.analyzedCommits,
+      ...result.analyzedCommits,
+    ]
+
+    return {
+      analyzedCommits: totalAnalyzedCommits,
+      failedCommits: result.failedCommits,
+      totalProcessed:
+        progressState.processedCommits.length + result.totalProcessed,
+    }
+  }
+
+  private async promptUserForResume(): Promise<boolean> {
+    const { question, close } = createPromiseReadline()
+    try {
+      const answer = await question("Resume from previous session? (y/n): ")
+      const normalizedAnswer = answer.toLowerCase().trim()
+      return normalizedAnswer === "y" || normalizedAnswer === "yes"
+    } finally {
+      close()
+    }
+  }
+}