commit-analyzer 1.1.3 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commit-analyzer",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "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/main.ts",
   "bin": {

package/src/1.domain/report-generation-service.ts

@@ -2,6 +2,14 @@ import { AnalyzedCommit } from "./analyzed-commit"
 import { Category, CategoryType } from "./category"
 import { DateRange } from "./date-range"
 
+export type TimePeriod =
+  | "hourly"
+  | "daily"
+  | "weekly"
+  | "monthly"
+  | "quarterly"
+  | "yearly"
+
 /**
  * Statistics for analyzed commits
  */
@@ -151,27 +159,31 @@ export class ReportGenerationService {
   /**
    * Determines the appropriate time period for summaries based on date range
    */
-  determineTimePeriod(commits: AnalyzedCommit[]): 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly' {
-    if (commits.length === 0) return 'yearly'
+  determineTimePeriod(commits: AnalyzedCommit[]): TimePeriod {
+    if (commits.length === 0) return "yearly"
+
+    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 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)
 
-    if (diffInDays <= 1) return 'daily'
-    if (diffInDays <= 7) return 'weekly'
-    if (diffInDays <= 31) return 'monthly'
-    if (diffInDays <= 93) return 'quarterly' // ~3 months
-    return 'yearly'
+    if (diffInDays <= 1) return "hourly"
+    if (diffInDays <= 7) return "daily"
+    if (diffInDays <= 31) return "weekly"
+    if (diffInDays <= 93) return "monthly" // ~3 months
+    if (diffInDays <= 365) return "quarterly" // ~3 months
+    return "yearly"
   }
 
   /**
    * Groups commits by the appropriate time period
    */
-  groupByTimePeriod(commits: AnalyzedCommit[], period: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly'): Map<string, AnalyzedCommit[]> {
+  groupByTimePeriod(
+    commits: AnalyzedCommit[],
+    period: TimePeriod,
+  ): Map<string, AnalyzedCommit[]> {
     const grouped = new Map<string, AnalyzedCommit[]>()
 
     for (const commit of commits) {
@@ -179,19 +191,22 @@ export class ReportGenerationService {
       let key: string
 
       switch (period) {
-        case 'daily':
+        case "hourly":
+          key = this.formatHourlyKey(date)
+          break
+        case "daily":
           key = this.formatDailyKey(date)
           break
-        case 'weekly':
+        case "weekly":
           key = this.formatWeeklyKey(date)
           break
-        case 'monthly':
+        case "monthly":
           key = this.formatMonthlyKey(date)
           break
-        case 'quarterly':
+        case "quarterly":
           key = this.formatQuarterlyKey(date)
           break
-        case 'yearly':
+        case "yearly":
         default:
           key = date.getFullYear().toString()
           break
@@ -206,15 +221,24 @@ export class ReportGenerationService {
     return grouped
   }
 
+  private formatHourlyKey(date: Date): string {
+    const hour = date.getHours()
+    const displayHour = hour === 0 ? 12 : hour > 12 ? hour - 12 : hour
+    const ampm = hour < 12 ? "AM" : "PM"
+    return `${displayHour}:00 ${ampm}`
+  }
+
   private formatDailyKey(date: Date): string {
     const year = date.getFullYear()
     const month = date.getMonth() + 1
     const day = date.getDate()
     const hour = date.getHours()
 
-    if (hour < 12) return `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')} Morning`
-    if (hour < 17) return `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')} Afternoon`
-    return `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')} Evening`
+    if (hour < 12)
+      return `${year}-${month.toString().padStart(2, "0")}-${day.toString().padStart(2, "0")} Morning`
+    if (hour < 17)
+      return `${year}-${month.toString().padStart(2, "0")}-${day.toString().padStart(2, "0")} Afternoon`
+    return `${year}-${month.toString().padStart(2, "0")}-${day.toString().padStart(2, "0")} Evening`
   }
 
   private formatWeeklyKey(date: Date): string {
@@ -223,15 +247,27 @@ export class ReportGenerationService {
     const endOfWeek = new Date(startOfWeek)
     endOfWeek.setDate(startOfWeek.getDate() + 6)
 
-    const formatDate = (d: Date) => 
-      `${d.getFullYear()}-${(d.getMonth() + 1).toString().padStart(2, '0')}-${d.getDate().toString().padStart(2, '0')}`
+    const formatDate = (d: Date) =>
+      `${d.getFullYear()}-${(d.getMonth() + 1).toString().padStart(2, "0")}-${d.getDate().toString().padStart(2, "0")}`
 
     return `Week of ${formatDate(startOfWeek)} to ${formatDate(endOfWeek)}`
   }
 
   private formatMonthlyKey(date: Date): string {
-    const months = ['January', 'February', 'March', 'April', 'May', 'June', 
-                   'July', 'August', 'September', 'October', 'November', 'December']
+    const months = [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December",
+    ]
     return `${months[date.getMonth()]} ${date.getFullYear()}`
   }
 
@@ -241,45 +277,160 @@ export class ReportGenerationService {
   }
 
   /**
-   * Converts analyzed commits to CSV string format for LLM consumption
+   * Converts analyzed commits to CSV string format for LLM consumption with enhanced context
    */
   convertToCSVString(commits: AnalyzedCommit[]): string {
-    const header = "year,category,summary,description"
+    const header = "year,category,summary,description,commit_count,date_range"
+
+    // Group commits by year and category for context
+    const contextMap = new Map<string, { count: number; dates: Date[] }>()
+
     const rows = commits.map((commit) => {
       const analysis = commit.getAnalysis()
+      const key = `${commit.getYear()}-${analysis.getCategory().getValue()}`
+
+      if (!contextMap.has(key)) {
+        contextMap.set(key, { count: 0, dates: [] })
+      }
+
+      const context = contextMap.get(key)!
+      context.count++
+      context.dates.push(commit.getDate())
+
+      const dateRange =
+        context.dates.length > 1
+          ? `${this.formatDate(Math.min(...context.dates.map((d) => d.getTime())))} to ${this.formatDate(Math.max(...context.dates.map((d) => d.getTime())))}`
+          : this.formatDate(commit.getDate())
+
       return [
         commit.getYear().toString(),
         this.escapeCsvField(analysis.getCategory().getValue()),
         this.escapeCsvField(analysis.getSummary()),
         this.escapeCsvField(analysis.getDescription()),
+        context.count.toString(),
+        this.escapeCsvField(dateRange),
       ].join(",")
     })
 
     return [header, ...rows].join("\n")
   }
 
+  private formatDate(date: Date | number): string {
+    const d = new Date(date)
+    return `${d.getFullYear()}-${(d.getMonth() + 1).toString().padStart(2, "0")}-${d.getDate().toString().padStart(2, "0")}`
+  }
+
   /**
-   * Converts grouped commits to CSV with time period information
+   * Converts grouped commits to CSV with time period information and enhanced context
    */
-  convertGroupedToCSV(groupedCommits: Map<string, AnalyzedCommit[]>, period: string): string {
-    const header = `${period},category,summary,description`
+  convertGroupedToCSV(
+    groupedCommits: Map<string, AnalyzedCommit[]>,
+    period: string,
+  ): string {
+    const header = `${period},category,summary,description,commit_count,similar_commits`
     const rows: string[] = []
-    
+
     for (const [timePeriod, commits] of groupedCommits) {
+      // Group commits by category within the time period for context
+      const categoryGroups = new Map<string, AnalyzedCommit[]>()
+
+      for (const commit of commits) {
+        const category = commit.getAnalysis().getCategory().getValue()
+        if (!categoryGroups.has(category)) {
+          categoryGroups.set(category, [])
+        }
+        categoryGroups.get(category)!.push(commit)
+      }
+
+      // Add context about similar commits in the same period and category
       for (const commit of commits) {
         const analysis = commit.getAnalysis()
-        rows.push([
-          this.escapeCsvField(timePeriod),
-          this.escapeCsvField(analysis.getCategory().getValue()),
-          this.escapeCsvField(analysis.getSummary()),
-          this.escapeCsvField(analysis.getDescription()),
-        ].join(","))
+        const category = analysis.getCategory().getValue()
+        const similarCommits = categoryGroups.get(category)!
+
+        // Find similar summaries in the same category
+        const similarSummaries = similarCommits
+          .filter((c) => c !== commit)
+          .map((c) => c.getAnalysis().getSummary())
+          .filter((summary) =>
+            this.isSimilarSummary(analysis.getSummary(), summary),
+          )
+          .slice(0, 3) // Limit to 3 similar items
+
+        rows.push(
+          [
+            this.escapeCsvField(timePeriod),
+            this.escapeCsvField(category),
+            this.escapeCsvField(analysis.getSummary()),
+            this.escapeCsvField(analysis.getDescription()),
+            similarCommits.length.toString(),
+            this.escapeCsvField(similarSummaries.join("; ")),
+          ].join(","),
+        )
       }
     }
 
     return [header, ...rows].join("\n")
   }
 
+  /**
+   * Determines if two summaries are similar based on common keywords
+   */
+  private isSimilarSummary(summary1: string, summary2: string): boolean {
+    const keywords1 = this.extractKeywords(summary1)
+    const keywords2 = this.extractKeywords(summary2)
+
+    // Check if they share significant keywords (at least 2 common words)
+    const commonKeywords = keywords1.filter((word) => keywords2.includes(word))
+    return commonKeywords.length >= 2
+  }
+
+  /**
+   * Extracts meaningful keywords from a summary for similarity detection
+   */
+  private extractKeywords(summary: string): string[] {
+    // Remove common stopwords and extract meaningful terms
+    const stopwords = new Set([
+      "the",
+      "a",
+      "an",
+      "and",
+      "or",
+      "but",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "of",
+      "with",
+      "by",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+    ])
+
+    return summary
+      .toLowerCase()
+      .replace(/[^\w\s]/g, " ")
+      .split(/\s+/)
+      .filter((word) => word.length > 2 && !stopwords.has(word))
+      .slice(0, 5) // Take first 5 meaningful words
+  }
+
   /**
    * Escape CSV fields that contain commas, quotes, or newlines
    */

package/src/3.presentation/cli-application.ts

@@ -24,7 +24,7 @@ export interface CLIOptions {
 }
 
 export class CLIApplication {
-  private static readonly VERSION = "1.1.3"
+  private static readonly VERSION = "1.1.4"
   private static readonly DEFAULT_COMMITS_OUTPUT_FILE = "results/commits.csv"
   private static readonly DEFAULT_REPORT_OUTPUT_FILE = "results/report.md"
 

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

@@ -243,9 +243,11 @@ ${csvContent}
 INSTRUCTIONS:
 1. Group the data by year (descending order, most recent first)
 2. Within each year, group by category: Features, Process Improvements, and Tweaks & Bug Fixes
-3. Consolidate similar items within each category to create readable summaries
-4. Focus on what was accomplished rather than individual commit details
-5. Use clear, professional language appropriate for stakeholders
+3. Use the 'commit_count' and 'date_range' columns to understand the scope and timeline of work
+4. Consolidate similar items within each category to create readable summaries
+5. Focus on what was accomplished rather than individual commit details
+6. Use clear, professional language appropriate for stakeholders
+7. Pay attention to recurring themes and patterns across commits
 
 CATEGORY MAPPING:
 - "feature" → "Features" section
@@ -253,12 +255,15 @@ CATEGORY MAPPING:
 - "tweak" → "Tweaks & Bug Fixes" section
 
 CONSOLIDATION GUIDELINES:
-- Group similar features together (e.g., "authentication system improvements")
-- Combine related bug fixes (e.g., "resolved 8 authentication issues")
-- Summarize process changes by theme (e.g., "CI/CD pipeline enhancements")
-- Use bullet points for individual items within categories
+- FIRST: Extract common themes and keywords from commit summaries within each category
+- SECOND: Identify and merge duplicate or highly similar work items (e.g., multiple "fix auth bug" commits become "resolved authentication issues")
+- Group similar features together by theme (e.g., "authentication system improvements", "payment processing enhancements")
+- Combine related bug fixes by area/system (e.g., "resolved 8 authentication issues", "fixed 5 database connection problems")
+- Summarize process changes by theme (e.g., "CI/CD pipeline enhancements", "testing infrastructure improvements")
+- Use bullet points for individual consolidated items within categories
 - Aim for 3-7 bullet points per category per year
 - Include specific numbers when relevant (e.g., "15 bug fixes", "3 new features")
+- Avoid listing near-identical items separately - consolidate them into meaningful groups
 
 OUTPUT FORMAT:
 Generate yearly summary sections with this exact structure (DO NOT include the main title or commit analysis section):
@@ -290,6 +295,16 @@ QUALITY REQUIREMENTS:
 - Avoid technical jargon where possible
 - Ensure each bullet point represents meaningful work
 - Make the report valuable for both technical and non-technical readers
+- Focus on business impact and user value rather than technical implementation details
+- When consolidating, preserve the most important aspects from similar commits
+- Use progressive disclosure: start with high-level themes, then add specific details
+
+CONTEXT ANALYSIS:
+Before consolidating, analyze the commit data for:
+1. Common file patterns or system areas being modified
+2. Recurring keywords in commit messages that indicate related work
+3. Sequential commits that build upon each other
+4. Bug fixes that address the same underlying issue
 
 Generate the markdown report now:`
   }
@@ -306,10 +321,12 @@ ${csvContent}
 INSTRUCTIONS:
 1. Group the data by ${periodDisplayName} (descending order, most recent first)
 2. Within each ${periodDisplayName.toLowerCase()}, group by category: Features, Process Improvements, and Tweaks & Bug Fixes
-3. Consolidate similar items within each category to create readable summaries
-4. Focus on what was accomplished rather than individual commit details
-5. Use clear, professional language appropriate for stakeholders
-6. Only include sections for time periods that have commits
+3. Use the 'commit_count' and 'similar_commits' columns to understand related work and consolidation opportunities
+4. Consolidate similar items within each category to create readable summaries
+5. Focus on what was accomplished rather than individual commit details
+6. Use clear, professional language appropriate for stakeholders
+7. Only include sections for time periods that have commits
+8. Pay attention to recurring themes and patterns across commits
 
 CATEGORY MAPPING:
 - "feature" → "Features" section
@@ -317,12 +334,15 @@ CATEGORY MAPPING:
 - "tweak" → "Tweaks & Bug Fixes" section
 
 CONSOLIDATION GUIDELINES:
-- Group similar features together (e.g., "authentication system improvements")
-- Combine related bug fixes (e.g., "resolved 8 authentication issues")
-- Summarize process changes by theme (e.g., "CI/CD pipeline enhancements")
-- Use bullet points for individual items within categories
+- FIRST: Extract common themes and keywords from commit summaries within each category
+- SECOND: Identify and merge duplicate or highly similar work items (e.g., multiple "fix auth bug" commits become "resolved authentication issues")
+- Group similar features together by theme (e.g., "authentication system improvements", "payment processing enhancements")
+- Combine related bug fixes by area/system (e.g., "resolved 8 authentication issues", "fixed 5 database connection problems")
+- Summarize process changes by theme (e.g., "CI/CD pipeline enhancements", "testing infrastructure improvements")
+- Use bullet points for individual consolidated items within categories
 - Aim for 3-7 bullet points per category per ${periodDisplayName.toLowerCase()}
 - Include specific numbers when relevant (e.g., "15 bug fixes", "3 new features")
+- Avoid listing near-identical items separately - consolidate them into meaningful groups
 
 OUTPUT FORMAT:
 Generate ${periodDisplayName.toLowerCase()} summary sections with this exact structure (DO NOT include the main title or commit analysis section):
@@ -354,6 +374,16 @@ QUALITY REQUIREMENTS:
 - Avoid technical jargon where possible
 - Ensure each bullet point represents meaningful work
 - Make the report valuable for both technical and non-technical readers
+- Focus on business impact and user value rather than technical implementation details
+- When consolidating, preserve the most important aspects from similar commits
+- Use progressive disclosure: start with high-level themes, then add specific details
+
+CONTEXT ANALYSIS:
+Before consolidating, analyze the commit data for:
+1. Common file patterns or system areas being modified
+2. Recurring keywords in commit messages that indicate related work
+3. Sequential commits that build upon each other
+4. Bug fixes that address the same underlying issue
 
 Generate the markdown report now:`
   }