commit-analyzer 1.0.3 → 1.1.0

package/.claude/settings.local.json

@@ -4,7 +4,17 @@
       "Bash(mkdir:*)",
       "Bash(bun install:*)",
       "Bash(bun run:*)",
-      "Bash(bun link:*)"
+      "Bash(bun link:*)",
+      "Bash(npm run typecheck:*)",
+      "Bash(npm run lint)",
+      "Bash(npm run build:*)",
+      "Bash(npm run dev:*)",
+      "Bash(bun dev:*)",
+      "Bash(git log:*)",
+      "Bash(git checkout:*)",
+      "Bash(npx ts-node:*)",
+      "Bash(node:*)",
+      "Bash(npm start:*)"
     ],
     "deny": [],
     "ask": []

package/README.md

@@ -13,13 +13,26 @@ A TypeScript/Node.js program that analyzes git commits and generates categorized
 - Automatically filters out merge commits for cleaner analysis
 - Robust error handling and validation
 
+## Prerequisites
+
+This tool requires Bun runtime. Install it globally:
+
+```bash
+# Install bun globally
+curl -fsSL https://bun.sh/install | bash
+# or
+npm install -g bun
+```
+
 ## Installation
 
 ```bash
 npm install
-npm run build
+bun link
 ```
 
+After linking, you can use `commit-analyzer` command globally.
+
 ## Usage
 
 ### Default Behavior
