commit-analyzer 1.0.2 → 1.1.0

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

@@ -0,0 +1,206 @@
+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, '""')}"`
+  }
+
+  private parseCSV(content: string): AnalyzedCommit[] {
+    const lines = content.split("\n").filter((line) => line.trim().length > 0)
+
+    if (lines.length < 2) {
+      throw new Error("Invalid CSV format: no data rows found")
+    }
+
+    // Validate header
+    const header = lines[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 = lines.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

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

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

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

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

@@ -0,0 +1,116 @@
+import { execSync } from "child_process"
+
+import { IVersionControlService } from "@presentation/version-control-service.interface"
+
+import { getErrorMessage } from "../utils"
+
+export class GitAdapter implements IVersionControlService {
+  private static readonly LARGE_DIFF_BUFFER = 50 * 1024 * 1024 // 50MB buffer for large diffs
+  private static readonly EXEC_OPTIONS = {
+    encoding: "utf8" as const,
+    stdio: ["pipe", "pipe", "pipe"] as ["pipe", "pipe", "pipe"],
+  }
+
+  async getCommitInfo(hash: string): Promise<{
+    hash: string
+    message: string
+    date: Date
+    diff: string
+  }> {
+    try {
+      const showOutput = execSync(
+        `git show --format="%H|%s|%ci" --no-patch "${hash}"`,
+        GitAdapter.EXEC_OPTIONS,
+      ).trim()
+
+      const [fullHash, message, dateStr] = showOutput.split("|")
+      const date = new Date(dateStr)
+
+      const diff = execSync(`git show "${hash}"`, {
+        ...GitAdapter.EXEC_OPTIONS,
+        maxBuffer: GitAdapter.LARGE_DIFF_BUFFER,
+      })
+
+      return {
+        hash: fullHash,
+        message,
+        date,
+        diff,
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to get commit info for ${hash}: ${getErrorMessage(error)}`,
+      )
+    }
+  }
+
+  async validateCommitHash(hash: string): Promise<boolean> {
+    try {
+      execSync(`git rev-parse --verify "${hash}"`, GitAdapter.EXEC_OPTIONS)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async isValidRepository(): Promise<boolean> {
+    try {
+      execSync("git rev-parse --git-dir", GitAdapter.EXEC_OPTIONS)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async getCurrentUserEmail(): Promise<string> {
+    try {
+      return execSync("git config user.email", GitAdapter.EXEC_OPTIONS).trim()
+    } catch (error) {
+      throw new Error(
+        `Failed to get current user email: ${getErrorMessage(error)}`,
+      )
+    }
+  }
+
+  async getCurrentUserName(): Promise<string> {
+    try {
+      return execSync("git config user.name", GitAdapter.EXEC_OPTIONS).trim()
+    } catch (error) {
+      throw new Error(
+        `Failed to get current user name: ${getErrorMessage(error)}`,
+      )
+    }
+  }
+
+  async getUserAuthoredCommits(params: {
+    authorEmail: string
+    limit?: number
+    since?: string
+    until?: string
+  }): Promise<string[]> {
+    const { authorEmail, limit, since, until } = params
+    try {
+      const limitFlag = limit ? `--max-count=${limit}` : ""
+      const sinceFlag = since ? `--since="${since}"` : ""
+      const untilFlag = until ? `--until="${until}"` : ""
+
+      const output = execSync(
+        `git log --author="${authorEmail}" --format="%H" --no-merges ${limitFlag} ${sinceFlag} ${untilFlag}`,
+        GitAdapter.EXEC_OPTIONS,
+      ).trim()
+
+      return this.parseCommitHashes(output)
+    } catch (error) {
+      throw new Error(
+        `Failed to get user authored commits: ${getErrorMessage(error)}`,
+      )
+    }
+  }
+
+  private parseCommitHashes(output: string): string[] {
+    if (!output) {
+      return []
+    }
+    return output.split("\n").filter((hash) => hash.length > 0)
+  }
+}

package/src/4.infrastructure/git-commit-repository.ts

@@ -0,0 +1,85 @@
+import { Commit } from "@domain/commit"
+import { CommitHash } from "@domain/commit-hash"
+
+import { ICommitRepository } from "@presentation/commit-repository.interface"
+import { IVersionControlService } from "@presentation/version-control-service.interface"
+
+export class GitCommitRepository implements ICommitRepository {
+  constructor(private readonly versionControlService: IVersionControlService) {}
+
+  async getByHash(hash: CommitHash): Promise<Commit> {
+    const commitInfo = await this.versionControlService.getCommitInfo(
+      hash.getValue(),
+    )
+
+    return new Commit({
+      hash,
+      message: commitInfo.message,
+      date: commitInfo.date,
+      diff: commitInfo.diff,
+    })
+  }
+
+  async getByAuthor(params: {
+    authorEmail: string
+    limit?: number
+    since?: string
+    until?: string
+  }): Promise<Commit[]> {
+    const { authorEmail, limit, since, until } = params
+    const commitHashes =
+      await this.versionControlService.getUserAuthoredCommits({
+        authorEmail,
+        limit,
+        since,
+        until,
+      })
+    const commits: Commit[] = []
+
+    for (const hashString of commitHashes) {
+      try {
+        const hash = CommitHash.create(hashString)
+        const commit = await this.getByHash(hash)
+        commits.push(commit)
+      } catch (error) {
+        console.warn(`Warning: Failed to load commit ${hashString}:`, error)
+      }
+    }
+
+    return commits
+  }
+
+  async getByHashes(hashes: CommitHash[]): Promise<Commit[]> {
+    const commits: Commit[] = []
+
+    for (const hash of hashes) {
+      try {
+        const commit = await this.getByHash(hash)
+        commits.push(commit)
+      } catch (error) {
+        console.warn(
+          `Warning: Failed to load commit ${hash.getShortHash()}:`,
+          error,
+        )
+      }
+    }
+
+    return commits
+  }
+
+  async exists(hash: CommitHash): Promise<boolean> {
+    return this.versionControlService.validateCommitHash(hash.getValue())
+  }
+
+  async getCurrentUserEmail(): Promise<string> {
+    return this.versionControlService.getCurrentUserEmail()
+  }
+
+  async getCurrentUserName(): Promise<string> {
+    return this.versionControlService.getCurrentUserName()
+  }
+
+  async isValidRepository(): Promise<boolean> {
+    return this.versionControlService.isValidRepository()
+  }
+}