commit-analyzer 1.0.2 → 1.1.0

package/src/csv-reader.ts

@@ -1,180 +0,0 @@
-import { readFileSync } from "fs"
-
-export interface ParsedCSVRow {
-  year: number
-  category: "tweak" | "feature" | "process"
-  summary: string
-  description: string
-}
-
-export class CSVReaderService {
-  static readCSV(filename: string): ParsedCSVRow[] {
-    try {
-      const content = readFileSync(filename, "utf8")
-      return this.parseCSV(content)
-    } catch (error) {
-      throw new Error(
-        `Failed to read CSV file ${filename}: ${error instanceof Error ? error.message : "Unknown error"}`,
-      )
-    }
-  }
-
-  private static parseCSV(content: string): ParsedCSVRow[] {
-    const lines = content.trim().split("\n")
-
-    if (lines.length === 0) {
-      throw new Error("CSV file is empty")
-    }
-
-    // Validate header
-    const header = lines[0].toLowerCase()
-    const expectedHeader = "year,category,summary,description"
-    if (header !== expectedHeader) {
-      throw new Error(
-        `Invalid CSV format. Expected header: "${expectedHeader}", got: "${header}"`,
-      )
-    }
-
-    const rows: ParsedCSVRow[] = []
-
-    for (let i = 1; i < lines.length; i++) {
-      const line = lines[i].trim()
-      if (line === "") continue // Skip empty lines
-
-      try {
-        const row = this.parseCSVLine(line, i + 1)
-        rows.push(row)
-      } catch (error) {
-        throw new Error(
-          `Error parsing CSV line ${i + 1}: ${error instanceof Error ? error.message : "Unknown error"}`,
-        )
-      }
-    }
-
-    return rows
-  }
-
-  private static parseCSVLine(line: string, lineNumber: number): ParsedCSVRow {
-    const fields = this.parseCSVFields(line)
-
-    if (fields.length !== 4) {
-      throw new Error(
-        `Expected 4 fields (year,category,summary,description), got ${fields.length}`,
-      )
-    }
-
-    const [yearStr, category, summary, description] = fields
-
-    // Validate year
-    const year = parseInt(yearStr, 10)
-    if (isNaN(year) || year < 1900 || year > 2100) {
-      throw new Error(`Invalid year: ${yearStr}`)
-    }
-
-    // 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")
-    }
-
-    return {
-      year,
-      category: category as "tweak" | "feature" | "process",
-      summary: summary.trim(),
-      description: description.trim(),
-    }
-  }
-
-  /**
-   * Parse CSV fields handling quoted fields with commas and escaped quotes
-   */
-  private static 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 static isValidCategory(
-    category: string,
-  ): category is "tweak" | "feature" | "process" {
-    return ["tweak", "feature", "process"].includes(category)
-  }
-
-  /**
-   * Get summary statistics about the CSV data
-   */
-  static getStatistics(rows: ParsedCSVRow[]): {
-    totalRows: number
-    yearRange: { min: number; max: number }
-    categoryBreakdown: Record<string, number>
-  } {
-    if (rows.length === 0) {
-      return {
-        totalRows: 0,
-        yearRange: { min: 0, max: 0 },
-        categoryBreakdown: { tweak: 0, feature: 0, process: 0 },
-      }
-    }
-
-    const years = rows.map((row) => row.year)
-    const categoryBreakdown = rows.reduce(
-      (acc, row) => {
-        acc[row.category]++
-        return acc
-      },
-      { tweak: 0, feature: 0, process: 0 } as Record<string, number>,
-    )
-
-    return {
-      totalRows: rows.length,
-      yearRange: {
-        min: Math.min(...years),
-        max: Math.max(...years),
-      },
-      categoryBreakdown,
-    }
-  }
-}
-

package/src/csv.ts

@@ -1,40 +0,0 @@
-import { writeFileSync } from "fs"
-import { AnalyzedCommit, CSVRow } from "./types"
-
-export class CSVService {
-  static generateCSV(commits: AnalyzedCommit[]): string {
-    const headers = "year,category,summary,description"
-    const rows = commits.map((commit) => this.formatRow(commit))
-
-    return [headers, ...rows].join("\n")
-  }
-
-  static exportToFile(commits: AnalyzedCommit[], filename: string): void {
-    const csvContent = this.generateCSV(commits)
-    writeFileSync(filename, csvContent, "utf8")
-  }
-
-  private static formatRow(commit: AnalyzedCommit): string {
-    const row: CSVRow = {
-      year: commit.year,
-      category: commit.analysis.category,
-      summary: commit.analysis.summary,
-      description: commit.analysis.description,
-    }
-
-    return [
-      row.year,
-      this.escapeCsvField(row.category),
-      this.escapeCsvField(row.summary),
-      this.escapeCsvField(row.description),
-    ].join(",")
-  }
-
-  private static escapeCsvField(field: string): string {
-    if (field.includes(",") || field.includes('"') || field.includes("\n")) {
-      return `"${field.replace(/"/g, '""')}"`
-    }
-    return field
-  }
-}
-

