@pasosdejesus/m 0.15.0

package/dist/tasks/engine.js

@@ -0,0 +1,149 @@
+// src/tasks/engine.ts
+// Engine management: setup, list, check for shared modules (WBA, credentials, etc.)
+import fs from 'fs';
+import path from 'path';
+import { success, info, problem } 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: {
+        'engine.unknown': 'Unknown engine command: {{0}}. Use: wba:setup, credentials:setup, list, check',
+    },
+    es: {
+        'engine.unknown': 'Comando de motor desconocido: {{0}}. Use: wba:setup, credentials:setup, list, check',
+    },
+}, commonCli);
+function getArg(args, name) {
+    const idx = args.indexOf(name);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : null;
+}
+function nextMigrationNumber(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.sql'));
+    const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+    return `${timestamp}${String(files.length + 1).padStart(3, '0')}`;
+}
+async function cmdWbaSetup() {
+    const migrateDir = path.join(process.cwd(), 'db', 'migrate');
+    const num = nextMigrationNumber(migrateDir);
+    const webEventPath = path.join(migrateDir, `${num}_create_web_event.sql`);
+    fs.writeFileSync(webEventPath, `-- Migration: create web_event table for WBA analytics
+CREATE TABLE IF NOT EXISTS web_event (
+  id SERIAL PRIMARY KEY,
+  session_id VARCHAR(64),
+  event_type VARCHAR(40) NOT NULL,
+  pathname VARCHAR(200),
+  locale VARCHAR(5),
+  referrer VARCHAR(500),
+  user_agent VARCHAR(500),
+  ip VARCHAR(45),
+  wallet VARCHAR(42),
+  metadata JSONB,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+`);
+    const num2 = nextMigrationNumber(migrateDir);
+    const txPath = path.join(migrateDir, `${num2}_create_transaction.sql`);
+    fs.writeFileSync(txPath, `-- Migration: create transaction table for WBA analytics
+-- Required columns: crypto, amount, wallet
+-- Run: bin/m db:migrate
+CREATE TABLE IF NOT EXISTS transaction (
+  id SERIAL PRIMARY KEY,
+  crypto VARCHAR(10) NOT NULL,
+  amount NUMERIC NOT NULL,
+  wallet VARCHAR(42) NOT NULL,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+`);
+    success(`✅ WBA migrations created:`);
+    console.log(`   ${webEventPath}`);
+    console.log(`   ${txPath}`);
+    console.log(`   Run: bin/m db:migrate`);
+}
+async function cmdCredentialsSetup() {
+    const migrateDir = path.join(process.cwd(), 'db', 'migrate');
+    const num = nextMigrationNumber(migrateDir);
+    const metaPath = path.join(migrateDir, `${num}_create_credential_metadata.sql`);
+    fs.writeFileSync(metaPath, `-- Migration: create credential_metadata cache table
+CREATE TABLE IF NOT EXISTS credential_metadata (
+  token_id INTEGER NOT NULL,
+  chain_id VARCHAR(20) NOT NULL DEFAULT 'celo',
+  name VARCHAR(255) NOT NULL,
+  type VARCHAR(50) NOT NULL,
+  site VARCHAR(50) NOT NULL,
+  is_premium BOOLEAN DEFAULT false,
+  is_soulbound BOOLEAN DEFAULT true,
+  image_url TEXT NOT NULL,
+  updated_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (token_id, chain_id)
+);
+`);
+    const num2 = nextMigrationNumber(migrateDir);
+    const emissionPath = path.join(migrateDir, `${num2}_create_credential_emission.sql`);
+    fs.writeFileSync(emissionPath, `-- Migration: create credential_emission tracking table
+-- Adjust wallet_address or usuario_id per project needs
+CREATE TABLE IF NOT EXISTS credential_emission (
+  id BIGSERIAL PRIMARY KEY,
+  wallet_address VARCHAR(42) NOT NULL,
+  token_id INTEGER NOT NULL,
+  chain_id VARCHAR(20) NOT NULL DEFAULT 'celo',
+  emitted_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  UNIQUE(wallet_address, token_id, chain_id)
+);
+`);
+    success(`✅ Credential migrations created:`);
+    console.log(`   ${metaPath}`);
+    console.log(`   ${emissionPath}`);
+    console.log(`   Run: bin/m db:migrate`);
+}
+async function cmdList() {
+    console.log('Available engines:');
+    console.log('  wba           — Web analytics (web_event + transaction)');
+    console.log('  credentials   — Blockchain credentials (credential_metadata + credential_emission)');
+    console.log();
+    console.log('Install: bin/m eng:<name>:setup');
+    console.log('Verify:  bin/m eng:check');
+}
+async function cmdCheck() {
+    info('Verifying engine schemas...');
+    const { runDbCheck } = await import('./db.js');
+    await runDbCheck();
+}
+export async function runEngine(args) {
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        console.log('Engine commands:');
+        console.log('  eng:wba:setup              — Create WBA migration files');
+        console.log('  eng:credentials:setup       — Create credential migration files');
+        console.log('  eng:list                    — List available engines');
+        console.log('  eng:check                   — Verify engine schemas');
+    }
+    const command = args[0];
+    const rest = args.slice(1);
+    try {
+        if (command === 'wba' && rest[0] === 'setup') {
+            await cmdWbaSetup();
+        }
+        else if (command === 'credentials' && rest[0] === 'setup') {
+            await cmdCredentialsSetup();
+        }
+        else {
+            switch (command) {
+                case 'list':
+                    await cmdList();
+                    break;
+                case 'check':
+                    await cmdCheck();
+                    break;
+                default:
+                    problem(t('engine.unknown', command));
+                    throw new Error(t('engine.unknown', command));
+            }
+        }
+    }
+    catch (err) {
+        problem(err.message || String(err));
+        throw err;
+    }
+}

