commit-analyzer 1.0.2 → 1.1.0

package/src/3.presentation/progress-repository.interface.ts

@@ -0,0 +1,49 @@
+import { AnalyzedCommit } from "@domain/analyzed-commit"
+import { CommitHash } from "@domain/commit-hash"
+
+/**
+ * Progress state for tracking analysis progress
+ */
+export interface ProgressState {
+  totalCommits: CommitHash[]
+  processedCommits: CommitHash[]
+  analyzedCommits: AnalyzedCommit[]
+  lastProcessedIndex: number
+  startTime: Date
+  outputFile: string
+}
+
+/**
+ * Repository interface for progress tracking operations
+ */
+export interface IProgressRepository {
+  /**
+   * Saves the current progress state
+   */
+  saveProgress(state: ProgressState): Promise<void>
+
+  /**
+   * Loads the saved progress state
+   */
+  loadProgress(): Promise<ProgressState | null>
+
+  /**
+   * Checks if there is saved progress
+   */
+  hasProgress(): Promise<boolean>
+
+  /**
+   * Clears any saved progress
+   */
+  clearProgress(): Promise<void>
+
+  /**
+   * Gets the remaining commits from a progress state
+   */
+  getRemainingCommits(state: ProgressState): CommitHash[]
+
+  /**
+   * Formats a progress summary for display
+   */
+  formatProgressSummary(state: ProgressState): string
+}

package/src/3.presentation/report-command.ts

@@ -0,0 +1,50 @@
+import { GenerateReportUseCase } from "@app/generate-report.usecase"
+
+import { ConsoleFormatter } from "./console-formatter"
+
+export interface ReportCommandOptions {
+  inputCsv?: string
+  output: string
+  includeStatistics?: boolean
+  sourceInfo?: {
+    type: "author" | "commits" | "csv"
+    value: string
+  }
+}
+
+export class ReportCommand {
+  constructor(private readonly generateReportUseCase: GenerateReportUseCase) {}
+
+  async execute(options: ReportCommandOptions): Promise<void> {
+    try {
+      console.log("\nGenerating report from existing CSV...")
+
+      const result = await this.generateReportUseCase.handle({
+        inputCsvPath: options.inputCsv,
+        outputPath: options.output,
+        includeStatistics: options.includeStatistics ?? true,
+        sourceInfo:
+          options.sourceInfo ||
+          (options.inputCsv
+            ? { type: "csv", value: options.inputCsv }
+            : undefined),
+      })
+
+      ConsoleFormatter.logReport(`Report generated: ${result.reportPath}`)
+
+      const stats = result.statistics
+      ConsoleFormatter.logSuccess(
+        `Processed ${result.commitsProcessed} commits`,
+      )
+
+      ConsoleFormatter.logInfo(
+        `Categories: ${stats.categoryBreakdown.feature} features, ${stats.categoryBreakdown.process} process, ${stats.categoryBreakdown.tweak} tweaks`,
+      )
+    } catch (error) {
+      ConsoleFormatter.logError(
+        error instanceof Error ? error.message : "Unknown error occurred",
+      )
+      throw error
+    }
+  }
+}

package/src/3.presentation/resume-command.ts

@@ -0,0 +1,59 @@
+import { ResumeAnalysisUseCase } from "@app/resume-analysis.usecase"
+
+import { ConsoleFormatter } from "./console-formatter"
+
+export interface ResumeCommandOptions {
+  verbose?: boolean
+}
+
+export class ResumeCommand {
+  constructor(private readonly resumeAnalysisUseCase: ResumeAnalysisUseCase) {}
+
+  async execute(options: ResumeCommandOptions): Promise<boolean> {
+    try {
+      const result = await this.resumeAnalysisUseCase.handle({
+        verbose: options.verbose,
+      })
+
+      if (!result) {
+        ConsoleFormatter.logInfo(
+          "No previous checkpoint found or user chose to start fresh",
+        )
+        return false
+      }
+
+      // Display results
+      ConsoleFormatter.logSuccess(
+        "Analysis resumed and completed successfully!",
+      )
+      ConsoleFormatter.logInfo(
+        `Total analyzed: ${result.analyzedCommits.length} commits`,
+      )
+
+      if (result.failedCommits > 0) {
+        ConsoleFormatter.logWarning(
+          `Failed commits during resume: ${result.failedCommits}`,
+        )
+      }
+
+      // Display category summary
+      const summary = result.analyzedCommits.reduce(
+        (acc, commit) => {
+          const category = commit.getAnalysis().getCategory().getValue()
+          acc[category] = (acc[category] || 0) + 1
+          return acc
+        },
+        {} as Record<string, number>,
+      )
+
+      ConsoleFormatter.displayAnalysisSummary(summary)
+
+      return true
+    } catch (error) {
+      ConsoleFormatter.logError(
+        error instanceof Error ? error.message : "Unknown error occurred",
+      )
+      throw error
+    }
+  }
+}

