@pasosdejesus/m 0.15.0

package/dist/i18n/locales/cli.js

@@ -0,0 +1,180 @@
+export const cliTranslations = {
+    en: {
+        'cmd.db_create_description': 'Creates the database',
+        'cmd.db_drop_description': 'Drops the database',
+        'cmd.db_super_createuser_description': 'Creates a superuser for the database',
+        'cmd.db_structure_dump_description': 'Dumps the database structure',
+        'cmd.db_structure_load_description': 'Loads the database structure',
+        'cmd.db_migrate_description': 'Runs database migrations',
+        'cmd.db_mig_make_description': 'Creates a new migration file',
+        'cmd.rollback_description': 'Rolls back the last migration (--step N to revert N)',
+        'cmd.db_rollback_description': 'Rolls back the last migration (--step N to revert N)',
+        'cmd.db_seed_description': 'Seeds the database',
+        'cmd.db_check_description': 'Checks expected database schemas',
+        'cmd.db_console_description': 'Opens a database console',
+        'cmd.db_test_connection_description': 'Tests the database connection non-interactively',
+        'cmd.db_dump_description': 'Dumps the database (data + schema) to db/backups/',
+        'cmd.db_restore_description': 'Restores the database from a backup in db/backups/',
+        'cmd.contract_compile_description': 'Compiles Smart Contracts in apps/hardhat',
+        'cmd.contract_test_description': 'Runs Smart Contract tests in apps/hardhat',
+        'cmd.contract_node_description': 'Runs a local Hardhat node',
+        'cmd.contract_deploy_description': 'Deploys Smart Contracts',
+        'cmd.create_description': 'Creates a new project',
+        'cmd.update_description': 'Synchronizes the current project with template improvements (interactive)',
+        'cmd.ai_framework_description': 'Shows a manifest of christian alignment (randomly chosen)',
+        'cmd.ai_verify_description': 'Generates a christological verification question',
+        'cmd.ai_verify_answer_description': 'Responds to the christological verification question',
+        'cmd.ai_context_description': 'Generates project context for AI chat (DeepSeek compatible)',
+        'cmd.ai_apply_description': 'Applies changes from clipboard (DeepSeek diff format)',
+        'cmd.ai_readfile_description': 'Displays file content (similar to Claude Code read_file)',
+        'cmd.ai_writefile_description': 'Creates or replaces a file with clipboard content',
+        'cmd.ai_grep_description': 'Searches for text in files (grep)',
+        'cmd.ai_skill_description': 'Shows SKILL.md and copies it to the clipboard',
+        'cmd.ai_glob_description': 'Searches for files by pattern (glob)',
+        'cmd.ai_principles_description': 'Shows the 4 guiding principles of the project (Amor, Respeto, Humildad, Hacer sin Excusas)',
+        'cmd.env_diff_description': 'Compares .env.example vs .env showing missing, extra, and changed variables',
+        'cmd.req_list_description': 'Lists requirements from REQ/ with status and cross-project',
+        'cmd.req_show_description': 'Shows a requirement from REQ/',
+        'cmd.req_cross_description': 'Lists requirements with cross-project impact',
+        'cmd.req_compare_description': 'Compares local REQ with remote issue (GitLab/GitHub)',
+        'cmd.req_sync_from_repo_description': 'Updates local REQ from remote issue',
+        'cmd.req_sync_to_repo_description': 'Updates remote issue from local REQ',
+        'cmd.req_list_repo_description': 'Lists open issues from the remote repository',
+        'cmd.req_create_description': 'Creates a new remote issue and local REQ (repo assigns IID)',
+        'cmd.req_close_description': 'Closes a requirement: sync to repo, close issue, delete local',
+        'cmd.credentials_description': 'PasosDeJesusCredentials administration commands',
+        'cmd.credentials_list_types_description': 'List credential types from contract',
+        'cmd.credentials_mint_description': 'Mint a credential to a wallet',
+        'cmd.credentials_register_type_description': 'Register a new credential type',
+        'cmd.credentials_recompose_image_description': 'Recompose credential image from cache',
+        'cmd.credentials_set_max_supply_description': 'Set max supply for a credential type',
+        'cmd.credentials_set_site_uri_description': 'Set base URI for a site',
+        'cmd.credentials_sync_cache_description': 'Sync credential_metadata cache from contract',
+        'cmd.credentials_revoke_credential_description': 'Revoke a credential from a wallet',
+        'cmd.credentials_grant_minter_description': 'Grant MINTER_ROLE to a wallet',
+        'cmd.credentials_revoke_minter_description': 'Revoke MINTER_ROLE from a wallet',
+        'cmd.ai_writefile_usage': 'Usage: m ai:writefile <file>',
+        'cmd.ai_grep_usage': 'Usage: m ai:grep <pattern> [path] [type]',
+        'cmd.ai_glob_usage': 'Usage: m ai:glob <pattern> [--path <path>] [--ignore <pattern>]',
+        'cmd.m_create_usage': 'Usage: m m:create <name> [description]',
+        'usage_line': 'Usage: m [options] [command]',
+        'cmd.options_header': 'Options:',
+        'cmd.commands_header': 'Commands:',
+        'cmd.version_description': 'output the version number',
+        'cmd.help_description': 'display help for command',
+        'cmd.command_not_found': 'Command not found: {{0}}',
+        'cmd.argument_required': 'Argument required for command: {{0}}',
+        'cmd.program_description': 'A modern CLI for msip projects',
+        'cmd.wallet_generate_description': 'Generate a new wallet with mnemonic',
+        'cmd.wallet_approve_description': 'Approve ERC20 token spending',
+        'cmd.wallet_list_description': 'List stored wallets',
+        'cmd.wallet_import_description': 'Import a wallet from mnemonic or private key',
+        'cmd.wallet_sign_description': 'Sign a transaction offline (airgapped)',
+        'cmd.wallet_send_description': 'Send native or ERC20 tokens',
+        'cmd.wallet_balance_description': 'Check wallet balance',
+        'cmd.wallet_derive_description': 'Derive a child wallet from mnemonic',
+        'cmd.wallet_call_description': 'Read data from a smart contract',
+        'cmd.eng_wba_description': 'Install WBA engine',
+        'cmd.eng_wba_setup_description': 'Create WBA migration files',
+        'cmd.eng_credentials_description': 'Install credentials engine',
+        'cmd.eng_credentials_setup_description': 'Create credential migration files',
+        'cmd.eng_list_description': 'List available engines',
+        'cmd.eng_check_description': 'Verify engine schemas',
+        'cmd.wallet_broadcast_description': 'Broadcast a signed transaction',
+        'cmd.wallet_keccak_description': 'Compute Keccak-256 hash of a string',
+        'cmd.create_arg_name': 'project name',
+        'cmd.create_arg_description': 'project description',
+        'cmd.create_arg_required': 'Project name is required',
+        'cmd.db_mig_make_missing_arg': 'Migration name is required',
+        'cmd.e2e_description': 'Run E2E tests (specs with Puppeteer, smoke with axios). Optional: path pattern, --smoke, --grep <filter>',
+    },
+    es: {
+        'cmd.db_create_description': 'Crea la base de datos',
+        'cmd.db_drop_description': 'Elimina la base de datos',
+        'cmd.db_super_createuser_description': 'Crea un superusuario para la base de datos',
+        'cmd.db_structure_dump_description': 'Vuelca la estructura de la base de datos',
+        'cmd.db_structure_load_description': 'Carga la estructura de la base de datos',
+        'cmd.db_migrate_description': 'Ejecuta las migraciones de la base de datos',
+        'cmd.db_mig_make_description': 'Crea un nuevo archivo de migración',
+        'cmd.rollback_description': 'Revierte la última migración (--step N para revertir N)',
+        'cmd.db_rollback_description': 'Revierte la última migración (--step N para revertir N)',
+        'cmd.db_seed_description': 'Siembra la base de datos',
+        'cmd.db_check_description': 'Verifica esquemas esperados de base de datos',
+        'cmd.db_console_description': 'Abre una consola de base de datos',
+        'cmd.db_test_connection_description': 'Prueba la conexión a la base de datos de forma no interactiva',
+        'cmd.db_dump_description': 'Respaldar la base de datos (datos + esquema) en db/backups/',
+        'cmd.db_restore_description': 'Restaurar la base de datos desde un respaldo en db/backups/',
+        'cmd.contract_compile_description': 'Compila los Contratos Inteligentes en apps/hardhat',
+        'cmd.contract_test_description': 'Ejecuta las pruebas de los Contratos Inteligentes en apps/hardhat',
+        'cmd.contract_node_description': 'Ejecuta un nodo local de Hardhat',
+        'cmd.contract_deploy_description': 'Despliega los Contratos Inteligentes',
+        'cmd.create_description': 'Crea un nuevo proyecto',
+        'cmd.update_description': 'Sincroniza el proyecto actual con las mejoras de las plantillas (interactivo)',
+        'cmd.ai_framework_description': 'Muestra un manifiesto de alineación cristiana (aleatorio)',
+        'cmd.ai_verify_description': 'Genera una pregunta de verificación cristológica',
+        'cmd.ai_verify_answer_description': 'Responde a la pregunta de verificación cristológica',
+        'cmd.ai_context_description': 'Genera contexto del proyecto para chat IA (compatible con DeepSeek)',
+        'cmd.ai_apply_description': 'Aplica cambios desde el portapapeles (formato diff de DeepSeek)',
+        'cmd.ai_readfile_description': 'Muestra contenido de archivos (como read_file de Claude Code)',
+        'cmd.ai_writefile_description': 'Crea o reemplaza un archivo con el contenido del portapapeles',
+        'cmd.ai_grep_description': 'Busca texto en archivos (grep)',
+        'cmd.ai_skill_description': 'Muestra SKILL.md y lo copia al portapapeles',
+        'cmd.ai_glob_description': 'Busca archivos por patrón (glob)',
+        'cmd.ai_principles_description': 'Muestra los 4 principios rectores del proyecto (Amor, Respeto, Humildad, Hacer sin Excusas)',
+        'cmd.env_diff_description': 'Compara .env.example vs .env mostrando variables faltantes, sobrantes y diferentes',
+        'cmd.req_list_description': 'Lista requerimientos de REQ/ con estado y cross-project',
+        'cmd.req_show_description': 'Muestra un requerimiento de REQ/',
+        'cmd.req_cross_description': 'Lista requerimientos con impacto cross-project',
+        'cmd.req_compare_description': 'Compara REQ local con issue remoto (GitLab/GitHub)',
+        'cmd.req_sync_from_repo_description': 'Actualiza REQ local desde issue remoto',
+        'cmd.req_sync_to_repo_description': 'Actualiza issue remoto desde REQ local',
+        'cmd.req_list_repo_description': 'Lista issues abiertos del repositorio remoto',
+        'cmd.req_create_description': 'Crea nuevo issue remoto y REQ local (repo asigna IID)',
+        'cmd.req_close_description': 'Cierra un requerimiento: sync→repo, cierra issue, elimina local',
+        'cmd.credentials_description': 'Órdenes de administración de PasosDeJesusCredentials',
+        'cmd.credentials_list_types_description': 'Lista tipos de credencial del contrato',
+        'cmd.credentials_mint_description': 'Acuña una credencial a una billetera',
+        'cmd.credentials_register_type_description': 'Registra un nuevo tipo de credencial',
+        'cmd.credentials_recompose_image_description': 'Recompone imagen de credencial desde caché',
+        'cmd.credentials_set_max_supply_description': 'Establece suministro máximo para un tipo',
+        'cmd.credentials_set_site_uri_description': 'Establece URI base para un sitio',
+        'cmd.credentials_sync_cache_description': 'Sincroniza caché credential_metadata desde el contrato',
+        'cmd.credentials_revoke_credential_description': 'Revoca una credencial de una billetera',
+        'cmd.credentials_grant_minter_description': 'Otorga MINTER_ROLE a una billetera',
+        'cmd.credentials_revoke_minter_description': 'Revoca MINTER_ROLE de una billetera',
+        'cmd.ai_writefile_usage': 'Uso: m ai:writefile <archivo>',
+        'cmd.ai_grep_usage': 'Uso: m ai:grep <patrón> [ruta] [tipo]',
+        'cmd.ai_glob_usage': 'Uso: m ai:glob <patrón> [--path <ruta>] [--ignore <patrón>]',
+        'cmd.m_create_usage': 'Uso: m m:create <nombre> [descripción]',
+        'usage_line': 'Uso: m [opciones] [orden]',
+        'cmd.options_header': 'Opciones:',
+        'cmd.commands_header': 'Órdenes:',
+        'cmd.version_description': 'muestra el número de versión',
+        'cmd.help_description': 'muestra la ayuda para la orden',
+        'cmd.command_not_found': 'Orden no encontrada: {{0}}',
+        'cmd.argument_required': 'Argumento requerido para la orden: {{0}}',
+        'cmd.program_description': 'Un CLI moderno para proyectos msip',
+        'cmd.wallet_generate_description': 'Genera una nueva billetera con mnemotécnico',
+        'cmd.wallet_approve_description': 'Aprueba gasto de token ERC20',
+        'cmd.wallet_list_description': 'Lista billeteras almacenadas',
+        'cmd.wallet_import_description': 'Importa una billetera desde mnemotécnico o clave privada',
+        'cmd.wallet_sign_description': 'Firma una transacción offline (airgapped)',
+        'cmd.wallet_send_description': 'Envía tokens nativos o ERC20',
+        'cmd.wallet_balance_description': 'Consulta saldo de billetera',
+        'cmd.wallet_derive_description': 'Deriva billetera hija desde mnemotécnico',
+        'cmd.wallet_call_description': 'Lee datos de un contrato inteligente',
+        'cmd.eng_wba_description': 'Instala motor WBA',
+        'cmd.eng_wba_setup_description': 'Crea archivos de migración WBA',
+        'cmd.eng_credentials_description': 'Instala motor credentials',
+        'cmd.eng_credentials_setup_description': 'Crea archivos de migración credentials',
+        'cmd.eng_list_description': 'Lista motores disponibles',
+        'cmd.eng_check_description': 'Verifica esquemas de motores',
+        'cmd.wallet_broadcast_description': 'Transmite una transacción firmada',
+        'cmd.wallet_keccak_description': 'Calcula hash Keccak-256 de un texto',
+        'cmd.create_arg_name': 'nombre del proyecto',
+        'cmd.create_arg_description': 'descripción del proyecto',
+        'cmd.create_arg_required': 'El nombre del proyecto es requerido',
+        'cmd.db_mig_make_missing_arg': 'El nombre de la migración es requerido',
+        'cmd.e2e_description': 'Ejecuta pruebas E2E (specs con Puppeteer, smoke con axios). Opcional: patrón, --smoke, --grep <filtro>',
+    },
+};