package/dist/tasks/env-diff.d.ts

@@ -0,0 +1,2 @@
+export declare function runEnvDiff(baseFile?: string, targetFile?: string): Promise<void>;
+//# sourceMappingURL=env-diff.d.ts.map

package/dist/tasks/env-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-diff.d.ts","sourceRoot":"","sources":["../../src/tasks/env-diff.ts"],"names":[],"mappings":"AA0DA,wBAAsB,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,iBA2FtE"}

package/dist/tasks/env-diff.js

@@ -0,0 +1,140 @@
+/**
+ * env:diff — Compares two .env files.
+ *
+ * Without arguments: compares ../.env.example against ../.env.
+ * With arguments:    env:diff <base> <target>
+ *
+ * Reports four categories:
+ *   1. Variables only in base (missing in target) — most prominent
+ *   2. Variables only in target (not in base)
+ *   3. Variables with different values — horizontal list
+ *   4. Variables with equal values — horizontal list
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { problem, success, info, warn } from '../util/colors.js';
+function parseEnvFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const vars = {};
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.substring(0, eqIdx).trim();
+            const value = trimmed.substring(eqIdx + 1);
+            if (key)
+                vars[key] = value;
+        }
+        return vars;
+    }
+    catch {
+        return null;
+    }
+}
+function formatHorizontalList(items, maxWidth = 78) {
+    if (items.length === 0)
+        return '';
+    let line = '';
+    const lines = [];
+    for (let i = 0; i < items.length; i++) {
+        const sep = i < items.length - 1 ? ', ' : '';
+        const candidate = line + items[i] + sep;
+        if (candidate.length > maxWidth && line.length > 0) {
+            lines.push(line.trimEnd());
+            line = '  ' + items[i] + sep;
+        }
+        else {
+            line = candidate;
+        }
+    }
+    if (line.trim())
+        lines.push(line.trimEnd());
+    return lines.join('\n');
+}
+export async function runEnvDiff(baseFile, targetFile) {
+    if (baseFile === '--help' || baseFile === '-h'
+        || targetFile === '--help' || targetFile === '-h') {
+        info('Uso: m env:diff [base] [target]');
+        info('  Sin argumentos: compara ../.env.example vs ../.env');
+        info('  Con 1 argumento: compara ../.env.example vs el archivo dado');
+        info('  Con 2 argumentos: compara base vs target');
+        return;
+    }
+    if (!baseFile && !targetFile) {
+        baseFile = path.join(process.cwd(), '..', '.env.example');
+        targetFile = path.join(process.cwd(), '..', '.env');
+    }
+    else if (baseFile && !targetFile) {
+        targetFile = baseFile;
+        baseFile = path.join(process.cwd(), '..', '.env.example');
+    }
+    const baseVars = parseEnvFile(baseFile);
+    const targetVars = parseEnvFile(targetFile);
+    if (baseVars === null) {
+        problem(`No se pudo leer: ${baseFile}`);
+        process.exit(2);
+    }
+    if (targetVars === null) {
+        problem(`No se pudo leer: ${targetFile}`);
+        process.exit(2);
+    }
+    const baseKeys = new Set(Object.keys(baseVars));
+    const targetKeys = new Set(Object.keys(targetVars));
+    const onlyBase = [...baseKeys].filter(k => !targetKeys.has(k)).sort();
+    const onlyTarget = [...targetKeys].filter(k => !baseKeys.has(k)).sort();
+    const common = [...baseKeys].filter(k => targetKeys.has(k)).sort();
+    const different = [];
+    const equal = [];
+    for (const key of common) {
+        if (baseVars[key] === targetVars[key]) {
+            equal.push(key);
+        }
+        else {
+            different.push(key);
+        }
+    }
+    console.log();
+    info(`  Base:  ${baseFile} (${baseKeys.size} variables)`);
+    info(`  Target: ${targetFile} (${targetKeys.size} variables)`);
+    console.log();
+    let hasDiff = false;
+    if (onlyBase.length > 0) {
+        hasDiff = true;
+        warn('⚠ Solo en .env.example (faltan en .env):');
+        for (const k of onlyBase)
+            console.log(`  ${k}`);
+        console.log();
+    }
+    if (onlyTarget.length > 0) {
+        hasDiff = true;
+        warn('⚠ Solo en .env (no están en .env.example):');
+        for (const k of onlyTarget)
+            console.log(`  ${k}`);
+        console.log();
+    }
+    if (different.length > 0) {
+        hasDiff = true;
+        warn('≠ Diferentes:');
+        console.log(formatHorizontalList(different));
+        console.log();
+    }
+    if (!hasDiff) {
+        success('✓ .env.example y .env son idénticos.');
+        process.exit(0);
+    }
+    if (equal.length > 0) {
+        if (equal.length > 10) {
+            success(`= Iguales: ${equal.length} variables`);
+        }
+        else {
+            success('= Iguales:');
+            console.log(formatHorizontalList(equal));
+        }
+        console.log();
+    }
+    process.exit(1);
+}

package/dist/tasks/fuzzy.d.ts

@@ -0,0 +1,9 @@
+export declare function similarity(a: string, b: string, maxDistance?: number): number;
+export declare function findBestMatch(search: string, content: string, threshold?: number, fileExt?: string): {
+    found: boolean;
+    text: string;
+    similarity: number;
+    startIndex: number;
+    endIndex: number;
+};
+//# sourceMappingURL=fuzzy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy.d.ts","sourceRoot":"","sources":["../../src/tasks/fuzzy.ts"],"names":[],"mappings":"AA2GA,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAM7E;AAGD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,MAAa,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG;IAC1G,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAmEA"}

package/dist/tasks/fuzzy.js

@@ -0,0 +1,153 @@
+// Funciones de fuzzy matching optimizadas para ai:edit
+// Reglas de normalización por extensión de archivo
+const rulesByExtension = {
+    // Lenguajes donde es SEGURO normalizar comillas
+    'js': { normalizeWhitespace: true, normalizePunctuationSpacing: true, normalizeQuotes: true, normalizeQuoteType: 'unify' },
+    'ts': { normalizeWhitespace: true, normalizePunctuationSpacing: true, normalizeQuotes: true, normalizeQuoteType: 'unify' },
+    'jsx': { normalizeWhitespace: true, normalizePunctuationSpacing: true, normalizeQuotes: true, normalizeQuoteType: 'unify' },
+    'tsx': { normalizeWhitespace: true, normalizePunctuationSpacing: true, normalizeQuotes: true, normalizeQuoteType: 'unify' },
+    // Archivos de texto plano
+    'md': { normalizeWhitespace: true, normalizePunctuationSpacing: true, normalizeQuotes: true, normalizeQuoteType: 'unify' },
+    'txt': { normalizeWhitespace: true, normalizePunctuationSpacing: true, normalizeQuotes: true, normalizeQuoteType: 'unify' },
+    // Por defecto: NO normalizar nada (seguro)
+    'default': { normalizeWhitespace: false, normalizePunctuationSpacing: false, normalizeQuotes: false, normalizeQuoteType: 'preserve' }
+};
+function getNormalizationRules(fileExt) {
+    if (!fileExt)
+        return rulesByExtension.default;
+    return rulesByExtension[fileExt] || rulesByExtension.default;
+}
+// Normalizar texto para comparación rápida (fingerprint)
+function quickFingerprint(str) {
+    return str
+        .replace(/\s+/g, ' ') // espacios múltiples → uno
+        .replace(/\t/g, ' ') // tabs → espacios
+        .replace(/[“”]/g, '"') // comillas curvas → rectas
+        .replace(/[‘’]/g, "'") // comillas simples curvas → rectas
+        .slice(0, 200); // solo primeros 200 caracteres para fingerprint
+}
+// Normalización completa para fuzzy matching (configurable por tipo de archivo)
+function normalizeForFuzzy(str, rules) {
+    let result = str;
+    if (rules.normalizeWhitespace) {
+        result = result
+            .replace(/\s+/g, ' ')
+            .replace(/\t/g, ' ');
+    }
+    if (rules.normalizeQuotes) {
+        result = result
+            .replace(/[“”]/g, '"')
+            .replace(/[‘’]/g, "'");
+        if (rules.normalizeQuoteType === 'unify') {
+            result = result.replace(/['"]/g, '"');
+        }
+    }
+    else {
+        // Solo normalizar comillas curvas a rectas, pero mantener diferencia
+        result = result
+            .replace(/[“”]/g, '"')
+            .replace(/[‘’]/g, "'");
+    }
+    if (rules.normalizePunctuationSpacing) {
+        result = result.replace(/\s*([;:,.!?])\s*/g, '$1');
+    }
+    return result.trim();
+}
+// Distancia de Levenshtein optimizada (solo calcular si es necesario)
+function levenshtein(a, b, maxDistance) {
+    // Si se especifica distancia máxima, podemos abortar temprano
+    const m = a.length;
+    const n = b.length;
+    if (Math.abs(m - n) > (maxDistance || 100)) {
+        return (maxDistance || 100) + 1;
+    }
+    let prev = new Array(n + 1).fill(0);
+    let curr = new Array(n + 1).fill(0);
+    for (let j = 0; j <= n; j++)
+        prev[j] = j;
+    for (let i = 1; i <= m; i++) {
+        curr[0] = i;
+        const minPossible = Math.min(...prev);
+        if (maxDistance !== undefined && minPossible > maxDistance) {
+            return maxDistance + 1;
+        }
+        for (let j = 1; j <= n; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+        }
+        ;
+        [prev, curr] = [curr, prev];
+    }
+    return prev[n];
+}
+// Calcular similitud (0 a 1) con límite de tiempo
+export function similarity(a, b, maxDistance) {
+    if (a.length === 0 && b.length === 0)
+        return 1;
+    const maxLen = Math.max(a.length, b.length);
+    const distance = levenshtein(a, b, maxDistance);
+    if (maxDistance !== undefined && distance > maxDistance)
+        return 0;
+    return 1 - distance / maxLen;
+}
+// Buscar la mejor coincidencia en el contenido (optimizado)
+export function findBestMatch(search, content, threshold = 0.85, fileExt) {
+    // 1. Exact match (rápido)
+    const exactIndex = content.indexOf(search);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            text: search,
+            similarity: 1,
+            startIndex: exactIndex,
+            endIndex: exactIndex + search.length
+        };
+    }
+    // Obtener reglas según extensión
+    const rules = getNormalizationRules(fileExt);
+    // 2. Normalized exact match (ignorar diferencias de formato)
+    const normalizedSearch = normalizeForFuzzy(search, rules);
+    const normalizedContent = normalizeForFuzzy(content, rules);
+    const normalizedIndex = normalizedContent.indexOf(normalizedSearch);
+    if (normalizedIndex !== -1) {
+        // Encontrar la posición original en content que corresponde a normalizedIndex
+        let originalStart = 0;
+        let normalizedPos = 0;
+        // Avanzar hasta la posición normalizada
+        for (let i = 0; i < content.length && normalizedPos < normalizedIndex; i++) {
+            const chunk = content[i];
+            const normalizedChunk = normalizeForFuzzy(chunk, rules);
+            if (normalizedChunk.length > 0) {
+                normalizedPos += normalizedChunk.length;
+            }
+            originalStart = i + 1;
+        }
+        // Extraer la subcadena original que coincide
+        let originalEnd = originalStart;
+        let matchedNormalized = '';
+        for (let i = originalStart; i < content.length && matchedNormalized.length < normalizedSearch.length; i++) {
+            const chunk = content[i];
+            const normalizedChunk = normalizeForFuzzy(chunk, rules);
+            if (normalizedChunk.length > 0) {
+                matchedNormalized += normalizedChunk;
+            }
+            originalEnd = i + 1;
+        }
+        const originalText = content.substring(originalStart, originalEnd);
+        return {
+            found: true,
+            text: originalText,
+            similarity: 0.95,
+            startIndex: originalStart,
+            endIndex: originalEnd
+        };
+    }
+    // 3. Si no, no hay match (por ahora, para no complicar)
+    return {
+        found: false,
+        text: '',
+        similarity: 0,
+        startIndex: -1,
+        endIndex: -1
+    };
+}

