@pasosdejesus/m 0.15.0

package/dist/tasks/e2e.d.ts

@@ -0,0 +1,2 @@
+export declare function runE2e(testPattern?: string, args?: string[]): Promise<void>;
+//# sourceMappingURL=e2e.d.ts.map

package/dist/tasks/e2e.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e.d.ts","sourceRoot":"","sources":["../../src/tasks/e2e.ts"],"names":[],"mappings":"AA2CA,wBAAsB,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,iBA6FrE"}

package/dist/tasks/e2e.js

@@ -0,0 +1,124 @@
+// test:e2e — Run E2E tests with Puppeteer + SIWE on OpenBSD/adJ
+import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { globSync } from 'glob';
+import { findChrome } from '../e2e/browser.js';
+import { problem, success, info, warn } from '../util/colors.js';
+import { createTranslator } from '../i18n/createTranslator.js';
+import { detectLocale } from '../util/locale.js';
+import commonCli from '../i18n/common-cli.js';
+const t = createTranslator(detectLocale(), {
+    en: {
+        'e2e.no_dir': 'No e2e/ directory found. Expected: e2e/specs/ or e2e/smoke/',
+        'e2e.no_chrome': 'Chrome not found — running smoke tests only. Set CHROME_PATH for browser tests.',
+        'e2e.fallback': 'No browser specs found in e2e/specs/ — falling back to smoke tests. Use --smoke to skip this warning.',
+        'e2e.no_specs': 'No spec files found in {{0}} matching: {{1}}',
+        'e2e.found': 'Found {{0}} spec(s)',
+        'e2e.running': '▶ {{0}}',
+        'e2e.failed': '  ✗ {{0}} failed (exit {{1}})',
+        'e2e.all_passed': 'All {{0}} spec(s) passed.',
+        'e2e.partial': '{{0}}/{{1}} spec(s) failed.',
+    },
+    es: {
+        'e2e.no_dir': 'No se encontró directorio e2e/. Esperado: e2e/specs/ o e2e/smoke/',
+        'e2e.no_chrome': 'Chrome no encontrado — ejecutando solo smoke tests. Define CHROME_PATH para pruebas con navegador.',
+        'e2e.fallback': 'No se encontraron specs en e2e/specs/ — usando smoke tests. Usa --smoke para evitar esta advertencia.',
+        'e2e.no_specs': 'No se encontraron archivos spec en {{0}} coincidiendo con: {{1}}',
+        'e2e.found': '{{0}} spec(s) encontrado(s)',
+        'e2e.running': '▶ {{0}}',
+        'e2e.failed': '  ✗ {{0}} falló (exit {{1}})',
+        'e2e.all_passed': 'Todos los {{0}} spec(s) pasaron.',
+        'e2e.partial': '{{0}}/{{1}} spec(s) fallaron.',
+    },
+}, commonCli);
+function findSpecs(subDir, pattern, e2eDir) {
+    const specDir = path.join(e2eDir, subDir);
+    if (!fs.existsSync(specDir))
+        return [];
+    const files = globSync(pattern, { cwd: specDir });
+    return files.map(f => ({ file: f, dir: specDir }));
+}
+export async function runE2e(testPattern, args = []) {
+    const cwd = process.cwd();
+    // If testPattern looks like a flag, move it to args
+    if (testPattern && testPattern.startsWith('--')) {
+        args.unshift(testPattern);
+        testPattern = undefined;
+    }
+    const smokeOnly = args.includes('--smoke');
+    const grepFilter = args.includes('--grep') ? args[args.indexOf('--grep') + 1] : null;
+    // 1. Detect e2e directory
+    const e2eDir = path.join(cwd, 'e2e');
+    if (!fs.existsSync(e2eDir)) {
+        problem(t("e2e.no_dir"));
+        process.exit(1);
+    }
+    // 2. Chrome check (skip for smoke-only)
+    let chromePath = null;
+    if (!smokeOnly) {
+        try {
+            chromePath = findChrome();
+        }
+        catch {
+            warn(t("e2e.no_chrome"));
+        }
+    }
+    // 3. Find specs — search in both specs/ and smoke/ when no flag specified
+    let specFiles = [];
+    // If pattern doesn't contain glob chars and isn't a full filename, wrap with *...*
+    let pattern = testPattern || '**/*.spec.mjs';
+    if (testPattern && !testPattern.includes('*') && !testPattern.endsWith('.spec.mjs')) {
+        pattern = `*${testPattern}*.spec.mjs`;
+    }
+    if (smokeOnly) {
+        specFiles = findSpecs('smoke', pattern, e2eDir);
+    }
+    else {
+        // Try specs/ first, then smoke/
+        specFiles = findSpecs('specs', pattern, e2eDir);
+        if (specFiles.length === 0) {
+            specFiles = findSpecs('smoke', pattern, e2eDir);
+            if (specFiles.length > 0) {
+                warn(t("e2e.fallback"));
+            }
+        }
+    }
+    // Apply grep filter
+    if (grepFilter && specFiles.length > 0) {
+        specFiles = specFiles.filter(s => s.file.includes(grepFilter));
+    }
+    if (specFiles.length === 0) {
+        const dirs = smokeOnly ? 'e2e/smoke/' : 'e2e/specs/ and e2e/smoke/';
+        info(t("e2e.no_specs", dirs, pattern));
+        process.exit(0);
+    }
+    info(t("e2e.found", String(specFiles.length)));
+    // 4. Run each spec
+    let failures = 0;
+    for (const { file, dir } of specFiles) {
+        const specPath = path.join(dir, file);
+        info(`\n▶ ${path.relative(e2eDir, specPath)}`);
+        const env = { ...process.env };
+        if (chromePath)
+            env.CHROME_PATH = chromePath;
+        const res = spawnSync('node', [specPath], {
+            stdio: 'inherit',
+            env,
+            cwd,
+        });
+        if (res.status !== 0) {
+            failures++;
+            problem(t("e2e.failed", file, String(res.status)));
+        }
+    }
+    // 5. Summary
+    if (failures === 0) {
+        success("\n" + t("e2e.all_passed", String(specFiles.length)));
+    }
+    else {
+        problem("\n" + t("e2e.partial", String(failures), String(specFiles.length)));
+    }
+    // process.exit() is mandatory in m CLI commands
+    process.exit(failures > 0 ? 1 : 0);
+}

