commit-analyzer 1.0.2 → 1.1.0

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

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

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

package/src/main.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env bun
+
+import { ApplicationError } from "@domain/application-error"
+
+import { ConsoleFormatter } from "@presentation/console-formatter"
+
+import { DIContainer } from "./di"
+
+async function main(): Promise<void> {
+  try {
+    // Extract options from command line args before creating container
+    const llmOption = extractLLMOption(process.argv)
+    const noCacheOption = extractNoCacheOption(process.argv)
+    const container = new DIContainer({ 
+      llm: llmOption,
+      noCache: noCacheOption 
+    })
+    const app = container.getApplication()
+
+    await app.run(process.argv)
+  } catch (error) {
+    if (error instanceof ApplicationError) {
+      ConsoleFormatter.logError(`[${error.code}]: ${error.message}`)
+      process.exit(1)
+    }
+
+    if (error instanceof Error) {
+      ConsoleFormatter.logError(`Unexpected error: ${error.message}`)
+      process.exit(1)
+    }
+
+    ConsoleFormatter.logError("Unknown error occurred")
+    process.exit(1)
+  }
+}
+
+/**
+ * Extract the --llm option from command line arguments
+ * This is needed before creating the DI container
+ */
+function extractLLMOption(args: string[]): string | undefined {
+  const llmIndex = args.findIndex(arg => arg === '--llm')
+  if (llmIndex !== -1 && llmIndex + 1 < args.length) {
+    return args[llmIndex + 1]
+  }
+  return undefined
+}
+
+/**
+ * Extract the --no-cache option from command line arguments
+ * This is needed before creating the DI container
+ */
+function extractNoCacheOption(args: string[]): boolean {
+  return args.includes('--no-cache')
+}
+
+// Run the application if this file is executed directly
+if (require.main === module) {
+  main().catch((error) => {
+    ConsoleFormatter.logError(`Failed to bootstrap application: ${error}`)
+    process.exit(1)
+  })
+}

package/src/utils/app-paths.ts

@@ -0,0 +1,36 @@
+import path from "path"
+
+/**
+ * Utility for managing application data directory paths
+ */
+export class AppPaths {
+  private static readonly APP_DATA_DIR = ".commit-analyzer"
+  
+  /**
+   * Get the application data directory path
+   */
+  static getAppDataDir(baseDir: string = process.cwd()): string {
+    return path.join(baseDir, AppPaths.APP_DATA_DIR)
+  }
+  
+  /**
+   * Get the cache directory path
+   */
+  static getCacheDir(baseDir: string = process.cwd()): string {
+    return path.join(AppPaths.getAppDataDir(baseDir), "cache")
+  }
+  
+  /**
+   * Get the progress file path
+   */
+  static getProgressFilePath(baseDir: string = process.cwd()): string {
+    return path.join(AppPaths.getAppDataDir(baseDir), "progress.json")
+  }
+  
+  /**
+   * Get any file path within the app data directory
+   */
+  static getAppDataFilePath(fileName: string, baseDir: string = process.cwd()): string {
+    return path.join(AppPaths.getAppDataDir(baseDir), fileName)
+  }
+}

package/src/utils/concurrency.ts

