commit-analyzer 1.1.4 → 1.1.6

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

@@ -1,485 +0,0 @@
-import { CategoryType } from "@domain/category"
-
-import { ILLMService } from "@app/llm-service"
-
-import { sleep } from "../utils"
-
-export abstract class LLMAdapter implements ILLMService {
-  protected static readonly DEFAULT_TIMEOUT = 60000
-  protected static readonly MAX_RETRIES = parseInt(
-    process.env.LLM_MAX_RETRIES || "3",
-    10,
-  )
-  protected static readonly INITIAL_RETRY_DELAY = parseInt(
-    process.env.LLM_INITIAL_RETRY_DELAY || "5000",
-    10,
-  )
-  protected static readonly MAX_RETRY_DELAY = parseInt(
-    process.env.LLM_MAX_RETRY_DELAY || "30000",
-    10,
-  )
-  protected static readonly RETRY_MULTIPLIER = parseFloat(
-    process.env.LLM_RETRY_MULTIPLIER || "2",
-  )
-
-  protected model: string = ""
-  protected verbose: boolean = false
-  protected retryEnabled: boolean = true
-
-  protected abstract getMaxPromptLength(): number
-
-  abstract detectAvailableModels(): Promise<string[]>
-  abstract isAvailable(): Promise<boolean>
-  protected abstract executeModelCommand(prompt: string): Promise<string>
-
-  setLLM(llm: string): void {
-    this.model = llm
-  }
-
-  // Deprecated: Use setLLM instead
-  setModel(model: string): void {
-    this.setLLM(model)
-  }
-
-  setVerbose(verbose: boolean): void {
-    this.verbose = verbose
-  }
-
-  setRetryEnabled(enabled: boolean): void {
-    this.retryEnabled = enabled
-  }
-
-  getMaxRetries(): number {
-    return LLMAdapter.MAX_RETRIES
-  }
-
-  async analyzeCommit(
-    message: string,
-    diff: string,
-  ): Promise<{
-    category: CategoryType
-    summary: string
-    description: string
-  }> {
-    const prompt = this.buildPrompt(message, diff)
-    let lastError: Error | null = null
-
-    if (!this.retryEnabled) {
-      try {
-        const output = await this.executeModelCommand(prompt)
-        return this.parseResponse(output)
-      } catch (error) {
-        throw new Error(
-          `Failed to analyze commit: ${error instanceof Error ? error.message : "Unknown error"}`,
-        )
-      }
-    }
-
-    for (let attempt = 1; attempt <= LLMAdapter.MAX_RETRIES; attempt++) {
-      try {
-        const output = await this.executeModelCommand(prompt)
-        return this.parseResponse(output)
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error("Unknown error")
-
-        if (attempt < LLMAdapter.MAX_RETRIES) {
-          const delay = Math.min(
-            LLMAdapter.INITIAL_RETRY_DELAY *
-              Math.pow(LLMAdapter.RETRY_MULTIPLIER, attempt - 1),
-            LLMAdapter.MAX_RETRY_DELAY,
-          )
-
-          if (this.verbose) {
-            console.log(
-              `  - Attempt ${attempt}/${LLMAdapter.MAX_RETRIES} failed. Retrying in ${delay / 1000}s...`,
-            )
-          }
-
-          await sleep(delay)
-        }
-      }
-    }
-
-    throw new Error(
-      `Failed to analyze commit after ${LLMAdapter.MAX_RETRIES} attempts: ${lastError?.message || "Unknown error"}`,
-    )
-  }
-
-  protected buildPrompt(commitMessage: string, diff: string): string {
-    return `Analyze this git commit and provide a categorization.
-
-COMMIT MESSAGE:
-${commitMessage}
-
-COMMIT DIFF:
-${diff}
-
-Based on the commit message and code changes, categorize this commit as one of:
-- "tweak": Minor adjustments, bug fixes, small improvements
-- "feature": New functionality, major additions  
-- "process": Build system, CI/CD, tooling, configuration changes
-
-IMPORTANT: You must respond with ONLY a valid JSON object in this exact format:
-
-\`\`\`json
-{
-  "category": "tweak|feature|process",
-  "summary": "One-line description (max 80 characters)",
-  "description": "Detailed explanation in 2-3 sentences"
-}
-\`\`\`
-
-Do not include any other text outside the JSON code block.`
-  }
-
-  protected parseResponse(response: string): {
-    category: CategoryType
-    summary: string
-    description: string
-  } {
-    try {
-      const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/)
-      if (!jsonMatch) {
-        throw new Error("No JSON block found in response")
-      }
-
-      const jsonString = jsonMatch[1].trim()
-      const parsed = JSON.parse(jsonString)
-
-      const { category, summary, description } = parsed
-
-      if (!this.isValidCategory(category)) {
-        throw new Error(`Invalid category: ${category}`)
-      }
-
-      if (!summary || !description) {
-        throw new Error("Missing required fields in response")
-      }
-
-      return {
-        category: category as CategoryType,
-        summary: summary.substring(0, 80), // Ensure max length
-        description: description,
-      }
-    } catch (error) {
-      if (this.verbose) {
-        console.log(
-          `  - Raw LLM response (first 2000 chars): ${response.substring(0, 2000)}`,
-        )
-        if (response.length > 2000) {
-          console.log(
-            `  - Response truncated (total length: ${response.length} chars)`,
-          )
-        }
-      }
-
-      throw new Error(
-        `Failed to parse LLM response: ${error instanceof Error ? error.message : "Unknown error"}`,
-      )
-    }
-  }
-
-  protected isValidCategory(category: string): category is CategoryType {
-    return ["tweak", "feature", "process"].includes(category)
-  }
-
-  async generateYearlySummariesFromCSV(csvContent: string): Promise<string> {
-    return this.generateTimePeriodSummariesFromCSV(csvContent, 'yearly')
-  }
-
-  async generateTimePeriodSummariesFromCSV(csvContent: string, period: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly'): Promise<string> {
-    const prompt = this.buildTimePeriodReportPrompt(csvContent, period)
-    let lastError: Error | null = null
-
-    if (!this.retryEnabled) {
-      try {
-        const output = await this.executeModelCommand(prompt)
-        return this.parseReportResponse(output)
-      } catch (error) {
-        throw new Error(
-          `Failed to generate report: ${error instanceof Error ? error.message : "Unknown error"}`,
-        )
-      }
-    }
-
-    for (let attempt = 1; attempt <= LLMAdapter.MAX_RETRIES; attempt++) {
-      try {
-        const output = await this.executeModelCommand(prompt)
-        return this.parseReportResponse(output)
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error("Unknown error")
-
-        if (this.verbose) {
-          console.log(`  - Error generating report:`)
-          console.log(`    Attempt: ${attempt}/${LLMAdapter.MAX_RETRIES}`)
-          console.log(`    Error: ${lastError.message}`)
-        }
-
-        if (attempt < LLMAdapter.MAX_RETRIES) {
-          const delay = Math.min(
-            LLMAdapter.INITIAL_RETRY_DELAY *
-              Math.pow(LLMAdapter.RETRY_MULTIPLIER, attempt - 1),
-            LLMAdapter.MAX_RETRY_DELAY,
-          )
-          if (this.verbose) {
-            console.log(`    Retrying in ${delay / 1000}s...`)
-          }
-          await sleep(delay)
-        }
-      }
-    }
-
-    throw new Error(
-      `Failed to generate report after ${LLMAdapter.MAX_RETRIES} attempts: ${lastError?.message || "Unknown error"}`,
-    )
-  }
-
-  private buildReportPrompt(csvContent: string): string {
-    return `Analyze the following CSV data containing git commit analysis results and generate a condensed markdown development summary report.
-
-CSV DATA:
-${csvContent}
-
-INSTRUCTIONS:
-1. Group the data by year (descending order, most recent first)
-2. Within each year, group by category: Features, Process Improvements, and Tweaks & Bug Fixes
-3. Use the 'commit_count' and 'date_range' columns to understand the scope and timeline of work
-4. Consolidate similar items within each category to create readable summaries
-5. Focus on what was accomplished rather than individual commit details
-6. Use clear, professional language appropriate for stakeholders
-7. Pay attention to recurring themes and patterns across commits
-
-CATEGORY MAPPING:
-- "feature" → "Features" section
-- "process" → "Processes" section  
-- "tweak" → "Tweaks & Bug Fixes" section
-
-CONSOLIDATION GUIDELINES:
-- FIRST: Extract common themes and keywords from commit summaries within each category
-- SECOND: Identify and merge duplicate or highly similar work items (e.g., multiple "fix auth bug" commits become "resolved authentication issues")
-- Group similar features together by theme (e.g., "authentication system improvements", "payment processing enhancements")
-- Combine related bug fixes by area/system (e.g., "resolved 8 authentication issues", "fixed 5 database connection problems")
-- Summarize process changes by theme (e.g., "CI/CD pipeline enhancements", "testing infrastructure improvements")
-- Use bullet points for individual consolidated items within categories
-- Aim for 3-7 bullet points per category per year
-- Include specific numbers when relevant (e.g., "15 bug fixes", "3 new features")
-- Avoid listing near-identical items separately - consolidate them into meaningful groups
-
-OUTPUT FORMAT:
-Generate yearly summary sections with this exact structure (DO NOT include the main title or commit analysis section):
-
-\`\`\`markdown
-## [YEAR]
-### Features
-- [Consolidated feature summary 1]
-- [Consolidated feature summary 2]
-- [Additional features as needed]
-
-### Processes
-- [Consolidated process improvement 1]
-- [Consolidated process improvement 2]
-- [Additional process items as needed]
-
-### Tweaks & Bug Fixes
-- [Consolidated tweak/fix summary 1]
-- [Consolidated tweak/fix summary 2]
-- [Additional tweaks/fixes as needed]
-
-## [PREVIOUS YEAR]
-[Repeat structure for each year in the data]
-\`\`\`
-
-QUALITY REQUIREMENTS:
-- Keep summaries concise but informative
-- Use active voice and clear language
-- Avoid technical jargon where possible
-- Ensure each bullet point represents meaningful work
-- Make the report valuable for both technical and non-technical readers
-- Focus on business impact and user value rather than technical implementation details
-- When consolidating, preserve the most important aspects from similar commits
-- Use progressive disclosure: start with high-level themes, then add specific details
-
-CONTEXT ANALYSIS:
-Before consolidating, analyze the commit data for:
-1. Common file patterns or system areas being modified
-2. Recurring keywords in commit messages that indicate related work
-3. Sequential commits that build upon each other
-4. Bug fixes that address the same underlying issue
-
-Generate the markdown report now:`
-  }
-
-  private buildTimePeriodReportPrompt(csvContent: string, period: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly'): string {
-    const periodDisplayName = this.getPeriodDisplayName(period)
-    const sectionHeader = this.getSectionHeader(period)
-    
-    return `Analyze the following CSV data containing git commit analysis results and generate a condensed markdown development summary report.
-
-CSV DATA:
-${csvContent}
-
-INSTRUCTIONS:
-1. Group the data by ${periodDisplayName} (descending order, most recent first)
-2. Within each ${periodDisplayName.toLowerCase()}, group by category: Features, Process Improvements, and Tweaks & Bug Fixes
-3. Use the 'commit_count' and 'similar_commits' columns to understand related work and consolidation opportunities
-4. Consolidate similar items within each category to create readable summaries
-5. Focus on what was accomplished rather than individual commit details
-6. Use clear, professional language appropriate for stakeholders
-7. Only include sections for time periods that have commits
-8. Pay attention to recurring themes and patterns across commits
-
-CATEGORY MAPPING:
-- "feature" → "Features" section
-- "process" → "Processes" section  
-- "tweak" → "Tweaks & Bug Fixes" section
-
-CONSOLIDATION GUIDELINES:
-- FIRST: Extract common themes and keywords from commit summaries within each category
-- SECOND: Identify and merge duplicate or highly similar work items (e.g., multiple "fix auth bug" commits become "resolved authentication issues")
-- Group similar features together by theme (e.g., "authentication system improvements", "payment processing enhancements")
-- Combine related bug fixes by area/system (e.g., "resolved 8 authentication issues", "fixed 5 database connection problems")
-- Summarize process changes by theme (e.g., "CI/CD pipeline enhancements", "testing infrastructure improvements")
-- Use bullet points for individual consolidated items within categories
-- Aim for 3-7 bullet points per category per ${periodDisplayName.toLowerCase()}
-- Include specific numbers when relevant (e.g., "15 bug fixes", "3 new features")
-- Avoid listing near-identical items separately - consolidate them into meaningful groups
-
-OUTPUT FORMAT:
-Generate ${periodDisplayName.toLowerCase()} summary sections with this exact structure (DO NOT include the main title or commit analysis section):
-
-\`\`\`markdown
-${sectionHeader}
-### Features
-- [Consolidated feature summary 1]
-- [Consolidated feature summary 2]
-- [Additional features as needed]
-
-### Processes
-- [Consolidated process improvement 1]
-- [Consolidated process improvement 2]
-- [Additional process items as needed]
-
-### Tweaks & Bug Fixes
-- [Consolidated tweak/fix summary 1]
-- [Consolidated tweak/fix summary 2]
-- [Additional tweaks/fixes as needed]
-
-${this.getPreviousPeriodExample(period)}
-[Repeat structure for each ${periodDisplayName.toLowerCase()} in the data]
-\`\`\`
-
-QUALITY REQUIREMENTS:
-- Keep summaries concise but informative
-- Use active voice and clear language
-- Avoid technical jargon where possible
-- Ensure each bullet point represents meaningful work
-- Make the report valuable for both technical and non-technical readers
-- Focus on business impact and user value rather than technical implementation details
-- When consolidating, preserve the most important aspects from similar commits
-- Use progressive disclosure: start with high-level themes, then add specific details
-
-CONTEXT ANALYSIS:
-Before consolidating, analyze the commit data for:
-1. Common file patterns or system areas being modified
-2. Recurring keywords in commit messages that indicate related work
-3. Sequential commits that build upon each other
-4. Bug fixes that address the same underlying issue
-
-Generate the markdown report now:`
-  }
-
-  private getPeriodDisplayName(period: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly'): string {
-    switch (period) {
-      case 'daily': return 'Daily Period'
-      case 'weekly': return 'Week'
-      case 'monthly': return 'Month'
-      case 'quarterly': return 'Quarter'
-      case 'yearly': return 'Year'
-    }
-  }
-
-  private getSectionHeader(period: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly'): string {
-    switch (period) {
-      case 'daily': return '## [DATE] [TIME_OF_DAY]'
-      case 'weekly': return '## [WEEK_RANGE]'
-      case 'monthly': return '## [MONTH] [YEAR]'
-      case 'quarterly': return '## [QUARTER] [YEAR]'
-      case 'yearly': return '## [YEAR]'
-    }
-  }
-
-  private getPreviousPeriodExample(period: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly'): string {
-    switch (period) {
-      case 'daily': return '## [PREVIOUS_DATE] [TIME_OF_DAY]'
-      case 'weekly': return '## [PREVIOUS_WEEK_RANGE]'
-      case 'monthly': return '## [PREVIOUS_MONTH] [YEAR]'
-      case 'quarterly': return '## [PREVIOUS_QUARTER] [YEAR]'
-      case 'yearly': return '## [PREVIOUS_YEAR]'
-    }
-  }
-
-  private parseReportResponse(response: string): string {
-    // Look for markdown block first
-    const markdownMatch = response.match(/```markdown\s*([\s\S]*?)\s*```/)
-    if (markdownMatch) {
-      return markdownMatch[1].trim()
-    }
-
-    // If no markdown block, look for content starting with "##" (yearly sections)
-    const yearSectionMatch = response.match(/^(##\s+\d{4}[\s\S]*)/m)
-    if (yearSectionMatch) {
-      return yearSectionMatch[1].trim()
-    }
-
-    // If no clear structure found, return the entire response but log a warning
-    if (this.verbose) {
-      console.log(
-        "  - Warning: Could not find structured yearly sections in LLM response",
-      )
-      console.log(`  - Response preview: ${response.substring(0, 200)}...`)
-    }
-
-    return response.trim()
-  }
-
-  protected truncatePrompt(prompt: string): string {
-    const maxLength = this.getMaxPromptLength()
-    if (prompt.length <= maxLength) {
-      return prompt
-    }
-
-    // Find the diff section and truncate it
-    const diffStartIndex = prompt.indexOf("COMMIT DIFF:")
-    if (diffStartIndex === -1) {
-      return prompt
-    }
-
-    const beforeDiff = prompt.substring(0, diffStartIndex)
-    const afterDiffHeader = prompt.substring(diffStartIndex)
-    const diffHeaderEnd = afterDiffHeader.indexOf("\n") + 1
-    const diffHeader = afterDiffHeader.substring(0, diffHeaderEnd)
-    const diffContent = afterDiffHeader.substring(diffHeaderEnd)
-
-    // Calculate how much space we have for the diff
-    const overhead = beforeDiff.length + diffHeader.length + 500 // Leave some buffer
-    const maxDiffLength = Math.max(1000, maxLength - overhead)
-
-    if (diffContent.length > maxDiffLength) {
-      const truncatedDiff = diffContent.substring(0, maxDiffLength)
-      const truncationNotice =
-        "\n\n[DIFF TRUNCATED - Original length: " +
-        diffContent.length +
-        " characters]"
-
-      return (
-        beforeDiff +
-        diffHeader +
-        truncatedDiff +
-        truncationNotice +
-        "\n\nBased on the commit message and code changes, categorize this commit..."
-      )
-    }
-
-    return prompt
-  }
-}

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

@@ -1,38 +0,0 @@
-import { Analysis } from "@domain/analysis"
-import { Category } from "@domain/category"
-import { Commit } from "@domain/commit"
-
-import { ILLMService } from "@app/llm-service"
-
-import { IAnalysisRepository } from "@presentation/analysis-repository.interface"
-
-export class LLMAnalysisRepository implements IAnalysisRepository {
-  constructor(private readonly llmService: ILLMService) {}
-
-  async analyze(commit: Commit): Promise<Analysis> {
-    const result = await this.llmService.analyzeCommit(
-      commit.getMessage(),
-      commit.getDiff(),
-    )
-
-    const category = Category.fromType(result.category)
-
-    return new Analysis({
-      category,
-      summary: result.summary,
-      description: result.description,
-    })
-  }
-
-  async isAvailable(): Promise<boolean> {
-    return this.llmService.isAvailable()
-  }
-
-  getMaxRetries(): number {
-    return this.llmService.getMaxRetries()
-  }
-
-  setVerbose(verbose: boolean): void {
-    this.llmService.setVerbose(verbose)
-  }
-}

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

@@ -1,57 +0,0 @@
-import { execSync } from "child_process"
-
-import { LLMAdapter } from "./llm-adapter"
-
-export class OpenAILLMAdapter extends LLMAdapter {
-  private static readonly MAX_PROMPT_LENGTH = parseInt(
-    process.env.OPENAI_MAX_PROMPT_LENGTH || "100000",
-    10,
-  )
-
-  protected getMaxPromptLength(): number {
-    return OpenAILLMAdapter.MAX_PROMPT_LENGTH
-  }
-
-  async detectAvailableModels(): Promise<string[]> {
-    try {
-      execSync("command -v codex", { stdio: "ignore" })
-      return ["codex -q", "openai"]
-    } 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 || "codex -q"
-
-    // Handle codex -q quirk: requires prompt as command line argument
-    if (modelCommand.includes("-q")) {
-      const escapedPrompt = truncatedPrompt.replace(/"/g, '\\"')
-      return execSync(`${modelCommand} "${escapedPrompt}"`, {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: LLMAdapter.DEFAULT_TIMEOUT,
-      })
-    }
-
-    // Fallback for non-quiet mode commands
-    return execSync(modelCommand, {
-      input: truncatedPrompt,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: LLMAdapter.DEFAULT_TIMEOUT,
-    })
-  }
-}
-

package/src/di.ts

@@ -1,109 +0,0 @@
-import { CommitAnalysisService } from "@domain/commit-analysis-service"
-import { DateFormattingService } from "@domain/date-formatting-service"
-import { ReportGenerationService } from "@domain/report-generation-service"
-
-import { AnalyzeCommitsUseCase } from "@app/analyze-commits.usecase"
-import { GenerateReportUseCase } from "@app/generate-report.usecase"
-import { ResumeAnalysisUseCase } from "@app/resume-analysis.usecase"
-
-import { AnalyzeCommand } from "@presentation/analyze-command"
-import { CLIApplication } from "@presentation/cli-application"
-import { CommitAnalysisController } from "@presentation/commit-analysis-controller"
-import { ReportCommand } from "@presentation/report-command"
-import { ResumeCommand } from "@presentation/resume-command"
-
-import { CacheService } from "@infra/cache-service"
-import { CachedAnalysisRepository } from "@infra/cached-analysis-repository"
-import { FileStorageRepository } from "@infra/file-storage-repository"
-import { FileSystemStorageAdapter } from "@infra/file-system-storage-adapter"
-import { GitAdapter } from "@infra/git-adapter"
-import { GitCommitRepository } from "@infra/git-commit-repository"
-import { JSONProgressTracker } from "@infra/json-progress-tracker"
-import { LLMAdapterFactory } from "@infra/llm-adapter-factory"
-import { LLMAnalysisRepository } from "@infra/llm-analysis-repository"
-
-export interface DIContainerOptions {
-  llm?: string
-  noCache?: boolean
-}
-
-export class DIContainer {
-  private readonly gitAdapter = new GitAdapter()
-  private readonly llmAdapter = LLMAdapterFactory.create(this.options?.llm)
-  private readonly storageAdapter = new FileSystemStorageAdapter()
-  private readonly cacheService = (() => {
-    const service = new CacheService()
-    if (this.options?.noCache) {
-      service.setCacheEnabled(false)
-    }
-    return service
-  })()
-  private readonly progressTracker = new JSONProgressTracker(
-    this.storageAdapter,
-  )
-
-  private readonly commitRepository = new GitCommitRepository(this.gitAdapter)
-  private readonly llmAnalysisRepository = new LLMAnalysisRepository(
-    this.llmAdapter,
-  )
-  private readonly analysisRepository = this.options?.noCache
-    ? this.llmAnalysisRepository
-    : new CachedAnalysisRepository(
-        this.llmAnalysisRepository,
-        this.cacheService,
-      )
-  private readonly storageRepository = new FileStorageRepository(
-    this.storageAdapter,
-  )
-
-  private readonly commitAnalysisService = new CommitAnalysisService(
-    this.commitRepository,
-    this.analysisRepository,
-  )
-  private readonly reportGenerationService = new ReportGenerationService()
-  private readonly dateFormattingService = new DateFormattingService()
-
-  private readonly analyzeCommitsUseCase = new AnalyzeCommitsUseCase(
-    this.commitAnalysisService,
-    this.progressTracker,
-    this.storageRepository,
-  )
-
-  private readonly generateReportUseCase = new GenerateReportUseCase(
-    this.reportGenerationService,
-    this.storageRepository,
-    this.llmAdapter,
-    this.dateFormattingService,
-    this.gitAdapter,
-  )
-
-  private readonly resumeAnalysisUseCase = new ResumeAnalysisUseCase(
-    this.progressTracker,
-    this.analyzeCommitsUseCase,
-  )
-
-  private readonly analyzeCommand = new AnalyzeCommand(
-    this.analyzeCommitsUseCase,
-    this.commitAnalysisService,
-    this.commitRepository,
-  )
-  private readonly reportCommand = new ReportCommand(this.generateReportUseCase)
-  private readonly resumeCommand = new ResumeCommand(this.resumeAnalysisUseCase)
-
-  private readonly controller = new CommitAnalysisController(
-    this.analyzeCommand,
-    this.reportCommand,
-    this.resumeCommand,
-    this.progressTracker,
-    this.cacheService,
-    this.commitRepository,
-  )
-
-  private readonly application = new CLIApplication(this.controller)
-
-  constructor(private readonly options?: DIContainerOptions) {}
-
-  getApplication(): CLIApplication {
-    return this.application
-  }
-}