@pasosdejesus/m 0.15.0

package/dist/shadcn_components/ui/tooltip.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/shadcn_components/ui/tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../src/shadcn_components/ui/tooltip.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,gBAAgB,MAAM,yBAAyB,CAAA;AAI3D,QAAA,MAAM,eAAe,iDAA4B,CAAA;AAEjD,QAAA,MAAM,OAAO,yCAAwB,CAAA;AAErC,QAAA,MAAM,cAAc,gHAA2B,CAAA;AAE/C,QAAA,MAAM,cAAc,gKAalB,CAAA;AAGF,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,CAAA"}

package/dist/shadcn_components/ui/tooltip.js

@@ -0,0 +1,11 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { cn } from '../cn.js';
+const TooltipProvider = TooltipPrimitive.Provider;
+const Tooltip = TooltipPrimitive.Root;
+const TooltipTrigger = TooltipPrimitive.Trigger;
+const TooltipContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => (_jsx(TooltipPrimitive.Content, { ref: ref, sideOffset: sideOffset, className: cn('z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2', className), ...props })));
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/shadcn_components/ui/use-toast.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import type { ToastActionElement, ToastProps } from './toast.js';
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    action?: ToastActionElement;
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType['ADD_TOAST'];
+    toast: ToasterToast;
+} | {
+    type: ActionType['UPDATE_TOAST'];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType['DISMISS_TOAST'];
+    toastId?: ToasterToast['id'];
+} | {
+    type: ActionType['REMOVE_TOAST'];
+    toastId?: ToasterToast['id'];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+export declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, 'id'>;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+export { useToast, toast };
+//# sourceMappingURL=use-toast.d.ts.map

package/dist/shadcn_components/ui/use-toast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-toast.d.ts","sourceRoot":"","sources":["../../../src/shadcn_components/ui/use-toast.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAKhE,KAAK,YAAY,GAAG,UAAU,GAAG;IAC/B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IACvB,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC7B,MAAM,CAAC,EAAE,kBAAkB,CAAA;CAC5B,CAAA;AAED,QAAA,MAAM,WAAW;;;;;CAKP,CAAA;AASV,KAAK,UAAU,GAAG,OAAO,WAAW,CAAA;AAEpC,KAAK,MAAM,GACP;IACE,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAA;IAC7B,KAAK,EAAE,YAAY,CAAA;CACpB,GACD;IACE,IAAI,EAAE,UAAU,CAAC,cAAc,CAAC,CAAA;IAChC,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;CAC7B,GACD;IACE,IAAI,EAAE,UAAU,CAAC,eAAe,CAAC,CAAA;IACjC,OAAO,CAAC,EAAE,YAAY,CAAC,IAAI,CAAC,CAAA;CAC7B,GACD;IACE,IAAI,EAAE,UAAU,CAAC,cAAc,CAAC,CAAA;IAChC,OAAO,CAAC,EAAE,YAAY,CAAC,IAAI,CAAC,CAAA;CAC7B,CAAA;AAEL,UAAU,KAAK;IACb,MAAM,EAAE,YAAY,EAAE,CAAA;CACvB;AAoBD,eAAO,MAAM,OAAO,GAAI,OAAO,KAAK,EAAE,QAAQ,MAAM,KAAG,KAmDtD,CAAA;AAaD,KAAK,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAA;AAErC,iBAAS,KAAK,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK;;;oBAGT,YAAY;EAwBpC;AAED,iBAAS,QAAQ;;wBAgBO,MAAM;YApIpB,YAAY,EAAE;EAsIvB;AAED,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAA"}

package/dist/shadcn_components/ui/use-toast.js

@@ -0,0 +1,126 @@
+'use client';
+// Inspired by react-hot-toast library
+import * as React from 'react';
+const TOAST_LIMIT = 4;
+const TOAST_REMOVE_DELAY = 1000000;
+const actionTypes = {
+    ADD_TOAST: 'ADD_TOAST',
+    UPDATE_TOAST: 'UPDATE_TOAST',
+    DISMISS_TOAST: 'DISMISS_TOAST',
+    REMOVE_TOAST: 'REMOVE_TOAST',
+};
+let count = 0;
+function genId() {
+    count = (count + 1) % Number.MAX_SAFE_INTEGER;
+    return count.toString();
+}
+const toastTimeouts = new Map();
+const addToRemoveQueue = (toastId) => {
+    if (toastTimeouts.has(toastId)) {
+        return;
+    }
+    const timeout = setTimeout(() => {
+        toastTimeouts.delete(toastId);
+        dispatch({
+            type: 'REMOVE_TOAST',
+            toastId: toastId,
+        });
+    }, TOAST_REMOVE_DELAY);
+    toastTimeouts.set(toastId, timeout);
+};
+export const reducer = (state, action) => {
+    switch (action.type) {
+        case 'ADD_TOAST':
+            return {
+                ...state,
+                toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+            };
+        case 'UPDATE_TOAST':
+            return {
+                ...state,
+                toasts: state.toasts.map((t) => t.id === action.toast.id ? { ...t, ...action.toast } : t),
+            };
+        case 'DISMISS_TOAST': {
+            const { toastId } = action;
+            if (toastId) {
+                addToRemoveQueue(toastId);
+            }
+            else {
+                state.toasts.forEach((toast) => {
+                    addToRemoveQueue(toast.id);
+                });
+            }
+            return {
+                ...state,
+                toasts: state.toasts.map((t) => t.id === toastId || toastId === undefined
+                    ? {
+                        ...t,
+                        open: false,
+                    }
+                    : t),
+            };
+        }
+        case 'REMOVE_TOAST':
+            if (action.toastId === undefined) {
+                return {
+                    ...state,
+                    toasts: [],
+                };
+            }
+            return {
+                ...state,
+                toasts: state.toasts.filter((t) => t.id !== action.toastId),
+            };
+    }
+};
+const listeners = [];
+let memoryState = { toasts: [] };
+function dispatch(action) {
+    memoryState = reducer(memoryState, action);
+    listeners.forEach((listener) => {
+        listener(memoryState);
+    });
+}
+function toast({ ...props }) {
+    const id = genId();
+    const update = (props) => dispatch({
+        type: 'UPDATE_TOAST',
+        toast: { ...props, id },
+    });
+    const dismiss = () => dispatch({ type: 'DISMISS_TOAST', toastId: id });
+    dispatch({
+        type: 'ADD_TOAST',
+        toast: {
+            ...props,
+            id,
+            open: true,
+            onOpenChange: (open) => {
+                if (!open)
+                    dismiss();
+            },
+        },
+    });
+    return {
+        id: id,
+        dismiss,
+        update,
+    };
+}
+function useToast() {
+    const [state, setState] = React.useState(memoryState);
+    React.useEffect(() => {
+        listeners.push(setState);
+        return () => {
+            const index = listeners.indexOf(setState);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    }, [state]);
+    return {
+        ...state,
+        toast,
+        dismiss: (toastId) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+    };
+}
+export { useToast, toast };

package/dist/tasks/context.d.ts

@@ -0,0 +1,13 @@
+interface ContextOptions {
+    output?: string;
+    branch?: string;
+    exclude?: string[];
+    maxSize?: number;
+    includePatterns?: string[];
+    noClipboard?: boolean;
+    full?: boolean;
+    limit?: number;
+}
+export declare function runAiContext(options?: ContextOptions): Promise<void>;
+export {};
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/tasks/context.ts"],"names":[],"mappings":"AA0BA,UAAU,cAAc;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAmQD,wBAAsB,YAAY,CAAC,OAAO,GAAE,cAAmB,iBAoF5D"}

package/dist/tasks/context.js

@@ -0,0 +1,310 @@
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createWriteStream, existsSync, readFileSync } from 'node:fs';
+import { info, success, warn, 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: {
+        'context.generating': '📁 Generating project context...',
+        'context.not_git': '❌ Error: Not in a git repository',
+        'context.git_hint': '   Run: git init (or clone a repository)',
+        'context.branch': '   Branch: {{0}}',
+        'context.output': '   Output: {{0}}',
+    },
+    es: {
+        'context.generating': '📁 Generando contexto del proyecto...',
+        'context.not_git': '❌ Error: No estás en un repositorio git',
+        'context.git_hint': '   Ejecuta: git init (o clona un repositorio)',
+        'context.branch': '   Branch: {{0}}',
+        'context.output': '   Output: {{0}}',
+    },
+}, commonCli);
+const DEFAULT_EXCLUDES = [
+    'dist', 'build', 'node_modules', 'coverage', '.next',
+    '__pycache__', '*.lock', '*.map', '*.min.js', '*.log',
+    '*.tmp', '.DS_Store', 'templates', 'tests'
+];
+const MAX_FILE_SIZE = 30 * 1024; // 30KB por defecto
+const DEFAULT_LIMIT_KB = 100; // 100KB por defecto para el contexto total
+async function findGitRoot() {
+    const result = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status === 0) {
+        return result.stdout.trim();
+    }
+    return null;
+}
+async function getCurrentBranch() {
+    const result = spawnSync('git', ['branch', '--show-current'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+        return result.stdout.trim();
+    }
+    return null;
+}
+async function getRemoteUrl() {
+    const result = spawnSync('git', ['config', '--get', 'remote.origin.url'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+        // Sanitizar: eliminar credenciales
+        return result.stdout.trim().replace(/\/\/[^@]*@/, '//');
+    }
+    return 'local';
+}
+function isExcluded(filePath, excludes) {
+    for (const pattern of excludes) {
+        // Soporte para patrones glob simples
+        if (pattern.includes('*')) {
+            const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+            if (regex.test(filePath))
+                return true;
+        }
+        else {
+            // Coincidencia exacta o de directorio
+            if (filePath === pattern ||
+                filePath.startsWith(`${pattern}/`) ||
+                filePath.includes(`/${pattern}/`)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function detectLanguage(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase() || '';
+    const langMap = {
+        'sh': 'bash', 'bash': 'bash', 'zsh': 'bash',
+        'py': 'python',
+        'js': 'javascript', 'ts': 'typescript',
+        'jsx': 'jsx', 'tsx': 'tsx',
+        'json': 'json',
+        'md': 'markdown',
+        'yml': 'yaml', 'yaml': 'yaml',
+        'c': 'c', 'h': 'c',
+        'cpp': 'cpp', 'hpp': 'cpp',
+        'go': 'go',
+        'rs': 'rust',
+        'sql': 'sql',
+        'html': 'html', 'css': 'css',
+        'toml': 'toml',
+        'tf': 'hcl', 'tfvars': 'hcl'
+    };
+    return langMap[ext] || '';
+}
+async function getFileList(branch) {
+    const branchArg = branch || await getCurrentBranch() || 'HEAD';
+    const result = spawnSync('git', ['ls-tree', '-r', '--name-only', branchArg], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status !== 0) {
+        return [];
+    }
+    return result.stdout.trim().split('\n').filter((f) => f);
+}
+async function getDirectoryTree(excludes = DEFAULT_EXCLUDES) {
+    // Construir patrones de exclusión para tree
+    const excludePatterns = excludes.filter(e => !e.includes('*')).join('|');
+    let treeCmd = ['tree', '-a', '--dirsfirst', '-L', '2'];
+    if (excludePatterns) {
+        treeCmd = treeCmd.concat(['-I', excludePatterns]);
+    }
+    const result = spawnSync('tree', treeCmd, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status !== 0) {
+        // Fallback a find si tree no está disponible
+        let findCmd = ['find', '.', '-type', 'd', '-maxdepth', '2'];
+        for (const pattern of excludes) {
+            if (!pattern.includes('*')) {
+                findCmd = findCmd.concat(['-not', '-path', `./${pattern}/*`, '-not', '-path', `./${pattern}`]);
+            }
+        }
+        const findResult = spawnSync('find', findCmd, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        return findResult.stdout || 'tree command not available';
+    }
+    return result.stdout;
+}
+async function getGitLog(limit = 5) {
+    const result = spawnSync('git', ['log', `-${limit}`, '--stat', '--oneline'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status !== 0) {
+        return 'git log not available';
+    }
+    return result.stdout;
+}
+async function writeContextFile(outputPath, files, excludes, maxSize, maxTotalBytes) {
+    const gitRoot = await findGitRoot();
+    const projectName = gitRoot ? gitRoot.split('/').pop() || 'proyecto' : 'proyecto';
+    const branch = await getCurrentBranch() || 'unknown';
+    const remoteUrl = await getRemoteUrl();
+    // Usar un array para acumular el contenido y escribirlo de una vez
+    const chunks = [];
+    // Cabecera del documento
+    chunks.push(`# Contexto del Proyecto: ${projectName}\n\n`);
+    chunks.push(`- **Branch:** ${branch}\n`);
+    chunks.push(`- **Repositorio:** ${remoteUrl}\n`);
+    chunks.push(`- **Fecha:** ${new Date().toISOString()}\n`);
+    chunks.push(`- **Ruta:** ${gitRoot || process.cwd()}\n\n`);
+    // Estructura de directorios
+    chunks.push(`## Estructura de Directorios\n\n`);
+    chunks.push(`\`\`\`\n`);
+    const tree = await getDirectoryTree(excludes);
+    chunks.push(tree);
+    chunks.push(`\`\`\`\n\n`);
+    // Historial de Git
+    chunks.push(`## Historial de Git (últimos 5 commits)\n\n`);
+    chunks.push(`\`\`\`\n`);
+    const gitLog = await getGitLog(5);
+    chunks.push(gitLog);
+    chunks.push(`\`\`\`\n\n`);
+    chunks.push(`---\n\n`);
+    let count = 0;
+    let totalSize = 0;
+    let skippedSize = 0;
+    let skippedExclude = 0;
+    let skippedLimit = 0;
+    for (const file of files) {
+        // Verificar exclusión
+        if (isExcluded(file, excludes)) {
+            skippedExclude++;
+            continue;
+        }
+        const fullPath = join(gitRoot || process.cwd(), file);
+        try {
+            const fileStat = await stat(fullPath);
+            // Verificar límite total antes de agregar
+            if (maxTotalBytes && totalSize + fileStat.size > maxTotalBytes) {
+                skippedLimit++;
+                continue;
+            }
+            if (fileStat.size > maxSize) {
+                warn(`   ⚠️ Omitido (>${maxSize / 1024}KB): ${file} (${Math.round(fileStat.size / 1024)}KB)`);
+                skippedSize++;
+                continue;
+            }
+            const content = await readFile(fullPath, 'utf-8');
+            const lang = detectLanguage(file);
+            const timestamp = new Date().toISOString().replace(/[-:]/g, '').slice(0, 15);
+            chunks.push(`___INICIO_ARCHIVO_${timestamp}___ ${file}\n\n`);
+            chunks.push(`\`\`\`${lang}\n`);
+            chunks.push(content);
+            if (!content.endsWith('\n'))
+                chunks.push('\n');
+            chunks.push(`\`\`\`\n\n`);
+            count++;
+            totalSize += fileStat.size;
+        }
+        catch (err) {
+            warn(`   ⚠️ No se pudo leer: ${file}`);
+        }
+    }
+    // Escribir todo de una vez
+    const writeStream = createWriteStream(outputPath);
+    writeStream.write(chunks.join(''));
+    writeStream.end();
+    // Esperar a que termine de escribir
+    await new Promise((resolve) => {
+        writeStream.on('close', () => resolve());
+    });
+    return { count, totalSize, skippedSize, skippedExclude, skippedLimit };
+}
+function loadExcludeFile(excludeFile) {
+    if (!excludeFile || !existsSync(excludeFile)) {
+        return DEFAULT_EXCLUDES;
+    }
+    const content = readFileSync(excludeFile, 'utf-8');
+    return content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'));
+}
+export async function runAiContext(options = {}) {
+    const outputFile = options.output || 'contexto.md';
+    const branch = options.branch;
+    const maxSize = options.full ? Number.MAX_SAFE_INTEGER : (options.maxSize || MAX_FILE_SIZE);
+    const excludePatterns = options.exclude || loadExcludeFile('.contextignore');
+    info(t("context.generating"));
+    if (branch)
+        info(`   Branch: ${branch}`);
+    info(`   Output: ${outputFile}`);
+    info(`   Excluyendo: ${excludePatterns.slice(0, 5).join(', ')}${excludePatterns.length > 5 ? '...' : ''}`);
+    console.log('');
+    // Verificar que estamos en un repositorio git
+    const gitRoot = await findGitRoot();
+    if (!gitRoot) {
+        problem(t("context.not_git"));
+        problem(t("context.git_hint"));
+    }
+    // Obtener lista de archivos
+    const files = await getFileList(branch);
+    if (files.length === 0) {
+        problem('❌ Error: No se encontraron archivos en el repositorio');
+        return;
+    }
+    // Aplicar límite de tamaño si se especificó
+    const limitKB = options.limit || DEFAULT_LIMIT_KB;
+    const maxTotalBytes = limitKB * 1024;
+    let currentTotalBytes = 0;
+    // Escribir archivo de contexto con límite
+    const result = await writeContextFile(outputFile, files, excludePatterns, maxSize, maxTotalBytes);
+    const outputStat = await stat(outputFile);
+    const outputSizeKB = Math.round(outputStat.size / 1024);
+    const totalSizeKB = Math.round(result.totalSize / 1024);
+    console.log('');
+    success(`✅ Contexto generado: ${outputFile}`);
+    info(`   Archivos incluidos: ${result.count}`);
+    info(`   Tamaño total contenido: ${totalSizeKB}KB`);
+    info(`   Tamaño del archivo: ${outputSizeKB}KB`);
+    if (limitKB && result.skippedLimit > 0) {
+        info(`   Limitado por --limit ${limitKB}KB: ${result.skippedLimit} archivos omitidos`);
+    }
+    if (result.skippedExclude > 0)
+        info(`   Omitidos por patrón: ${result.skippedExclude}`);
+    if (result.skippedSize > 0)
+        info(`   Omitidos por tamaño (>${maxSize / 1024}KB): ${result.skippedSize}`);
+    console.log('');
+    info(`📋 Para enviar a DeepSeek:`);
+    info(`   1. En chat.deepseek.com haz clic en "Adjuntar archivo"`);
+    info(`   2. Selecciona ${outputFile}`);
+    info(`   3. El archivo se cargará automáticamente`);
+    if (result.count === 0) {
+        warn(`\n⚠️ Advertencia: No se incluyó ningún archivo.`);
+        warn(`   Revisa tus patrones de exclusión en .contextignore`);
+    }
+    const shouldCopy = !options.noClipboard; // Por defecto true
+    // Copiar al portapapeles si no es --no-clip
+    if (shouldCopy) {
+        try {
+            const content = await readFile(outputFile, 'utf-8');
+            const { execSync } = await import('node:child_process');
+            // Usar execSync con input - esto funciona bien en OpenBSD
+            execSync('xclip -selection clipboard', {
+                input: content,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'ignore', 'ignore']
+            });
+            success(`📋 Contexto copiado al portapapeles (${outputSizeKB}KB)`);
+        }
+        catch (err) {
+            warn(`⚠️ No se pudo copiar al portapapeles: ${err.message}`);
+            warn('   El archivo se guardó como: ' + outputFile);
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+}

package/dist/tasks/create.d.ts

@@ -0,0 +1,2 @@
+export declare function runCreateProject(name: string, description?: string): Promise<void>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/tasks/create.ts"],"names":[],"mappings":"AA4DA,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,iBAuCxE"}

package/dist/tasks/create.js

@@ -0,0 +1,91 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { problem, success } from '../util/colors.js';
+import { createTranslator } from '../i18n/createTranslator.js';
+import { detectLocale } from '../util/locale.js';
+import commonCli from '../i18n/common-cli.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const t = createTranslator(detectLocale(), {
+    en: {
+        'create.generating': 'Generating project in {{0}}...',
+        'create.file_added': 'Added {{0}}',
+        'create.error': 'Error creating project: {{0}}',
+        'create.done': 'Project created successfully.',
+    },
+    es: {
+        'create.generating': 'Generando proyecto en {{0}}...',
+        'create.file_added': 'Agregado {{0}}',
+        'create.error': 'Error al crear el proyecto: {{0}}',
+        'create.done': 'Proyecto creado exitosamente.',
+    },
+}, commonCli);
+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;
+    return path.join(__dirname, 'templates');
+}
+function render(content, name, description) {
+    const pkg = JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url), 'utf-8'));
+    return content
+        .replace(/\{\{name\}\}/g, name)
+        .replace(/\{\{description\}\}/g, description)
+        .replace(/\{\{m_version\}\}/g, pkg.version);
+}
+function getAllFiles(dir) {
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.name === 'pnpm-lock.yaml' || entry.name.startsWith('.env'))
+            continue;
+        if (entry.isDirectory()) {
+            files.push(...getAllFiles(fullPath));
+        }
+        else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+export async function runCreateProject(name, description) {
+    const desc = description || '';
+    const templateDir = getTemplateDir();
+    const cwd = process.cwd();
+    const destDir = path.resolve(cwd, name);
+    if (fs.existsSync(destDir)) {
+        problem(t('create.error', `Directory ${name} already exists`));
+        process.exit(1);
+    }
+    const allFiles = getAllFiles(templateDir);
+    const templateBase = templateDir.replace(/\/+$/, '');
+    for (const srcPath of allFiles) {
+        const destRelPath = path.relative(templateBase, srcPath).replace(/\.hbs$/, '');
+        const destPath = path.join(destDir, destRelPath);
+        fs.mkdirSync(path.dirname(destPath), { recursive: true });
+        if (srcPath.endsWith('.hbs')) {
+            const content = fs.readFileSync(srcPath, 'utf-8');
+            const rendered = render(content, name, desc);
+            fs.writeFileSync(destPath, rendered, 'utf-8');
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+        success(t('create.file_added', '/' + destRelPath));
+    }
+    // Make bin/m executable
+    const binM = path.join(destDir, 'apps', 'nextjs', 'bin', 'm');
+    if (fs.existsSync(binM)) {
+        fs.chmodSync(binM, 0o755);
+        success(`Made ${path.join(name, 'apps', 'nextjs', 'bin', 'm')} executable`);
+    }
+    success(t('create.done'));
+}

package/dist/tasks/db.d.ts

@@ -0,0 +1,19 @@
+export declare function runDbCreate(): Promise<void>;
+export declare function runDbDrop(): Promise<void>;
+export declare function runDbSuperCreateUser(): Promise<void>;
+export declare function runDbConsole(query?: string): Promise<void>;
+export declare function runDbTestConnection(): Promise<void>;
+export declare function runDbStructureDump(): Promise<void>;
+export declare function runDbStructureLoad(): Promise<void>;
+export declare function runDbTypesGen(): Promise<void>;
+export declare function runDbMigrate(): Promise<void>;
+export declare function runDbMigMake(name: string): Promise<void>;
+export declare function runDbRollback(): Promise<void>;
+export declare function runDbDump(name?: string): Promise<void>;
+export declare function runDbRestore(name?: string): Promise<void>;
+export declare function runDbSeed(): Promise<void>;
+/**
+ * db:check — verify expected DB schemas for installed modules.
+ */
+export declare function runDbCheck(): Promise<void>;
+//# sourceMappingURL=db.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/tasks/db.ts"],"names":[],"mappings":"AAyNA,wBAAsB,WAAW,kBAUhC;AAED,wBAAsB,SAAS,kBAU9B;AAED,wBAAsB,oBAAoB,kBAyIzC;AAED,wBAAsB,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,iBAyDhD;AAED,wBAAsB,mBAAmB,kBAkBxC;AAkBD,wBAAsB,kBAAkB,kBAyCvC;AAED,wBAAsB,kBAAkB,kBAgCvC;AAED,wBAAsB,aAAa,kBAclC;AAED,wBAAsB,YAAY,kBAwCjC;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,iBA4B9C;AAED,wBAAsB,aAAa,kBAuBlC;AAED,wBAAsB,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,iBA6B5C;AAED,wBAAsB,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,iBAmD/C;AAED,wBAAsB,SAAS,kBAAoD;AAEnF;;GAEG;AACH,wBAAsB,UAAU,kBAsF/B"}