commit-analyzer 1.0.2 → 1.1.0

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

@@ -0,0 +1,27 @@
+import { Analysis } from "@domain/analysis"
+import { Commit } from "@domain/commit"
+
+/**
+ * Repository interface for commit analysis operations
+ */
+export interface IAnalysisRepository {
+  /**
+   * Analyzes a commit and returns the analysis result
+   */
+  analyze(commit: Commit): Promise<Analysis>
+
+  /**
+   * Checks if the analysis service is available
+   */
+  isAvailable(): Promise<boolean>
+
+  /**
+   * Gets the maximum number of retry attempts for analysis
+   */
+  getMaxRetries(): number
+
+  /**
+   * Sets verbose mode for detailed error information
+   */
+  setVerbose(verbose: boolean): void
+}

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

@@ -0,0 +1,128 @@
+import { AnalyzedCommit } from "@domain/analyzed-commit"
+import { CommitAnalysisService } from "@domain/commit-analysis-service"
+
+import {
+  AnalyzeCommitsResult,
+  AnalyzeCommitsUseCase,
+} from "@app/analyze-commits.usecase"
+
+import { getErrorMessage } from "../utils"
+
+import { ICommitRepository } from "./commit-repository.interface"
+import { ConsoleFormatter } from "./console-formatter"
+
+export interface AnalyzeCommandOptions {
+  commits: string[]
+  output: string
+  author?: string
+  limit?: number
+  verbose?: boolean
+  since?: string
+  until?: string
+  batchSize?: number
+}
+
+export class AnalyzeCommand {
+  constructor(
+    private readonly analyzeCommitsUseCase: AnalyzeCommitsUseCase,
+    private readonly commitAnalysisService: CommitAnalysisService,
+    private readonly commitRepository: ICommitRepository,
+  ) {}
+
+  async execute(options: AnalyzeCommandOptions): Promise<void> {
+    try {
+      const commitHashes = await this.resolveCommitHashes(options)
+      const analysisResult = await this.performAnalysis(commitHashes, options)
+      this.displayResults(analysisResult, options.output)
+    } catch (error) {
+      ConsoleFormatter.logError(getErrorMessage(error))
+      throw error
+    }
+  }
+
+  private async resolveCommitHashes(
+    options: AnalyzeCommandOptions,
+  ): Promise<string[]> {
+    if (options.commits.length > 0) {
+      return options.commits
+    }
+    const { userEmail, userCommits } = await this.fetchUserCommits(options)
+    const commitHashes = userCommits.map((commit) =>
+      commit.getHash().getValue(),
+    )
+    if (commitHashes.length === 0) {
+      ConsoleFormatter.logWarning(`No commits found for user: ${userEmail}`)
+      throw new Error("No commits found for analysis")
+    }
+    ConsoleFormatter.logInfo(
+      `Found ${commitHashes.length} commits for user: ${userEmail}`,
+    )
+    return commitHashes
+  }
+
+  private async fetchUserCommits(options: AnalyzeCommandOptions) {
+    if (options.author) {
+      const userCommits = await this.commitRepository.getByAuthor({
+        authorEmail: options.author,
+        limit: options.limit,
+        since: options.since,
+        until: options.until,
+      })
+      return { userEmail: options.author, userCommits }
+    }
+    const userEmail = await this.commitRepository.getCurrentUserEmail()
+    const userCommits = await this.commitAnalysisService.getCurrentUserCommits({
+      limit: options.limit,
+      since: options.since,
+      until: options.until,
+    })
+    return { userEmail, userCommits }
+  }
+
+  private async performAnalysis(
+    commitHashes: string[],
+    options: AnalyzeCommandOptions,
+  ): Promise<AnalyzeCommitsResult> {
+    if (commitHashes.length === 0) {
+      throw new Error("No commits provided for analysis")
+    }
+    return await this.analyzeCommitsUseCase.handle({
+      commitHashes,
+      outputFile: options.output,
+      verbose: options.verbose,
+      batchSize: options.batchSize,
+    })
+  }
+
+  private displayResults(
+    result: AnalyzeCommitsResult,
+    outputFile: string,
+  ): void {
+    ConsoleFormatter.logSection(
+      `Analysis complete! Results exported to ${outputFile}`,
+    )
+    ConsoleFormatter.logSuccess(
+      `Successfully analyzed ${result.analyzedCommits.length}/${result.totalProcessed} commits`,
+    )
+    if (result.failedCommits > 0) {
+      ConsoleFormatter.logWarning(
+        `Failed to analyze ${result.failedCommits} commits (see errors above)`,
+      )
+    }
+    const summary = this.createAnalysisSummary(result.analyzedCommits)
+    ConsoleFormatter.displayAnalysisSummary(summary)
+  }
+
+  private createAnalysisSummary(
+    analyzedCommits: AnalyzedCommit[],
+  ): Record<string, number> {
+    return analyzedCommits.reduce(
+      (summary, commit) => {
+        const category = commit.getAnalysis().getCategory().getValue()
+        summary[category] = (summary[category] || 0) + 1
+        return summary
+      },
+      {} as Record<string, number>,
+    )
+  }
+}

