@pasosdejesus/m 0.15.0

package/dist/tasks/readfile.js

@@ -0,0 +1,177 @@
+import { readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { success, problem, warn } from '../util/colors.js';
+import { setClipboard as setCB } 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: {
+        'readfile.no_files': '❌ No files specified. Diagnostic copied to clipboard.',
+        'readfile.not_regular': '⚠️ {{0}}: Not a regular file',
+        'readfile.header': '📄 {{0}} ({{1}} lines, {{2}}KB)',
+        'readfile.not_found': '❌ {{0}}: File not found. Diagnostic copied to clipboard.',
+        'readfile.read_error': '❌ {{0}}: Read error. Diagnostic copied to clipboard.',
+        'readfile.copied_kb': '📋 Content copied to clipboard ({{0}}KB)',
+        'readfile.copied_bytes': '📋 Content copied to clipboard ({{0}} bytes)',
+    },
+    es: {
+        'readfile.no_files': '❌ No se especificó ningún archivo. Diagnóstico copiado al portapapeles.',
+        'readfile.not_regular': '⚠️ {{0}}: No es un archivo regular',
+        'readfile.header': '📄 {{0}} ({{1}} líneas, {{2}}KB)',
+        'readfile.not_found': '❌ {{0}}: Archivo no encontrado. Diagnóstico copiado al portapapeles.',
+        'readfile.read_error': '❌ {{0}}: Error de lectura. Diagnóstico copiado al portapapeles.',
+        'readfile.copied_kb': '📋 Contenido copiado al portapapeles ({{0}}KB)',
+        'readfile.copied_bytes': '📋 Contenido copiado al portapapeles ({{0}} bytes)',
+    },
+}, commonCli);
+function formatFileContent(content, _filePath, options) {
+    const lines = content.split('\n');
+    let startLine = 0;
+    let endLine = lines.length;
+    if (options.offset !== undefined)
+        startLine = Math.max(0, options.offset - 1);
+    if (options.lines !== undefined)
+        endLine = Math.min(lines.length, startLine + options.lines);
+    if (options.head !== undefined) {
+        endLine = Math.min(lines.length, options.head);
+        startLine = 0;
+    }
+    if (options.tail !== undefined) {
+        startLine = Math.max(0, lines.length - options.tail);
+        endLine = lines.length;
+    }
+    const selectedLines = lines.slice(startLine, endLine);
+    if (options.raw)
+        return selectedLines.join('\n');
+    return selectedLines.map((_, idx) => {
+        const lineNum = startLine + idx + 1;
+        return `${lineNum.toString().padStart(4, ' ')} | ${selectedLines[idx]}`;
+    }).join('\n');
+}
+async function setClipboard(content) {
+    try {
+        await setCB(content);
+    }
+    catch { /* silent */ }
+}
+export async function runAiReadFile(args) {
+    const files = [];
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--lines':
+                options.lines = parseInt(args[++i]);
+                break;
+            case '--offset':
+                options.offset = parseInt(args[++i]);
+                break;
+            case '--head':
+                options.head = parseInt(args[++i]);
+                break;
+            case '--tail':
+                options.tail = parseInt(args[++i]);
+                break;
+            case '--raw':
+                options.raw = true;
+                break;
+            case '--no-clip':
+                options.noClip = true;
+                break;
+            default:
+                if (!arg.startsWith('-'))
+                    files.push(arg);
+        }
+    }
+    if (files.length === 0) {
+        const diagnostic = `❌ Error: No se especificó ningún archivo.
+
+Uso correcto:
+  ./bin/m ai:readfile <archivo1> [archivo2 ...]
+
+Opciones disponibles:
+  --lines <N>    Mostrar N líneas (desde offset o inicio)
+  --offset <N>   Comenzar desde la línea N
+  --head <N>     Mostrar primeras N líneas
+  --tail <N>     Mostrar últimas N líneas
+  --raw          Mostrar sin números de línea en pantalla
+  --no-clip      No copiar al portapapeles (por defecto copia)
+
+Ejemplo:
+  ./bin/m ai:readfile src/m.ts --head 20`;
+        await setClipboard(diagnostic);
+        problem(t('readfile.no_files'));
+    }
+    const shouldClip = !options.noClip;
+    const clipboardContents = [];
+    for (const file of files) {
+        const fullPath = resolve(process.cwd(), file);
+        try {
+            const fileStat = await stat(fullPath);
+            if (!fileStat.isFile()) {
+                warn(t('readfile.not_regular', file));
+                continue;
+            }
+            const content = await readFile(fullPath, 'utf-8');
+            const formatted = formatFileContent(content, file, options);
+            const sizeKB = Math.round(fileStat.size / 1024);
+            const lineCount = content.split('\n').length;
+            success(`\n${t('readfile.header', file, lineCount.toString(), sizeKB.toString())}`);
+            console.log(formatted);
+            console.log('');
+            if (shouldClip) {
+                let clipContent = content;
+                let lineInfo = '';
+                const lines = content.split('\n');
+                if (options.head !== undefined) {
+                    clipContent = lines.slice(0, options.head).join('\n');
+                    lineInfo = ` (primeras ${options.head} líneas)`;
+                }
+                else if (options.tail !== undefined) {
+                    clipContent = lines.slice(-options.tail).join('\n');
+                    lineInfo = ` (últimas ${options.tail} líneas)`;
+                }
+                else if (options.offset !== undefined) {
+                    const start = options.offset - 1;
+                    const end = options.lines ? start + options.lines : lines.length;
+                    clipContent = lines.slice(start, end).join('\n');
+                    lineInfo = ` (líneas ${options.offset}-${end})`;
+                }
+                else if (options.lines !== undefined) {
+                    clipContent = lines.slice(0, options.lines).join('\n');
+                    lineInfo = ` (primeras ${options.lines} líneas)`;
+                }
+                const HASH = '\u0023\u0023';
+                clipboardContents.push(`${HASH} Archivo: ${file}${lineInfo}`);
+                clipboardContents.push('```');
+                clipboardContents.push(clipContent);
+                clipboardContents.push('```');
+                clipboardContents.push('');
+            }
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                const diagnostic = `❌ Error: Archivo no encontrado\n\nNo se encontró el archivo: ${file}\n\nRuta buscada: ${fullPath}\nDirectorio actual: ${process.cwd()}\n\nSugerencias:\n1. Verifica que la ruta sea correcta y relativa al directorio actual.\n2. Usa rutas relativas, no absolutas (ej: "src/m.ts" en lugar de "/home/usuario/src/m.ts").\n3. Ejecuta: ls -la ${file} para confirmar que existe.\n4. Usa ./bin/m ai:glob "*.ts" para listar archivos disponibles.`;
+                await setClipboard(diagnostic);
+                problem(t('readfile.not_found', file));
+            }
+            else {
+                const diagnostic = `❌ Error leyendo archivo: ${file}\n\nMensaje: ${err.message}\nRuta: ${fullPath}\n\nSugerencia: Verifica los permisos del archivo.`;
+                await setClipboard(diagnostic);
+                problem(t('readfile.read_error', file));
+            }
+        }
+    }
+    if (shouldClip && clipboardContents.length > 0) {
+        const clipContent = clipboardContents.join('\n');
+        if (clipContent.length > 0) {
+            await setClipboard(clipContent);
+            const sizeKB = Math.round(clipContent.length / 1024);
+            if (sizeKB > 0)
+                success(t('readfile.copied_kb', sizeKB.toString()));
+            else
+                success(t('readfile.copied_bytes', clipContent.length.toString()));
+        }
+    }
+}

