@jcjeon/integration-cli 0.2.0

package/apps/server/src/modules/changelog/changelog.service.ts

@@ -0,0 +1,690 @@
+import { execFileSync, execSync } from 'child_process';
+import { createHash } from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { JI_PATHS } from '../../common/ji-paths';
+import { AgentChangelogEntity, ChangeType } from '../../database/entities/agent-changelog.entity';
+
+interface ParsedFile {
+  filePath: string;
+  changeType: ChangeType;
+  patch: string;
+  fullPatch: string;
+  additions: number;
+  deletions: number;
+}
+
+export interface DirectorySnapshotEntry {
+  hash: string;
+  content: string | null;
+  isBinary: boolean;
+}
+
+export type DirectorySnapshot = Map<string, DirectorySnapshotEntry>;
+
+export interface AgentChangelog {
+  agentId: number;
+  files: Array<{
+    id: number;
+    filePath: string;
+    changeType: ChangeType;
+    additions: number;
+    deletions: number;
+    patch: string | null;
+    patchPath: string | null;
+  }>;
+}
+
+interface MergeResult {
+  success: boolean;
+  message: string;
+}
+
+const IGNORED_DIRS = new Set([
+  '.git',
+  '.ji',
+  '.next',
+  '.turbo',
+  'build',
+  'coverage',
+  'dist',
+  'node_modules',
+]);
+const MAX_TEXT_SNAPSHOT_BYTES = 1024 * 1024;
+
+@Injectable()
+export class GitChangelogService {
+  private readonly logger = new Logger(GitChangelogService.name);
+
+  constructor(
+    @InjectRepository(AgentChangelogEntity)
+    private readonly changelogRepo: Repository<AgentChangelogEntity>,
+  ) {}
+
+  isGitRepo(dir: string): boolean {
+    try {
+      execSync('git rev-parse --git-dir', { cwd: dir, stdio: 'ignore', timeout: 3000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getCurrentHead(repoDir: string): string {
+    return execSync('git rev-parse HEAD', { cwd: repoDir, encoding: 'utf8', timeout: 3000 }).trim();
+  }
+
+  getCurrentBranch(repoDir: string): string {
+    try {
+      const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: repoDir, encoding: 'utf8', timeout: 3000 }).trim();
+      return branch.replace(/[^a-zA-Z0-9._-]/g, '-').slice(0, 40);
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  getRepoRoot(dir: string): string {
+    return execSync('git rev-parse --show-toplevel', { cwd: dir, encoding: 'utf8', timeout: 3000 }).trim();
+  }
+
+  createWorktree(workingDir: string, agentType: string): { worktreePath: string; branchName: string; agentWorkDir: string } {
+    const repoRoot = this.getRepoRoot(workingDir);
+    const ts = Date.now();
+    const currentBranch = this.getCurrentBranch(workingDir);
+    const branchName = `${agentType}-${currentBranch}-${ts}`;
+    const worktreePath = path.join(JI_PATHS.worktrees, branchName);
+    fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+
+    execFileSync('git', ['worktree', 'add', worktreePath, '-b', branchName, 'HEAD'], {
+      cwd: repoRoot,
+      stdio: 'ignore',
+      timeout: 10000,
+    });
+
+    const relativeSubDir = path.relative(repoRoot, workingDir);
+    const agentWorkDir = relativeSubDir ? path.join(worktreePath, relativeSubDir) : worktreePath;
+
+    this.logger.log(`Worktree created: ${worktreePath} (branch: ${branchName}, agentDir: ${agentWorkDir})`);
+    return { worktreePath, branchName, agentWorkDir };
+  }
+
+  removeWorktree(repoDir: string, worktreePath: string, branchName: string): void {
+    try {
+      const repoRoot = this.getRepoRoot(repoDir);
+      execFileSync('git', ['worktree', 'remove', '--force', worktreePath], {
+        cwd: repoRoot,
+        stdio: 'ignore',
+        timeout: 10000,
+      });
+      execFileSync('git', ['branch', '-D', branchName], {
+        cwd: repoRoot,
+        stdio: 'ignore',
+        timeout: 5000,
+      });
+      this.logger.log(`Worktree removed: ${worktreePath} (branch: ${branchName})`);
+    } catch (err) {
+      this.logger.warn(`Failed to remove worktree (ignored): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  async captureAndSave(
+    taskId: string,
+    agentId: number,
+    worktreePath: string,
+    startCommitHash: string,
+    commitMessage: string,
+    runId?: number,
+  ): Promise<string | null> {
+    try {
+      execSync('git add -A', { cwd: worktreePath, stdio: 'ignore', timeout: 10000 });
+
+      const safeMsg = commitMessage.replace(/'/g, "'\\''");
+      execSync(
+        `git -c core.hooksPath=/dev/null commit --allow-empty -m '${safeMsg}'`,
+        { cwd: worktreePath, stdio: 'ignore', timeout: 10000 },
+      );
+
+      const snapshotSha = execSync('git rev-parse HEAD', {
+        cwd: worktreePath,
+        encoding: 'utf8',
+        timeout: 5000,
+      }).trim();
+
+      const diffOutput = execSync(`git diff "${startCommitHash}"..HEAD`, {
+        cwd: worktreePath,
+        encoding: 'utf8',
+        maxBuffer: 50 * 1024 * 1024,
+        timeout: 30000,
+      });
+
+      if (!diffOutput.trim()) {
+        this.logger.log(`Agent ${agentId}: no changes`);
+        return snapshotSha;
+      }
+
+      const files = this.parseDiff(diffOutput);
+      if (files.length) {
+        await this.saveParsedFiles(taskId, agentId, runId, files);
+        this.logger.log(`Agent ${agentId}: saved ${files.length} changelog file(s)`);
+      }
+
+      return snapshotSha;
+    } catch (err) {
+      this.logger.warn(`Agent ${agentId} changelog capture failed: ${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    }
+  }
+
+  createDirectorySnapshot(rootDir: string): DirectorySnapshot {
+    const snapshot: DirectorySnapshot = new Map();
+
+    try {
+      this.walkDirectory(rootDir, rootDir, snapshot);
+    } catch (err) {
+      this.logger.warn(`Directory snapshot failed (${rootDir}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    return snapshot;
+  }
+
+  async captureDirectoryAndSave(
+    taskId: string,
+    agentId: number,
+    rootDir: string,
+    before: DirectorySnapshot,
+    runId?: number,
+  ): Promise<number> {
+    try {
+      const after = this.createDirectorySnapshot(rootDir);
+      const files = this.diffDirectorySnapshots(before, after);
+
+      if (!files.length) {
+        this.logger.log(`Agent ${agentId}: no directory changes`);
+        return 0;
+      }
+
+      await this.saveParsedFiles(taskId, agentId, runId, files);
+      this.logger.log(`Agent ${agentId}: saved ${files.length} directory changelog file(s)`);
+      return files.length;
+    } catch (err) {
+      this.logger.warn(`Agent ${agentId} directory changelog capture failed: ${err instanceof Error ? err.message : String(err)}`);
+      return 0;
+    }
+  }
+
+  mergeToMain(mainRepoDir: string, snapshotSha: string, agentId: number): void {
+    try {
+      execSync(
+        `git -c core.hooksPath=/dev/null merge --no-ff "${snapshotSha}" -m "chore: apply agent-${agentId} changes"`,
+        { cwd: mainRepoDir, stdio: 'ignore', timeout: 30000 },
+      );
+      this.logger.log(`Agent ${agentId}: merged snapshot ${snapshotSha.slice(0, 7)}`);
+    } catch (err) {
+      this.logger.warn(`Agent ${agentId}: merge conflict; changelog remains available. ${err instanceof Error ? err.message : String(err)}`);
+      try {
+        execSync('git merge --abort', { cwd: mainRepoDir, stdio: 'ignore', timeout: 5000 });
+      } catch {}
+    }
+  }
+
+  mergeAll(worktreePath: string, workingDir: string): MergeResult {
+    if (!fs.existsSync(worktreePath)) {
+      return { success: false, message: `worktree 경로가 존재하지 않습니다: ${worktreePath}` };
+    }
+
+    try {
+      const repoRoot = this.getRepoRoot(workingDir);
+      const branchName = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+        cwd: worktreePath,
+        encoding: 'utf8',
+        timeout: 3000,
+      }).trim();
+
+      execFileSync(
+        'git',
+        ['-c', 'core.hooksPath=/dev/null', 'merge', '--no-ff', branchName],
+        { cwd: repoRoot, timeout: 30000 },
+      );
+      this.logger.log(`Merged branch ${branchName} into ${repoRoot}`);
+      return { success: true, message: '전체 병합이 완료되었습니다.' };
+    } catch (err) {
+      try {
+        const repoRoot = this.getRepoRoot(workingDir);
+        execFileSync('git', ['merge', '--abort'], { cwd: repoRoot });
+      } catch {}
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.warn(`Merge failed: ${msg}`);
+      return { success: false, message: msg };
+    }
+  }
+
+  mergeFile(worktreePath: string, workingDir: string, filePath: string): MergeResult {
+    if (!fs.existsSync(worktreePath)) {
+      return { success: false, message: `worktree 경로가 존재하지 않습니다: ${worktreePath}` };
+    }
+
+    try {
+      const safeFilePath = this.normalizeGitPathspec(filePath);
+      const repoRoot = this.getRepoRoot(workingDir);
+      const branchName = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+        cwd: worktreePath,
+        encoding: 'utf8',
+        timeout: 3000,
+      }).trim();
+
+      execFileSync('git', ['checkout', branchName, '--', safeFilePath], {
+        cwd: repoRoot,
+        timeout: 10000,
+      });
+      this.logger.log(`Merged file from worktree: ${safeFilePath}`);
+      return { success: true, message: `${safeFilePath} 병합이 완료되었습니다.` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.warn(`File merge failed (${filePath}): ${msg}`);
+      return { success: false, message: msg };
+    }
+  }
+
+  async mergeAllFromChangelog(taskId: string, agentId: number, workingDir: string): Promise<MergeResult> {
+    try {
+      const rows = await this.findLatestAgentRows(taskId, agentId);
+      if (!rows.length) {
+        return { success: false, message: '저장된 changelog patch가 없습니다.' };
+      }
+
+      const patchText = this.buildPatchText(rows);
+      if (!patchText) {
+        return { success: false, message: '저장된 changelog patch가 없거나 잘려 있습니다.' };
+      }
+
+      const repoRoot = this.getRepoRoot(workingDir);
+      this.applyPatchText(repoRoot, patchText);
+      return { success: true, message: '저장된 changelog patch를 적용했습니다.' };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.warn(`Stored changelog merge failed: ${msg}`);
+      return { success: false, message: msg };
+    }
+  }
+
+  async mergeFileFromChangelog(taskId: string, agentId: number, workingDir: string, filePath: string): Promise<MergeResult> {
+    try {
+      const safeFilePath = this.normalizeGitPathspec(filePath);
+      const rows = await this.findLatestAgentRows(taskId, agentId);
+      const row = rows.find((entry) => entry.filePath === safeFilePath);
+
+      if (!row) {
+        return { success: false, message: '이 파일의 저장된 changelog patch가 없습니다.' };
+      }
+
+      const patchText = this.readStoredPatch(row);
+      if (!patchText) {
+        return { success: false, message: '저장된 changelog patch가 없거나 잘려 있습니다.' };
+      }
+
+      const repoRoot = this.getRepoRoot(workingDir);
+      this.applyPatchText(repoRoot, patchText);
+      return { success: true, message: `${safeFilePath} 파일에 저장된 changelog patch를 적용했습니다.` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.warn(`Stored changelog file merge failed (${filePath}): ${msg}`);
+      return { success: false, message: msg };
+    }
+  }
+
+  async getLatestRunId(taskId: string): Promise<number | null> {
+    const row = await this.changelogRepo.findOne({
+      where: { taskId },
+      order: { runId: 'DESC' },
+      select: ['runId'],
+    });
+    return row?.runId ?? null;
+  }
+
+  async getByTask(taskId: string, runId?: number): Promise<AgentChangelog[]> {
+    const targetRunId = runId ?? (await this.getLatestRunId(taskId));
+
+    const rows = await this.changelogRepo.find({
+      where: targetRunId != null ? { taskId, runId: targetRunId } : { taskId },
+      order: { agentId: 'ASC', id: 'ASC' },
+    });
+
+    const byAgent = new Map<number, AgentChangelog>();
+    for (const row of rows) {
+      if (!byAgent.has(row.agentId)) {
+        byAgent.set(row.agentId, { agentId: row.agentId, files: [] });
+      }
+      byAgent.get(row.agentId)!.files.push({
+        id: row.id,
+        filePath: row.filePath,
+        changeType: row.changeType,
+        additions: row.additions,
+        deletions: row.deletions,
+        patch: row.patch,
+        patchPath: row.patchPath,
+      });
+    }
+
+    return Array.from(byAgent.values());
+  }
+
+  private async findLatestAgentRows(taskId: string, agentId: number): Promise<AgentChangelogEntity[]> {
+    const targetRunId = await this.getLatestRunId(taskId);
+    return this.changelogRepo.find({
+      where: targetRunId != null ? { taskId, agentId, runId: targetRunId } : { taskId, agentId },
+      order: { id: 'ASC' },
+    });
+  }
+
+  private buildPatchText(rows: AgentChangelogEntity[]): string | null {
+    const patches: string[] = [];
+    for (const row of rows) {
+      const patchText = this.readStoredPatch(row);
+      if (!patchText) return null;
+      patches.push(patchText.trimEnd());
+    }
+    return patches.length ? `${patches.join('\n')}\n` : null;
+  }
+
+  private readStoredPatch(row: AgentChangelogEntity): string | null {
+    try {
+      if (row.patchPath && fs.existsSync(row.patchPath)) {
+        return fs.readFileSync(row.patchPath, 'utf8');
+      }
+
+      if (row.patch && !row.patch.includes('\n... (truncated)')) {
+        return row.patch;
+      }
+
+      return null;
+    } catch (err) {
+      this.logger.warn(`Failed to read stored patch ${row.patchPath ?? row.id}: ${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    }
+  }
+
+  private applyPatchText(repoRoot: string, patchText: string): void {
+    const tempPath = path.join(JI_PATHS.patches, `.apply-${Date.now()}-${Math.random().toString(36).slice(2)}.patch`);
+    try {
+      fs.mkdirSync(JI_PATHS.patches, { recursive: true });
+      fs.writeFileSync(tempPath, patchText, 'utf8');
+      execFileSync('git', ['apply', '--index', '--whitespace=nowarn', tempPath], {
+        cwd: repoRoot,
+        timeout: 30000,
+      });
+    } finally {
+      try {
+        if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+      } catch {}
+    }
+  }
+
+  private async saveParsedFiles(
+    taskId: string,
+    agentId: number,
+    runId: number | undefined,
+    files: ParsedFile[],
+  ): Promise<void> {
+    await this.changelogRepo.save(
+      files.map((f, index) => {
+        const patchPath = this.writePatchFile(taskId, agentId, runId, f.filePath, f.fullPatch, index);
+        return this.changelogRepo.create({
+          taskId,
+          agentId,
+          runId: runId ?? null,
+          filePath: f.filePath,
+          changeType: f.changeType,
+          patch: f.patch,
+          patchPath,
+          additions: f.additions,
+          deletions: f.deletions,
+        });
+      }),
+    );
+  }
+
+  private walkDirectory(rootDir: string, currentDir: string, snapshot: DirectorySnapshot): void {
+    let entries: fs.Dirent[];
+
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (err) {
+      this.logger.warn(`Directory read skipped (${currentDir}): ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+
+      try {
+        if (entry.isDirectory()) {
+          if (!IGNORED_DIRS.has(entry.name)) {
+            this.walkDirectory(rootDir, fullPath, snapshot);
+          }
+          continue;
+        }
+
+        if (!entry.isFile()) continue;
+
+        const relativePath = this.toRelativeGitPath(rootDir, fullPath);
+        if (!relativePath) continue;
+
+        const snapshotEntry = this.readSnapshotEntry(fullPath);
+        if (snapshotEntry) {
+          snapshot.set(relativePath, snapshotEntry);
+        }
+      } catch (err) {
+        this.logger.warn(`Directory entry skipped (${fullPath}): ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+
+  private readSnapshotEntry(filePath: string): DirectorySnapshotEntry | null {
+    try {
+      const data = fs.readFileSync(filePath);
+      const hash = createHash('sha256').update(data).digest('hex');
+      const isBinary = this.isBinaryBuffer(data);
+      const content = !isBinary && data.byteLength <= MAX_TEXT_SNAPSHOT_BYTES
+        ? data.toString('utf8')
+        : null;
+
+      return { hash, content, isBinary };
+    } catch (err) {
+      this.logger.warn(`File snapshot skipped (${filePath}): ${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    }
+  }
+
+  private diffDirectorySnapshots(before: DirectorySnapshot, after: DirectorySnapshot): ParsedFile[] {
+    const paths = Array.from(new Set([...before.keys(), ...after.keys()])).sort();
+    const files: ParsedFile[] = [];
+
+    for (const filePath of paths) {
+      const beforeEntry = before.get(filePath);
+      const afterEntry = after.get(filePath);
+
+      if (beforeEntry && afterEntry && beforeEntry.hash === afterEntry.hash) continue;
+
+      const changeType: ChangeType = beforeEntry && afterEntry
+        ? 'modified'
+        : beforeEntry
+          ? 'deleted'
+          : 'added';
+
+      const beforeContent = beforeEntry?.content ?? null;
+      const afterContent = afterEntry?.content ?? null;
+      const fullPatch = this.buildDirectoryPatch(filePath, changeType, beforeContent, afterContent);
+      const additions = afterContent == null ? 0 : this.countContentLines(afterContent);
+      const deletions = beforeContent == null ? 0 : this.countContentLines(beforeContent);
+
+      files.push({
+        filePath,
+        changeType,
+        patch: fullPatch.length > 200_000 ? `${fullPatch.slice(0, 200_000)}\n... (truncated)` : fullPatch,
+        fullPatch,
+        additions,
+        deletions,
+      });
+    }
+
+    return files;
+  }
+
+  private buildDirectoryPatch(
+    filePath: string,
+    changeType: ChangeType,
+    beforeContent: string | null,
+    afterContent: string | null,
+  ): string {
+    const header = [`diff --git a/${filePath} b/${filePath}`];
+
+    if (changeType === 'added') header.push('new file mode 100644');
+    if (changeType === 'deleted') header.push('deleted file mode 100644');
+
+    const oldContent = changeType === 'added' ? '' : beforeContent;
+    const newContent = changeType === 'deleted' ? '' : afterContent;
+
+    if (oldContent == null || newContent == null) {
+      header.push('Binary files differ or file is too large to inline');
+      return `${header.join('\n')}\n`;
+    }
+
+    const beforeLines = this.countContentLines(oldContent);
+    const afterLines = this.countContentLines(newContent);
+    const oldPath = changeType === 'added' ? '/dev/null' : `a/${filePath}`;
+    const newPath = changeType === 'deleted' ? '/dev/null' : `b/${filePath}`;
+
+    header.push(`--- ${oldPath}`);
+    header.push(`+++ ${newPath}`);
+    header.push(`@@ -${this.formatHunkRange(beforeLines)} +${this.formatHunkRange(afterLines)} @@`);
+    header.push(this.prefixContentLines('-', oldContent).trimEnd());
+    header.push(this.prefixContentLines('+', newContent).trimEnd());
+
+    return `${header.filter((line) => line.length > 0).join('\n')}\n`;
+  }
+
+  private countContentLines(content: string): number {
+    if (!content) return 0;
+    const withoutTrailingNewline = content.endsWith('\n') ? content.slice(0, -1) : content;
+    return withoutTrailingNewline ? withoutTrailingNewline.split('\n').length : 0;
+  }
+
+  private formatHunkRange(lineCount: number): string {
+    return lineCount === 0 ? '0,0' : `1,${lineCount}`;
+  }
+
+  private prefixContentLines(prefix: string, content: string): string {
+    if (!content) return '';
+    const withoutTrailingNewline = content.endsWith('\n') ? content.slice(0, -1) : content;
+    if (!withoutTrailingNewline) return '';
+    return withoutTrailingNewline.split('\n').map((line) => `${prefix}${line}`).join('\n');
+  }
+
+  private isBinaryBuffer(data: Buffer): boolean {
+    return data.includes(0);
+  }
+
+  private toRelativeGitPath(rootDir: string, fullPath: string): string {
+    const relativePath = path.relative(rootDir, fullPath).replace(/\\/g, '/');
+    const normalized = path.posix.normalize(relativePath);
+
+    if (
+      !normalized ||
+      normalized === '.' ||
+      normalized === '..' ||
+      normalized.startsWith('../') ||
+      path.posix.isAbsolute(normalized)
+    ) {
+      return '';
+    }
+
+    return normalized;
+  }
+
+  private writePatchFile(
+    taskId: string,
+    agentId: number,
+    runId: number | undefined,
+    filePath: string,
+    patchText: string,
+    index: number,
+  ): string {
+    const runSegment = runId != null ? `run-${runId}` : 'run-unversioned';
+    const dir = path.join(
+      JI_PATHS.patches,
+      this.toPathSegment(taskId),
+      runSegment,
+      `agent-${agentId}`,
+    );
+    const filename = `${String(index + 1).padStart(3, '0')}-${this.toPathSegment(filePath).slice(0, 96)}.patch`;
+    const patchPath = path.join(dir, filename);
+
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(patchPath, patchText, 'utf8');
+    return patchPath;
+  }
+
+  private toPathSegment(value: string): string {
+    const sanitized = value.replace(/[^a-zA-Z0-9._-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+    return sanitized || 'item';
+  }
+
+  private normalizeGitPathspec(filePath: string): string {
+    const normalized = path.posix.normalize(filePath.replace(/\\/g, '/'));
+
+    if (
+      !filePath.trim() ||
+      normalized === '.' ||
+      normalized === '..' ||
+      normalized.startsWith('../') ||
+      path.posix.isAbsolute(normalized)
+    ) {
+      throw new Error(`유효하지 않은 파일 경로입니다: ${filePath}`);
+    }
+
+    return normalized;
+  }
+
+  private parseDiff(diff: string): ParsedFile[] {
+    const files: ParsedFile[] = [];
+    const sections = diff.split(/^diff --git /m).filter(Boolean);
+
+    for (const section of sections) {
+      const full = `diff --git ${section}`;
+      const lines = section.split('\n');
+      const header = lines[0] ?? '';
+      const match = header.match(/^a\/(.+?) b\/(.+)$/);
+      if (!match) continue;
+
+      const filePath = match[2];
+
+      let changeType: ChangeType = 'modified';
+      if (full.includes('\nnew file mode')) changeType = 'added';
+      else if (full.includes('\ndeleted file mode')) changeType = 'deleted';
+      else if (full.includes('\nrename from ')) changeType = 'renamed';
+
+      let additions = 0;
+      let deletions = 0;
+      for (const line of lines) {
+        if (line.startsWith('+') && !line.startsWith('+++')) additions++;
+        else if (line.startsWith('-') && !line.startsWith('---')) deletions++;
+      }
+
+      files.push({
+        filePath,
+        changeType,
+        patch: full.length > 200_000 ? `${full.slice(0, 200_000)}\n... (truncated)` : full,
+        fullPatch: full,
+        additions,
+        deletions,
+      });
+    }
+
+    return files;
+  }
+}