@timmeck/brain 1.9.0 → 2.1.0

package/src/services/code.service.ts

@@ -1,271 +0,0 @@
-import type { CodeModuleRecord } from '../types/code.types.js';
-import type { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
-import type { ProjectRepository } from '../db/repositories/project.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import { analyzeCode } from '../code/analyzer.js';
-import { fingerprintCode } from '../code/fingerprint.js';
-import { computeReusabilityScore } from '../code/scorer.js';
-import { detectGranularity } from '../code/registry.js';
-import { findExactMatches, findSemanticMatches, findStructuralMatches } from '../code/matcher.js';
-import { sha256 } from '../utils/hash.js';
-import { getEventBus } from '../utils/events.js';
-import { getLogger } from '../utils/logger.js';
-import type { EmbeddingEngine } from '../embeddings/engine.js';
-
-export interface AnalyzeInput {
-  project: string;
-  name: string;
-  filePath: string;
-  language: string;
-  source: string;
-  description?: string;
-}
-
-export interface FindReusableInput {
-  query?: string;
-  language?: string;
-  projectId?: number;
-  limit?: number;
-}
-
-export class CodeService {
-  private logger = getLogger();
-  private eventBus = getEventBus();
-  private embeddingEngine: EmbeddingEngine | null = null;
-
-  constructor(
-    private codeModuleRepo: CodeModuleRepository,
-    private projectRepo: ProjectRepository,
-    private synapseManager: SynapseManager,
-  ) {}
-
-  setEmbeddingEngine(engine: EmbeddingEngine): void {
-    this.embeddingEngine = engine;
-  }
-
-  analyzeAndRegister(input: AnalyzeInput): { moduleId: number; isNew: boolean; reusabilityScore: number } {
-    // Ensure project exists
-    let project = this.projectRepo.findByName(input.project);
-    if (!project) {
-      const id = this.projectRepo.create({ name: input.project, path: null, language: input.language, framework: null });
-      project = this.projectRepo.getById(id)!;
-    }
-
-    // Analyze the code
-    const analysis = analyzeCode(input.source, input.language);
-    const fingerprint = fingerprintCode(input.source, input.language);
-    const sourceHash = sha256(input.source);
-
-    // Check if module already exists (by fingerprint)
-    const existing = this.codeModuleRepo.findByFingerprint(fingerprint);
-    if (existing) {
-      // Source Hash Change Detection: compare hash to decide if re-analysis needed
-      if (existing.source_hash === sourceHash) {
-        // Unchanged — skip re-analysis
-        this.logger.debug(`Module ${existing.name} unchanged (hash match), skipping`);
-        this.synapseManager.strengthen(
-          { type: 'code_module', id: existing.id },
-          { type: 'project', id: project.id },
-          'uses_module',
-        );
-        return { moduleId: existing.id, isNew: false, reusabilityScore: existing.reusability_score };
-      }
-
-      // Hash changed — re-analyze
-      this.logger.info(`Module ${existing.name} changed (hash drift), re-analyzing`);
-      const reScore = computeReusabilityScore({
-        source: input.source,
-        filePath: input.filePath,
-        exports: analysis.exports,
-        internalDeps: analysis.internalDeps,
-        hasTypeAnnotations: analysis.hasTypeAnnotations,
-        complexity: analysis.complexity,
-      });
-
-      this.codeModuleRepo.update(existing.id, {
-        source_hash: sourceHash,
-        lines_of_code: analysis.linesOfCode,
-        complexity: analysis.complexity,
-        reusability_score: reScore,
-        updated_at: new Date().toISOString(),
-      });
-
-      // Re-index dependency synapses on change
-      this.indexDependencySynapses(existing.id, analysis.internalDeps, project.id);
-
-      this.synapseManager.strengthen(
-        { type: 'code_module', id: existing.id },
-        { type: 'project', id: project.id },
-        'uses_module',
-      );
-
-      this.eventBus.emit('module:updated', { moduleId: existing.id });
-
-      return { moduleId: existing.id, isNew: false, reusabilityScore: reScore };
-    }
-
-    // Compute reusability score (with complexity)
-    const reusabilityScore = computeReusabilityScore({
-      source: input.source,
-      filePath: input.filePath,
-      exports: analysis.exports,
-      internalDeps: analysis.internalDeps,
-      hasTypeAnnotations: analysis.hasTypeAnnotations,
-      complexity: analysis.complexity,
-    });
-
-    const granularity = detectGranularity(input.source, input.language);
-
-    const moduleId = this.codeModuleRepo.create({
-      project_id: project.id,
-      name: input.name,
-      file_path: input.filePath,
-      language: input.language,
-      fingerprint,
-      description: input.description ?? null,
-      source_hash: sourceHash,
-      lines_of_code: analysis.linesOfCode,
-      complexity: analysis.complexity,
-      reusability_score: reusabilityScore,
-    });
-
-    // Create synapse: module ↔ project
-    this.synapseManager.strengthen(
-      { type: 'code_module', id: moduleId },
-      { type: 'project', id: project.id },
-      'uses_module',
-    );
-
-    // Create dependency synapses for internal imports
-    this.indexDependencySynapses(moduleId, analysis.internalDeps, project.id);
-
-    // Compute and store pairwise module similarities
-    this.computeModuleSimilarities(moduleId, input.source, input.language);
-
-    this.eventBus.emit('module:registered', { moduleId, projectId: project.id });
-    this.logger.info(`Code module registered (id=${moduleId}, name=${input.name}, granularity=${granularity}, score=${reusabilityScore.toFixed(2)})`);
-
-    return { moduleId, isNew: true, reusabilityScore };
-  }
-
-  findReusable(input: FindReusableInput): CodeModuleRecord[] {
-    if (input.query) {
-      return this.codeModuleRepo.search(input.query);
-    }
-    if (input.language) {
-      return this.codeModuleRepo.findByLanguage(input.language, input.limit);
-    }
-    if (input.projectId) {
-      return this.codeModuleRepo.findByProject(input.projectId);
-    }
-    return [];
-  }
-
-  checkSimilarity(source: string, language: string): Array<{ moduleId: number; score: number; matchType: string }> {
-    const fingerprint = fingerprintCode(source, language);
-    const allModules = this.codeModuleRepo.findByLanguage(language);
-
-    const exact = findExactMatches(fingerprint, allModules);
-    if (exact.length > 0) return exact;
-
-    return findSemanticMatches(source, allModules, 0.5);
-  }
-
-  listModules(projectId?: number, language?: string, limit?: number): CodeModuleRecord[] {
-    if (projectId) {
-      return this.codeModuleRepo.findByProject(projectId);
-    }
-    if (language) {
-      return this.codeModuleRepo.findByLanguage(language, limit);
-    }
-    return this.codeModuleRepo.findAll(limit);
-  }
-
-  getById(id: number): CodeModuleRecord | undefined {
-    return this.codeModuleRepo.getById(id);
-  }
-
-  private computeModuleSimilarities(moduleId: number, source: string, language: string): void {
-    const allModules = this.codeModuleRepo.findByLanguage(language, 100);
-    const candidates = allModules.filter(m => m.id !== moduleId);
-    if (candidates.length === 0) return;
-
-    const matches = findStructuralMatches(source, language, candidates, 0.3);
-
-    // Get vector similarity scores if embedding engine is ready
-    const vectorScores = this.embeddingEngine?.isReady()
-      ? this.embeddingEngine.computeModuleVectorScores(moduleId, language)
-      : undefined;
-
-    // Merge structural matches with vector boost
-    const scoreMap = new Map<number, number>();
-    for (const match of matches) {
-      if (match.score >= 0.3 && match.moduleId !== moduleId) {
-        scoreMap.set(match.moduleId, match.score);
-      }
-    }
-
-    // Add vector-only matches that structural search missed
-    if (vectorScores) {
-      for (const [candId, vecScore] of vectorScores) {
-        if (vecScore >= 0.5 && candId !== moduleId) {
-          const existing = scoreMap.get(candId);
-          if (existing) {
-            // Boost structural score with vector similarity
-            scoreMap.set(candId, Math.min(1.0, existing + vecScore * 0.15));
-          } else {
-            // Vector-only match
-            scoreMap.set(candId, vecScore * 0.8);
-          }
-        }
-      }
-    }
-
-    for (const [candId, score] of scoreMap) {
-      this.codeModuleRepo.upsertSimilarity(moduleId, candId, score);
-
-      // High similarity → create synapse
-      if (score >= 0.7) {
-        this.synapseManager.strengthen(
-          { type: 'code_module', id: moduleId },
-          { type: 'code_module', id: candId },
-          'similar_to',
-        );
-      }
-    }
-  }
-
-  private indexDependencySynapses(moduleId: number, internalDeps: string[], projectId: number): void {
-    const projectModules = this.codeModuleRepo.findByProject(projectId);
-
-    for (const dep of internalDeps) {
-      // Normalize the dep path to match against registered modules
-      const depName = dep.replace(/^\.\//, '').replace(/\.\w+$/, '');
-
-      const target = projectModules.find(m => {
-        const modulePath = m.file_path.replace(/\\/g, '/').replace(/\.\w+$/, '');
-        return modulePath.endsWith(depName) || m.name === depName;
-      });
-
-      if (target && target.id !== moduleId) {
-        this.synapseManager.strengthen(
-          { type: 'code_module', id: moduleId },
-          { type: 'code_module', id: target.id },
-          'depends_on',
-        );
-      }
-    }
-  }
-
-  listProjects(): Array<{ id: number; name: string; path: string | null; language: string | null; framework: string | null; moduleCount: number }> {
-    const projects = this.projectRepo.getAll();
-    return projects.map(p => ({
-      id: p.id,
-      name: p.name,
-      path: p.path,
-      language: p.language,
-      framework: p.framework,
-      moduleCount: this.codeModuleRepo.findByProject(p.id).length,
-    }));
-  }
-}

package/src/services/error.service.ts

@@ -1,266 +0,0 @@
-import type { ErrorRecord } from '../types/error.types.js';
-import type { ErrorRepository } from '../db/repositories/error.repository.js';
-import type { ProjectRepository } from '../db/repositories/project.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import type { MatchingConfig } from '../types/config.types.js';
-import type { EmbeddingEngine } from '../embeddings/engine.js';
-import { parseError } from '../parsing/error-parser.js';
-import { generateFingerprint } from '../matching/fingerprint.js';
-import { matchError, type MatchResult } from '../matching/error-matcher.js';
-import { getEventBus } from '../utils/events.js';
-import { getLogger } from '../utils/logger.js';
-
-export interface ReportErrorInput {
-  project: string;
-  errorOutput: string;
-  filePath?: string;
-  terminalId?: number;
-  taskContext?: string;
-  workingDirectory?: string;
-  command?: string;
-}
-
-export interface ErrorQueryInput {
-  projectId?: number;
-  resolved?: boolean;
-  search?: string;
-  limit?: number;
-}
-
-export class ErrorService {
-  private logger = getLogger();
-  private eventBus = getEventBus();
-  private matchingConfig: MatchingConfig | null = null;
-  private embeddingEngine: EmbeddingEngine | null = null;
-
-  constructor(
-    private errorRepo: ErrorRepository,
-    private projectRepo: ProjectRepository,
-    private synapseManager: SynapseManager,
-    matchingConfig?: MatchingConfig,
-  ) {
-    this.matchingConfig = matchingConfig ?? null;
-  }
-
-  setEmbeddingEngine(engine: EmbeddingEngine): void {
-    this.embeddingEngine = engine;
-  }
-
-  report(input: ReportErrorInput): { errorId: number; isNew: boolean; matches: MatchResult[]; crossProjectMatches?: MatchResult[] } {
-    // 1. Ensure project exists
-    let project = this.projectRepo.findByName(input.project);
-    if (!project) {
-      const id = this.projectRepo.create({ name: input.project, path: null, language: null, framework: null });
-      project = this.projectRepo.getById(id)!;
-    }
-
-    // 2. Build context from available information
-    const context = this.buildContext(input);
-
-    // 3. Parse the error
-    const parsed = parseError(input.errorOutput);
-    if (!parsed) {
-      this.logger.warn('Could not parse error output');
-      const errorId = this.errorRepo.create({
-        project_id: project.id,
-        terminal_id: input.terminalId ?? null,
-        fingerprint: '',
-        type: 'UnknownError',
-        message: input.errorOutput.split('\n')[0] ?? input.errorOutput,
-        raw_output: input.errorOutput,
-        context,
-        file_path: input.filePath ?? null,
-        line_number: null,
-        column_number: null,
-      });
-      return { errorId, isNew: true, matches: [] };
-    }
-
-    // 4. Generate fingerprint
-    const fingerprint = generateFingerprint(parsed.errorType, parsed.message, parsed.frames);
-
-    // 5. Check for existing error with same fingerprint
-    const existing = this.errorRepo.findByFingerprint(fingerprint);
-    if (existing.length > 0) {
-      const err = existing[0]!;
-      this.errorRepo.incrementOccurrence(err.id);
-      // Update context if previously null
-      if (!err.context && context) {
-        this.errorRepo.update(err.id, { context });
-      }
-      this.logger.info(`Known error (id=${err.id}), occurrence incremented`);
-
-      // Strengthen synapse
-      this.synapseManager.strengthen(
-        { type: 'error', id: err.id },
-        { type: 'project', id: project.id },
-        'co_occurs',
-      );
-
-      return { errorId: err.id, isNew: false, matches: [] };
-    }
-
-    // 6. Create new error record
-    const errorId = this.errorRepo.create({
-      project_id: project.id,
-      terminal_id: input.terminalId ?? null,
-      fingerprint,
-      type: parsed.errorType,
-      message: parsed.message,
-      raw_output: input.errorOutput,
-      context,
-      file_path: parsed.sourceFile ?? input.filePath ?? null,
-      line_number: parsed.sourceLine ?? null,
-      column_number: null,
-    });
-
-    // 7. Create synapse: error ↔ project
-    this.synapseManager.strengthen(
-      { type: 'error', id: errorId },
-      { type: 'project', id: project.id },
-      'co_occurs',
-    );
-
-    // 8. Find similar errors
-    const candidates = this.errorRepo.findByProject(project.id)
-      .filter(e => e.id !== errorId);
-    const newError = this.errorRepo.getById(errorId)!;
-    const matches = matchError(newError, candidates);
-
-    // 9. Create similarity synapses for strong matches
-    for (const match of matches.filter(m => m.isStrong)) {
-      this.synapseManager.strengthen(
-        { type: 'error', id: errorId },
-        { type: 'error', id: match.errorId },
-        'similar_to',
-      );
-    }
-
-    // 10. Error Chain Detection: link to recent unresolved errors in same project
-    this.detectErrorChain(errorId, project.id);
-
-    // 11. Cross-Project Transfer Learning
-    let crossProjectMatches: MatchResult[] = [];
-    if (this.matchingConfig?.crossProjectMatching) {
-      crossProjectMatches = this.findCrossProjectMatches(newError, project.id);
-      for (const match of crossProjectMatches.filter(m => m.isStrong)) {
-        this.synapseManager.strengthen(
-          { type: 'error', id: errorId },
-          { type: 'error', id: match.errorId },
-          'cross_project',
-        );
-      }
-    }
-
-    this.eventBus.emit('error:reported', { errorId, projectId: project.id, fingerprint });
-    this.logger.info(`New error reported (id=${errorId}, type=${parsed.errorType})`);
-
-    return { errorId, isNew: true, matches, crossProjectMatches };
-  }
-
-  query(input: ErrorQueryInput): ErrorRecord[] {
-    if (input.search && input.search.trim()) {
-      return this.errorRepo.search(input.search.trim());
-    }
-    if (input.resolved === false) {
-      return this.errorRepo.findUnresolved(input.projectId);
-    }
-    if (input.projectId) {
-      return this.errorRepo.findByProject(input.projectId);
-    }
-    // Default: return recent errors (most recent first)
-    return this.errorRepo.findAll(input.limit ?? 100);
-  }
-
-  matchSimilar(errorId: number): MatchResult[] {
-    const error = this.errorRepo.getById(errorId);
-    if (!error) return [];
-
-    const candidates = this.errorRepo.findByProject(error.project_id)
-      .filter(e => e.id !== errorId);
-
-    // Hybrid search: include vector scores if embedding engine is available
-    const vectorScores = this.embeddingEngine?.isReady()
-      ? this.embeddingEngine.computeErrorVectorScores(errorId, error.project_id)
-      : undefined;
-
-    return matchError(error, candidates, vectorScores);
-  }
-
-  resolve(errorId: number, solutionId?: number): void {
-    this.errorRepo.update(errorId, {
-      resolved: 1,
-      resolved_at: new Date().toISOString(),
-    });
-
-    if (solutionId) {
-      this.eventBus.emit('error:resolved', { errorId, solutionId });
-    }
-  }
-
-  getById(id: number): ErrorRecord | undefined {
-    return this.errorRepo.getById(id);
-  }
-
-  countSince(since: string, projectId?: number): number {
-    return this.errorRepo.countSince(since, projectId);
-  }
-
-  getErrorChain(errorId: number): { parents: ErrorRecord[]; children: ErrorRecord[] } {
-    return {
-      parents: this.errorRepo.findChainParents(errorId),
-      children: this.errorRepo.findChainChildren(errorId),
-    };
-  }
-
-  private findCrossProjectMatches(error: ErrorRecord, currentProjectId: number): MatchResult[] {
-    const allProjects = this.projectRepo.getAll();
-    const otherProjects = allProjects.filter(p => p.id !== currentProjectId);
-    const weight = this.matchingConfig?.crossProjectWeight ?? 0.7;
-
-    const allMatches: MatchResult[] = [];
-    for (const project of otherProjects) {
-      const candidates = this.errorRepo.findByProject(project.id)
-        .filter(e => e.resolved === 1); // Only look at resolved errors from other projects
-      const matches = matchError(error, candidates);
-      // Apply cross-project weight discount
-      for (const match of matches) {
-        match.score *= weight;
-        match.isStrong = match.score >= 0.90;
-        allMatches.push(match);
-      }
-    }
-
-    return allMatches.sort((a, b) => b.score - a.score).slice(0, 5);
-  }
-
-  private detectErrorChain(newErrorId: number, projectId: number): void {
-    // Look for recent unresolved errors in the same project (last 10 minutes)
-    const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000).toISOString();
-    const recentErrors = this.errorRepo.findRecentByProject(projectId, tenMinutesAgo, 5);
-
-    for (const recent of recentErrors) {
-      if (recent.id === newErrorId) continue;
-      if (recent.resolved === 0) {
-        // This new error appeared while trying to fix a recent error → chain
-        this.errorRepo.createChain(recent.id, newErrorId, 'caused_by_fix');
-        this.synapseManager.strengthen(
-          { type: 'error', id: recent.id },
-          { type: 'error', id: newErrorId },
-          'causes',
-        );
-        this.logger.info(`Error chain: #${recent.id} → #${newErrorId} (caused_by_fix)`);
-        break; // Link to most recent parent only
-      }
-    }
-  }
-
-  private buildContext(input: ReportErrorInput): string | null {
-    const parts: string[] = [];
-    if (input.taskContext) parts.push(`task: ${input.taskContext}`);
-    if (input.command) parts.push(`command: ${input.command}`);
-    if (input.workingDirectory) parts.push(`cwd: ${input.workingDirectory}`);
-    if (input.filePath) parts.push(`file: ${input.filePath}`);
-    return parts.length > 0 ? parts.join(' | ') : null;
-  }
-}

package/src/services/git.service.ts

@@ -1,132 +0,0 @@
-import { execSync } from 'node:child_process';
-import type Database from 'better-sqlite3';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import { getLogger } from '../utils/logger.js';
-
-export interface GitCommitInfo {
-  hash: string;
-  message: string;
-  author: string;
-  timestamp: string;
-  filesChanged: number;
-  insertions: number;
-  deletions: number;
-}
-
-export class GitService {
-  private logger = getLogger();
-
-  constructor(
-    private db: Database.Database,
-    private synapseManager: SynapseManager,
-  ) {}
-
-  /**
-   * Get current git info for context enrichment
-   */
-  getGitContext(cwd?: string): { branch: string | null; diff: string | null; lastCommit: string | null } {
-    try {
-      const opts = cwd ? { cwd, timeout: 5000 } : { timeout: 5000 };
-      const branch = execSync('git rev-parse --abbrev-ref HEAD', { ...opts, encoding: 'utf8' }).trim();
-      const diff = execSync('git diff --stat HEAD', { ...opts, encoding: 'utf8' }).trim();
-      const lastCommit = execSync('git log -1 --pretty=format:"%H %s"', { ...opts, encoding: 'utf8' }).trim();
-      return { branch, diff: diff || null, lastCommit };
-    } catch {
-      return { branch: null, diff: null, lastCommit: null };
-    }
-  }
-
-  /**
-   * Store a git commit and link it to an error
-   */
-  linkErrorToCommit(errorId: number, projectId: number, commitHash: string, relationship: string = 'introduced_by'): void {
-    try {
-      // Store commit info
-      const commitInfo = this.getCommitInfo(commitHash);
-      if (commitInfo) {
-        this.db.prepare(`
-          INSERT OR IGNORE INTO git_commits (project_id, commit_hash, message, author, timestamp, files_changed, insertions, deletions)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(projectId, commitInfo.hash, commitInfo.message, commitInfo.author, commitInfo.timestamp,
-          commitInfo.filesChanged, commitInfo.insertions, commitInfo.deletions);
-      }
-
-      // Link error to commit
-      this.db.prepare(`
-        INSERT OR IGNORE INTO error_commits (error_id, commit_hash, relationship)
-        VALUES (?, ?, ?)
-      `).run(errorId, commitHash, relationship);
-
-      this.logger.info(`Linked error #${errorId} to commit ${commitHash.slice(0, 8)} (${relationship})`);
-    } catch (err) {
-      this.logger.warn(`Failed to link error to commit: ${err}`);
-    }
-  }
-
-  /**
-   * Find which commit introduced an error
-   */
-  findIntroducingCommit(errorId: number): Array<{ commitHash: string; message: string; relationship: string }> {
-    const rows = this.db.prepare(`
-      SELECT ec.commit_hash, ec.relationship, gc.message
-      FROM error_commits ec
-      LEFT JOIN git_commits gc ON ec.commit_hash = gc.commit_hash
-      WHERE ec.error_id = ?
-      ORDER BY ec.created_at DESC
-    `).all(errorId) as Array<{ commit_hash: string; message: string | null; relationship: string }>;
-
-    return rows.map(r => ({
-      commitHash: r.commit_hash,
-      message: r.message ?? 'unknown',
-      relationship: r.relationship,
-    }));
-  }
-
-  /**
-   * Find errors introduced by a specific commit
-   */
-  findErrorsByCommit(commitHash: string): Array<{ errorId: number; relationship: string }> {
-    const rows = this.db.prepare(`
-      SELECT error_id, relationship FROM error_commits WHERE commit_hash = ?
-    `).all(commitHash) as Array<{ error_id: number; relationship: string }>;
-
-    return rows.map(r => ({ errorId: r.error_id, relationship: r.relationship }));
-  }
-
-  /**
-   * Capture current git diff for error context
-   */
-  captureDiff(cwd?: string): string | null {
-    try {
-      const opts = cwd ? { cwd, timeout: 5000, encoding: 'utf8' as const } : { timeout: 5000, encoding: 'utf8' as const };
-      const diff = execSync('git diff HEAD --no-color', opts).trim();
-      // Truncate to avoid huge diffs
-      return diff.length > 5000 ? diff.slice(0, 5000) + '\n... (truncated)' : diff || null;
-    } catch {
-      return null;
-    }
-  }
-
-  private getCommitInfo(hash: string, cwd?: string): GitCommitInfo | null {
-    try {
-      const opts = cwd ? { cwd, timeout: 5000, encoding: 'utf8' as const } : { timeout: 5000, encoding: 'utf8' as const };
-      const info = execSync(`git log -1 --pretty=format:"%H|||%s|||%an|||%aI" ${hash}`, opts).trim();
-      const [commitHash, message, author, timestamp] = info.split('|||');
-
-      const stat = execSync(`git diff --stat ${hash}~1..${hash}`, opts).trim();
-      const statMatch = stat.match(/(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/);
-
-      return {
-        hash: commitHash ?? hash,
-        message: message ?? '',
-        author: author ?? '',
-        timestamp: timestamp ?? new Date().toISOString(),
-        filesChanged: parseInt(statMatch?.[1] ?? '0', 10),
-        insertions: parseInt(statMatch?.[2] ?? '0', 10),
-        deletions: parseInt(statMatch?.[3] ?? '0', 10),
-      };
-    } catch {
-      return null;
-    }
-  }
-}