commit-analyzer 1.0.3 → 1.1.1

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

@@ -0,0 +1,143 @@
+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 getRepositoryName(): Promise<string> {
+    try {
+      // Try to get the repository name from remote origin URL
+      const remoteUrl = execSync("git config --get remote.origin.url", GitAdapter.EXEC_OPTIONS).trim()
+      
+      // Extract repository name from various URL formats
+      // git@github.com:user/repo.git -> repo
+      // https://github.com/user/repo.git -> repo
+      // https://github.com/user/repo -> repo
+      const match = remoteUrl.match(/\/([^\/]+?)(?:\.git)?$/)
+      if (match && match[1]) {
+        return match[1]
+      }
+      
+      // Fallback: get the directory name
+      const dirName = execSync("basename $(git rev-parse --show-toplevel)", GitAdapter.EXEC_OPTIONS).trim()
+      return dirName
+    } catch (error) {
+      // Final fallback: use current directory name
+      try {
+        return execSync("basename $(pwd)", GitAdapter.EXEC_OPTIONS).trim()
+      } catch {
+        return "Unknown Project"
+      }
+    }
+  }
+
+  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()
+  }
+}

package/src/4.infrastructure/json-progress-tracker.ts

@@ -0,0 +1,182 @@
+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 { ConsoleFormatter } from "@presentation/console-formatter"
+import {
+  IProgressRepository,
+  ProgressState,
+} from "@presentation/progress-repository.interface"
+import { IStorageService } from "@presentation/storage-service.interface"
+
+import { calculatePercentage } from "../utils"
+import { AppPaths } from "../utils/app-paths"
+
+export class JSONProgressTracker implements IProgressRepository {
+  private static readonly JSON_INDENT = 2
+
+  constructor(private readonly storageService: IStorageService) {}
+
+  private getProgressFilePath(): string {
+    return AppPaths.getProgressFilePath()
+  }
+
+  async saveProgress(state: ProgressState): Promise<void> {
+    const serializedState = this.serializeProgressState(state)
+    const content = JSON.stringify(
+      serializedState,
+      null,
+      JSONProgressTracker.JSON_INDENT,
+    )
+    await this.storageService.writeFile(
+      this.getProgressFilePath(),
+      content,
+    )
+  }
+
+  async loadProgress(): Promise<ProgressState | null> {
+    if (!(await this.hasProgress())) {
+      return null
+    }
+
+    try {
+      const content = await this.storageService.readFile(
+        this.getProgressFilePath(),
+      )
+      const serializedState = JSON.parse(content)
+      return this.deserializeProgressState(serializedState)
+    } catch (error) {
+      ConsoleFormatter.logError(`Failed to load progress file: ${error}`)
+      return null
+    }
+  }
+
+  async hasProgress(): Promise<boolean> {
+    return this.storageService.fileExists(this.getProgressFilePath())
+  }
+
+  async clearProgress(): Promise<void> {
+    await this.storageService.deleteFile(this.getProgressFilePath())
+  }
+
+  getRemainingCommits(state: ProgressState): CommitHash[] {
+    const processedHashes = new Set(
+      state.processedCommits.map((hash) => hash.getValue()),
+    )
+    return state.totalCommits.filter(
+      (hash) => !processedHashes.has(hash.getValue()),
+    )
+  }
+
+  formatProgressSummary(state: ProgressState): string {
+    const processed = state.processedCommits.length
+    const total = state.totalCommits.length
+    const remaining = total - processed
+    const percentComplete = calculatePercentage(processed, total)
+
+    return `
+      Previous session:
+      - Started: ${state.startTime.toLocaleString()}
+      - Progress: ${processed}/${total} commits (${percentComplete}%)
+      - Remaining: ${remaining} commits
+      - Output file: ${state.outputFile}
+    `.trim()
+  }
+
+  private serializeProgressState(
+    state: ProgressState,
+  ): Record<string, unknown> {
+    return {
+      totalCommits: state.totalCommits.map((hash) => hash.getValue()),
+      processedCommits: state.processedCommits.map((hash) => hash.getValue()),
+      analyzedCommits: state.analyzedCommits.map((commit) => ({
+        hash: commit.getHash().getValue(),
+        message: commit.getMessage(),
+        date: commit.getDate().toISOString(),
+        year: commit.getYear(),
+        category: commit.getAnalysis().getCategory().getValue(),
+        summary: commit.getAnalysis().getSummary(),
+        description: commit.getAnalysis().getDescription(),
+      })),
+      lastProcessedIndex: state.lastProcessedIndex,
+      startTime: state.startTime.toISOString(),
+      outputFile: state.outputFile,
+    }
+  }
+
+  private deserializeProgressState(
+    data: Record<string, unknown>,
+  ): ProgressState {
+    this.validateProgressData(data)
+
+    return {
+      totalCommits: (data.totalCommits as string[]).map((hash: string) =>
+        CommitHash.create(hash),
+      ),
+      processedCommits: (data.processedCommits as string[]).map(
+        (hash: string) => CommitHash.create(hash),
+      ),
+      analyzedCommits: this.deserializeAnalyzedCommits(
+        data.analyzedCommits as Record<string, unknown>[],
+      ),
+      lastProcessedIndex: data.lastProcessedIndex as number,
+      startTime: new Date(data.startTime as string),
+      outputFile: data.outputFile as string,
+    }
+  }
+
+  private validateProgressData(data: Record<string, unknown>): void {
+    if (!Array.isArray(data.totalCommits)) {
+      throw new Error("Invalid progress data: totalCommits must be an array")
+    }
+
+    if (!Array.isArray(data.processedCommits)) {
+      throw new Error(
+        "Invalid progress data: processedCommits must be an array",
+      )
+    }
+
+    if (typeof data.lastProcessedIndex !== "number") {
+      throw new Error(
+        "Invalid progress data: lastProcessedIndex must be a number",
+      )
+    }
+
+    if (typeof data.startTime !== "string") {
+      throw new Error("Invalid progress data: startTime must be a string")
+    }
+
+    if (typeof data.outputFile !== "string") {
+      throw new Error("Invalid progress data: outputFile must be a string")
+    }
+  }
+
+  private deserializeAnalyzedCommits(
+    data: Record<string, unknown>[],
+  ): AnalyzedCommit[] {
+    if (!Array.isArray(data)) {
+      return []
+    }
+
+    return data.map((item: Record<string, unknown>) => {
+      const hash = CommitHash.create(item.hash as string)
+      const commit = new Commit({
+        hash,
+        message: item.message as string,
+        date: new Date(item.date as string),
+        diff: "", // We don't store diff in progress, so use empty string
+      })
+
+      const category = Category.create(item.category as string)
+      const analysis = new Analysis({
+        category,
+        summary: item.summary as string,
+        description: item.description as string,
+      })
+
+      return new AnalyzedCommit(commit, analysis)
+    })
+  }
+}

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

@@ -0,0 +1,26 @@
+import { ClaudeLLMAdapter } from "./claude-llm-adapter"
+import { GeminiLLMAdapter } from "./gemini-llm-adapter"
+import { LLMAdapter } from "./llm-adapter"
+import { OpenAILLMAdapter } from "./openai-llm-adapter"
+
+export class LLMAdapterFactory {
+  static create(llm?: string): LLMAdapter {
+    const normalizedLLM = llm?.toLowerCase()
+
+    switch (normalizedLLM) {
+      case "gemini":
+        return new GeminiLLMAdapter()
+      case "openai":
+      case "gpt":
+        return new OpenAILLMAdapter()
+      case "claude":
+      default:
+        return new ClaudeLLMAdapter()
+    }
+  }
+
+  static getSupportedLLMs(): string[] {
+    return ["claude", "gemini", "openai"]
+  }
+}
+