package/src/3.presentation/cli-application.ts

@@ -0,0 +1,255 @@
+import { Command } from "commander"
+
+import { getErrorMessage } from "../utils"
+
+import { CommitAnalysisController } from "./commit-analysis-controller"
+import { ConsoleFormatter } from "./console-formatter"
+
+export interface CLIOptions {
+  output?: string
+  outputDir?: string
+  commits: string[]
+  author?: string
+  limit?: number
+  resume?: boolean
+  clear?: boolean
+  llm?: string
+  report?: boolean
+  inputCsv?: string
+  verbose?: boolean
+  since?: string
+  until?: string
+  noCache?: boolean
+  batchSize?: number
+}
+
+export class CLIApplication {
+  private static readonly VERSION = "1.1.0"
+  private static readonly DEFAULT_COMMITS_OUTPUT_FILE = "results/commits.csv"
+  private static readonly DEFAULT_REPORT_OUTPUT_FILE = "results/report.md"
+
+  constructor(private readonly controller: CommitAnalysisController) {}
+
+  async run(args: string[]): Promise<void> {
+    try {
+      const program = this.createProgram()
+      await program.parseAsync(args)
+    } catch (error) {
+      ConsoleFormatter.logError(getErrorMessage(error))
+      process.exit(1)
+    }
+  }
+
+  private createProgram(): Command {
+    const program = new Command()
+
+    program
+      .name("commit-analyzer")
+      .description(
+        "Analyze user authored git commits and generate rich commit descriptions and stakeholder reports from them.",
+      )
+      .version(CLIApplication.VERSION)
+      .option(
+        "-o, --output <file>",
+        `Output CSV file (default: ${CLIApplication.DEFAULT_COMMITS_OUTPUT_FILE})`,
+      )
+      .option(
+        "--output-dir <dir>",
+        "Output directory for CSV and report files (default: current directory)",
+      )
+      .option(
+        "-a, --author <email>",
+        "Filter commits by author email (defaults to current user)",
+      )
+      .option(
+        "-l, --limit <number>",
+        "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("--llm <llm>", "LLM CLI tool to use (claude, gemini, openai)")
+      .option(
+        "--report",
+        "Generate condensed markdown report from existing CSV",
+      )
+      .option(
+        "--input-csv <file>",
+        "Input CSV file to read for report generation",
+      )
+      .option(
+        "-v, --verbose",
+        "Enable verbose logging (shows detailed error information)",
+      )
+      .option(
+        "--since <date>",
+        "Only analyze commits since this date (YYYY-MM-DD, '1 week ago', '2024-01-01')",
+      )
+      .option(
+        "--until <date>",
+        "Only analyze commits until this date (YYYY-MM-DD, '1 day ago', '2024-12-31')",
+      )
+      .option("--no-cache", "Disable caching of analysis results")
+      .option(
+        "--batch-size <number>",
+        "Number of commits to process per batch (default: 1 for sequential processing)",
+        parseInt,
+      )
+      .argument(
+        "[commits...]",
+        "Commit hashes to analyze (if none provided, uses current user's commits)",
+      )
+      .action(async (commits: string[], options: Record<string, unknown>) => {
+        const cliOptions = this.parseOptions(options, commits)
+        await this.executeCommand(cliOptions)
+      })
+    return program
+  }
+
+  private parseOptions(
+    options: Record<string, unknown>,
+    args: string[],
+  ): CLIOptions {
+    const { commits } = this.determineCommitsToAnalyze(args)
+    return {
+      output: this.determineOutputPath(
+        this.getStringOption(options.output),
+        this.getStringOption(options.outputDir),
+      ),
+      outputDir: this.getStringOption(options.outputDir),
+      commits,
+      author: this.getStringOption(options.author),
+      limit: this.getNumberOption(options.limit),
+      resume: this.getBooleanOption(options.resume),
+      clear: this.getBooleanOption(options.clear),
+      llm: this.getStringOption(options.llm),
+      report: this.getBooleanOption(options.report),
+      inputCsv: this.getStringOption(options.inputCsv),
+      verbose: this.getBooleanOption(options.verbose),
+      since: this.getStringOption(options.since),
+      until: this.getStringOption(options.until),
+      noCache: this.getBooleanOption(options.noCache),
+      batchSize: this.getNumberOption(options.batchSize),
+    }
+  }
+
+  private getStringOption(value: unknown): string | undefined {
+    return typeof value === "string" ? value : undefined
+  }
+
+  private getNumberOption(value: unknown): number | undefined {
+    return typeof value === "number" ? value : undefined
+  }
+
+  private getBooleanOption(value: unknown): boolean | undefined {
+    return typeof value === "boolean" ? value : undefined
+  }
+
+  private async executeCommand(options: CLIOptions): Promise<void> {
+    // Handle clear flag
+    if (options.clear) {
+      await this.controller.handleClearProgress()
+      if (!options.resume) {
+        return
+      }
+    }
+
+    // Handle input CSV mode (report generation only)
+    if (options.inputCsv) {
+      await this.controller.handleReportGeneration({
+        inputCsv: options.inputCsv,
+        output: options.output || CLIApplication.DEFAULT_REPORT_OUTPUT_FILE,
+        sourceInfo: { type: "csv", value: options.inputCsv },
+      })
+      return
+    }
+
+    // Handle resume mode
+    if (options.resume) {
+      const resumed = await this.controller.handleResumeAnalysis({
+        verbose: options.verbose,
+      })
+
+      if (resumed && options.report) {
+        const reportOutput = options.output
+          ? this.getReportOutputPath(options.output)
+          : CLIApplication.DEFAULT_REPORT_OUTPUT_FILE
+
+        await this.controller.handleReportGeneration({
+          inputCsv: options.output,
+          output: reportOutput,
+          sourceInfo: {
+            type: "csv",
+            value: options.output || CLIApplication.DEFAULT_COMMITS_OUTPUT_FILE,
+          },
+        })
+      }
+      return
+    }
+
+    // Handle normal analysis mode
+    const analyzeOptions = {
+      commits: options.commits,
+      output: options.output!,
+      author: options.author,
+      limit: options.limit,
+      verbose: options.verbose,
+      since: options.since,
+      until: options.until,
+      batchSize: options.batchSize,
+    }
+
+    if (options.report) {
+      // Analysis + Report workflow
+      const reportOutput = options.output
+        ? this.getReportOutputPath(options.output)
+        : CLIApplication.DEFAULT_REPORT_OUTPUT_FILE
+
+      await this.controller.handleAnalysisWithReport(analyzeOptions, {
+        output: reportOutput,
+        sourceInfo:
+          options.commits.length > 0
+            ? { type: "commits", value: options.commits.join(",") }
+            : { type: "author", value: options.author || "current user" },
+      })
+    } else {
+      // Analysis only workflow
+      await this.controller.handleAnalysis(analyzeOptions)
+    }
+  }
+
+  private determineCommitsToAnalyze(args: string[]): { commits: string[] } {
+    let commits: string[] = []
+    if (args.length > 0) {
+      commits = args
+    }
+    return { commits }
+  }
+
+  private determineOutputPath(
+    outputOption?: string,
+    outputDir?: string,
+  ): string {
+    if (outputOption) {
+      return outputOption
+    }
+    if (outputDir) {
+      return `${outputDir}/commits.csv`
+    }
+    return CLIApplication.DEFAULT_COMMITS_OUTPUT_FILE
+  }
+
+  private getReportOutputPath(csvPath: string): string {
+    // If no specific output path provided, use the default report path
+    if (!csvPath) {
+      return CLIApplication.DEFAULT_REPORT_OUTPUT_FILE
+    }
+
+    // Extract directory from CSV path and use report.md as filename
+    if (csvPath.endsWith(".csv")) {
+      const dir = csvPath.substring(0, csvPath.lastIndexOf("/"))
+      return dir ? `${dir}/report.md` : "report.md"
+    }
+    return csvPath + ".md"
+  }
+}

package/src/3.presentation/command-handler.interface.ts

@@ -0,0 +1,4 @@
+export interface ICommandHandler<TCommand, TResult> {
+  handle(command: TCommand): Promise<TResult>
+}
+

package/src/3.presentation/commit-analysis-controller.ts

@@ -0,0 +1,101 @@
+import { CacheService } from "@infra/cache-service"
+
+import { AnalyzeCommand, AnalyzeCommandOptions } from "./analyze-command"
+import { ICommitRepository } from "./commit-repository.interface"
+import { ConsoleFormatter } from "./console-formatter"
+import { IProgressRepository } from "./progress-repository.interface"
+import { ReportCommand, ReportCommandOptions } from "./report-command"
+import { ResumeCommand, ResumeCommandOptions } from "./resume-command"
+
+export class CommitAnalysisController {
+  constructor(
+    private readonly analyzeCommand: AnalyzeCommand,
+    private readonly reportCommand: ReportCommand,
+    private readonly resumeCommand: ResumeCommand,
+    private readonly progressRepository: IProgressRepository,
+    private readonly cacheService: CacheService,
+    private readonly commitRepository: ICommitRepository,
+  ) {}
+
+  /**
+   * Handles the main analysis workflow
+   */
+  async handleAnalysis(options: AnalyzeCommandOptions): Promise<void> {
+    await this.analyzeCommand.execute(options)
+  }
+
+  /**
+   * Handles report generation
+   */
+  async handleReportGeneration(options: ReportCommandOptions): Promise<void> {
+    await this.reportCommand.execute(options)
+  }
+
+  /**
+   * Handles resuming analysis from checkpoint
+   */
+  async handleResumeAnalysis(options: ResumeCommandOptions): Promise<boolean> {
+    return this.resumeCommand.execute(options)
+  }
+
+  /**
+   * Handles the combined analysis and report workflow
+   */
+  async handleAnalysisWithReport(
+    analyzeOptions: AnalyzeCommandOptions,
+    reportOptions: ReportCommandOptions,
+  ): Promise<void> {
+    // First run analysis
+    await this.handleAnalysis(analyzeOptions)
+
+    // Resolve source info with actual user email if needed
+    const resolvedSourceInfo = await this.resolveSourceInfo(
+      reportOptions.sourceInfo,
+      analyzeOptions.author,
+    )
+
+    // Then generate report using the analysis output
+    const reportOptionsWithInput: ReportCommandOptions = {
+      ...reportOptions,
+      inputCsv: analyzeOptions.output,
+      sourceInfo: resolvedSourceInfo,
+    }
+
+    await this.handleReportGeneration(reportOptionsWithInput)
+  }
+
+  /**
+   * Handles clearing progress and cache
+   */
+  async handleClearProgress(): Promise<void> {
+    await this.progressRepository.clearProgress()
+    await this.cacheService.clear()
+    ConsoleFormatter.logSuccess("✓ Progress checkpoint and cache cleared")
+  }
+
+  /**
+   * Resolves source info with actual user email when needed
+   */
+  private async resolveSourceInfo(
+    sourceInfo?: { type: "author" | "commits" | "csv"; value: string },
+    authorOption?: string,
+  ): Promise<
+    { type: "author" | "commits" | "csv"; value: string } | undefined
+  > {
+    if (!sourceInfo) {
+      return undefined
+    }
+
+    // If source is author and value is 'current user', get actual email
+    if (sourceInfo.type === "author" && sourceInfo.value === "current user") {
+      const actualEmail =
+        authorOption || (await this.commitRepository.getCurrentUserEmail())
+      return {
+        type: "author",
+        value: actualEmail,
+      }
+    }
+
+    return sourceInfo
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Commit } from "@domain/commit"
+import { CommitHash } from "@domain/commit-hash"
+
+/**
+ * Repository interface for accessing commit data
+ */
+export interface ICommitRepository {
+  /**
+   * Retrieves a commit by its hash
+   */
+  getByHash(hash: CommitHash): Promise<Commit>
+
+  /**
+   * Retrieves commits authored by a specific user
+   */
+  getByAuthor(params: {
+    authorEmail: string
+    limit?: number
+    since?: string
+    until?: string
+  }): Promise<Commit[]>
+
+  /**
+   * Retrieves commits from a list of hashes
+   */
+  getByHashes(hashes: CommitHash[]): Promise<Commit[]>
+
+  /**
+   * Validates if a commit hash exists in the repository
+   */
+  exists(hash: CommitHash): Promise<boolean>
+
+  /**
+   * Gets the current user's email from the repository configuration
+   */
+  getCurrentUserEmail(): Promise<string>
+
+  /**
+   * Gets the current user's name from the repository configuration
+   */
+  getCurrentUserName(): Promise<string>
+
+  /**
+   * Checks if the current directory is a valid repository
+   */
+  isValidRepository(): Promise<boolean>
+}

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

@@ -0,0 +1,129 @@
+/**
+ * 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')
+  }
+}