package/dist/i18n/types.d.ts

@@ -0,0 +1,3 @@
+export type LocaleStrings = Record<string, string>;
+export type TranslationSet = Record<string, LocaleStrings>;
+//# sourceMappingURL=types.d.ts.map

package/dist/i18n/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/i18n/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAElD,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA"}

package/dist/i18n/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export declare const getVersion: () => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,UAAU,QAAO,MAE7B,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * @pasosdejesus/m — Package entry point.
+ *
+ * Currently only exports getVersion(). The real API lives in subpath exports:
+ *   @pasosdejesus/m/i18n, /test-utils, /debug, /wba, /wba/routes,
+ *   /shadcn-components/cn, /shadcn-components/ui/*
+ *
+ * See API.md for the full catalog.
+ */
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+export const getVersion = () => {
+    return pkg.version;
+};

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+import { getVersion } from './index.js';
+import { createRequire } from 'module';
+describe('getVersion', () => {
+    it('should return the correct version from package.json', () => {
+        const require = createRequire(import.meta.url);
+        const pkg = require('../package.json');
+        expect(getVersion()).toBe(pkg.version);
+    });
+});

package/dist/m.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=m.d.ts.map

package/dist/m.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m.d.ts","sourceRoot":"","sources":["../src/m.ts"],"names":[],"mappings":""}