package/src/3.presentation/storage-repository.interface.ts

@@ -0,0 +1,33 @@
+import { AnalyzedCommit } from "@domain/analyzed-commit"
+
+export interface IStorageRepository {
+  /**
+   * Exports analyzed commits to CSV format
+   */
+  exportToCSV(commits: AnalyzedCommit[], filePath: string): Promise<void>
+
+  /**
+   * Imports commits from CSV format
+   */
+  importFromCSV(filePath: string): Promise<AnalyzedCommit[]>
+
+  /**
+   * Generates a markdown report from analyzed commits
+   */
+  generateReport(commits: AnalyzedCommit[], outputPath: string): Promise<void>
+
+  /**
+   * Reads commits from a file (one hash per line)
+   */
+  readCommitHashesFromFile(filePath: string): Promise<string[]>
+
+  /**
+   * Ensures a directory exists
+   */
+  ensureDirectoryExists(directoryPath: string): Promise<void>
+
+  /**
+   * Writes content to a file
+   */
+  writeFile(filePath: string, content: string): Promise<void>
+}

package/src/3.presentation/storage-service.interface.ts

@@ -0,0 +1,32 @@
+export interface IStorageService {
+  /**
+   * Writes content to a file
+   */
+  writeFile(filePath: string, content: string): Promise<void>
+
+  /**
+   * Reads content from a file
+   */
+  readFile(filePath: string): Promise<string>
+
+  /**
+   * Checks if a file exists
+   */
+  fileExists(filePath: string): Promise<boolean>
+
+  /**
+   * Creates a directory if it doesn't exist
+   */
+  ensureDirectory(directoryPath: string): Promise<void>
+
+  /**
+   * Deletes a file
+   */
+  deleteFile(filePath: string): Promise<void>
+
+  /**
+   * Reads lines from a file
+   */
+  readLines(filePath: string): Promise<string[]>
+}
+

package/src/3.presentation/version-control-service.interface.ts

@@ -0,0 +1,41 @@
+export interface IVersionControlService {
+  /**
+   * Gets detailed commit information by hash
+   */
+  getCommitInfo(hash: string): Promise<{
+    hash: string
+    message: string
+    date: Date
+    diff: string
+  }>
+
+  /**
+   * Validates if a commit hash exists
+   */
+  validateCommitHash(hash: string): Promise<boolean>
+
+  /**
+   * Checks if current directory is a valid repository
+   */
+  isValidRepository(): Promise<boolean>
+
+  /**
+   * Gets current user's email from repository config
+   */
+  getCurrentUserEmail(): Promise<string>
+
+  /**
+   * Gets current user's name from repository config
+   */
+  getCurrentUserName(): Promise<string>
+
+  /**
+   * Gets commits authored by a specific user
+   */
+  getUserAuthoredCommits(params: {
+    authorEmail: string
+    limit?: number
+    since?: string
+    until?: string
+  }): Promise<string[]>
+}

package/src/4.infrastructure/cache-service.ts