package/src/errors.ts

@@ -1,49 +0,0 @@
-export class CommitAnalyzerError extends Error {
-  constructor(
-    message: string,
-    public readonly code: string,
-  ) {
-    super(message)
-    this.name = "CommitAnalyzerError"
-  }
-}
-
-export class GitError extends CommitAnalyzerError {
-  constructor(message: string) {
-    super(message, "GIT_ERROR")
-  }
-}
-
-export class LLMError extends CommitAnalyzerError {
-  constructor(message: string) {
-    super(message, "LLM_ERROR")
-  }
-}
-
-export class ValidationError extends CommitAnalyzerError {
-  constructor(message: string) {
-    super(message, "VALIDATION_ERROR")
-  }
-}
-
-export class FileError extends CommitAnalyzerError {
-  constructor(message: string) {
-    super(message, "FILE_ERROR")
-  }
-}
-
-export function handleError(error: unknown): never {
-  if (error instanceof CommitAnalyzerError) {
-    console.error(`Error [${error.code}]: ${error.message}`)
-    process.exit(1)
-  }
-
-  if (error instanceof Error) {
-    console.error(`Unexpected error: ${error.message}`)
-    process.exit(1)
-  }
-
-  console.error("Unknown error occurred")
-  process.exit(1)
-}
-

package/src/git.ts

@@ -1,112 +0,0 @@
-import { execSync } from "child_process"
-import { CommitInfo } from "./types"
-
-export class GitService {
-  static async getCommitInfo(hash: string): Promise<CommitInfo> {
-    try {
-      const showOutput = execSync(
-        `git show --format="%H|%s|%ci" --no-patch "${hash}"`,
-        {
-          encoding: "utf8",
-          stdio: ["pipe", "pipe", "pipe"],
-        },
-      ).trim()
-
-      const [fullHash, message, dateStr] = showOutput.split("|")
-      const date = new Date(dateStr)
-      const year = date.getFullYear()
-
-      const diff = execSync(`git show "${hash}"`, {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-        maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large diffs
-      })
-
-      return {
-        hash: fullHash,
-        message,
-        date,
-        diff,
-        year,
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to get commit info for ${hash}: ${error instanceof Error ? error.message : "Unknown error"}`,
-      )
-    }
-  }
-
-  static validateCommitHash(hash: string): boolean {
-    try {
-      execSync(`git rev-parse --verify "${hash}"`, {
-        stdio: ["pipe", "pipe", "pipe"],
-      })
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  static isGitRepository(): boolean {
-    try {
-      execSync("git rev-parse --git-dir", {
-        stdio: ["pipe", "pipe", "pipe"],
-      })
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  static getCurrentUserEmail(): string {
-    try {
-      return execSync("git config user.email", {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-      }).trim()
-    } catch (error) {
-      throw new Error(
-        `Failed to get current user email: ${error instanceof Error ? error.message : "Unknown error"}`,
-      )
-    }
-  }
-
-  static getCurrentUserName(): string {
-    try {
-      return execSync("git config user.name", {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"],
-      }).trim()
-    } catch (error) {
-      throw new Error(
-        `Failed to get current user name: ${error instanceof Error ? error.message : "Unknown error"}`,
-      )
-    }
-  }
-
-  static getUserAuthoredCommits(author?: string, limit?: number): string[] {
-    try {
-      const authorFilter = author || this.getCurrentUserEmail()
-      const limitFlag = limit ? `--max-count=${limit}` : ""
-
-      const output = execSync(
-        `git log --author="${authorFilter}" --format="%H" --no-merges ${limitFlag}`,
-        {
-          encoding: "utf8",
-          stdio: ["pipe", "pipe", "pipe"],
-        },
-      ).trim()
-
-      if (!output) {
-        return []
-      }
-
-      return output.split("\n").filter((hash) => hash.length > 0)
-    } catch (error) {
-      throw new Error(
-        `Failed to get user authored commits: ${error instanceof Error ? error.message : "Unknown error"}`,
-      )
-    }
-  }
-}
-