package/dist/m.js

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+/**
+ * m CLI — Main entry point.
+ *
+ * Registers all generic commands (db:*, wallet:*, m:*, ai:tools, eng:*) in a CommandDef map,
+ * parses process.argv manually, and dispatches to the matching handler.
+ * PdJ-specific commands are loaded via plugins (see @pasosdejesus/mpdj).
+ */
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+import * as fs from 'fs';
+import { runDbCreate, runDbDrop, runDbSuperCreateUser, runDbStructureDump, runDbStructureLoad, runDbMigrate, runDbRollback, runDbSeed, runDbCheck, runDbConsole, runDbMigMake, runDbTestConnection, runDbDump, runDbRestore } from './tasks/db.js';
+import { runAiContext } from './tasks/context.js';
+import { runAiEdit } from './tasks/edit.js';
+import { runAiReadFile } from './tasks/readfile.js';
+import { runAiWriteFile } from './tasks/writefile.js';
+import { runAiGrep } from './tasks/grep.js';
+import { runAiGlob } from './tasks/glob.js';
+import { runUpdate } from './tasks/update.js';
+import { runE2e } from './tasks/e2e.js';
+import { runEnvDiff } from './tasks/env-diff.js';
+import { runWallet } from './tasks/wallet.js';
+import { runEngine } from './tasks/engine.js';
+import { createTranslator } from './i18n/createTranslator.js';
+import { detectLocale, setLocale } from './util/locale.js';
+import commonCli from './i18n/common-cli.js';
+import { cliTranslations } from './i18n/locales/cli.js';
+import { problem, success } from './util/colors.js';
+import { parseFlags } from './util/cli-parser.js';
+import { getPluginCommands } from './plugin.js';
+// Custom .env loading
+const CWD = process.cwd();
+const searchPaths = [
+    path.join(CWD, '../..', '.env'), path.join(CWD, '../..', '.env.test'),
+    path.join(CWD, '..', '.env'), path.join(CWD, '..', '.env.test'),
+    path.join(CWD, '.env'), path.join(CWD, '.env.test'),
+];
+for (const p of searchPaths) {
+    if (fs.existsSync(p))
+        dotenv.config({ path: p, override: true, quiet: true });
+}
+async function main() {
+    const locale = detectLocale();
+    setLocale(locale);
+    const cliT = createTranslator(locale, cliTranslations, commonCli);
+    const commands = {
+        'db:create': { handler: runDbCreate, description: cliT('cmd.db_create_description') },
+        'db:drop': { handler: runDbDrop, description: cliT('cmd.db_drop_description') },
+        'db:super:createuser': { handler: runDbSuperCreateUser, description: cliT('cmd.db_super_createuser_description') },
+        'db:structure:dump': { handler: runDbStructureDump, description: cliT('cmd.db_structure_dump_description') },
+        'db:structure:load': { handler: runDbStructureLoad, description: cliT('cmd.db_structure_load_description') },
+        'db:migrate': { handler: runDbMigrate, description: cliT('cmd.db_migrate_description') },
+        'db:mig:make': {
+            handler: (name) => {
+                if (!name) {
+                    problem(cliT('cmd.db_mig_make_missing_arg'));
+                    process.exit(1);
+                }
+                return runDbMigMake(name);
+            },
+            description: cliT('cmd.db_mig_make_description'), argRequired: true, argName: 'name'
+        },
+        'db:rollback': { handler: runDbRollback, description: cliT('cmd.db_rollback_description'), argOptional: true, argName: '--step N' },
+        'db:seed': { handler: runDbSeed, description: cliT('cmd.db_seed_description') },
+        'db:check': { handler: runDbCheck, description: cliT('cmd.db_check_description') },
+        'db:console': { handler: runDbConsole, description: cliT('cmd.db_console_description'), argOptional: true, argName: 'query' },
+        'db:test': { handler: runDbTestConnection, description: cliT('cmd.db_test_connection_description') },
+        'db:dump': { handler: (name) => runDbDump(name), description: cliT('cmd.db_dump_description'), argOptional: true, argName: 'name' },
+        'db:restore': { handler: (name) => runDbRestore(name), description: cliT('cmd.db_restore_description'), argOptional: true, argName: 'name' },
+        'ai:edit': {
+            handler: async () => {
+                const { options: f } = parseFlags(process.argv.slice(3), { 'dry-run': { type: 'boolean', alias: '-n' } });
+                await runAiEdit({ dryRun: !!f['dry-run'] });
+            },
+            description: cliT('cmd.ai_apply_description'), argOptional: true, argName: 'flags'
+        },
+        'ai:context': {
+            handler: async () => {
+                const { options: f } = parseFlags(process.argv.slice(3), {
+                    'output': { type: 'string' }, 'branch': { type: 'string' }, 'max-size': { type: 'number' },
+                    'full': { type: 'boolean' }, 'limit': { type: 'number' }, 'no-clip': { type: 'boolean', alias: '--nc' },
+                });
+                await runAiContext({
+                    output: f['output'], branch: f['branch'],
+                    maxSize: typeof f['max-size'] === 'number' ? f['max-size'] * 1024 : undefined,
+                    full: !!f['full'], limit: f['limit'], noClipboard: !!f['no-clip'],
+                });
+            },
+            description: cliT('cmd.ai_context_description'), argOptional: true, argName: 'output'
+        },
+        'ai:readfile': {
+            handler: async () => { await runAiReadFile(process.argv.slice(3)); },
+            description: cliT('cmd.ai_readfile_description'), argOptional: true, argName: 'file'
+        },
+        'ai:writefile': {
+            handler: async () => {
+                const args = process.argv.slice(3);
+                if (!args[0]) {
+                    problem(cliT('cmd.ai_writefile_usage'));
+                    return;
+                }
+                await runAiWriteFile(args[0]);
+            },
+            description: cliT('cmd.ai_writefile_description'), argOptional: true, argName: 'file'
+        },
+        'ai:grep': {
+            handler: async () => {
+                const { options: f, positional } = parseFlags(process.argv.slice(3), {
+                    'path': { type: 'string' }, 'type': { type: 'string' },
+                    'context': { type: 'number', alias: '-C' }, 'ignore-case': { type: 'boolean', alias: '-i' },
+                });
+                const pattern = positional[0];
+                if (!pattern) {
+                    problem(cliT('cmd.ai_grep_usage'));
+                    return;
+                }
+                const opts = {};
+                if (f['path'])
+                    opts.path = f['path'];
+                if (f['type'])
+                    opts.type = f['type'];
+                if (f['context'])
+                    opts.context = f['context'];
+                if (f['ignore-case'])
+                    opts.ignoreCase = true;
+                if (!opts.path && positional.length > 1 && !positional[1].startsWith('-'))
+                    opts.path = positional[1];
+                await runAiGrep(pattern, opts);
+            },
+            description: cliT('cmd.ai_grep_description'), argOptional: true, argName: 'pattern'
+        },
+        'ai:glob': {
+            handler: async () => {
+                const { options: f, positional } = parseFlags(process.argv.slice(3), { 'path': { type: 'string' }, 'ignore': { type: 'string' } });
+                const pattern = positional[0];
+                if (!pattern) {
+                    problem(cliT('cmd.ai_glob_usage'));
+                    return;
+                }
+                await runAiGlob(pattern, { path: f['path'], ignore: f['ignore'] ? [f['ignore']] : undefined });
+            },
+            description: cliT('cmd.ai_glob_description'), argOptional: true, argName: 'pattern'
+        },
+        'env:diff': {
+            handler: async () => {
+                const { positional } = parseFlags(process.argv.slice(3), {});
+                await runEnvDiff(positional[0], positional[1]);
+            },
+            description: cliT('cmd.env_diff_description'), argOptional: true, argName: 'base [target]'
+        },
+        'm:create': {
+            handler: async () => {
+                const args = process.argv.slice(3);
+                const name = args[0];
+                const description = args.slice(1).join(' ');
+                if (!name) {
+                    problem(cliT('cmd.m_create_usage'));
+                    return;
+                }
+                await (await import('./tasks/create.js')).runCreateProject(name, description);
+            },
+            description: cliT('cmd.create_description'), argRequired: true, argName: 'name'
+        },
+        'm:update': {
+            handler: async () => {
+                const { options: f } = parseFlags(process.argv.slice(3), { 'check': { type: 'boolean', alias: '-c' }, 'yes': { type: 'boolean', alias: '-y' } });
+                await runUpdate({ check: !!f['check'], yes: !!f['yes'] });
+            },
+            description: cliT('cmd.update_description')
+        }
+    };
+    // Wallet commands
+    const walletCmd = (sub) => ({
+        handler: async () => { await runWallet([sub, ...process.argv.slice(3)]); },
+        description: cliT(`cmd.wallet_${sub.replace(/-/g, '_')}_description`)
+    });
+    for (const sub of ['generate', 'approve', 'list', 'import', 'sign', 'send', 'balance', 'derive', 'call', 'broadcast', 'keccak']) {
+        commands[`wallet:${sub}`] = walletCmd(sub);
+    }
+    // Engine commands
+    const engCmd = (subs, key) => ({
+        handler: async () => { await runEngine([...subs, ...process.argv.slice(3)]); },
+        description: cliT(`cmd.eng_${key}_description`)
+    });
+    commands['eng:wba:setup'] = engCmd(['wba', 'setup'], 'wba_setup');
+    commands['eng:credentials:setup'] = engCmd(['credentials', 'setup'], 'credentials_setup');
+    commands['eng:list'] = engCmd(['list'], 'list');
+    commands['eng:check'] = engCmd(['check'], 'check');
+    // Hardhat contract commands
+    const hasHardhatDir = fs.existsSync(path.join(CWD, 'apps', 'hardhat'))
+        || fs.existsSync(path.join(CWD, '..', 'hardhat')) || fs.existsSync(path.join(CWD, 'hardhat'))
+        || fs.existsSync(path.join(CWD, 'hardhat.config.ts')) || fs.existsSync(path.join(CWD, 'hardhat.config.js'));
+    if (hasHardhatDir) {
+        commands['contract:test'] = {
+            handler: async (arg) => {
+                // Lazy-load the contract-test package, which registers via plugin system
+                await import('@pasosdejesus/contract-test');
+                // Invoke the handler registered by the plugin
+                const pluginCmds = getPluginCommands();
+                const cmd = pluginCmds['contract:test'];
+                if (cmd?.handler) {
+                    await cmd.handler(arg);
+                }
+            },
+            description: cliT('cmd.contract_test_description')
+        };
+    }
+    // test:e2e
+    const hasE2eDir = fs.existsSync(path.join(CWD, 'e2e'));
+    if (hasE2eDir) {
+        commands['test:e2e'] = {
+            handler: async (arg) => { await runE2e(arg, process.argv.slice(3)); },
+            description: cliT('cmd.e2e_description'), argOptional: true,
+        };
+    }
+    // ── Help ──
+    function showVersion() {
+        const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+        success(`m CLI v${pkg.version}`);
+    }
+    function showHelp() {
+        console.log(cliT('usage_line'));
+        console.log();
+        console.log(cliT('cmd.options_header'));
+        console.log('  -V, --version      ' + cliT('cmd.version_description'));
+        console.log('  -h, --help         ' + cliT('cmd.help_description'));
+        console.log();
+        console.log(cliT('cmd.commands_header'));
+        function findProjectRoot(start) {
+            let current = start;
+            while (current !== path.parse(current).root) {
+                if (fs.existsSync(path.join(current, 'apps')))
+                    return current;
+                current = path.dirname(current);
+            }
+            return start;
+        }
+        function findProjectPackage(root) {
+            const pkgPath = path.join(root, 'package.json');
+            if (fs.existsSync(pkgPath))
+                return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            return null;
+        }
+        const projectRoot = findProjectRoot(process.cwd());
+        const projectPkg = findProjectPackage(projectRoot);
+        const hasKysely = projectPkg?.dependencies?.kysely || projectPkg?.devDependencies?.kysely;
+        const hasViem = projectPkg?.dependencies?.viem || projectPkg?.devDependencies?.viem;
+        const hasHardhat = fs.existsSync(path.join(projectRoot, 'apps', 'hardhat'))
+            || fs.existsSync(path.join(projectRoot, 'hardhat'))
+            || fs.existsSync(path.join(projectRoot, 'hardhat.config.ts'))
+            || fs.existsSync(path.join(projectRoot, 'hardhat.config.js'));
+        const categories = {
+            'AI': ['ai:context', 'ai:edit', 'ai:readfile', 'ai:writefile', 'ai:grep', 'ai:glob'],
+            'ENV': ['env:diff'],
+            'Project': ['m:create', 'm:update'],
+            'Test': ['test:e2e'],
+        };
+        if (hasHardhat)
+            categories['Contracts'] = ['contract:test'];
+        if (hasKysely) {
+            categories['Database'] = ['db:create', 'db:drop', 'db:super:createuser', 'db:structure:dump', 'db:structure:load',
+                'db:migrate', 'db:mig:make', 'db:rollback', 'db:seed', 'db:check', 'db:console', 'db:test', 'db:dump', 'db:restore'];
+            categories['Engine'] = ['eng:wba:setup', 'eng:credentials:setup', 'eng:list', 'eng:check'];
+        }
+        if (hasViem) {
+            categories['Wallet'] = ['wallet:generate', 'wallet:approve', 'wallet:list', 'wallet:import', 'wallet:send', 'wallet:balance', 'wallet:sign', 'wallet:broadcast', 'wallet:call', 'wallet:derive', 'wallet:keccak'];
+        }
+        // Plugin categories
+        const pluginCmds = getPluginCommands();
+        const pluginNames = Object.keys(pluginCmds);
+        if (pluginNames.some(n => n.startsWith('ai:'))) {
+            categories['AI'] = [...(categories['AI'] || []), ...pluginNames.filter(n => n.startsWith('ai:'))];
+        }
+        if (pluginNames.some(n => n.startsWith('req:'))) {
+            categories['Requirements'] = pluginNames.filter(n => n.startsWith('req:'));
+        }
+        if (pluginNames.some(n => n.startsWith('eng:credentials:'))) {
+            categories['Engine/Credentials'] = pluginNames.filter(n => n.startsWith('eng:credentials:'));
+        }
+        for (const [category, cmdNames] of Object.entries(categories)) {
+            console.log(`  ${category}:`);
+            for (const cmdName of cmdNames) {
+                const cmd = commands[cmdName];
+                if (cmd) {
+                    let syntax = cmdName;
+                    if (cmd.argRequired)
+                        syntax += ` <${cmd.argName || 'name'}>`;
+                    else if (cmd.argOptional)
+                        syntax += ` [${cmd.argName || 'output'}]`;
+                    console.log(`    ${syntax.padEnd(30)} ${cmd.description}`);
+                }
+            }
+            console.log();
+        }
+    }
+    // Load plugin commands (deferred for async plugin registration)
+    const pluginCmds = getPluginCommands();
+    for (const [name, def] of Object.entries(pluginCmds)) {
+        commands[name] = def;
+    }
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        showHelp();
+        process.exit(0);
+    }
+    if (args[0] === '--version' || args[0] === '-V') {
+        showVersion();
+        process.exit(0);
+    }
+    const commandName = args[0];
+    const commandArg = args[1];
+    const command = commands[commandName];
+    if (!command) {
+        problem(cliT('cmd.command_not_found', commandName));
+        console.log();
+        showHelp();
+        process.exit(1);
+    }
+    if (command.argRequired && !commandArg) {
+        problem(cliT('cmd.argument_required', commandName));
+        console.log();
+        showHelp();
+        process.exit(1);
+    }
+    try {
+        await command.handler(commandArg);
+    }
+    catch (error) {
+        problem(error.message || 'Unknown error');
+        process.exit(1);
+    }
+}
+main().catch(err => { problem(err.message); process.exit(1); });

