commit-analyzer 1.1.4 → 1.1.6

package/src/3.presentation/console-formatter.ts

@@ -1,129 +0,0 @@
-/**
- * Console formatter for consistent output styling
- */
-export class ConsoleFormatter {
-  /**
-   * Log a success message with checkmark
-   */
-  static logSuccess(message: string): void {
-    console.log(`✓ ${message}`)
-  }
-
-  /**
-   * Log an error message with X mark
-   */
-  static logError(message: string): void {
-    console.error(`❌ ${message}`)
-  }
-
-  /**
-   * Log a warning message with warning icon
-   */
-  static logWarning(message: string): void {
-    console.log(`⚠️  ${message}`)
-  }
-
-  /**
-   * Log a debug message for development purposes
-   */
-  static logDebug(message: string): void {
-    console.log(`🐛 ${message}`)
-  }
-
-  /**
-   * Log an info message with bullet point
-   */
-  static logInfo(message: string): void {
-    console.log(`  - ${message}`)
-  }
-
-  /**
-   * Log a progress message with arrow
-   */
-  static logProgress(message: string): void {
-    console.log(`▶️  ${message}`)
-  }
-
-  /**
-   * Log a completion message with celebration icon
-   */
-  static logComplete(message: string): void {
-    console.log(`🎉 ${message}`)
-  }
-
-  /**
-   * Log a file operation with folder icon
-   */
-  static logFile(message: string): void {
-    console.log(`📁 ${message}`)
-  }
-
-  /**
-   * Log a save operation with disk icon
-   */
-  static logSave(message: string): void {
-    console.log(`💾 ${message}`)
-  }
-
-  /**
-   * Log a report generation with chart icon
-   */
-  static logReport(message: string): void {
-    console.log(`📊 ${message}`)
-  }
-
-  /**
-   * Log with indentation for nested information
-   */
-  static logIndented(message: string, level: number = 1): void {
-    const indent = '  '.repeat(level)
-    console.log(`${indent}${message}`)
-  }
-
-  /**
-   * Log a section header with newlines for spacing
-   */
-  static logSection(title: string): void {
-    console.log(`\n${title}`)
-  }
-
-  /**
-   * Log with custom emoji/icon
-   */
-  static logWithIcon(icon: string, message: string): void {
-    console.log(`${icon} ${message}`)
-  }
-
-  /**
-   * Display analysis summary in a formatted way
-   */
-  static displayAnalysisSummary(summary: Record<string, number>): void {
-    this.logSection("Summary by category:")
-    Object.entries(summary).forEach(([category, count]) => {
-      this.logInfo(`${category}: ${count} commits`)
-    })
-  }
-
-  /**
-   * Update progress bar inline
-   */
-  static updateProgress(current: number, total: number, description?: string): void {
-    const percentage = Math.round((current / total) * 100)
-    const completed = Math.round((current / total) * 20) // 20 characters for progress bar
-    const remaining = 20 - completed
-    
-    const progressBar = '█'.repeat(completed) + '░'.repeat(remaining)
-    const desc = description ? ` ${description}` : ''
-    
-    // Use \r to overwrite the line
-    process.stdout.write(`\r▶️  [${progressBar}] ${percentage}% (${current}/${total})${desc}`)
-  }
-
-  /**
-   * Complete progress and clear the line
-   */
-  static completeProgress(): void {
-    // Clear the current line and move to beginning
-    process.stdout.write('\r\x1b[K')
-  }
-}

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

@@ -1,49 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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 the repository/project name
-   */
-  getRepositoryName(): 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

@@ -1,271 +0,0 @@
-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`
-    )
-  }
-}