commit-analyzer 1.1.4 → 1.1.6

package/src/1.domain/analysis.ts

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

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

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

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

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

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

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

package/src/1.domain/date-formatting-service.ts

@@ -1,81 +0,0 @@
-import { AnalyzedCommit } from "./analyzed-commit"
-
-/**
- * Domain service for formatting date ranges based on time periods
- */
-export class DateFormattingService {
-  /**
-   * Format date range based on the span of commits
-   */
-  formatDateRange(commits: AnalyzedCommit[]): string {
-    const dates = commits.map(c => c.getDate())
-    const minDate = new Date(Math.min(...dates.map(d => d.getTime())))
-    const maxDate = new Date(Math.max(...dates.map(d => d.getTime())))
-    
-    const diffInMilliseconds = maxDate.getTime() - minDate.getTime()
-    const diffInDays = diffInMilliseconds / (1000 * 60 * 60 * 24)
-    
-    
-    // For very small differences, use a more conservative approach
-    if (diffInDays < 0.05) { // Less than ~1 hour
-      return this.formatHourlyRange(minDate, maxDate)
-    } else if (diffInDays <= 1) {
-      return this.formatDailyRange(minDate, maxDate)
-    } else if (diffInDays <= 7) {
-      return this.formatWeeklyRange(minDate, maxDate)
-    } else if (diffInDays <= 31) {
-      return this.formatMonthlyRange(minDate, maxDate)
-    } else if (diffInDays <= 365) {
-      return this.formatMonthlyRange(minDate, maxDate)
-    } else {
-      return this.formatYearlyRange(minDate, maxDate)
-    }
-  }
-
-
-  private formatHourlyRange(minDate: Date, maxDate: Date): string {
-    const formatTime = (date: Date) => {
-      const hour = date.getHours()
-      const ampm = hour < 12 ? 'am' : 'pm'
-      const displayHour = hour === 0 ? 12 : hour > 12 ? hour - 12 : hour
-      return `${displayHour}${ampm}`
-    }
-    
-    // If same time, just show the single time
-    if (minDate.getTime() === maxDate.getTime()) {
-      return formatTime(minDate)
-    }
-    
-    return `${formatTime(minDate)} to ${formatTime(maxDate)}`
-  }
-
-  private formatDailyRange(minDate: Date, maxDate: Date): string {
-    const minDay = minDate.toLocaleDateString('en-US', { weekday: 'long' })
-    const maxDay = maxDate.toLocaleDateString('en-US', { weekday: 'long' })
-    return `${minDay} to ${maxDay}`
-  }
-
-  private formatWeeklyRange(minDate: Date, maxDate: Date): string {
-    const formatWeekly = (date: Date) => `${(date.getMonth() + 1).toString().padStart(2, '0')}/${date.getDate().toString().padStart(2, '0')}`
-    return `${formatWeekly(minDate)} - ${formatWeekly(maxDate)}`
-  }
-
-  private formatMonthlyRange(minDate: Date, maxDate: Date): string {
-    const minMonth = minDate.toLocaleDateString('en-US', { month: 'short' })
-    const maxMonth = maxDate.toLocaleDateString('en-US', { month: 'short' })
-    const minYear = minDate.getFullYear()
-    const maxYear = maxDate.getFullYear()
-    
-    if (minYear === maxYear) {
-      return `${minMonth} - ${maxMonth}`
-    } else {
-      return `${minMonth} ${minYear} - ${maxMonth} ${maxYear}`
-    }
-  }
-
-  private formatYearlyRange(minDate: Date, maxDate: Date): string {
-    const minYear = minDate.getFullYear()
-    const maxYear = maxDate.getFullYear()
-    return minYear === maxYear ? minYear.toString() : `${minYear} - ${maxYear}`
-  }
-}

package/src/1.domain/date-range.ts

@@ -1,76 +0,0 @@
-/**
- * Value object for date ranges in commit analysis
- */
-export class DateRange {
-  private constructor(
-    private readonly startDate: Date,
-    private readonly endDate: Date,
-  ) {}
-
-  static create(startDate: Date, endDate: Date): DateRange {
-    if (!startDate || !endDate) {
-      throw new Error('Start date and end date are required')
-    }
-
-    if (startDate > endDate) {
-      throw new Error('Start date cannot be after end date')
-    }
-
-    return new DateRange(new Date(startDate), new Date(endDate))
-  }
-
-  static fromYear(year: number): DateRange {
-    if (!Number.isInteger(year) || year < 1970) {
-      throw new Error('Invalid year provided')
-    }
-
-    const startDate = new Date(year, 0, 1) // January 1st
-    const endDate = new Date(year, 11, 31, 23, 59, 59, 999) // December 31st
-
-    return new DateRange(startDate, endDate)
-  }
-
-  static fromYearRange(startYear: number, endYear: number): DateRange {
-    if (startYear > endYear) {
-      throw new Error('Start year cannot be after end year')
-    }
-
-    const startDate = new Date(startYear, 0, 1)
-    const endDate = new Date(endYear, 11, 31, 23, 59, 59, 999)
-
-    return new DateRange(startDate, endDate)
-  }
-
-  getStartDate(): Date {
-    return new Date(this.startDate)
-  }
-
-  getEndDate(): Date {
-    return new Date(this.endDate)
-  }
-
-  contains(date: Date): boolean {
-    return date >= this.startDate && date <= this.endDate
-  }
-
-  getYearSpan(): number {
-    return this.endDate.getFullYear() - this.startDate.getFullYear() + 1
-  }
-
-  getYears(): number[] {
-    const years: number[] = []
-    for (let year = this.startDate.getFullYear(); year <= this.endDate.getFullYear(); year++) {
-      years.push(year)
-    }
-    return years
-  }
-
-  equals(other: DateRange): boolean {
-    return this.startDate.getTime() === other.startDate.getTime() &&
-           this.endDate.getTime() === other.endDate.getTime()
-  }
-
-  toString(): string {
-    return `${this.startDate.getFullYear()}-${this.endDate.getFullYear()}`
-  }
-}