package/dist/plugin.d.ts

@@ -0,0 +1,10 @@
+export interface CommandDef {
+    handler: (arg?: string) => Promise<void> | void;
+    description: string;
+    argRequired?: boolean;
+    argOptional?: boolean;
+    argName?: string;
+}
+export declare function registerCommands(commands: Record<string, CommandDef>): void;
+export declare function getPluginCommands(): Record<string, CommandDef>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAChD,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAID,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI,CAE3E;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAE9D"}

package/dist/plugin.js

@@ -0,0 +1,7 @@
+const pluginCommands = {};
+export function registerCommands(commands) {
+    Object.assign(pluginCommands, commands);
+}
+export function getPluginCommands() {
+    return pluginCommands;
+}

package/dist/shadcn_components/cn.d.ts

@@ -0,0 +1,13 @@
+/**
+ * cn() — Tailwind class merging utility.
+ *
+ * Combines clsx (conditional classes) with tailwind-merge (conflict resolution).
+ * Shadcn UI components use this internally; projects can import it directly
+ * via @pasosdejesus/m/shadcn-components/cn.
+ *
+ * Why not just clsx? tailwind-merge handles conflicting Tailwind utilities
+ * (e.g., combining "px-4" and "px-2" keeps the last one).
+ */
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=cn.d.ts.map

package/dist/shadcn_components/cn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cn.d.ts","sourceRoot":"","sources":["../../src/shadcn_components/cn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAG5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist/shadcn_components/cn.js

@@ -0,0 +1,15 @@
+/**
+ * cn() — Tailwind class merging utility.
+ *
+ * Combines clsx (conditional classes) with tailwind-merge (conflict resolution).
+ * Shadcn UI components use this internally; projects can import it directly
+ * via @pasosdejesus/m/shadcn-components/cn.
+ *
+ * Why not just clsx? tailwind-merge handles conflicting Tailwind utilities
+ * (e.g., combining "px-4" and "px-2" keeps the last one).
+ */
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}