@@ -0,0 +1,271 @@
+import { promises as fs } from "fs"
+import path from "path"
+
+import { Analysis } from "@domain/analysis"
+import { Category, CategoryType } from "@domain/category"
+
+import { AppPaths } from "../utils/app-paths"
+
+/**
+ * Cache entry for storing analyzed commit results
+ */
+interface CacheEntry {
+  hash: string
+  timestamp: number
+  analysis: {
+    category: string
+    summary: string
+    description: string
+  }
+}
+
+/**
+ * Service for caching analyzed commit results
+ */
+export class CacheService {
+  private static readonly DEFAULT_TTL_DAYS = 30
+  private static readonly CACHE_FILE_PREFIX = "commit-"
+  
+  private readonly cacheDir: string
+  private readonly ttlMs: number
+  private cacheEnabled: boolean = true
+
+  constructor(
+    baseDir: string = process.cwd(),
+    ttlDays: number = CacheService.DEFAULT_TTL_DAYS
+  ) {
+    this.cacheDir = AppPaths.getCacheDir(baseDir)
+    this.ttlMs = ttlDays * 24 * 60 * 60 * 1000
+  }
+
+  /**
+   * Enable or disable caching
+   */
+  setCacheEnabled(enabled: boolean): void {
+    this.cacheEnabled = enabled
+  }
+
+  /**
+   * Initialize cache directory
+   */
+  async initialize(): Promise<void> {
+    if (!this.cacheEnabled) {
+      return
+    }
+
+    try {
+      await fs.mkdir(this.cacheDir, { recursive: true })
+    } catch (error) {
+      console.warn("Failed to initialize cache directory:", error)
+      this.cacheEnabled = false
+    }
+  }
+
+  /**
+   * Get cached analysis result for a commit hash
+   */
+  async get(commitHash: string): Promise<Analysis | null> {
+    if (!this.cacheEnabled) {
+      return null
+    }
+
+    try {
+      const cacheFilePath = this.getCacheFilePath(commitHash)
+      
+      // Check if cache file exists
+      const stat = await fs.stat(cacheFilePath)
+      const now = Date.now()
+      
+      // Check if cache entry is expired
+      if (now - stat.mtimeMs > this.ttlMs) {
+        await this.delete(commitHash)
+        return null
+      }
+
+      // Read and parse cache entry
+      const cacheData = await fs.readFile(cacheFilePath, "utf-8")
+      const entry: CacheEntry = JSON.parse(cacheData)
+
+      // Verify hash matches
+      if (entry.hash !== commitHash) {
+        await this.delete(commitHash)
+        return null
+      }
+
+      // Reconstruct Analysis object
+      const category = Category.create(entry.analysis.category as CategoryType)
+      return new Analysis({
+        category,
+        summary: entry.analysis.summary,
+        description: entry.analysis.description,
+      })
+    } catch {
+      // Cache miss or error - return null
+      return null
+    }
+  }
+
+  /**
+   * Store analysis result in cache
+   */
+  async set(commitHash: string, analysis: Analysis): Promise<void> {
+    if (!this.cacheEnabled) {
+      return
+    }
+
+    try {
+      await this.initialize()
+      
+      const entry: CacheEntry = {
+        hash: commitHash,
+        timestamp: Date.now(),
+        analysis: {
+          category: analysis.getCategory().getValue(),
+          summary: analysis.getSummary(),
+          description: analysis.getDescription(),
+        },
+      }
+
+      const cacheFilePath = this.getCacheFilePath(commitHash)
+      await fs.writeFile(cacheFilePath, JSON.stringify(entry, null, 2))
+    } catch (error) {
+      // Silent fail for cache writes
+      console.warn(`Failed to cache analysis for ${commitHash}:`, error)
+    }
+  }
+
+  /**
+   * Delete cached entry for a commit hash
+   */
+  async delete(commitHash: string): Promise<void> {
+    if (!this.cacheEnabled) {
+      return
+    }
+
+    try {
+      const cacheFilePath = this.getCacheFilePath(commitHash)
+      await fs.unlink(cacheFilePath)
+    } catch {
+      // Silent fail for cache deletes
+    }
+  }
+
+  /**
+   * Clear all cache entries
+   */
+  async clear(): Promise<void> {
+    if (!this.cacheEnabled) {
+      return
+    }
+
+    try {
+      const files = await fs.readdir(this.cacheDir)
+      const cacheFiles = files.filter(file => 
+        file.startsWith(CacheService.CACHE_FILE_PREFIX)
+      )
+      
+      await Promise.all(
+        cacheFiles.map(file => 
+          fs.unlink(path.join(this.cacheDir, file)).catch(() => {})
+        )
+      )
+    } catch {
+      // Silent fail for cache clear
+    }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  async getStats(): Promise<{
+    totalEntries: number
+    totalSize: number
+    oldestEntry: Date | null
+    newestEntry: Date | null
+  }> {
+    if (!this.cacheEnabled) {
+      return {
+        totalEntries: 0,
+        totalSize: 0,
+        oldestEntry: null,
+        newestEntry: null,
+      }
+    }
+
+    try {
+      const files = await fs.readdir(this.cacheDir)
+      const cacheFiles = files.filter(file => 
+        file.startsWith(CacheService.CACHE_FILE_PREFIX)
+      )
+
+      let totalSize = 0
+      let oldestTime = Number.MAX_SAFE_INTEGER
+      let newestTime = 0
+
+      for (const file of cacheFiles) {
+        const filePath = path.join(this.cacheDir, file)
+        const stat = await fs.stat(filePath)
+        totalSize += stat.size
+        oldestTime = Math.min(oldestTime, stat.mtimeMs)
+        newestTime = Math.max(newestTime, stat.mtimeMs)
+      }
+
+      return {
+        totalEntries: cacheFiles.length,
+        totalSize,
+        oldestEntry: cacheFiles.length > 0 ? new Date(oldestTime) : null,
+        newestEntry: cacheFiles.length > 0 ? new Date(newestTime) : null,
+      }
+    } catch {
+      return {
+        totalEntries: 0,
+        totalSize: 0,
+        oldestEntry: null,
+        newestEntry: null,
+      }
+    }
+  }
+
+  /**
+   * Clean expired cache entries
+   */
+  async cleanExpired(): Promise<number> {
+    if (!this.cacheEnabled) {
+      return 0
+    }
+
+    try {
+      const files = await fs.readdir(this.cacheDir)
+      const cacheFiles = files.filter(file => 
+        file.startsWith(CacheService.CACHE_FILE_PREFIX)
+      )
+
+      const now = Date.now()
+      let cleanedCount = 0
+
+      for (const file of cacheFiles) {
+        const filePath = path.join(this.cacheDir, file)
+        try {
+          const stat = await fs.stat(filePath)
+          if (now - stat.mtimeMs > this.ttlMs) {
+            await fs.unlink(filePath)
+            cleanedCount++
+          }
+        } catch {
+          // Skip files that can't be processed
+        }
+      }
+
+      return cleanedCount
+    } catch {
+      return 0
+    }
+  }
+
+  private getCacheFilePath(commitHash: string): string {
+    return path.join(
+      this.cacheDir,
+      `${CacheService.CACHE_FILE_PREFIX}${commitHash}.json`
+    )
+  }
+}

package/src/4.infrastructure/cached-analysis-repository.ts

@@ -0,0 +1,46 @@
+import { Analysis } from "@domain/analysis"
+import { Commit } from "@domain/commit"
+
+import { IAnalysisRepository } from "@presentation/analysis-repository.interface"
+
+import { CacheService } from "./cache-service"
+
+/**
+ * Cached analysis repository that wraps another analysis repository
+ */
+export class CachedAnalysisRepository implements IAnalysisRepository {
+  constructor(
+    private readonly baseRepository: IAnalysisRepository,
+    private readonly cacheService: CacheService,
+  ) {}
+
+  async analyze(commit: Commit): Promise<Analysis> {
+    const commitHash = commit.getHash().getValue()
+
+    // Try to get from cache first
+    const cachedAnalysis = await this.cacheService.get(commitHash)
+    if (cachedAnalysis) {
+      return cachedAnalysis
+    }
+
+    // Cache miss - analyze with base repository
+    const analysis = await this.baseRepository.analyze(commit)
+
+    // Store in cache for next time
+    await this.cacheService.set(commitHash, analysis)
+
+    return analysis
+  }
+
+  async isAvailable(): Promise<boolean> {
+    return this.baseRepository.isAvailable()
+  }
+
+  getMaxRetries(): number {
+    return this.baseRepository.getMaxRetries()
+  }
+
+  setVerbose(verbose: boolean): void {
+    this.baseRepository.setVerbose(verbose)
+  }
+}

package/src/4.infrastructure/claude-llm-adapter.ts

@@ -0,0 +1,124 @@
+import { execSync } from "child_process"
+
+import { CategoryType } from "@domain/category"
+
+import { LLMAdapter } from "./llm-adapter"
+
+export class ClaudeLLMAdapter extends LLMAdapter {
+  private static readonly MAX_PROMPT_LENGTH = parseInt(
+    process.env.CLAUDE_MAX_PROMPT_LENGTH || "100000",
+    10,
+  )
+
+  protected getMaxPromptLength(): number {
+    return ClaudeLLMAdapter.MAX_PROMPT_LENGTH
+  }
+
+  async detectAvailableModels(): Promise<string[]> {
+    try {
+      execSync("command -v claude", { stdio: "ignore" })
+      return ["claude", "claude --model sonnet", "claude --model haiku"]
+    } catch {
+      return []
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    const available = await this.detectAvailableModels()
+    return available.length > 0
+  }
+
+  protected async executeModelCommand(prompt: string): Promise<string> {
+    const truncatedPrompt = this.truncatePrompt(prompt)
+
+    if (this.verbose) {
+      console.log(`  - Prompt length: ${truncatedPrompt.length} characters`)
+    }
+
+    const modelCommand = this.model || "claude --model sonnet"
+
+    return execSync(modelCommand, {
+      input: truncatedPrompt,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: LLMAdapter.DEFAULT_TIMEOUT,
+    })
+  }
+
+  protected parseResponse(response: string): {
+    category: CategoryType
+    summary: string
+    description: string
+  } {
+    try {
+      // First try standard JSON parsing
+      return super.parseResponse(response)
+    } catch {
+      // Claude often responds in natural language format, so try to parse that
+      if (this.verbose) {
+        console.log(`  - Standard JSON parsing failed, trying Claude natural language parsing...`)
+      }
+      return this.parseClaudeNaturalLanguageResponse(response)
+    }
+  }
+
+  private parseClaudeNaturalLanguageResponse(response: string): {
+    category: CategoryType
+    summary: string
+    description: string
+  } {
+    // Try to extract category from various Claude response patterns
+    const categoryMatch = response.match(/\*\*?Category\*\*?:?\s*(tweak|feature|process)/i) ||
+                         response.match(/Category:\s*(tweak|feature|process)/i) ||
+                         response.match(/\*\*(tweak|feature|process)\*\*/i) ||
+                         response.match(/(tweak|feature|process)\s*commit/i) ||
+                         response.match(/should be categorized as[:\s]*\*\*?(tweak|feature|process)/i)
+    const category = categoryMatch?.[1]?.toLowerCase()
+
+    if (!category || !this.isValidCategory(category)) {
+      if (this.verbose) {
+        console.log(`  - Failed to extract category from Claude response`)
+        console.log(`  - Response snippet: ${response.substring(0, 500)}`)
+      }
+      throw new Error(`Could not extract valid category from Claude response`)
+    }
+
+    // Try to extract summary from patterns
+    const summaryMatch = response.match(/\*\*?Summary\*\*?:?\s*([^\n\r]+)/i) ||
+                        response.match(/Summary:\s*([^\n\r]+)/i)
+    let summary = summaryMatch?.[1]?.trim()
+    
+    if (!summary) {
+      // Fallback: try to find a descriptive line
+      const lines = response.split('\n').filter(line => line.trim())
+      summary = lines.find(line => 
+        line.includes('refactor') || 
+        line.includes('add') || 
+        line.includes('fix') ||
+        line.includes('update') ||
+        line.includes('implement')
+      )?.trim() || "Code changes"
+    }
+
+    // Try to extract description
+    const descMatch = response.match(/\*\*?Description\*\*?:?\s*([\s\S]+?)(?=\n\n|\n\*\*|\n---|\n#|$)/i) ||
+                     response.match(/Description:\s*([\s\S]+?)(?=\n\n|\n\*\*|\n---|\n#|$)/i)
+    let description = descMatch?.[1]?.trim()
+    
+    if (!description) {
+      // Fallback: extract the longest meaningful sentence
+      const sentences = response.split(/[.!?]+/).filter(s => s.trim().length > 20)
+      description = sentences[0]?.trim() || "Commit contains code changes"
+    }
+
+    // Clean up and truncate
+    summary = summary.substring(0, 80).replace(/[*"]/g, '').trim()
+    description = description.replace(/[*"]/g, '').trim()
+
+    return {
+      category: category as CategoryType,
+      summary: summary || "Code changes",
+      description: description || "This commit contains code changes."
+    }
+  }
+}