@@ -0,0 +1,81 @@
+/**
+ * Utility for managing concurrent operations with semaphore-like behavior
+ */
+export class ConcurrencyManager {
+  private running = 0
+  private queue: (() => void)[] = []
+
+  constructor(private readonly maxConcurrency: number) {}
+
+  /**
+   * Execute a function with concurrency control
+   */
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const runTask = async () => {
+        this.running++
+        try {
+          const result = await fn()
+          resolve(result)
+        } catch (error) {
+          reject(error)
+        } finally {
+          this.running--
+          this.processQueue()
+        }
+      }
+
+      if (this.running < this.maxConcurrency) {
+        runTask()
+      } else {
+        this.queue.push(runTask)
+      }
+    })
+  }
+
+  private processQueue(): void {
+    if (this.queue.length > 0 && this.running < this.maxConcurrency) {
+      const nextTask = this.queue.shift()!
+      nextTask()
+    }
+  }
+}
+
+/**
+ * Process items in parallel with controlled concurrency
+ */
+export async function processInParallel<T, R>(
+  items: T[],
+  processor: (item: T, index: number) => Promise<R>,
+  maxConcurrency: number = 5
+): Promise<R[]> {
+  const manager = new ConcurrencyManager(maxConcurrency)
+  const promises = items.map((item, index) =>
+    manager.execute(() => processor(item, index))
+  )
+  return Promise.all(promises)
+}
+
+/**
+ * Process items in batches with parallel processing within each batch
+ */
+export async function processInBatches<T, R>(
+  items: T[],
+  processor: (item: T, index: number) => Promise<R>,
+  batchSize: number = 10,
+  maxConcurrencyPerBatch: number = 5
+): Promise<R[]> {
+  const results: R[] = []
+  
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize)
+    const batchResults = await processInParallel(
+      batch,
+      (item, batchIndex) => processor(item, i + batchIndex),
+      maxConcurrencyPerBatch
+    )
+    results.push(...batchResults)
+  }
+  
+  return results
+}

package/src/utils.ts

@@ -0,0 +1,77 @@
+import readline from "readline"
+
+/**
+ * Common utility functions used across the application
+ */
+
+/**
+ * Extracts error message from unknown error type
+ */
+export function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Unknown error"
+}
+
+/**
+ * Creates a promise-based readline interface for user input
+ */
+export function createPromiseReadline(): {
+  question: (prompt: string) => Promise<string>
+  close: () => void
+} {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+
+  return {
+    question: (prompt: string): Promise<string> => {
+      return new Promise((resolve) => {
+        rl.question(prompt, (answer: string) => {
+          resolve(answer.trim())
+        })
+      })
+    },
+    close: () => rl.close(),
+  }
+}
+
+/**
+ * Sleep utility for async delays
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Formats file size in human readable format
+ */
+export function formatFileSize(bytes: number): string {
+  const units = ["B", "KB", "MB", "GB"]
+  let size = bytes
+  let unitIndex = 0
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024
+    unitIndex++
+  }
+
+  return `${size.toFixed(1)} ${units[unitIndex]}`
+}
+
+/**
+ * Truncates text to specified length with ellipsis
+ */
+export function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) {
+    return text
+  }
+  return text.substring(0, maxLength - 3) + "..."
+}
+
+/**
+ * Calculates percentage with proper rounding
+ */
+export function calculatePercentage(part: number, total: number): number {
+  if (total === 0) return 0
+  return Math.round((part / total) * 100)
+}

package/tsconfig.json

@@ -12,7 +12,13 @@
     "resolveJsonModule": true,
     "declaration": true,
     "declarationMap": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "paths": {
+      "@domain/*": ["./src/1.domain/*"],
+      "@app/*": ["./src/2.application/*"],
+      "@presentation/*": ["./src/3.presentation/*"],
+      "@infra/*": ["./src/4.infrastructure/*"]
+    }
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/src/cli.ts