package/dist/tasks/glob.d.ts

@@ -0,0 +1,5 @@
+export declare function runAiGlob(pattern: string, options?: {
+    path?: string;
+    ignore?: string[];
+}): Promise<void>;
+//# sourceMappingURL=glob.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/tasks/glob.ts"],"names":[],"mappings":"AAqBA,wBAAsB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,iBAyChG"}

package/dist/tasks/glob.js

@@ -0,0 +1,57 @@
+import { glob } from 'glob';
+import { resolve } from 'node:path';
+import { info, success, problem } from '../util/colors.js';
+import { setClipboard } from './edit.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: {
+        'glob.no_files': 'No files found. Diagnostic copied to clipboard.',
+        'glob.done': '✅ Search completed ({{0}}KB copied to clipboard)',
+        'glob.error': '❌ Error: {{0}}. Diagnostic copied to clipboard.',
+    },
+    es: {
+        'glob.no_files': 'No se encontraron archivos. Diagnóstico copiado al portapapeles.',
+        'glob.done': '✅ Búsqueda completada ({{0}}KB copiados al portapapeles)',
+        'glob.error': '❌ Error: {{0}}. Diagnóstico copiado al portapapeles.',
+    },
+}, commonCli);
+export async function runAiGlob(pattern, options = {}) {
+    const searchPath = options.path ? resolve(process.cwd(), options.path) : process.cwd();
+    const ignore = options.ignore || ['node_modules/**', 'dist/**', '.git/**'];
+    try {
+        const files = await glob(pattern, { cwd: searchPath, ignore, absolute: false });
+        if (files.length === 0) {
+            const diagnostic = `🔍 No se encontraron archivos para el patrón: "${pattern}"
+
+Ruta buscada: ${searchPath}
+Ignorados: ${ignore.join(', ')}
+
+Sugerencias:
+1. Verifica que el patrón sea correcto (ej: "*.ts", "src/**/*.tsx").
+2. Usa --path para especificar una ruta diferente.
+3. Usa --ignore para excluir patrones adicionales.
+4. Ejecuta: ls -la ${searchPath} para confirmar que hay archivos.`;
+            await setClipboard(diagnostic);
+            info(t('glob.no_files'));
+        }
+        const output = files.join('\n');
+        console.log(output);
+        await setClipboard(output);
+        success(t('glob.done', Math.round(output.length / 1024).toString()));
+    }
+    catch (err) {
+        const diagnostic = `❌ Error en glob: ${err.message}
+
+Patrón: "${pattern}"
+Ruta: ${searchPath}
+
+Sugerencias:
+1. Verifica la sintaxis del patrón glob.
+2. Asegura que la ruta sea correcta y exista.
+3. Si el patrón es complejo, simplifícalo (ej: "*.ts" en lugar de "**/*.ts").`;
+        await setClipboard(diagnostic);
+        problem(t('glob.error', err.message));
+    }
+}

