commit-analyzer 1.1.4 → 1.1.6

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

@@ -1,46 +0,0 @@
-import { Analysis } from "@domain/analysis"
-import { Commit } from "@domain/commit"
-
-import { IAnalysisRepository } from "@presentation/analysis-repository.interface"
-
-import { CacheService } from "./cache-service"
-
-/**
- * Cached analysis repository that wraps another analysis repository
- */
-export class CachedAnalysisRepository implements IAnalysisRepository {
-  constructor(
-    private readonly baseRepository: IAnalysisRepository,
-    private readonly cacheService: CacheService,
-  ) {}
-
-  async analyze(commit: Commit): Promise<Analysis> {
-    const commitHash = commit.getHash().getValue()
-
-    // Try to get from cache first
-    const cachedAnalysis = await this.cacheService.get(commitHash)
-    if (cachedAnalysis) {
-      return cachedAnalysis
-    }
-
-    // Cache miss - analyze with base repository
-    const analysis = await this.baseRepository.analyze(commit)
-
-    // Store in cache for next time
-    await this.cacheService.set(commitHash, analysis)
-
-    return analysis
-  }
-
-  async isAvailable(): Promise<boolean> {
-    return this.baseRepository.isAvailable()
-  }
-
-  getMaxRetries(): number {
-    return this.baseRepository.getMaxRetries()
-  }
-
-  setVerbose(verbose: boolean): void {
-    this.baseRepository.setVerbose(verbose)
-  }
-}

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