@@ -151,7 +164,7 @@ npx commit-analyzer --clear
 npx commit-analyzer --resume
 ```
 
-The checkpoint file (`.commit-analyzer-progress.json`) contains:
+The checkpoint file (`.commit-analyzer/progress.json`) contains:
 - List of all commits to process
 - Successfully processed commits (including failed ones to skip on resume)
 - Analyzed commit data (only successful ones)
@@ -159,6 +172,24 @@ The checkpoint file (`.commit-analyzer-progress.json`) contains:
 
 **Important**: When a commit fails after all retries (default 3), the process stops immediately to prevent wasting API calls. The successfully analyzed commits up to that point are saved to the CSV file.
 
+### Application Data Directory
+
+The tool creates a `.commit-analyzer/` directory to store internal files:
+
+```
+.commit-analyzer/
+├── progress.json        # Progress checkpoint data
+└── cache/              # Cached analysis results
+    ├── commit-abc123.json
+    ├── commit-def456.json
+    └── ...
+```
+
+- **Progress checkpoint**: Enables resuming interrupted analysis sessions
+- **Analysis cache**: Stores LLM analysis results to avoid re-processing the same commits (TTL: 30 days)
+
+Use `--no-cache` to disable caching if needed.
+
 ### Retry Logic
 
 The tool includes automatic retry logic with exponential backoff for handling API failures when processing many commits. This is especially useful when analyzing large numbers of commits that might trigger rate limits.

package/commits.csv

@@ -0,0 +1,2 @@
+year,category,summary,description
+2025,process,"Refactor project structure with numbered layers, path aliases, and automated","Major architectural reorganization moving from nested directories to numbered layer structure (1.domain, 2.application, 3.presentation, 4.infrastructure). Implements TypeScript path aliases (@domain, @app, @presentation, @infra) for cleaner imports and adds ESLint plugin for automatic import sorting and organization. All files renamed to kebab-case and imports updated throughout the codebase to use the new alias system. This improves code maintainability, reduces import path complexity, and establishes consistent file organization patterns."

package/eslint.config.mts

@@ -0,0 +1,45 @@
+import js from "@eslint/js"
+import { defineConfig } from "eslint/config"
+import simpleImportSort from "eslint-plugin-simple-import-sort"
+import globals from "globals"
+import tseslint from "typescript-eslint"
+
+export default defineConfig([
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts}"],
+    plugins: { js },
+    extends: ["js/recommended"],
+    languageOptions: { globals: globals.node },
+  },
+  tseslint.configs.recommended,
+  {
+    plugins: {
+      "simple-import-sort": simpleImportSort,
+    },
+    rules: {
+      "simple-import-sort/imports": [
+        "warn",
+        {
+          groups: [
+            // Side effect imports
+            ["^\\u0000"],
+            // Packages. `react` related packages come first.
+            ["^react", "^@?\\w"],
+            // Aliases (adjust these regexes for your aliases)
+            ["^@domain"],
+            ["^@app"],
+            ["^@presentation"],
+            ["^@infra"],
+            // Parent imports
+            ["^\\.\\.(?!/?$)", "^\\.\\./?$"],
+            // Relative imports
+            ["^\\./(?=.*/)(?!/?$)", "^\\.(?!/?$)", "^\\./?$"],
+            // Style imports
+            ["^.+\\.s?css$"],
+          ],
+        },
+      ],
+      "simple-import-sort/exports": "warn",
+    },
+  },
+])

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "commit-analyzer",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Analyze git commits and generate categories, summaries, and descriptions for each commit. Optionally generate a yearly breakdown report of your commit history.",
-  "main": "dist/index.js",
+  "main": "dist/main.ts",
   "bin": {
-    "commit-analyzer": "dist/index.js"
+    "commit-analyzer": "dist/main.ts"
   },
   "prettier": {
     "semi": false
   },
   "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "ts-node src/index.ts",
+    "build": "bun build src/main.ts --outfile=dist/main.ts --compile",
+    "start": "bun src/main.ts",
+    "dev": "bun src/main.ts",
     "lint": "eslint src/**/*.ts",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "link": "bun link",
+    "publish": "bun publish"
   },
   "keywords": [
     "git",
@@ -26,12 +28,18 @@
   "author": "steverodri",
   "license": "MIT",
   "devDependencies": {
+    "@eslint/js": "^9.34.0",
     "@types/node": "^20.0.0",
     "@typescript-eslint/eslint-plugin": "^6.0.0",
     "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.0.0",
+    "eslint": "^9.34.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "globals": "^16.3.0",
+    "jiti": "^2.5.1",
     "ts-node": "^10.0.0",
-    "typescript": "^5.0.0"
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.40.0"
   },
   "dependencies": {
     "commander": "^11.0.0"

package/src/1.domain/analysis.ts

@@ -0,0 +1,93 @@
+import { Category } from "./category"
+
+/**
+ * Domain entity representing the analysis of a commit
+ */
+export class Analysis {
+  private static readonly MAX_SUMMARY_LENGTH = 80
+  private static readonly MIN_DESCRIPTION_LENGTH = 10
+  private readonly category: Category
+  private readonly summary: string
+  private readonly description: string
+
+  constructor(params: {
+    category: Category
+    summary: string
+    description: string
+  }) {
+    const { category, summary, description } = params
+    this.category = category
+    this.summary = summary
+    this.description = description
+
+    if (!summary || summary.trim().length === 0) {
+      throw new Error("Summary cannot be empty")
+    }
+
+    if (!description || description.trim().length === 0) {
+      throw new Error("Description cannot be empty")
+    }
+
+    if (summary.length > Analysis.MAX_SUMMARY_LENGTH) {
+      throw new Error(
+        `Summary cannot exceed ${Analysis.MAX_SUMMARY_LENGTH} characters`,
+      )
+    }
+
+    if (description.length < Analysis.MIN_DESCRIPTION_LENGTH) {
+      throw new Error(
+        `Description must be at least ${Analysis.MIN_DESCRIPTION_LENGTH} characters`,
+      )
+    }
+  }
+
+  getCategory(): Category {
+    return this.category
+  }
+
+  getSummary(): string {
+    return this.summary
+  }
+
+  getDescription(): string {
+    return this.description
+  }
+
+  getSummaryTruncated(): string {
+    return this.summary.length > Analysis.MAX_SUMMARY_LENGTH
+      ? this.summary.substring(0, Analysis.MAX_SUMMARY_LENGTH - 3) + "..."
+      : this.summary
+  }
+
+  isFeatureAnalysis(): boolean {
+    return this.category.isFeature()
+  }
+
+  isTweakAnalysis(): boolean {
+    return this.category.isTweak()
+  }
+
+  isProcessAnalysis(): boolean {
+    return this.category.isProcess()
+  }
+
+  equals(other: Analysis): boolean {
+    return (
+      this.category.equals(other.category) &&
+      this.summary === other.summary &&
+      this.description === other.description
+    )
+  }
+
+  toPlainObject(): {
+    category: string
+    summary: string
+    description: string
+  } {
+    return {
+      category: this.category.getValue(),
+      summary: this.summary,
+      description: this.description,
+    }
+  }
+}

package/src/1.domain/analyzed-commit.ts

@@ -0,0 +1,97 @@
+import { Analysis } from "./analysis"
+import { Commit } from "./commit"
+import { CommitHash } from "./commit-hash"
+
+/**
+ * Domain entity representing a commit with its analysis
+ */
+export class AnalyzedCommit {
+  constructor(
+    private readonly commit: Commit,
+    private readonly analysis: Analysis,
+  ) {
+    if (!commit) {
+      throw new Error("Commit is required")
+    }
+
+    if (!analysis) {
+      throw new Error("Analysis is required")
+    }
+  }
+
+  getCommit(): Commit {
+    return this.commit
+  }
+
+  getAnalysis(): Analysis {
+    return this.analysis
+  }
+
+  getHash(): CommitHash {
+    return this.commit.getHash()
+  }
+
+  getMessage(): string {
+    return this.commit.getMessage()
+  }
+
+  getDate(): Date {
+    return this.commit.getDate()
+  }
+
+  getYear(): number {
+    return this.commit.getYear()
+  }
+
+  getShortHash(length: number = 8): string {
+    return this.commit.getShortHash(length)
+  }
+
+  isLargeChange(): boolean {
+    return this.commit.isLargeChange()
+  }
+
+  equals(other: AnalyzedCommit): boolean {
+    return (
+      this.commit.equals(other.commit) && this.analysis.equals(other.analysis)
+    )
+  }
+
+  toCSVRow(): {
+    timestamp: string
+    category: string
+    summary: string
+    description: string
+  } {
+    return {
+      timestamp: this.getDate().toISOString(),
+      category: this.analysis.getCategory().getValue(),
+      summary: this.analysis.getSummary(),
+      description: this.analysis.getDescription(),
+    }
+  }
+
+  toReportData(): {
+    hash: string
+    shortHash: string
+    message: string
+    date: Date
+    year: number
+    category: string
+    summary: string
+    description: string
+    isLargeChange: boolean
+  } {
+    return {
+      hash: this.commit.getHash().getValue(),
+      shortHash: this.getShortHash(),
+      message: this.getMessage(),
+      date: this.getDate(),
+      year: this.getYear(),
+      category: this.analysis.getCategory().getValue(),
+      summary: this.analysis.getSummary(),
+      description: this.analysis.getDescription(),
+      isLargeChange: this.isLargeChange(),
+    }
+  }
+}

package/src/1.domain/application-error.ts

@@ -0,0 +1,32 @@
+/**
+ * Base class for application errors
+ */
+export abstract class ApplicationError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+  ) {
+    super(message)
+    this.name = "ApplicationError"
+  }
+}
+
+/**
+ * Error for validation failures
+ */
+export class ValidationError extends ApplicationError {
+  constructor(message: string) {
+    super(message, "VALIDATION_ERROR")
+    this.name = "ValidationError"
+  }
+}
+
+/**
+ * Error for not found resources
+ */
+export class NotFoundError extends ApplicationError {
+  constructor(resource: string, identifier: string) {
+    super(`${resource} not found: ${identifier}`, "NOT_FOUND")
+    this.name = "NotFoundError"
+  }
+}

package/src/1.domain/category.ts

@@ -0,0 +1,52 @@
+/**
+ * Value object for commit analysis category
+ */
+export type CategoryType = "tweak" | "feature" | "process"
+
+export class Category {
+  private static readonly VALID_CATEGORIES: CategoryType[] = ["tweak", "feature", "process"]
+
+  private constructor(private readonly value: CategoryType) {}
+
+  static create(category: string): Category {
+    if (!category || typeof category !== 'string') {
+      throw new Error('Category cannot be empty')
+    }
+
+    const normalizedCategory = category.toLowerCase().trim() as CategoryType
+    
+    if (!this.VALID_CATEGORIES.includes(normalizedCategory)) {
+      throw new Error(`Invalid category: ${category}. Must be one of: ${this.VALID_CATEGORIES.join(', ')}`)
+    }
+
+    return new Category(normalizedCategory)
+  }
+
+  static fromType(category: CategoryType): Category {
+    return new Category(category)
+  }
+
+  getValue(): CategoryType {
+    return this.value
+  }
+
+  equals(other: Category): boolean {
+    return this.value === other.value
+  }
+
+  toString(): string {
+    return this.value
+  }
+
+  isFeature(): boolean {
+    return this.value === "feature"
+  }
+
+  isTweak(): boolean {
+    return this.value === "tweak"
+  }
+
+  isProcess(): boolean {
+    return this.value === "process"
+  }
+}

package/src/1.domain/commit-analysis-service.ts

@@ -0,0 +1,92 @@
+import { IAnalysisRepository } from "@presentation/analysis-repository.interface"
+import { ICommitRepository } from "@presentation/commit-repository.interface"
+
+import { AnalyzedCommit } from "./analyzed-commit"
+import { Commit } from "./commit"
+import { CommitHash } from "./commit-hash"
+
+/**
+ * Domain service for commit analysis operations
+ */
+export class CommitAnalysisService {
+  constructor(
+    private readonly commitRepository: ICommitRepository,
+    private readonly analysisRepository: IAnalysisRepository,
+  ) {}
+
+  /**
+   * Analyzes a single commit
+   */
+  async analyzeCommit(hash: CommitHash): Promise<AnalyzedCommit> {
+    const commit = await this.commitRepository.getByHash(hash)
+    const analysis = await this.analysisRepository.analyze(commit)
+
+    return new AnalyzedCommit(commit, analysis)
+  }
+
+  /**
+   * Analyzes multiple commits
+   */
+  async analyzeCommits(hashes: CommitHash[]): Promise<AnalyzedCommit[]> {
+    const analyzedCommits: AnalyzedCommit[] = []
+
+    for (const hash of hashes) {
+      try {
+        const analyzedCommit = await this.analyzeCommit(hash)
+        analyzedCommits.push(analyzedCommit)
+      } catch (error) {
+        // Re-throw the error - let the application layer handle logging
+        throw new Error(
+          `Failed to analyze commit ${hash.getShortHash()}: ${error instanceof Error ? error.message : String(error)}`,
+        )
+      }
+    }
+
+    return analyzedCommits
+  }
+
+  /**
+   * Validates that all commit hashes exist
+   */
+  async validateCommits(
+    hashes: CommitHash[],
+  ): Promise<{ valid: CommitHash[]; invalid: CommitHash[] }> {
+    const valid: CommitHash[] = []
+    const invalid: CommitHash[] = []
+
+    for (const hash of hashes) {
+      const exists = await this.commitRepository.exists(hash)
+      if (exists) {
+        valid.push(hash)
+      } else {
+        invalid.push(hash)
+      }
+    }
+
+    return { valid, invalid }
+  }
+
+  /**
+   * Gets commits authored by the current user
+   */
+  async getCurrentUserCommits(params?: {
+    limit?: number
+    since?: string
+    until?: string
+  }): Promise<Commit[]> {
+    const userEmail = await this.commitRepository.getCurrentUserEmail()
+    return this.commitRepository.getByAuthor({
+      authorEmail: userEmail,
+      limit: params?.limit,
+      since: params?.since,
+      until: params?.until,
+    })
+  }
+
+  /**
+   * Checks if the analysis service is ready
+   */
+  async isAnalysisServiceReady(): Promise<boolean> {
+    return this.analysisRepository.isAvailable()
+  }
+}

package/src/1.domain/commit-hash.ts

@@ -0,0 +1,40 @@
+/**
+ * Value object for Git commit hash
+ */
+export class CommitHash {
+  private constructor(private readonly value: string) {}
+
+  static create(hash: string): CommitHash {
+    if (!hash || typeof hash !== 'string') {
+      throw new Error('Commit hash cannot be empty')
+    }
+
+    // Git short hash is minimum 4 characters, full hash is 40
+    if (hash.length < 4 || hash.length > 40) {
+      throw new Error('Invalid commit hash length')
+    }
+
+    // Only hexadecimal characters allowed
+    if (!/^[a-f0-9]+$/i.test(hash)) {
+      throw new Error('Commit hash must contain only hexadecimal characters')
+    }
+
+    return new CommitHash(hash)
+  }
+
+  getValue(): string {
+    return this.value
+  }
+
+  getShortHash(length: number = 8): string {
+    return this.value.substring(0, Math.min(length, this.value.length))
+  }
+
+  equals(other: CommitHash): boolean {
+    return this.value === other.value
+  }
+
+  toString(): string {
+    return this.value
+  }
+}

package/src/1.domain/commit.ts

@@ -0,0 +1,99 @@
+import { CommitHash } from "./commit-hash"
+
+/**
+ * Domain entity representing a Git commit
+ */
+export class Commit {
+  private readonly hash: CommitHash
+  private readonly message: string
+  private readonly date: Date
+  private readonly diff: string
+
+  constructor(params: {
+    hash: CommitHash
+    message: string
+    date: Date
+    diff: string
+  }) {
+    const { hash, message, date, diff } = params
+    this.hash = hash
+    this.message = message
+    this.date = date
+    this.diff = diff
+    if (!message || message.trim().length === 0) {
+      throw new Error("Commit message cannot be empty")
+    }
+
+    if (!date) {
+      throw new Error("Commit date is required")
+    }
+
+    if (!diff) {
+      throw new Error("Commit diff is required")
+    }
+  }
+
+  getHash(): CommitHash {
+    return this.hash
+  }
+
+  getMessage(): string {
+    return this.message
+  }
+
+  getDate(): Date {
+    return new Date(this.date)
+  }
+
+  getDiff(): string {
+    return this.diff
+  }
+
+  getYear(): number {
+    return this.date.getFullYear()
+  }
+
+  getShortHash(length: number = 8): string {
+    return this.hash.getShortHash(length)
+  }
+
+  getDiffStats(): {
+    additions: number
+    deletions: number
+    filesChanged: number
+  } {
+    const lines = this.diff.split("\n")
+    let additions = 0
+    let deletions = 0
+    const filesChanged = new Set<string>()
+
+    for (const line of lines) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        additions++
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        deletions++
+      } else if (line.startsWith("diff --git")) {
+        // Extract filename from diff header
+        const match = line.match(/diff --git a\/(.+) b\/(.+)/)
+        if (match) {
+          filesChanged.add(match[1])
+        }
+      }
+    }
+
+    return {
+      additions,
+      deletions,
+      filesChanged: filesChanged.size,
+    }
+  }
+
+  isLargeChange(): boolean {
+    const stats = this.getDiffStats()
+    return stats.additions + stats.deletions > 100 || stats.filesChanged > 10
+  }
+
+  equals(other: Commit): boolean {
+    return this.hash.equals(other.hash)
+  }
+}