commit-analyzer 1.1.4 → 1.1.6

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

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

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

@@ -1,278 +0,0 @@
-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.4"
-  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) {
-      const reportOutputPath = this.determineReportOutputPath(options)
-
-      await this.controller.handleReportGeneration({
-        inputCsv: options.inputCsv,
-        output: reportOutputPath,
-        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"
-  }
-
-  private determineReportOutputPath(options: CLIOptions): string {
-    // Check if explicit output or outputDir was provided in raw options
-    // We need to check raw options to distinguish between user-provided and default values
-    const hasExplicitOutput =
-      process.argv.includes("--output") || process.argv.includes("-o")
-    const hasExplicitOutputDir = process.argv.includes("--output-dir")
-
-    if (hasExplicitOutput || hasExplicitOutputDir) {
-      return options.output || CLIApplication.DEFAULT_REPORT_OUTPUT_FILE
-    }
-
-    // Default: generate report in same directory as CSV with .md extension
-    return this.getReportPathFromCsv(options.inputCsv!)
-  }
-
-  private getReportPathFromCsv(csvPath: string): string {
-    const lastSlash = csvPath.lastIndexOf("/")
-    const directory = lastSlash >= 0 ? csvPath.substring(0, lastSlash + 1) : ""
-    return directory + "report.md"
-  }
-}

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

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

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

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

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