@@ -1,124 +0,0 @@
-import { execSync } from "child_process"
-
-import { CategoryType } from "@domain/category"
-
-import { LLMAdapter } from "./llm-adapter"
-
-export class ClaudeLLMAdapter extends LLMAdapter {
-  private static readonly MAX_PROMPT_LENGTH = parseInt(
-    process.env.CLAUDE_MAX_PROMPT_LENGTH || "100000",
-    10,
-  )
-
-  protected getMaxPromptLength(): number {
-    return ClaudeLLMAdapter.MAX_PROMPT_LENGTH
-  }
-
-  async detectAvailableModels(): Promise<string[]> {
-    try {
-      execSync("command -v claude", { stdio: "ignore" })
-      return ["claude", "claude --model sonnet", "claude --model haiku"]
-    } 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 || "claude --model sonnet"
-
-    return execSync(modelCommand, {
-      input: truncatedPrompt,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: LLMAdapter.DEFAULT_TIMEOUT,
-    })
-  }
-
-  protected parseResponse(response: string): {
-    category: CategoryType
-    summary: string
-    description: string
-  } {
-    try {
-      // First try standard JSON parsing
-      return super.parseResponse(response)
-    } catch {
-      // Claude often responds in natural language format, so try to parse that
-      if (this.verbose) {
-        console.log(`  - Standard JSON parsing failed, trying Claude natural language parsing...`)
-      }
-      return this.parseClaudeNaturalLanguageResponse(response)
-    }
-  }
-
-  private parseClaudeNaturalLanguageResponse(response: string): {
-    category: CategoryType
-    summary: string
-    description: string
-  } {
-    // Try to extract category from various Claude response patterns
-    const categoryMatch = response.match(/\*\*?Category\*\*?:?\s*(tweak|feature|process)/i) ||
-                         response.match(/Category:\s*(tweak|feature|process)/i) ||
-                         response.match(/\*\*(tweak|feature|process)\*\*/i) ||
-                         response.match(/(tweak|feature|process)\s*commit/i) ||
-                         response.match(/should be categorized as[:\s]*\*\*?(tweak|feature|process)/i)
-    const category = categoryMatch?.[1]?.toLowerCase()
-
-    if (!category || !this.isValidCategory(category)) {
-      if (this.verbose) {
-        console.log(`  - Failed to extract category from Claude response`)
-        console.log(`  - Response snippet: ${response.substring(0, 500)}`)
-      }
-      throw new Error(`Could not extract valid category from Claude response`)
-    }
-
-    // Try to extract summary from patterns
-    const summaryMatch = response.match(/\*\*?Summary\*\*?:?\s*([^\n\r]+)/i) ||
-                        response.match(/Summary:\s*([^\n\r]+)/i)
-    let summary = summaryMatch?.[1]?.trim()
-    
-    if (!summary) {
-      // Fallback: try to find a descriptive line
-      const lines = response.split('\n').filter(line => line.trim())
-      summary = lines.find(line => 
-        line.includes('refactor') || 
-        line.includes('add') || 
-        line.includes('fix') ||
-        line.includes('update') ||
-        line.includes('implement')
-      )?.trim() || "Code changes"
-    }
-
-    // Try to extract description
-    const descMatch = response.match(/\*\*?Description\*\*?:?\s*([\s\S]+?)(?=\n\n|\n\*\*|\n---|\n#|$)/i) ||
-                     response.match(/Description:\s*([\s\S]+?)(?=\n\n|\n\*\*|\n---|\n#|$)/i)
-    let description = descMatch?.[1]?.trim()
-    
-    if (!description) {
-      // Fallback: extract the longest meaningful sentence
-      const sentences = response.split(/[.!?]+/).filter(s => s.trim().length > 20)
-      description = sentences[0]?.trim() || "Commit contains code changes"
-    }
-
-    // Clean up and truncate
-    summary = summary.substring(0, 80).replace(/[*"]/g, '').trim()
-    description = description.replace(/[*"]/g, '').trim()
-
-    return {
-      category: category as CategoryType,
-      summary: summary || "Code changes",
-      description: description || "This commit contains code changes."
-    }
-  }
-}

package/src/4.infrastructure/csv-service.ts

@@ -1,252 +0,0 @@
-import { Analysis } from "@domain/analysis"
-import { AnalyzedCommit } from "@domain/analyzed-commit"
-import { Category } from "@domain/category"
-import { Commit } from "@domain/commit"
-import { CommitHash } from "@domain/commit-hash"
-
-import { IStorageService } from "@presentation/storage-service.interface"
-
-export class CSVService {
-  private static readonly CSV_HEADERS = "timestamp,category,summary,description"
-  private static readonly CSV_SPECIAL_CHARS = [",", '"', "\n"]
-
-  constructor(private readonly storageService: IStorageService) {}
-
-  async exportToCSV(
-    commits: AnalyzedCommit[],
-    filePath: string,
-  ): Promise<void> {
-    const csvContent = this.generateCSV(commits)
-    await this.storageService.writeFile(filePath, csvContent)
-  }
-
-  async importFromCSV(filePath: string): Promise<AnalyzedCommit[]> {
-    const content = await this.storageService.readFile(filePath)
-    return this.parseCSV(content)
-  }
-
-  private generateCSV(commits: AnalyzedCommit[]): string {
-    const rows = commits.map((commit) => this.formatRow(commit))
-    return [CSVService.CSV_HEADERS, ...rows].join("\n")
-  }
-
-  private formatRow(commit: AnalyzedCommit): string {
-    const row = commit.toCSVRow()
-    return this.joinCsvFields(row)
-  }
-
-  private joinCsvFields(row: {
-    timestamp: string
-    category: string
-    summary: string
-    description: string
-  }): string {
-    return [
-      row.timestamp,
-      this.escapeCsvField(row.category),
-      this.escapeCsvField(row.summary),
-      this.escapeCsvField(row.description),
-    ].join(",")
-  }
-
-  private escapeCsvField(field: string): string {
-    if (this.needsEscaping(field)) {
-      return this.escapeAndQuoteField(field)
-    }
-    return field
-  }
-
-  private needsEscaping(field: string): boolean {
-    return CSVService.CSV_SPECIAL_CHARS.some((char) => field.includes(char))
-  }
-
-  private escapeAndQuoteField(field: string): string {
-    return `"${field.replace(/"/g, '""')}"`
-  }
-
-  /**
-   * Split CSV content into rows, properly handling quoted fields that may contain newlines
-   */
-  private splitCSVIntoRows(content: string): string[] {
-    const rows: string[] = []
-    let currentRow = ""
-    let inQuotes = false
-    let i = 0
-
-    while (i < content.length) {
-      const char = content[i]
-      const nextChar = content[i + 1]
-
-      if (char === '"') {
-        if (inQuotes && nextChar === '"') {
-          // Escaped quote inside quoted field
-          currentRow += '""'
-          i += 2
-        } else {
-          // Start or end of quoted field
-          inQuotes = !inQuotes
-          currentRow += '"'
-          i++
-        }
-      } else if (char === "\n" && !inQuotes) {
-        // Row separator outside quotes
-        if (currentRow.trim().length > 0) {
-          rows.push(currentRow)
-        }
-        currentRow = ""
-        i++
-      } else {
-        // Regular character (including newlines inside quotes)
-        currentRow += char
-        i++
-      }
-    }
-
-    // Add the last row if it exists
-    if (currentRow.trim().length > 0) {
-      rows.push(currentRow)
-    }
-
-    return rows
-  }
-
-  private parseCSV(content: string): AnalyzedCommit[] {
-    const rows = this.splitCSVIntoRows(content)
-
-    if (rows.length < 2) {
-      throw new Error("Invalid CSV format: no data rows found")
-    }
-
-    // Validate header
-    const header = rows[0].toLowerCase()
-    const expectedHeader = "timestamp,category,summary,description"
-    if (header !== expectedHeader) {
-      throw new Error(
-        `Invalid CSV format. Expected header: "${expectedHeader}", got: "${header}"`,
-      )
-    }
-
-    // Skip header row
-    const dataRows = rows.slice(1)
-    const commits: AnalyzedCommit[] = []
-
-    for (let i = 0; i < dataRows.length; i++) {
-      const row = dataRows[i]
-      try {
-        const commit = this.parseCSVRow(row)
-        commits.push(commit)
-      } catch (error) {
-        console.warn(`Warning: Failed to parse CSV row ${i + 2}: ${row}`)
-        console.warn(`Error: ${error}`)
-      }
-    }
-
-    return commits
-  }
-
-  private parseCSVRow(row: string): AnalyzedCommit {
-    const fields = this.parseCSVFields(row)
-
-    if (fields.length !== 4) {
-      throw new Error(
-        `Expected 4 fields (timestamp,category,summary,description), got ${fields.length}`,
-      )
-    }
-
-    const [timestampStr, category, summary, description] = fields
-
-    // Validate timestamp
-    const timestamp = new Date(timestampStr)
-    if (isNaN(timestamp.getTime())) {
-      throw new Error(`Invalid timestamp: ${timestampStr}`)
-    }
-
-    // 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")
-    }
-
-    // Create a minimal commit object for CSV import
-    // We'll use placeholder values for hash and diff since they're not in the CSV
-    const placeholderHash = CommitHash.create(
-      "0000000000000000000000000000000000000000",
-    )
-    const placeholderDiff = "# Placeholder diff for CSV import\n+1\n-0" // Minimal valid diff
-    const placeholderMessage = summary // Use summary as message
-
-    const commit = new Commit({
-      hash: placeholderHash,
-      message: placeholderMessage,
-      date: timestamp, // Use actual timestamp from CSV
-      diff: placeholderDiff,
-    })
-
-    // Create analysis from CSV data
-    const analysisCategory = Category.create(category)
-    const analysis = new Analysis({
-      category: analysisCategory,
-      summary: summary.trim(),
-      description: description.trim(),
-    })
-
-    return new AnalyzedCommit(commit, analysis)
-  }
-
-  /**
-   * Parse CSV fields handling quoted fields with commas and escaped quotes
-   */
-  private 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 isValidCategory(
-    category: string,
-  ): category is "tweak" | "feature" | "process" {
-    return ["tweak", "feature", "process"].includes(category)
-  }
-}

package/src/4.infrastructure/file-storage-repository.ts

@@ -1,108 +0,0 @@
-import { AnalyzedCommit } from "@domain/analyzed-commit"
-
-import { IStorageRepository } from "@presentation/storage-repository.interface"
-import { IStorageService } from "@presentation/storage-service.interface"
-
-import { CSVService } from "./csv-service"
-
-export class FileStorageRepository implements IStorageRepository {
-  private readonly csvService: CSVService
-
-  constructor(private readonly storageService: IStorageService) {
-    this.csvService = new CSVService(storageService)
-  }
-
-  async exportToCSV(
-    commits: AnalyzedCommit[],
-    filePath: string,
-  ): Promise<void> {
-    await this.csvService.exportToCSV(commits, filePath)
-  }
-
-  async importFromCSV(filePath: string): Promise<AnalyzedCommit[]> {
-    return this.csvService.importFromCSV(filePath)
-  }
-
-  async generateReport(
-    commits: AnalyzedCommit[],
-    outputPath: string,
-  ): Promise<void> {
-    // Generate markdown report content
-    const reportContent = this.generateMarkdownReport(commits)
-    await this.storageService.writeFile(outputPath, reportContent)
-  }
-
-  async readCommitHashesFromFile(filePath: string): Promise<string[]> {
-    return this.storageService.readLines(filePath)
-  }
-
-  async ensureDirectoryExists(directoryPath: string): Promise<void> {
-    await this.storageService.ensureDirectory(directoryPath)
-  }
-
-  async writeFile(filePath: string, content: string): Promise<void> {
-    await this.storageService.writeFile(filePath, content)
-  }
-
-  private generateMarkdownReport(commits: AnalyzedCommit[]): string {
-    let content = "# Development Summary Report\n\n"
-
-    // Basic statistics
-    const totalCommits = commits.length
-    const years = commits.map((c) => c.getYear())
-    const minYear = Math.min(...years)
-    const maxYear = Math.max(...years)
-
-    const categoryBreakdown = commits.reduce(
-      (acc, commit) => {
-        const category = commit.getAnalysis().getCategory().getValue()
-        acc[category] = (acc[category] || 0) + 1
-        return acc
-      },
-      {} as Record<string, number>,
-    )
-
-    content += `## Analysis Summary\n\n`
-    content += `**Total Commits Analyzed:** ${totalCommits}\n`
-    content += `**Time Period:** ${minYear} - ${maxYear}\n\n`
-
-    content += `### Breakdown by Category\n\n`
-    content += `- **Features:** ${categoryBreakdown.feature || 0} commits\n`
-    content += `- **Process/Infrastructure:** ${categoryBreakdown.process || 0} commits\n`
-    content += `- **Tweaks/Fixes:** ${categoryBreakdown.tweak || 0} commits\n\n`
-
-    // Group by year and add yearly summaries
-    const commitsByYear = new Map<number, AnalyzedCommit[]>()
-    for (const commit of commits) {
-      const year = commit.getYear()
-      if (!commitsByYear.has(year)) {
-        commitsByYear.set(year, [])
-      }
-      commitsByYear.get(year)!.push(commit)
-    }
-
-    content += `## Yearly Development Highlights\n\n`
-
-    const sortedYears = Array.from(commitsByYear.keys()).sort((a, b) => b - a)
-    for (const year of sortedYears) {
-      const yearCommits = commitsByYear.get(year)!
-      const features = yearCommits.filter((c) =>
-        c.getAnalysis().isFeatureAnalysis(),
-      )
-
-      content += `### ${year}\n\n`
-      content += `${yearCommits.length} commits total, including ${features.length} new features.\n\n`
-
-      // Show top features
-      if (features.length > 0) {
-        content += `**Key Features:**\n`
-        for (const feature of features.slice(0, 5)) {
-          content += `- ${feature.getAnalysis().getSummary()}\n`
-        }
-        content += "\n"
-      }
-    }
-
-    return content
-  }
-}

package/src/4.infrastructure/file-system-storage-adapter.ts

@@ -1,87 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "fs"
-import { dirname, join } from "path"
-
-import { IStorageService } from "@presentation/storage-service.interface"
-
-import { getErrorMessage } from "../utils"
-
-export class FileSystemStorageAdapter implements IStorageService {
-  private static readonly DEFAULT_ENCODING = "utf8"
-
-  async writeFile(filePath: string, content: string): Promise<void> {
-    try {
-      // Ensure directory exists
-      const dir = dirname(filePath)
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true })
-      }
-      
-      writeFileSync(
-        filePath,
-        content,
-        FileSystemStorageAdapter.DEFAULT_ENCODING,
-      )
-    } catch (error) {
-      throw new Error(
-        `Failed to write file ${filePath}: ${getErrorMessage(error)}`,
-      )
-    }
-  }
-
-  async readFile(filePath: string): Promise<string> {
-    try {
-      return readFileSync(filePath, FileSystemStorageAdapter.DEFAULT_ENCODING)
-    } catch (error) {
-      throw new Error(
-        `Failed to read file ${filePath}: ${getErrorMessage(error)}`,
-      )
-    }
-  }
-
-  async fileExists(filePath: string): Promise<boolean> {
-    return existsSync(filePath)
-  }
-
-  async ensureDirectory(directoryPath: string): Promise<void> {
-    try {
-      mkdirSync(directoryPath, { recursive: true })
-    } catch (error) {
-      throw new Error(
-        `Failed to create directory ${directoryPath}: ${getErrorMessage(error)}`,
-      )
-    }
-  }
-
-  async deleteFile(filePath: string): Promise<void> {
-    try {
-      if (await this.fileExists(filePath)) {
-        unlinkSync(filePath)
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to delete file ${filePath}: ${getErrorMessage(error)}`,
-      )
-    }
-  }
-
-  async readLines(filePath: string): Promise<string[]> {
-    const content = await this.readFile(filePath)
-    return content
-      .split("\n")
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0)
-  }
-
-  resolveOutputPath(filename: string, outputDir?: string): string {
-    if (outputDir) {
-      return join(outputDir, filename)
-    }
-    return filename
-  }
-}

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

@@ -1,46 +0,0 @@
-import { execSync } from "child_process"
-
-import { LLMAdapter } from "./llm-adapter"
-
-export class GeminiLLMAdapter extends LLMAdapter {
-  private static readonly MAX_PROMPT_LENGTH = parseInt(
-    process.env.GEMINI_MAX_PROMPT_LENGTH || "100000",
-    10,
-  )
-
-  protected getMaxPromptLength(): number {
-    return GeminiLLMAdapter.MAX_PROMPT_LENGTH
-  }
-
-  async detectAvailableModels(): Promise<string[]> {
-    try {
-      execSync("command -v gemini", { stdio: "ignore" })
-      return ["gemini"]
-    } 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 || "gemini"
-
-    return execSync(modelCommand, {
-      input: truncatedPrompt,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: LLMAdapter.DEFAULT_TIMEOUT,
-    })
-  }
-}
-