deepdebug-local-agent 1.0.22 → 1.1.0

package/src/patch-manager.js

@@ -3,14 +3,14 @@ import path from 'path';
 import crypto from 'crypto';
 
 /**
- * PatchManager - Sistema robusto de aplicação de patches
+ * PatchManager - Robust patch application system
  *
  * Features:
- * - Validação rigorosa de unified diff
- * - Sistema de backup com rollback
- * - Mensagens de erro detalhadas
- * - Suporte a múltiplos arquivos
- * - Cleanup automático de backups antigos
+ * - Strict unified diff validation
+ * - Backup system with rollback
+ * - Detailed error messages
+ * - Multi-file support
+ * - Automatic cleanup of old backups
  */
 export class PatchManager {
     constructor(workspaceRoot) {
@@ -24,8 +24,8 @@ export class PatchManager {
     // ============================================
 
     /**
-     * Valida se o diff está no formato unified diff correto
-     * @param {string} diffText - Texto do diff
+     * Validates whether the diff is in the correct unified diff format
+     * @param {string} diffText - Diff text
      * @returns {ValidationResult} - { valid: boolean, errors: string[] }
      */
     validateDiff(diffText) {
@@ -37,7 +37,7 @@ export class PatchManager {
 
         const lines = diffText.split('\n');
 
-        // Verificar se tem pelo menos os headers básicos
+        // Check that it has at least the basic headers
         const hasOldFileHeader = lines.some(l => l.startsWith('--- '));
         const hasNewFileHeader = lines.some(l => l.startsWith('+++ '));
         const hasHunkHeader = lines.some(l => /^@@ -\d+,?\d* \+\d+,?\d* @@/.test(l));
@@ -52,7 +52,7 @@ export class PatchManager {
             errors.push('Missing hunk header (@@ -line,count +line,count @@)');
         }
 
-        // Validar estrutura dos hunks
+        // Validate the structure of the hunks
         const hunkErrors = this._validateHunks(lines);
         errors.push(...hunkErrors);
 
@@ -63,9 +63,9 @@ export class PatchManager {
     }
 
     /**
-     * Faz parse do diff em estrutura manipulável
-     * @param {string} diffText - Texto do diff
-     * @returns {ParsedPatch} - Estrutura parseada do patch
+     * Parses the diff into a manipulable structure
+     * @param {string} diffText - Diff text
+     * @returns {ParsedPatch} - Parsed patch structure
      */
     parseDiff(diffText) {
         const validation = this.validateDiff(diffText);
@@ -81,7 +81,7 @@ export class PatchManager {
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
 
-            // Detectar início de novo arquivo
+            // Detect the start of a new file
             if (line.startsWith('--- ')) {
                 if (currentPatch) {
                     if (currentHunk) {
@@ -104,7 +104,7 @@ export class PatchManager {
                 continue;
             }
 
-            // Detectar início de hunk
+            // Detect the start of a hunk
             const hunkMatch = line.match(/^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@(.*)$/);
             if (hunkMatch && currentPatch) {
                 if (currentHunk) {
@@ -122,18 +122,18 @@ export class PatchManager {
                 continue;
             }
 
-            // Coletar linhas do hunk
+            // Collect the hunk lines
             if (currentHunk && (line.startsWith(' ') || line.startsWith('+') || line.startsWith('-') || line === '')) {
                 const type = line.startsWith('+') ? 'add' :
                     line.startsWith('-') ? 'remove' : 'context';
                 currentHunk.lines.push({
                     type,
-                    content: line.substring(1) // Remove o prefixo
+                    content: line.substring(1) // Remove the prefix
                 });
             }
         }
 
-        // Adicionar último patch/hunk
+        // Add the last patch/hunk
         if (currentPatch) {
             if (currentHunk) {
                 currentPatch.hunks.push(currentHunk);
@@ -153,40 +153,40 @@ export class PatchManager {
     }
 
     /**
-     * Cria backup de um arquivo
-     * @param {string} filePath - Caminho relativo do arquivo
+     * Creates a backup of a file
+     * @param {string} filePath - Relative path of the file
      * @returns {Promise<BackupResult>}
      */
     async backupFile(filePath) {
         const fullPath = path.join(this.workspaceRoot, filePath);
 
-        // Verificar se arquivo existe
+        // Check whether the file exists
         try {
             await fs.access(fullPath);
         } catch {
             throw new PatchError('FILE_NOT_FOUND', `File not found: ${filePath}`);
         }
 
-        // Criar diretório de backup
+        // Create the backup directory
         await this._ensureBackupDir();
 
-        // Ler conteúdo original
+        // Read the original content
         const originalContent = await fs.readFile(fullPath, 'utf8');
 
-        // Gerar ID único para o backup
+        // Generate a unique ID for the backup
         const timestamp = Date.now();
         const hash = crypto.createHash('md5').update(filePath + timestamp).digest('hex').substring(0, 8);
         const backupId = `${timestamp}-${hash}`;
 
-        // Criar nome do arquivo de backup
+        // Build the backup file name
         const safeFileName = filePath.replace(/[\/\\]/g, '_');
         const backupFileName = `${backupId}_${safeFileName}`;
         const backupPath = path.join(this.backupDir, backupFileName);
 
-        // Salvar backup
+        // Save the backup
         await fs.writeFile(backupPath, originalContent, 'utf8');
 
-        // Salvar metadados
+        // Save the metadata
         const metadataPath = path.join(this.backupDir, `${backupId}.meta.json`);
         const metadata = {
             backupId,
@@ -199,10 +199,10 @@ export class PatchManager {
         };
         await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), 'utf8');
 
-        // Cleanup de backups antigos
+        // Cleanup of old backups
         await this._cleanupOldBackups(filePath);
 
-        console.log(`📦 Backup created: ${backupId} for ${filePath}`);
+        console.log(`📦 Backup created: ${backupId} for ${filePath}`);
 
         return {
             backupId,
@@ -214,9 +214,9 @@ export class PatchManager {
     }
 
     /**
-     * Aplica um patch parseado ao workspace
-     * @param {ParsedPatch} parsedPatch - Resultado do parseDiff
-     * @param {object} options - Opções { createBackup: boolean, dryRun: boolean }
+     * Applies a parsed patch to the workspace
+     * @param {ParsedPatch} parsedPatch - Result of parseDiff
+     * @param {object} options - Options { createBackup: boolean, dryRun: boolean }
      * @returns {Promise<ApplyResult>}
      */
     async applyPatch(parsedPatch, options = {}) {
@@ -237,20 +237,20 @@ export class PatchManager {
             }
 
             try {
-                // Criar backup se solicitado
+                // Create a backup if requested
                 if (createBackup && !dryRun) {
                     const backup = await this.backupFile(targetPath);
                     backups.push(backup);
                 }
 
-                // Ler arquivo original
+                // Read the original file
                 const fullPath = path.join(this.workspaceRoot, targetPath);
                 let originalContent;
 
                 try {
                     originalContent = await fs.readFile(fullPath, 'utf8');
                 } catch (err) {
-                    // Arquivo novo sendo criado
+                    // A new file is being created
                     if (patch.oldFile === '/dev/null' || patch.oldFile.endsWith('/dev/null')) {
                         originalContent = '';
                     } else {
@@ -258,10 +258,10 @@ export class PatchManager {
                     }
                 }
 
-                // Aplicar cada hunk
+                // Apply each hunk
                 const originalLines = originalContent.split('\n');
                 let modifiedLines = [...originalLines];
-                let offset = 0; // Offset causado por adições/remoções anteriores
+                let offset = 0; // Offset caused by previous additions/removals
 
                 for (let hunkIndex = 0; hunkIndex < patch.hunks.length; hunkIndex++) {
                     const hunk = patch.hunks[hunkIndex];
@@ -275,11 +275,11 @@ export class PatchManager {
                     offset = hunkResult.newOffset;
                 }
 
-                // Salvar arquivo modificado (se não for dry run)
+                // Save the modified file (unless it is a dry run)
                 if (!dryRun) {
                     const newContent = modifiedLines.join('\n');
                     await fs.writeFile(fullPath, newContent, 'utf8');
-                    console.log(`✅ Patched: ${targetPath}`);
+                    console.log(`✅ Patched: ${targetPath}`);
                 }
 
                 results.push({
@@ -290,14 +290,14 @@ export class PatchManager {
                 });
 
             } catch (err) {
-                // Rollback dos backups já criados nesta operação
+                // Roll back the backups already created in this operation
                 if (!dryRun && backups.length > 0) {
-                    console.log(`⚠️ Rolling back ${backups.length} backups due to error...`);
+                    console.log(`⚠️ Rolling back ${backups.length} backups due to error...`);
                     for (const backup of backups) {
                         try {
                             await this.rollback(backup.backupId);
                         } catch (rollbackErr) {
-                            console.error(`❌ Rollback failed for ${backup.backupId}: ${rollbackErr.message}`);
+                            console.error(`❌ Rollback failed for ${backup.backupId}: ${rollbackErr.message}`);
                         }
                     }
                 }
@@ -308,7 +308,7 @@ export class PatchManager {
                     error: err instanceof PatchError ? err.message : err.toString()
                 });
 
-                // Parar no primeiro erro
+                // Stop at the first error
                 break;
             }
         }
@@ -326,14 +326,14 @@ export class PatchManager {
     }
 
     /**
-     * Restaura um arquivo do backup
-     * @param {string} backupId - ID do backup
+     * Restores a file from a backup
+     * @param {string} backupId - Backup ID
      * @returns {Promise<boolean>}
      */
     async rollback(backupId) {
         const metadataPath = path.join(this.backupDir, `${backupId}.meta.json`);
 
-        // Ler metadados
+        // Read the metadata
         let metadata;
         try {
             const metadataContent = await fs.readFile(metadataPath, 'utf8');
@@ -342,7 +342,7 @@ export class PatchManager {
             throw new PatchError('BACKUP_NOT_FOUND', `Backup not found: ${backupId}`);
         }
 
-        // Ler conteúdo do backup
+        // Read the backup content
         const backupFullPath = path.join(this.backupDir, path.basename(metadata.backupPath));
         let backupContent;
         try {
@@ -351,22 +351,22 @@ export class PatchManager {
             throw new PatchError('BACKUP_CORRUPTED', `Backup file corrupted or missing: ${backupId}`);
         }
 
-        // Verificar checksum
+        // Verify the checksum
         const currentChecksum = crypto.createHash('md5').update(backupContent).digest('hex');
         if (currentChecksum !== metadata.checksum) {
             throw new PatchError('CHECKSUM_MISMATCH', `Backup checksum mismatch for ${backupId}`);
         }
 
-        // Restaurar arquivo original
+        // Restore the original file
         await fs.writeFile(metadata.fullPath, backupContent, 'utf8');
 
-        console.log(`🔄 Rolled back: ${metadata.originalPath} from backup ${backupId}`);
+        console.log(`🔄 Rolled back: ${metadata.originalPath} from backup ${backupId}`);
 
         return true;
     }
 
     /**
-     * Lista todos os backups disponíveis
+     * Lists all available backups
      * @returns {Promise<BackupInfo[]>}
      */
     async listBackups() {
@@ -391,18 +391,18 @@ export class PatchManager {
                     size: metadata.size
                 });
             } catch {
-                // Ignorar arquivos de metadados corrompidos
+                // Ignore corrupted metadata files
             }
         }
 
-        // Ordenar por timestamp (mais recente primeiro)
+        // Sort by timestamp (most recent first)
         backups.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
 
         return backups;
     }
 
     /**
-     * Aplica patch de forma segura com backup automático e rollback em falha
+     * Applies a patch safely with automatic backup and rollback on failure
      * @param {string} diffText - Texto do diff
      * @param {string} incidentId - ID do incident (para logging)
      * @returns {Promise<SafePatchResult>}
@@ -410,10 +410,10 @@ export class PatchManager {
     async safePatch(diffText, incidentId = null) {
         const startTime = Date.now();
 
-        console.log(`🔧 SafePatch starting${incidentId ? ` for incident ${incidentId}` : ''}...`);
-        console.log(`📝 Diff size: ${diffText.length} characters`);
+        console.log(`🔧 SafePatch starting${incidentId ? ` for incident ${incidentId}` : ''}...`);
+        console.log(`📝 Diff size: ${diffText.length} characters`);
 
-        // 1. Validar diff
+        // 1. Validate the diff
         const validation = this.validateDiff(diffText);
         if (!validation.valid) {
             return {
@@ -424,11 +424,11 @@ export class PatchManager {
             };
         }
 
-        // 2. Parsear diff
+        // 2. Parse the diff
         let parsed;
         try {
             parsed = this.parseDiff(diffText);
-            console.log(`📊 Parsed: ${parsed.totalFiles} file(s), ${parsed.totalHunks} hunk(s)`);
+            console.log(`📊 Parsed: ${parsed.totalFiles} file(s), ${parsed.totalHunks} hunk(s)`);
         } catch (err) {
             return {
                 success: false,
@@ -438,7 +438,7 @@ export class PatchManager {
             };
         }
 
-        // 3. Aplicar com backup
+        // 3. Apply with backup
         let result;
         try {
             result = await this.applyPatch(parsed, { createBackup: true, dryRun: false });
@@ -454,7 +454,7 @@ export class PatchManager {
         const duration = Date.now() - startTime;
 
         if (result.success) {
-            console.log(`✅ SafePatch completed in ${duration}ms`);
+            console.log(`✅ SafePatch completed in ${duration}ms`);
             return {
                 success: true,
                 filesModified: result.filesModified,
@@ -464,7 +464,7 @@ export class PatchManager {
                 duration
             };
         } else {
-            console.log(`❌ SafePatch failed: ${result.results.find(r => !r.success)?.error}`);
+            console.log(`❌ SafePatch failed: ${result.results.find(r => !r.success)?.error}`);
             return {
                 success: false,
                 error: result.results.find(r => !r.success)?.error || 'Unknown error',
@@ -479,7 +479,7 @@ export class PatchManager {
     // ============================================
 
     /**
-     * Valida a estrutura dos hunks
+     * Validates the structure of the hunks
      */
     _validateHunks(lines) {
         const errors = [];
@@ -493,10 +493,10 @@ export class PatchManager {
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
 
-            // Detectar início de hunk
+            // Detect the start of a hunk
             const hunkMatch = line.match(/^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@/);
             if (hunkMatch) {
-                // Verificar hunk anterior
+                // Check the previous hunk
                 if (inHunk) {
                     if (actualOldLines !== expectedOldLines) {
                         errors.push(`Hunk #${hunkNumber}: expected ${expectedOldLines} old lines, got ${actualOldLines}`);
@@ -515,7 +515,7 @@ export class PatchManager {
                 continue;
             }
 
-            // Contar linhas dentro do hunk
+            // Count lines inside the hunk
             if (inHunk) {
                 if (line.startsWith(' ')) {
                     actualOldLines++;
@@ -525,16 +525,16 @@ export class PatchManager {
                 } else if (line.startsWith('+')) {
                     actualNewLines++;
                 } else if (line.startsWith('\\')) {
-                    // "" - ignorar
+                    // "" - ignore
                 } else if (line.startsWith('diff ') || line.startsWith('index ') ||
                     line.startsWith('--- ') || line.startsWith('+++ ')) {
-                    // Novo arquivo, resetar
+                    // New file, reset
                     inHunk = false;
                 }
             }
         }
 
-        // Verificar último hunk
+        // Check the last hunk
         if (inHunk) {
             if (actualOldLines !== expectedOldLines && expectedOldLines > 0) {
                 errors.push(`Hunk #${hunkNumber}: expected ${expectedOldLines} old lines, got ${actualOldLines}`);
@@ -548,17 +548,17 @@ export class PatchManager {
     }
 
     /**
-     * Extrai o caminho do arquivo do header
+     * Extracts the file path from the header
      */
     _extractFilePath(line, prefix) {
         let filePath = line.substring(prefix.length).trim();
 
-        // Remover prefixo a/ ou b/
+        // Remove the a/ or b/ prefix
         if (filePath.startsWith('a/') || filePath.startsWith('b/')) {
             filePath = filePath.substring(2);
         }
 
-        // Remover timestamp se presente (git diff format)
+        // Remove the timestamp if present (git diff format)
         const tabIndex = filePath.indexOf('\t');
         if (tabIndex > 0) {
             filePath = filePath.substring(0, tabIndex);
@@ -568,7 +568,7 @@ export class PatchManager {
     }
 
     /**
-     * Aplica um único hunk ao array de linhas
+     * Applies a single hunk to the array of lines
      */
     _applyHunk(lines, hunk, offset, hunkNumber) {
         let startLine = hunk.oldStart - 1 + offset; // 0-indexed
@@ -609,24 +609,24 @@ export class PatchManager {
         // Context verified (exact or fuzzy match) - apply the changes
         const newLines = [...lines];
 
-        // Calcular quantas linhas remover e quais linhas adicionar
+        // Calculate how many lines to remove and which lines to add
         const linesToAdd = hunk.lines.filter(l => l.type === 'add').map(l => l.content);
         const removeCount = hunk.lines.filter(l => l.type === 'remove').length;
         const contextAndRemoveCount = originalLines.length;
 
-        // Construir o novo conteúdo para esta seção
+        // Build the new content for this section
         const newSectionLines = [];
         for (const hunkLine of hunk.lines) {
             if (hunkLine.type === 'context' || hunkLine.type === 'add') {
                 newSectionLines.push(hunkLine.content);
             }
-            // 'remove' lines são ignoradas (não vão para o novo conteúdo)
+            // 'remove' lines are ignored (they do not go into the new content)
         }
 
-        // Substituir a seção antiga pela nova
+        // Replace the old section with the new one
         newLines.splice(startLine, contextAndRemoveCount, ...newSectionLines);
 
-        // Calcular novo offset
+        // Calculate the new offset
         const addedCount = linesToAdd.length;
         const newOffset = offset + addedCount - removeCount;
 
@@ -640,7 +640,7 @@ export class PatchManager {
     }
 
     /**
-     * Trunca string para exibição
+     * Truncates a string for display
      */
     /**
      * Check if context lines match at a given position in the file.
@@ -682,19 +682,19 @@ export class PatchManager {
     }
 
     /**
-     * Garante que o diretório de backup existe
+     * Ensures the backup directory exists
      */
     async _ensureBackupDir() {
         try {
             await fs.access(this.backupDir);
         } catch {
             await fs.mkdir(this.backupDir, { recursive: true });
-            console.log(`📁 Created backup directory: ${this.backupDir}`);
+            console.log(`📁 Created backup directory: ${this.backupDir}`);
         }
     }
 
     /**
-     * Remove backups antigos para um arquivo específico
+     * Removes old backups for a specific file
      */
     async _cleanupOldBackups(originalPath) {
         const backups = await this.listBackups();
@@ -704,7 +704,7 @@ export class PatchManager {
             return;
         }
 
-        // Remover backups mais antigos
+        // Remove the oldest backups
         const toRemove = fileBackups.slice(this.maxBackupsPerFile);
 
         for (const backup of toRemove) {
@@ -715,9 +715,9 @@ export class PatchManager {
                 await fs.unlink(path.join(this.backupDir, backupFileName));
                 await fs.unlink(path.join(this.backupDir, `${backup.backupId}.meta.json`));
 
-                console.log(`🗑️ Removed old backup: ${backup.backupId}`);
+                console.log(`🗑️ Removed old backup: ${backup.backupId}`);
             } catch (err) {
-                console.warn(`⚠️ Failed to remove old backup ${backup.backupId}: ${err.message}`);
+                console.warn(`⚠️ Failed to remove old backup ${backup.backupId}: ${err.message}`);
             }
         }
     }

package/src/patch_bkp.js

@@ -5,8 +5,8 @@ import pkg from "unidiff";
 const { parsePatch, applyPatch } = pkg;
 
 /**
- * Aplica um unified diff ao arquivo alvo.
- * VERSION 2: Melhor logging e fallback para replace direto.
+ * Applies a unified diff to the target file.
+ * VERSION 2: Better logging and fallback to direct replace.
  */
 export async function applyUnifiedDiff(root, diffText) {
     console.log("🔧 [patch_bkp.js] Applying unified diff...");
@@ -17,14 +17,14 @@ export async function applyUnifiedDiff(root, diffText) {
         throw new Error("Empty diff text provided");
     }
 
-    // Log primeiras linhas do diff para debug
+    // Log the first lines of the diff for debugging
     const diffLines = diffText.split("\n");
     console.log("📋 Diff preview:");
     for (let i = 0; i < Math.min(10, diffLines.length); i++) {
         console.log(`   ${i + 1}: ${diffLines[i]}`);
     }
 
-    // Parse o diff
+    // Parse the diff
     let patches;
     try {
         patches = parsePatch(diffText);
@@ -45,7 +45,7 @@ export async function applyUnifiedDiff(root, diffText) {
         hunks: p?.hunks?.length || 0
     });
 
-    // Descobre path alvo a partir do patch
+    // Determine the target path from the patch
     const targetRel =
         p?.newFileName?.replace(/^b\//, "") ||
         p?.oldFileName?.replace(/^a\//, "");
@@ -59,12 +59,12 @@ export async function applyUnifiedDiff(root, diffText) {
     const full = path.join(root, targetRel);
     console.log("📄 Full path:", full);
 
-    // Verificar se arquivo existe
+    // Check whether the file exists
     if (!(await exists(full))) {
         throw new Error(`Target file not found: ${full}`);
     }
 
-    // Ler arquivo original
+    // Read the original file
     let original;
     try {
         original = await readFile(full, "utf8");
@@ -73,7 +73,7 @@ export async function applyUnifiedDiff(root, diffText) {
         throw new Error(`Failed to read target file: ${readErr.message}`);
     }
 
-    // Tentar aplicar o patch
+    // Try to apply the patch
     let result;
     try {
         result = applyPatch(original, p);
@@ -84,13 +84,13 @@ export async function applyUnifiedDiff(root, diffText) {
     }
 
     if (result === false) {
-        // Log mais detalhes sobre por que falhou
+        // Log more details about why it failed
         console.error("❌ Patch failed to apply. Possible reasons:");
         console.error("   - Line numbers don't match current file");
         console.error("   - Context lines don't match");
         console.error("   - File was modified since diff was generated");
 
-        // Log hunks para debug
+        // Log hunks for debugging
         if (p.hunks) {
             for (const hunk of p.hunks) {
                 console.error(`   Hunk: @@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
@@ -100,7 +100,7 @@ export async function applyUnifiedDiff(root, diffText) {
         throw new Error("Patch failed to apply - context mismatch");
     }
 
-    // Escrever resultado
+    // Write the result
     try {
         await writeFile(full, result, "utf8");
         console.log("✅ Patch applied successfully!");
@@ -118,7 +118,7 @@ export async function applyUnifiedDiff(root, diffText) {
 }
 
 /**
- * Conta quantas linhas foram alteradas
+ * Counts how many lines were changed
  */
 function countChangedLines(patch) {
     if (!patch.hunks) return 0;
@@ -132,8 +132,8 @@ function countChangedLines(patch) {
 }
 
 /**
- * Fallback: aplica substituição direta do arquivo
- * Usado quando o patch unidiff falha mas temos o conteúdo completo
+ * Fallback: applies a direct file replacement
+ * Used when the unidiff patch fails but we have the full content
  */
 export async function applyDirectReplace(root, targetRel, newContent) {
     console.log("🔄 [patch_bkp.js] Applying direct replace...");