package/dist/tasks/grep.d.ts

@@ -0,0 +1,9 @@
+interface GrepOptions {
+    path?: string;
+    type?: string;
+    context?: number;
+    ignoreCase?: boolean;
+}
+export declare function runAiGrep(pattern: string, options?: GrepOptions): Promise<void>;
+export {};
+//# sourceMappingURL=grep.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../src/tasks/grep.ts"],"names":[],"mappings":"AAyBA,UAAU,WAAW;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAsB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,iBAuEvE"}

package/dist/tasks/grep.js

@@ -0,0 +1,93 @@
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { info, success, problem } from '../util/colors.js';
+import { setClipboard, getClipboard } from './edit.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: {
+        'grep.empty_clipboard': '❌ Empty clipboard',
+        'grep.done': '✅ Search completed ({{0}}KB copied to clipboard)',
+        'grep.no_matches': 'No matches found in clipboard',
+        'grep.error': '❌ Error: {{0}}. Diagnostic copied to clipboard.',
+        'grep.no_files': 'No matches found. Diagnostic copied to clipboard.',
+    },
+    es: {
+        'grep.empty_clipboard': '❌ Portapapeles vacío',
+        'grep.done': '✅ Búsqueda completada ({{0}}KB copiados al portapapeles)',
+        'grep.no_matches': 'No se encontraron coincidencias en el portapapeles',
+        'grep.error': '❌ Error: {{0}}. Diagnóstico copiado al portapapeles.',
+        'grep.no_files': 'No se encontraron coincidencias. Diagnóstico copiado al portapapeles.',
+    },
+}, commonCli);
+export async function runAiGrep(pattern, options = {}) {
+    if (!options.path) {
+        const clipboardContent = await getClipboard();
+        if (!clipboardContent) {
+            problem(t('grep.empty_clipboard'));
+            return;
+        }
+        const lines = clipboardContent.split('\n');
+        const matches = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(pattern)) {
+                matches.push(`${i + 1}: ${lines[i]}`);
+            }
+        }
+        if (matches.length > 0) {
+            const output = matches.join('\n');
+            console.log(output);
+            await setClipboard(output);
+            success(t('grep.done', Math.round(output.length / 1024).toString()));
+        }
+        else {
+            info(t('grep.no_matches'));
+            await setClipboard('');
+        }
+        return;
+    }
+    const searchPath = resolve(process.cwd(), options.path);
+    const args = ['-r', '-n'];
+    if (options.context)
+        args.push('-C', String(options.context));
+    if (options.ignoreCase)
+        args.push('-i');
+    args.push(pattern, searchPath);
+    const result = spawnSync('grep', args, { encoding: 'utf-8' });
+    if (result.error) {
+        const diagnostic = `❌ Error en la búsqueda: ${result.error.message}
+
+Patrón: "${pattern}"
+Ruta: ${searchPath}
+Comando: grep ${args.join(' ')}
+
+Sugerencias:
+1. Verifica que la ruta exista.
+2. Verifica los permisos de los archivos.`;
+        await setClipboard(diagnostic);
+        problem(t('grep.error', result.error.message));
+    }
+    const output = (result.stdout || '').trim();
+    const errOutput = (result.stderr || '').trim();
+    if (output) {
+        console.log(output);
+        await setClipboard(output);
+        success(t('grep.done', Math.round(output.length / 1024).toString()));
+    }
+    else if (errOutput) {
+        problem(`❌ ${errOutput}`);
+    }
+    else {
+        const diagnostic = `🔍 No se encontraron coincidencias para: "${pattern}"
+
+Ruta buscada: ${searchPath}
+
+Sugerencias:
+1. Verifica que el patrón sea correcto.
+2. Usa --ignore-case si el caso podría ser diferente.
+3. Verifica que haya archivos en: ${searchPath}`;
+        await setClipboard(diagnostic);
+        info(t('grep.no_files'));
+    }
+}

package/dist/tasks/readfile.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"readfile.d.ts","sourceRoot":"","sources":["../../src/tasks/readfile.ts"],"names":[],"mappings":"AA6DA,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,iBAmG/C"}