commit-analyzer 1.1.4 → 1.1.6

package/src/main.ts

@@ -1,63 +0,0 @@
-#!/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

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

@@ -1,81 +0,0 @@
-/**
- * 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

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

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "lib": ["ES2020"],
-    "module": "commonjs",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": 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"]
-}