@@ -1,170 +0,0 @@
-import { readFileSync, mkdirSync } from "fs"
-import { Command } from "commander"
-import { join, dirname } from "path"
-
-export interface CLIOptions {
-  output?: string
-  outputDir?: string
-  file?: string
-  commits: string[]
-  author?: string
-  limit?: number
-  useDefaults: boolean
-  resume?: boolean
-  clear?: boolean
-  model?: string
-  report?: boolean
-  inputCsv?: string
-  verbose?: boolean
-}
-
-export class CLIService {
-  static parseArguments(): CLIOptions {
-    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("1.0.2")
-      .option("-o, --output <file>", "Output CSV file (default: commits.csv)")
-      .option(
-        "--output-dir <dir>",
-        "Output directory for CSV and report files (default: current directory)",
-      )
-      .option(
-        "-f, --file <file>",
-        "Read commit hashes from file (one per line)",
-      )
-      .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("-m, --model <model>", "LLM model to use (claude, gemini, codex)")
-      .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)",
-      )
-      .argument(
-        "[commits...]",
-        "Commit hashes to analyze (if none provided, uses current user's commits)",
-      )
-      .parse()
-
-    const options = program.opts()
-    const args = program.args
-
-    let commits: string[] = []
-    let useDefaults = false
-
-    if (options.file) {
-      commits = this.readCommitsFromFile(options.file)
-    } else if (args.length > 0) {
-      commits = args
-    } else {
-      useDefaults = true
-    }
-
-    return {
-      output:
-        options.output ||
-        CLIService.resolveOutputPath("commits.csv", options.outputDir),
-      outputDir: options.outputDir,
-      file: options.file,
-      commits,
-      author: options.author,
-      limit: options.limit,
-      useDefaults,
-      resume: options.resume,
-      clear: options.clear,
-      model: options.model,
-      report: options.report,
-      inputCsv: options.inputCsv,
-      verbose: options.verbose,
-    }
-  }
-
-  private static readCommitsFromFile(filename: string): string[] {
-    try {
-      const content = readFileSync(filename, "utf8")
-      return content
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0)
-    } catch (error) {
-      throw new Error(
-        `Failed to read commits from file ${filename}: ${error instanceof Error ? error.message : "Unknown error"}`,
-      )
-    }
-  }
-
-  /**
-   * Resolve the full file path with optional output directory.
-   */
-  static resolveOutputPath(filename: string, outputDir?: string): string {
-    if (outputDir) {
-      // Ensure output directory exists
-      try {
-        mkdirSync(outputDir, { recursive: true })
-      } catch (error) {
-        throw new Error(
-          `Failed to create output directory ${outputDir}: ${error instanceof Error ? error.message : "Unknown error"}`,
-        )
-      }
-      return join(outputDir, filename)
-    }
-    return filename
-  }
-
-  static showHelp(): void {
-    console.log(`
-Usage: commit-analyzer [options] [commits...]
-
-Analyze git commits and generate categorized summaries using LLM.
-If no commits are specified, analyzes all commits authored by the current user.
-
-Options:
-  -o, --output <file>     Output file (default: commits.csv for analysis, report.md for reports)
-  --output-dir <dir>      Output directory for CSV and report files (default: current directory)
-  -f, --file <file>       Read commit hashes from file (one per line)
-  -a, --author <email>  Filter commits by author email (defaults to current user)
-  -l, --limit <number>  Limit number of commits to analyze
-  -r, --resume          Resume from last checkpoint if available
-  -c, --clear           Clear any existing progress checkpoint
-  --report              Generate condensed markdown report from existing CSV
-  --input-csv <file>    Input CSV file to read for report generation
-  -v, --verbose         Enable verbose logging (shows detailed error information)
-  -h, --help           Display help for command
-  -V, --version        Display version number
-
-Examples:
-  commit-analyzer                                    # Analyze your authored commits
-  commit-analyzer --limit 10                         # Analyze your last 10 commits
-  commit-analyzer --author user@example.com          # Analyze specific user's commits
-  commit-analyzer abc123 def456 ghi789               # Analyze specific commits
-  commit-analyzer --file commits.txt                 # Read commits from file
-  commit-analyzer --output analysis.csv --limit 20   # Analyze last 20 commits to custom file
-  commit-analyzer --resume                           # Resume from last checkpoint
-  commit-analyzer --clear                            # Clear checkpoint and start fresh
-  commit-analyzer --report                           # Analyze commits, generate CSV, then generate report
-  commit-analyzer --input-csv data.csv --report      # Skip analysis, generate report from existing CSV
-  commit-analyzer --report -o custom-report.md       # Analyze commits, generate CSV, then generate custom report
-    `)
-  }
-}