commit-analyzer 1.0.3 → 1.1.1

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.3")
-      .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
-    `)
-  }
-}

package/src/csv-reader.ts

@@ -1,180 +0,0 @@
-import { readFileSync } from "fs"
-
-export interface ParsedCSVRow {
-  year: number
-  category: "tweak" | "feature" | "process"
-  summary: string
-  description: string
-}
-
-export class CSVReaderService {
-  static readCSV(filename: string): ParsedCSVRow[] {
-    try {
-      const content = readFileSync(filename, "utf8")
-      return this.parseCSV(content)
-    } catch (error) {
-      throw new Error(
-        `Failed to read CSV file ${filename}: ${error instanceof Error ? error.message : "Unknown error"}`,
-      )
-    }
-  }
-
-  private static parseCSV(content: string): ParsedCSVRow[] {
-    const lines = content.trim().split("\n")
-
-    if (lines.length === 0) {
-      throw new Error("CSV file is empty")
-    }
-
-    // Validate header
-    const header = lines[0].toLowerCase()
-    const expectedHeader = "year,category,summary,description"
-    if (header !== expectedHeader) {
-      throw new Error(
-        `Invalid CSV format. Expected header: "${expectedHeader}", got: "${header}"`,
-      )
-    }
-
-    const rows: ParsedCSVRow[] = []
-
-    for (let i = 1; i < lines.length; i++) {
-      const line = lines[i].trim()
-      if (line === "") continue // Skip empty lines
-
-      try {
-        const row = this.parseCSVLine(line, i + 1)
-        rows.push(row)
-      } catch (error) {
-        throw new Error(
-          `Error parsing CSV line ${i + 1}: ${error instanceof Error ? error.message : "Unknown error"}`,
-        )
-      }
-    }
-
-    return rows
-  }
-
-  private static parseCSVLine(line: string, lineNumber: number): ParsedCSVRow {
-    const fields = this.parseCSVFields(line)
-
-    if (fields.length !== 4) {
-      throw new Error(
-        `Expected 4 fields (year,category,summary,description), got ${fields.length}`,
-      )
-    }
-
-    const [yearStr, category, summary, description] = fields
-
-    // Validate year
-    const year = parseInt(yearStr, 10)
-    if (isNaN(year) || year < 1900 || year > 2100) {
-      throw new Error(`Invalid year: ${yearStr}`)
-    }
-
-    // Validate category
-    if (!this.isValidCategory(category)) {
-      throw new Error(
-        `Invalid category: ${category}. Must be one of: tweak, feature, process`,
-      )
-    }
-
-    // Validate required fields
-    if (!summary.trim()) {
-      throw new Error("Summary field cannot be empty")
-    }
-
-    if (!description.trim()) {
-      throw new Error("Description field cannot be empty")
-    }
-
-    return {
-      year,
-      category: category as "tweak" | "feature" | "process",
-      summary: summary.trim(),
-      description: description.trim(),
-    }
-  }
-
-  /**
-   * Parse CSV fields handling quoted fields with commas and escaped quotes
-   */
-  private static parseCSVFields(line: string): string[] {
-    const fields: string[] = []
-    let currentField = ""
-    let inQuotes = false
-    let i = 0
-
-    while (i < line.length) {
-      const char = line[i]
-      const nextChar = line[i + 1]
-
-      if (char === '"') {
-        if (inQuotes && nextChar === '"') {
-          // Escaped quote inside quoted field
-          currentField += '"'
-          i += 2
-        } else {
-          // Start or end of quoted field
-          inQuotes = !inQuotes
-          i++
-        }
-      } else if (char === "," && !inQuotes) {
-        // Field separator outside quotes
-        fields.push(currentField)
-        currentField = ""
-        i++
-      } else {
-        // Regular character
-        currentField += char
-        i++
-      }
-    }
-
-    // Add the last field
-    fields.push(currentField)
-
-    return fields
-  }
-
-  private static isValidCategory(
-    category: string,
-  ): category is "tweak" | "feature" | "process" {
-    return ["tweak", "feature", "process"].includes(category)
-  }
-
-  /**
-   * Get summary statistics about the CSV data
-   */
-  static getStatistics(rows: ParsedCSVRow[]): {
-    totalRows: number
-    yearRange: { min: number; max: number }
-    categoryBreakdown: Record<string, number>
-  } {
-    if (rows.length === 0) {
-      return {
-        totalRows: 0,
-        yearRange: { min: 0, max: 0 },
-        categoryBreakdown: { tweak: 0, feature: 0, process: 0 },
-      }
-    }
-
-    const years = rows.map((row) => row.year)
-    const categoryBreakdown = rows.reduce(
-      (acc, row) => {
-        acc[row.category]++
-        return acc
-      },
-      { tweak: 0, feature: 0, process: 0 } as Record<string, number>,
-    )
-
-    return {
-      totalRows: rows.length,
-      yearRange: {
-        min: Math.min(...years),
-        max: Math.max(...years),
-      },
-      categoryBreakdown,
-    }
-  }
-}
-

package/src/csv.ts

@@ -1,40 +0,0 @@
-import { writeFileSync } from "fs"
-import { AnalyzedCommit, CSVRow } from "./types"
-
-export class CSVService {
-  static generateCSV(commits: AnalyzedCommit[]): string {
-    const headers = "year,category,summary,description"
-    const rows = commits.map((commit) => this.formatRow(commit))
-
-    return [headers, ...rows].join("\n")
-  }
-
-  static exportToFile(commits: AnalyzedCommit[], filename: string): void {
-    const csvContent = this.generateCSV(commits)
-    writeFileSync(filename, csvContent, "utf8")
-  }
-
-  private static formatRow(commit: AnalyzedCommit): string {
-    const row: CSVRow = {
-      year: commit.year,
-      category: commit.analysis.category,
-      summary: commit.analysis.summary,
-      description: commit.analysis.description,
-    }
-
-    return [
-      row.year,
-      this.escapeCsvField(row.category),
-      this.escapeCsvField(row.summary),
-      this.escapeCsvField(row.description),
-    ].join(",")
-  }
-
-  private static escapeCsvField(field: string): string {
-    if (field.includes(",") || field.includes('"') || field.includes("\n")) {
-      return `"${field.replace(/"/g, '""')}"`
-    }
-    return field
-  }
-}
-