package/dist/tasks/update.d.ts

@@ -0,0 +1,5 @@
+export declare function runUpdate(options?: {
+    check?: boolean;
+    yes?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=update.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../src/tasks/update.ts"],"names":[],"mappings":"AA2GA,wBAAsB,SAAS,CAAC,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,iBAsG3E"}

package/dist/tasks/update.js

@@ -0,0 +1,200 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { globSync } from 'glob';
+import { 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 updateT = createTranslator(detectLocale(), {
+    en: {
+        'update.comparing': 'Comparing project files with templates...',
+        'update.file_new': 'New file available: {{0}}',
+        'update.file_diff': 'Differences found in {{0}}',
+        'update.prompt': 'Apply this update? [y: yes, n: no, d: diff, e: edit]: ',
+        'update.applied': 'Update applied to {{0}}',
+        'update.skipped': 'Skipped {{0}}',
+        'update.error': 'Error updating {{0}}: {{1}}',
+        'update.finished': 'Update process finished.',
+    },
+    es: {
+        'update.comparing': 'Comparando los archivos del proyecto con las plantillas...',
+        'update.file_new': 'Nuevo archivo disponible: {{0}}',
+        'update.file_diff': 'Diferencias encontradas en {{0}}',
+        'update.prompt': '¿Deseas aplicar esta actualización? [y: sí, n: no, d: diff, e: editar]: ',
+        'update.applied': 'Actualización aplicada a {{0}}',
+        'update.skipped': 'Se saltó {{0}}',
+        'update.error': 'Error al actualizar {{0}}: {{1}}',
+        'update.finished': 'Proceso de actualización terminado.',
+    },
+}, commonCli);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function getTemplateDir() {
+    // __dirname is dist/tasks/ in the npm package
+    // dist/templates/ is where build copies templates
+    const distTemplates = path.join(__dirname, '..', 'templates');
+    if (fs.existsSync(distTemplates))
+        return distTemplates;
+    // Fallback for development: source tree templates/
+    const srcTemplates = path.join(__dirname, '..', '..', 'templates');
+    if (fs.existsSync(srcTemplates))
+        return srcTemplates;
+    // Last resort: templates/ next to tasks/
+    return path.join(__dirname, 'templates');
+}
+function getAllFiles(dirPath) {
+    return globSync('**/*', { cwd: dirPath, nodir: true });
+}
+async function showDiff(file1, file2) {
+    const hasDiff = spawnSync('which', ['diff'], { stdio: 'ignore' }).status === 0;
+    if (hasDiff) {
+        // OpenBSD diff doesn't support --color=always; test if it does before using it
+        const supportsColor = spawnSync('diff', ['--color=always', '/dev/null', '/dev/null'], { stdio: 'ignore' }).status === 0;
+        if (supportsColor) {
+            spawnSync('diff', ['-u', '--color=always', file1, file2], { stdio: 'inherit' });
+        }
+        else {
+            spawnSync('diff', ['-u', file1, file2], { stdio: 'inherit' });
+        }
+    }
+    else {
+        warn('Command "diff" not found. Showing content directly.');
+        info(`Template content for ${path.basename(file1)}:`);
+        console.log(fs.readFileSync(file1, 'utf-8'));
+    }
+}
+async function mergePackageJson(projectPath, templatePath) {
+    const projectPkg = JSON.parse(fs.readFileSync(projectPath, 'utf-8'));
+    const templatePkg = JSON.parse(fs.readFileSync(templatePath, 'utf-8'));
+    // Logic to merge specifically pnpm overrides and missing devDependencies
+    if (templatePkg.pnpm) {
+        projectPkg.pnpm = { ...(projectPkg.pnpm || {}), ...templatePkg.pnpm };
+    }
+    // Update dependencies only if they are missing or if we want to force template versions
+    const sections = ['dependencies', 'devDependencies'];
+    for (const section of sections) {
+        if (templatePkg[section]) {
+            projectPkg[section] = { ...(projectPkg[section] || {}), ...templatePkg[section] };
+        }
+    }
+    fs.writeFileSync(projectPath, JSON.stringify(projectPkg, null, 2), 'utf-8');
+}
+function findProjectRoot(startDir) {
+    let current = startDir;
+    while (current !== path.parse(current).root) {
+        // A project root in 'm' must have an 'apps' directory
+        if (fs.existsSync(path.join(current, 'apps'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return startDir;
+}
+export async function runUpdate(options) {
+    const t = updateT;
+    const opts = options || {};
+    const yesMode = opts.yes || false;
+    const checkMode = opts.check || false;
+    // Initialize readline only when needed (lazy initialization)
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const question = (query) => new Promise((resolve) => rl.question(query, resolve));
+    try {
+        const startDir = process.cwd();
+        const projectRoot = findProjectRoot(startDir);
+        const templateDir = getTemplateDir();
+        info(`Project root identified at: ${projectRoot}`);
+        info(t('update.comparing'));
+        // Filter out .env files and other non-template assets
+        const templateFiles = getAllFiles(templateDir).filter(f => {
+            const name = path.basename(f);
+            return f !== 'pnpm-lock.yaml' &&
+                !name.startsWith('.env');
+        });
+        for (const relPath of templateFiles) {
+            // Determine project path (remove .hbs from relPath if present)
+            const projectRelPath = relPath.endsWith('.hbs') ? relPath.slice(0, -4) : relPath;
+            const projectPath = path.join(projectRoot, projectRelPath);
+            const templatePath = path.join(templateDir, relPath);
+            if (!fs.existsSync(projectPath)) {
+                if (checkMode) {
+                    info(t('update.file_new', projectRelPath));
+                }
+                else if (yesMode) {
+                    fs.mkdirSync(path.dirname(projectPath), { recursive: true });
+                    fs.copyFileSync(templatePath, projectPath);
+                    success(t('update.applied', projectRelPath));
+                }
+                else {
+                    info(t('update.file_new', projectRelPath));
+                    const answer = await question(t('update.prompt'));
+                    if (answer.toLowerCase() === 'y') {
+                        fs.mkdirSync(path.dirname(projectPath), { recursive: true });
+                        fs.copyFileSync(templatePath, projectPath);
+                        success(t('update.applied', projectRelPath));
+                    }
+                }
+            }
+            else {
+                const projectContent = fs.readFileSync(projectPath, 'utf-8');
+                const templateContent = fs.readFileSync(templatePath, 'utf-8');
+                if (projectContent !== templateContent) {
+                    if (checkMode) {
+                        info(t('update.file_diff', projectRelPath));
+                        await showDiff(templatePath, projectPath);
+                    }
+                    else if (yesMode) {
+                        if (projectRelPath.endsWith('package.json')) {
+                            await mergePackageJson(projectPath, templatePath);
+                        }
+                        else {
+                            fs.copyFileSync(templatePath, projectPath);
+                        }
+                        success(t('update.applied', projectRelPath));
+                    }
+                    else {
+                        info(t('update.file_diff', projectRelPath));
+                        let loop = true;
+                        while (loop) {
+                            const answer = await question(t('update.prompt'));
+                            switch (answer.toLowerCase()) {
+                                case 'y':
+                                    if (projectRelPath.endsWith('package.json')) {
+                                        await mergePackageJson(projectPath, templatePath);
+                                    }
+                                    else {
+                                        fs.copyFileSync(templatePath, projectPath);
+                                    }
+                                    success(t('update.applied', projectRelPath));
+                                    loop = false;
+                                    break;
+                                case 'n':
+                                    info(t('update.skipped', relPath));
+                                    loop = false;
+                                    break;
+                                case 'd':
+                                    await showDiff(templatePath, projectPath);
+                                    break;
+                                case 'e':
+                                    const editor = process.env.EDITOR || 'vi';
+                                    spawnSync(editor, [projectPath], { stdio: 'inherit' });
+                                    loop = false;
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        success(t('update.finished'));
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/tasks/util.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Searches for the `ia/` directory in multiple locations.
+ * Returns the first path found, or null if none exists.
+ *
+ * Search order:
+ *   1. Global installation: /usr/local/lib/node_modules/@pasosdejesus/m/ia
+ *   2. Package root: <package>/ia
+ *   3. Explicit node_modules: <cwd>/node_modules/@pasosdejesus/m/ia
+ *   4. Local project: <cwd>/ia
+ */
+export declare function findIaDir(): Promise<string | null>;
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/tasks/util.ts"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAuBxD"}

package/dist/tasks/util.js

@@ -0,0 +1,42 @@
+/**
+ * Shared utilities for task implementations.
+ */
+import { access } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Searches for the `ia/` directory in multiple locations.
+ * Returns the first path found, or null if none exists.
+ *
+ * Search order:
+ *   1. Global installation: /usr/local/lib/node_modules/@pasosdejesus/m/ia
+ *   2. Package root: <package>/ia
+ *   3. Explicit node_modules: <cwd>/node_modules/@pasosdejesus/m/ia
+ *   4. Local project: <cwd>/ia
+ */
+export async function findIaDir() {
+    const packageRoot = join(__dirname, '..', '..', '..');
+    const distIa = join(__dirname, '..', 'ia');
+    const paths = [
+        join('/usr/local/lib/node_modules', '@pasosdejesus', 'm', 'ia'),
+        join(packageRoot, 'ia'),
+        distIa,
+        join(process.cwd(), 'node_modules', '@pasosdejesus', 'm', 'ia'),
+        join(process.cwd(), 'node_modules', '@pasosdejesus', 'mpdj', 'ia'),
+        join(process.cwd(), 'ia'),
+        // Monorepo root: check packages/mpdj/ia/ (source) and packages/mpdj/dist/ia/ (compiled)
+        join(process.cwd(), 'packages', 'mpdj', 'ia'),
+        join(process.cwd(), 'packages', 'mpdj', 'dist', 'ia'),
+    ];
+    for (const p of paths) {
+        try {
+            await access(p);
+            return p;
+        }
+        catch {
+            // Not found, continue
+        }
+    }
+    return null;
+}

package/dist/tasks/wallet.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/tasks/wallet.ts"],"names":[],"mappings":"AAorBA,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,iBAiE7C"}