package/dist/tasks/edit.d.ts

@@ -0,0 +1,7 @@
+export declare function getClipboard(): Promise<string>;
+export declare function setClipboard(content: string): Promise<void>;
+export declare function runAiEdit(options?: {
+    dryRun?: boolean;
+    input?: string;
+}): Promise<void>;
+//# sourceMappingURL=edit.d.ts.map

package/dist/tasks/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../src/tasks/edit.ts"],"names":[],"mappings":"AAgFA,wBAAsB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAsBpD;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBjE;AAmTD,wBAAsB,SAAS,CAAC,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,iBA0FjF"}

package/dist/tasks/edit.js

@@ -0,0 +1,471 @@
+import { readFile, writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { info, success, problem, warn } from '../util/colors.js';
+import { findBestMatch } from './fuzzy.js';
+import { createTranslator } from '../i18n/createTranslator.js';
+import { detectLocale } from '../util/locale.js';
+import commonCli from '../i18n/common-cli.js';
+const t = createTranslator(detectLocale(), {
+    en: {
+        'edit.dry_create': '   [DRY RUN] Would create: {{0}}',
+        'edit.created': '   ✅ Created: {{0}}',
+        'edit.dry_replace': '   [DRY RUN] Would replace: {{0}}',
+        'edit.replaced': '   ✅ Replaced: {{0}}',
+        'edit.dry_update': '   [DRY RUN] Would update: {{0}}',
+        'edit.updated': '   ✅ Updated: {{0}}',
+        'edit.fuzzy_match': '   ⚠️ Approximate match ({{0}}%) in {{1}}',
+        'edit.dry_fuzzy': '   [DRY RUN] Would update with fuzzy: {{0}}',
+        'edit.fuzzy_updated': '   ✅ Updated (fuzzy {{0}}%): {{1}}',
+        'edit.insufficient': '   ❌ Insufficient match ({{0}}%). Diagnostic copied to clipboard.',
+        'edit.read_error': '   ❌ Error reading {{0}}: {{1}}',
+        'edit.dry_delete': '   [DRY RUN] Would delete: {{0}}',
+        'edit.no_delete': '   ⚠️ Delete not implemented: {{0}}',
+        'edit.reading_file': '📁 Reading file: {{0}}',
+        'edit.reading_clipboard': '📋 Reading clipboard...',
+        'edit.empty_clipboard': '❌ Clipboard empty.',
+        'edit.analyzing': '🔍 Analyzing changes...',
+        'edit.no_changes': '❌ No changes found in expected format.',
+        'edit.found_changes': '📝 Found {{0}} change(s):',
+        'edit.dry_mode': '🏃‍♂️ DRY RUN MODE - Changes will not be applied:',
+        'edit.summary_dry': '📊 Summary (dry-run): {{0}} applicable changes, {{1}} problems',
+        'edit.summary_ok': '✅ Applied {{0}} change(s) successfully.',
+        'edit.summary_partial': '⚠️ {{0}} change(s) applied, {{1}} failed.',
+        'edit.saved': '📋 Content saved to: {{0}}',
+        'edit.view': '   View with: cat {{0}}',
+    },
+    es: {
+        'edit.dry_create': '   [DRY RUN] Crearía: {{0}}',
+        'edit.created': '   ✅ Creado: {{0}}',
+        'edit.dry_replace': '   [DRY RUN] Reemplazaría: {{0}}',
+        'edit.replaced': '   ✅ Reemplazado: {{0}}',
+        'edit.dry_update': '   [DRY RUN] Actualizaría: {{0}}',
+        'edit.updated': '   ✅ Actualizado: {{0}}',
+        'edit.fuzzy_match': '   ⚠️ Coincidencia aproximada ({{0}}%) en {{1}}',
+        'edit.dry_fuzzy': '   [DRY RUN] Actualizaría con fuzzy: {{0}}',
+        'edit.fuzzy_updated': '   ✅ Actualizado (fuzzy {{0}}%): {{1}}',
+        'edit.insufficient': '   ❌ Coincidencia insuficiente ({{0}}%). Diagnóstico copiado al portapapeles.',
+        'edit.read_error': '   ❌ Error leyendo {{0}}: {{1}}',
+        'edit.dry_delete': '   [DRY RUN] Eliminaría: {{0}}',
+        'edit.no_delete': '   ⚠️ Eliminación no implementada: {{0}}',
+        'edit.reading_file': '📁 Leyendo archivo: {{0}}',
+        'edit.reading_clipboard': '📋 Leyendo portapapeles...',
+        'edit.empty_clipboard': '❌ Portapapeles vacío.',
+        'edit.analyzing': '🔍 Analizando cambios...',
+        'edit.no_changes': '❌ No se encontraron cambios en el formato esperado.',
+        'edit.found_changes': '📝 Se encontraron {{0}} cambio(s):',
+        'edit.dry_mode': '🏃‍♂️ MODO PRUEBA (dry-run) - No se aplicarán cambios:',
+        'edit.summary_dry': '📊 Resumen (dry-run): {{0}} cambios aplicables, {{1}} problemas',
+        'edit.summary_ok': '✅ Aplicados {{0}} cambio(s) correctamente.',
+        'edit.summary_partial': '⚠️ {{0}} cambio(s) aplicados, {{1}} fallaron.',
+        'edit.saved': '📋 Contenido guardado en: {{0}}',
+        'edit.view': '   Puedes verlo con: cat {{0}}',
+    },
+}, commonCli);
+const TEMP_CLIPBOARD_FILE = join(tmpdir(), 'm_clipboard.txt');
+function isX11Available() {
+    if (!process.env.DISPLAY)
+        return false;
+    try {
+        execSync('xclip -version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getClipboard() {
+    if (isX11Available()) {
+        try {
+            const result = execSync('xclip -selection clipboard -o', {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore']
+            });
+            if (result.trim())
+                return result;
+        }
+        catch (err) {
+            // Fallar silenciosamente
+        }
+    }
+    try {
+        await access(TEMP_CLIPBOARD_FILE);
+        const content = await readFile(TEMP_CLIPBOARD_FILE, 'utf-8');
+        if (content.trim())
+            return content;
+    }
+    catch {
+        // No existe o está vacío
+    }
+    return '';
+}
+export async function setClipboard(content) {
+    if (isX11Available()) {
+        try {
+            execSync('xclip -selection clipboard', {
+                input: content,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'ignore', 'ignore']
+            });
+            return;
+        }
+        catch (err) {
+            // Fallar silenciosamente
+        }
+    }
+    await writeFile(TEMP_CLIPBOARD_FILE, content, 'utf-8');
+    info(t('edit.saved', TEMP_CLIPBOARD_FILE));
+    info(t('edit.view', TEMP_CLIPBOARD_FILE));
+}
+function parseDiffUnified(diffContent) {
+    const lines = diffContent.split('\n');
+    const original = [];
+    const modified = [];
+    let inHunk = false;
+    for (const line of lines) {
+        if (line.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (!inHunk)
+            continue;
+        if (line.startsWith('-') && !line.startsWith('---')) {
+            original.push(line.substring(1));
+        }
+        else if (line.startsWith('+') && !line.startsWith('+++')) {
+            modified.push(line.substring(1));
+        }
+        else if (line.startsWith(' ')) {
+            original.push(line.substring(1));
+            modified.push(line.substring(1));
+        }
+        else if (line.startsWith('\\')) {
+            continue;
+        }
+    }
+    return { original, modified };
+}
+function parseSearchReplace(content) {
+    const changes = [];
+    const regex = /## Edit:\s*`([^`]+)`\s*\n```(?:\w*)\n___BUSCAR_(\d+[T_]\d+)___\n([\s\S]+?)\n___REMPLAZAR_\d+[T_]\d+___\n([\s\S]+?)\n___FIN_(\d+[T_]\d+)___\n```/;
+    const match = regex.exec(content);
+    if (match) {
+        const buscarTimestamp = match[2];
+        const finTimestamp = match[5];
+        if (buscarTimestamp !== finTimestamp) {
+            return null;
+        }
+        changes.push({
+            file: match[1],
+            oldString: match[3].trim(),
+            newString: match[4].trim()
+        });
+    }
+    else {
+    }
+    return changes.length > 0 ? changes : null;
+}
+function parseFullFile(content) {
+    const regex = /^## Archivo:\s*`([^`]+)`\s*\n\s*```(\w*)\n([\s\S]+?)```/;
+    const match = content.match(regex);
+    if (match) {
+        return {
+            file: match[1],
+            language: match[2] || '',
+            code: match[3].trim()
+        };
+    }
+    return null;
+}
+function parseGitDiffHeader(content) {
+    const regex = /```diff\n(?:--git a\/(.+?) b\/.+?\n)?([\s\S]+?)```/;
+    const match = content.match(regex);
+    if (match) {
+        return {
+            file: match[1] || '',
+            diff: match[2]
+        };
+    }
+    return null;
+}
+function parseInlineDiff(content) {
+    const changes = [];
+    const searchReplaceChanges = parseSearchReplace(content);
+    if (searchReplaceChanges) {
+        return searchReplaceChanges.map(c => ({ file: c.file, original: c.oldString, modified: c.newString }));
+    }
+    const sections = content.split(/(?=^## Archivo:|^## Edit:|^```diff)/m);
+    for (let i = 0; i < sections.length; i++) {
+        const section = sections[i];
+        const fullFile = parseFullFile(section);
+        if (fullFile) {
+            changes.push({
+                file: fullFile.file,
+                original: '',
+                modified: fullFile.code
+            });
+            continue;
+        }
+        const gitDiff = parseGitDiffHeader(section);
+        if (gitDiff && gitDiff.file) {
+            const { original, modified } = parseDiffUnified(gitDiff.diff);
+            changes.push({
+                file: gitDiff.file,
+                original: original.join('\n'),
+                modified: modified.join('\n')
+            });
+            continue;
+        }
+        const diffMatch = section.match(/```diff\n([\s\S]+?)```/);
+        if (diffMatch) {
+            const diffLines = diffMatch[1].split('\n');
+            let fileName = '';
+            let diffContent = '';
+            for (const line of diffLines) {
+                if (line.startsWith('--- a/')) {
+                    fileName = line.substring(6);
+                }
+                else if (line.startsWith('+++ b/')) {
+                    fileName = line.substring(6);
+                }
+                else if (line.startsWith('--- ')) {
+                    // Formato: --- a/ruta.ts
+                    const match = line.match(/--- a\/(.+)/);
+                    if (match)
+                        fileName = match[1];
+                }
+                else if (line.startsWith('+++ ')) {
+                    const match = line.match(/\+\+\+ b\/(.+)/);
+                    if (match)
+                        fileName = match[1];
+                }
+                else {
+                    diffContent += line + '\n';
+                }
+            }
+            if (fileName || sections[i - 1]) {
+                // Si no encontramos fileName en el diff, usar el de la sección anterior
+                if (!fileName && sections[i - 1]) {
+                    const prevSection = sections[i - 1];
+                    const fileMatch = prevSection.match(/## Archivo: `([^`]+)`/);
+                    if (fileMatch)
+                        fileName = fileMatch[1];
+                }
+                const { original, modified } = parseDiffUnified(diffContent);
+                changes.push({
+                    file: fileName,
+                    original: original.join('\n'),
+                    modified: modified.join('\n')
+                });
+            }
+        }
+    }
+    return changes;
+}
+function detectChangeType(change) {
+    const original = change.original || '';
+    const modified = change.modified || '';
+    if (original.trim() === '' && modified.trim() !== '') {
+        return {
+            file: change.file,
+            type: 'create',
+            modified: modified
+        };
+    }
+    if (modified.trim() === '' && original.trim() !== '') {
+        return {
+            file: change.file,
+            type: 'delete',
+            original: original
+        };
+    }
+    return {
+        file: change.file,
+        type: 'update',
+        original: original,
+        modified: modified
+    };
+}
+async function applyChange(change, dryRun = false) {
+    const filePath = change.file.startsWith('/')
+        ? change.file
+        : join(process.cwd(), change.file);
+    switch (change.type) {
+        case 'create':
+            if (dryRun) {
+                info(t('edit.dry_create', change.file));
+                return true;
+            }
+            await writeFile(filePath, change.modified || '');
+            success(t("edit.created", change.file));
+            return true;
+        case 'update':
+            try {
+                const currentContent = await readFile(filePath, 'utf-8');
+                const modifiedContent = change.modified || '';
+                if (!change.original || change.original.trim() === '') {
+                    if (dryRun) {
+                        info(t("edit.dry_replace", change.file));
+                        return true;
+                    }
+                    await writeFile(filePath, modifiedContent);
+                    success(t("edit.replaced", change.file));
+                    return true;
+                }
+                // 1. Exact match
+                if (currentContent.includes(change.original)) {
+                    if (dryRun) {
+                        info(t("edit.dry_update", change.file));
+                        return true;
+                    }
+                    const newContent = currentContent.replace(change.original, modifiedContent);
+                    await writeFile(filePath, newContent);
+                    success(t("edit.updated", change.file));
+                    return true;
+                }
+                // Extraer extensión del archivo
+                const fileExt = change.file.split('.').pop() || '';
+                // 2. Fuzzy match
+                const best = findBestMatch(change.original, currentContent, 0.85, fileExt);
+                if (best.found) {
+                    const simPercent = Math.round(best.similarity * 100);
+                    warn(t("edit.fuzzy_match", String(simPercent), change.file));
+                    if (dryRun) {
+                        info(t("edit.dry_fuzzy", change.file));
+                        return true;
+                    }
+                    const newContent = currentContent.replace(best.text, modifiedContent);
+                    await writeFile(filePath, newContent);
+                    success(t("edit.fuzzy_updated", String(simPercent), change.file));
+                    return true;
+                }
+                // 3. Generar diagnóstico
+                const bestAny = findBestMatch(change.original, currentContent, 0);
+                const diagnostic = `❌ No se encontró el bloque original en ${change.file}
+        
+Similitud máxima encontrada: ${Math.round(bestAny.similarity * 100)}% (umbral mínimo: 85%)
+
+Bloque buscado (primeros 200 chars):
+\`\`\`
+${change.original.substring(0, 200)}${change.original.length > 200 ? '...' : ''}
+\`\`\`
+
+Bloque más similar encontrado:
+\`\`\`
+${bestAny.text.substring(0, 200)}${bestAny.text.length > 200 ? '...' : ''}
+\`\`\`
+
+Sugerencias para el agente:
+1. Pide al usuario ejecutar: ./bin/m ai:readfile ${change.file}
+2. Pídele que te pegue el contenido EXACTO del archivo
+3. Usa ese contenido como BUSCAR en tu SEARCH/REPLACE
+4. Si el archivo es grande (>2KB) o el bloque a reemplazar es muy extenso:
+   - Propón una refactorización para dividir el archivo en módulos más pequeños (ej: en lib/)
+   - O usa ./bin/m ai:writefile para crear un archivo nuevo simplificado
+   - O divide el cambio en múltiples reemplazos pequeños (uno por línea o bloque pequeño)
+5. El umbral de similitud actual es 85%; si la similitud es baja, el bloque no coincide`;
+                const { setClipboard } = await import('./edit.js');
+                await setClipboard(diagnostic);
+                problem(t("edit.insufficient", String(Math.round(bestAny.similarity * 100))));
+                return false;
+            }
+            catch (err) {
+                problem(t("edit.read_error", change.file, String(err)));
+                return false;
+            }
+        case 'delete':
+            if (dryRun) {
+                info(t("edit.dry_delete", change.file));
+                return true;
+            }
+            warn(t("edit.no_delete", change.file));
+            return false;
+        default:
+            return false;
+    }
+}
+export async function runAiEdit(options = {}) {
+    let content = options.input || '';
+    if (options.input) {
+        info(t("edit.reading_file", options.input));
+        content = await readFile(options.input, 'utf-8');
+    }
+    else {
+        info('📋 Leyendo portapapeles...');
+        content = await getClipboard();
+    }
+    if (!content) {
+        problem(t('edit.empty_clipboard'));
+        info('');
+        info('📋 Instrucciones:');
+        info('   1. Copia la respuesta de DeepSeek Chat (Ctrl+C o Cmd+C)');
+        info('   2. Ejecuta: ./bin/m ai:apply');
+        return;
+    }
+    info('🔍 Analizando cambios...');
+    const changesRaw = parseInlineDiff(content);
+    if (changesRaw.length === 0) {
+        problem('❌ No se encontraron cambios en el formato esperado.');
+        info('');
+        info('Formatos aceptados:');
+        info('');
+        info('1. SEARCH/REPLACE (recomendado):');
+        info('   ## Edit: `ruta/archivo.ts`');
+        info('   ```diff');
+        info('   ___BUSCAR_TIMESTAMP___');
+        info('   código original exacto');
+        info('   ___REMPLAZAR_TIMESTAMP___');
+        info('   código nuevo');
+        info('   ___FIN_TIMESTAMP___');
+        info('   ```');
+        info('');
+        info('2. Bloque completo:');
+        info('   ## Archivo: `ruta/archivo.ts`');
+        info('   ```typescript');
+        info('   // contenido completo');
+        info('   ```');
+        info('');
+        info('3. Diff unificado:');
+        info('   ```diff');
+        info('   - línea vieja');
+        info('   + línea nueva');
+        info('   ```');
+        info('');
+        info('💡 Si usas SEARCH/REPLACE, asegúrate de:');
+        info('   - El timestamp es el mismo en BUSCAR, REPLAZAR y FIN');
+        info('   - El código BUSCAR coincide EXACTAMENTE con el archivo');
+        info('   - Usa `ai:readfile` para copiar el contenido exacto');
+        return;
+    }
+    info(t("edit.found_changes", String(changesRaw.length)));
+    console.log('');
+    const changes = changesRaw.map(detectChangeType);
+    if (options.dryRun) {
+        info(t('edit.dry_mode'));
+        console.log('');
+    }
+    let successCount = 0;
+    let failCount = 0;
+    for (const change of changes) {
+        const ok = await applyChange(change, options.dryRun || false);
+        if (ok) {
+            successCount++;
+        }
+        else {
+            failCount++;
+        }
+    }
+    console.log('');
+    if (options.dryRun) {
+        info(t("edit.summary_dry", String(successCount), String(failCount)));
+    }
+    else {
+        if (failCount === 0) {
+            success(t("edit.summary_ok", String(successCount)));
+        }
+        else {
+            problem(t("edit.summary_partial", String(successCount), String(failCount)));
+        }
+    }
+}

package/dist/tasks/engine.d.ts

@@ -0,0 +1,2 @@
+export declare function runEngine(args: string[]): Promise<void>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/tasks/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/tasks/engine.ts"],"names":[],"mappings":"AA+HA,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,iBA+B7C"}