arckode-framework 1.3.2 → 1.4.1

package/cli/index.ts

@@ -1,237 +1,32 @@
 #!/usr/bin/env bun
 // CLI — Arckode Framework Tooling
-// Punto de entrada para generación y análisis
+// Punto de entrada: routing de comandos. Cada comando vive en cli/commands/.
 
-import { mkdir, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { generateModule, generateConnector } from './generate'
 import { analyzeProject, printAnalysis, buildManifest } from './analyze'
-import { claudeMdStub } from './stubs/claude-md-stub'
+import { writeFile } from 'node:fs/promises'
 
 async function main() {
   const [, , cmd, ...args] = process.argv
 
   switch (cmd) {
-    // ─── Crear proyecto ───
     case 'new': {
       const name = args[0]
-      if (!name) { console.log('Uso: bun arckode.ts new <nombre-proyecto> [--db=sqlite|mysql|postgres]'); return }
-
-      // Detectar DB adapter: --db=mysql | --db=postgres | default: sqlite
+      if (!name) { console.log('Uso: arckode new <nombre-proyecto> [--db=sqlite|mysql|postgres]'); return }
       const dbFlag = args.find(a => a.startsWith('--db='))?.split('=')[1] ?? 'sqlite'
-      const db: 'sqlite' | 'mysql' | 'postgres' =
-        dbFlag === 'mysql' || dbFlag === 'postgres' ? dbFlag : 'sqlite'
-
-      const base = join(process.cwd(), name)
-
-      // Crear estructura del proyecto
-      await mkdir(join(base, 'src', 'modules'), { recursive: true })
-      await mkdir(join(base, 'src', 'connectors'), { recursive: true })
-
-      // ─── CLAUDE.md ─────────────────────────────────────────────────────
-      // Contenido del stub vive en cli/stubs/claude-md-stub.ts
-      // (sincronizado con CLAUDE.md maestro del framework)
-      await writeFile(join(base, 'CLAUDE.md'), claudeMdStub({ projectName: name, db }))
-
-      // composition-root.ts
-      await writeFile(join(base, 'src', 'composition-root.ts'), [
-        `// composition-root.ts — ÚNICO archivo que describe TODO el sistema`,
-        `// La IA lee esto y sabe: módulos, conectores, dependencias.`,
-        `// ============================================================`,
-        ``,
-        `import {`,
-        `  ConfigStore, Container, Logger, ORM, Router,`,
-        `  NodeServer, MemoryCache, System, Auth, loadEnv,`,
-        `} from 'arckode-framework'`,
-        ...(db === 'sqlite' ? [
-          `import { SqliteAdapter } from 'arckode-framework/adapters/sqlite'`,
-        ] : db === 'mysql' ? [
-          `import { MySQLAdapter } from 'arckode-framework/adapters/mysql'`,
-        ] : [
-          `import { PostgresAdapter } from 'arckode-framework/adapters/postgres'`,
-        ]),
-        `import { jwtTokenAdapter } from 'arckode-framework/adapters/jwt'`,
-        ``,
-        `// ─── 1. ENV + CONFIG ─────────────────────────`,
-        `// loadEnv() carga .env + .env.{NODE_ENV} — process.env tiene prioridad máxima`,
-        `const env = await loadEnv()`,
-        ``,
-        `const config = new ConfigStore()`,
-        `config.define({`,
-        `  PORT:       { type: 'number', default: 3000 },`,
-        ...(db === 'sqlite' ? [
-          `  DB_PATH:    { type: 'string', default: './data/db.sqlite' },`,
-        ] : db === 'mysql' ? [
-          `  DB_HOST:    { type: 'string', required: true },`,
-          `  DB_USER:    { type: 'string', required: true },`,
-          `  DB_PASSWORD:{ type: 'string', required: true },`,
-          `  DB_NAME:    { type: 'string', required: true },`,
-          `  DB_PORT:    { type: 'number', default: 3306 },`,
-        ] : [
-          `  DATABASE_URL: { type: 'string', required: true },`,
-        ]),
-        `  JWT_SECRET: { type: 'string', required: true },`,
-        `  LOG_LEVEL:  { type: 'string', default: 'info' },`,
-        `}).load(env)`,
-        ``,
-        `// ─── 2. INFRAESTRUCTURA ──────────────────────`,
-        `const logger = new Logger('app', config.get('LOG_LEVEL') as any)`,
-        `const container = new Container()`,
-        ...(db === 'sqlite' ? [
-          `const dbAdapter = new SqliteAdapter({ path: config.get('DB_PATH') })`,
-        ] : db === 'mysql' ? [
-          `const dbAdapter = new MySQLAdapter({`,
-          `  host:     config.get('DB_HOST'),`,
-          `  port:     config.get<number>('DB_PORT'),`,
-          `  user:     config.get('DB_USER'),`,
-          `  password: config.get('DB_PASSWORD'),`,
-          `  database: config.get('DB_NAME'),`,
-          `})`,
-        ] : [
-          `const dbAdapter = new PostgresAdapter({ connectionString: config.get('DATABASE_URL') })`,
-        ]),
-        `await dbAdapter.connect()`,
-        `const orm = new ORM(dbAdapter)`,
-        `const router = new Router()`,
-        `const http = new NodeServer(config.get<number>('PORT'), logger)`,
-        `const cache = new MemoryCache()`,
-        `const auth = new Auth(jwtTokenAdapter, config.get('JWT_SECRET'), logger)`,
-        ``,
-        `// ─── 3. CONTAINER ────────────────────────────`,
-        `container.register('config', () => config)`,
-        `container.register('logger', () => logger)`,
-        `container.register('db', () => dbAdapter, () => dbAdapter.close())`,
-        `container.register('orm', () => orm)`,
-        `container.register('cache', () => cache)`,
-        `container.init()`,
-        ``,
-        `// ─── 4. SISTEMA ───────────────────────────────`,
-        `const system = new System({`,
-        `  config, container, logger, orm, router, http, cache, auth,`,
-        `})`,
-        ``,
-        `// ─── 5. MÓDULOS ───────────────────────────────`,
-        `// Cada módulo se autorregistra: su index.ts llama registerXxxModels(orm)`,
-        `// en el create(). Acá SOLO addModule(). No tocar orm.define() manualmente.`,
-        ``,
-        `// import { MiModuloModule } from './modules/mi-modulo'`,
-        `// system.addModule(MiModuloModule())`,
-        ``,
-        `// ─── 6. CONECTORES ────────────────────────────`,
-        `// Generar con: arckode make:connector nombre-x mod-a mod-b`,
-        `// import { connectModAModB } from './connectors/mod-a-mod-b'`,
-        `// system.addConnector('mod-a-mod-b', connectModAModB)`,
-        ``,
-        `// Para atomicidad multi-tabla (financieras, ledgers, transferencias):`,
-        `// import { OrmTransactor } from 'arckode-framework'`,
-        `// const transactor = new OrmTransactor(orm)`,
-        `// → inyectarlo al service que lo necesite (Regla #19)`,
-        ``,
-        `// ─── 7. RUTAS BASE ────────────────────────────`,
-        `router.get('/health', async () => ({`,
-        `  status: 200, body: { status: 'ok', uptime: process.uptime() }`,
-        `}))`,
-        ``,
-        `// ─── 8. INIT + MIGRATE + START ────────────────`,
-        `// Orden CRÍTICO: init() ejecuta los create() de los módulos (registra modelos),`,
-        `// luego migrate() crea las tablas, luego start() levanta el HTTP.`,
-        `system.init()`,
-        `await orm.migrate()`,
-        ``,
-        `// ─── 9. SEEDS (solo en desarrollo) ────────────`,
-        `if (env.RUN_SEEDS === 'true') {`,
-        `  // await seeds.runAll()`,
-        `}`,
-        ``,
-        `await system.start()`,
-        ``,
-        `process.on('SIGINT', async () => { await system.stop(); process.exit(0) })`,
-        `process.on('SIGTERM', async () => { await system.stop(); process.exit(0) })`,
-        ``,
-      ].join('\n'))
-
-      // package.json — dependencias según el DB elegido
-      const dbDeps: Record<string, string> = db === 'mysql'
-        ? { 'mysql2': '^3.0.0' }
-        : db === 'postgres'
-          ? { 'pg': '^8.0.0' }
-          : { 'better-sqlite3': '^11.0.0' }
-
-      const dbDevDeps: Record<string, string> = db === 'postgres'
-        ? { '@types/pg': '^8.0.0' }
-        : db === 'sqlite'
-          ? { '@types/better-sqlite3': '^7.6.0' }
-          : {}
-
-      await writeFile(join(base, 'package.json'), JSON.stringify({
-        name,
-        version: '1.0.0',
-        type: 'module',
-        scripts: {
-          dev:          `bun --watch src/composition-root.ts`,
-          start:        `bun run src/composition-root.ts`,
-          test:         `bun test`,
-          'test:watch': `bun test --watch`,
-          analyze:      `bun run node_modules/arckode-framework/cli/index.ts analyze`,
-          'analyze:ci': `bun run node_modules/arckode-framework/cli/index.ts analyze --ci`,
-        },
-        dependencies: {
-          'arckode-framework': 'latest',
-          'jsonwebtoken': '^9.0.0',
-          ...dbDeps,
-        },
-        devDependencies: {
-          '@types/jsonwebtoken': '^9.0.0',
-          ...dbDevDeps,
-        },
-      }, null, 2))
-
-      // .env según el DB elegido
-      const envContent = db === 'mysql'
-        ? `PORT=3000\nDB_HOST=localhost\nDB_PORT=3306\nDB_USER=root\nDB_PASSWORD=secret\nDB_NAME=${name}\nJWT_SECRET=cambiar-en-produccion\nLOG_LEVEL=info\n`
-        : db === 'postgres'
-          ? `PORT=3000\nDATABASE_URL=postgres://user:password@localhost:5432/${name}\nJWT_SECRET=cambiar-en-produccion\nLOG_LEVEL=info\n`
-          : `PORT=3000\nDB_PATH=./data/db.sqlite\nJWT_SECRET=cambiar-en-produccion\nLOG_LEVEL=info\n`
-
-      await writeFile(join(base, '.env'), envContent)
-
-      // .env.example
-      await writeFile(join(base, '.env.example'), `PORT=3000
-DB_PATH=./data/db.sqlite
-JWT_SECRET=cambiar-en-produccion
-LOG_LEVEL=info
-`)
-
-      // .gitignore
-      await writeFile(join(base, '.gitignore'), `node_modules/
-dist/
-data/
-.env
-`)
-
-      // Crear data/
-      await mkdir(join(base, 'data'), { recursive: true })
-
-      console.log(`\n✅ Proyecto "${name}" creado (DB: ${db})`)
-      console.log(`\n  Siguientes pasos:`)
-      console.log(`  cd ${name}`)
-      console.log(`  bun install`)
-      console.log(`  bun run dev`)
-      console.log(`\n  La IA arranca leyendo CLAUDE.md → arckode.json`)
+      const db = (dbFlag === 'mysql' || dbFlag === 'postgres' ? dbFlag : 'sqlite') as 'sqlite' | 'mysql' | 'postgres'
+      const { newProject } = await import('./commands/new')
+      await newProject(name, db)
       break
     }
 
-    // ─── Generar módulo ───
     case 'make:module': {
       const name = args[0]
-      if (!name) { console.log('Uso: bun arckode.ts make:module <Nombre>'); return }
-
-      const basePath = join(process.cwd(), 'src')
-
-      // Preguntar campos (versión simple con defaults)
+      if (!name) { console.log('Uso: arckode make:module <Nombre>'); return }
       await generateModule({
         name,
-        basePath,
+        basePath: join(process.cwd(), 'src'),
         description: `Módulo de ${name}`,
         fields: {
           nombre: { type: 'string', required: true },
@@ -241,32 +36,20 @@ data/
       break
     }
 
-    // ─── Generar conector ───
     case 'make:connector': {
       const name = args[0]
       const modules = args.slice(1)
-      if (!name || modules.length < 2) {
-        console.log('Uso: bun arckode.ts make:connector <nombre> <mod1> <mod2> ...')
-        return
-      }
-
-      const basePath = join(process.cwd(), 'src')
-      await generateConnector({ name, basePath, modules })
+      if (!name || modules.length < 2) { console.log('Uso: arckode make:connector <nombre> <mod1> <mod2> ...'); return }
+      await generateConnector({ name, basePath: join(process.cwd(), 'src'), modules })
       break
     }
 
-    // ─── Analizar arquitectura ───
     case 'analyze': {
       const basePath = process.cwd()
       const result = await analyzeProject(basePath)
-
-      // arckode.json siempre se regenera — es el snapshot que la IA lee primero
       const manifest = buildManifest(result)
-      const dest = join(basePath, 'arckode.json')
-      await writeFile(dest, JSON.stringify(manifest, null, 2))
-
+      await writeFile(join(basePath, 'arckode.json'), JSON.stringify(manifest, null, 2))
       if (args.includes('--ci')) {
-        // Modo CI: sin output de consola, exit 1 si hay violaciones
         if (!result.valid) process.exit(1)
       } else {
         printAnalysis(result)
@@ -276,29 +59,24 @@ data/
       break
     }
 
-    // ─── Generar auth ───
     case 'make:auth': {
       const { makeAuth } = await import('./commands/make-auth')
       await makeAuth(join(process.cwd(), 'src'))
       break
     }
 
-    // ─── Generar helper puro ───
     case 'make:helper': {
       const helperName = args[0]
-      if (!helperName) { console.log('Uso: bun arckode.ts make:helper <nombre>'); return }
+      if (!helperName) { console.log('Uso: arckode make:helper <nombre>'); return }
       const { makeHelper } = await import('./commands/make-helper')
       await makeHelper(helperName, join(process.cwd(), 'src'))
       break
     }
 
-    // ─── Generar adapter de librería externa ───
     case 'make:adapter': {
-      const adapterName = args[0]
-      const interfaceName = args[1]
+      const [adapterName, interfaceName] = args
       if (!adapterName || !interfaceName) {
-        console.log('Uso: bun arckode.ts make:adapter <NombreAdapter> <NombreInterfaz>')
-        console.log('Ejemplo: bun arckode.ts make:adapter Stripe PaymentAdapter')
+        console.log('Uso: arckode make:adapter <NombreAdapter> <NombreInterfaz>')
         return
       }
       const { makeAdapter } = await import('./commands/make-adapter')
@@ -306,57 +84,47 @@ data/
       break
     }
 
-    // ─── Generar seed ───
     case 'make:seed': {
       const seedName = args[0]
-      if (!seedName) { console.log('Uso: bun arckode.ts make:seed <Nombre>'); return }
+      if (!seedName) { console.log('Uso: arckode make:seed <Nombre>'); return }
       const { makeSeed } = await import('./commands/make-seed')
       await makeSeed(seedName, join(process.cwd(), 'src'))
       break
     }
 
-    // ─── Ejecutar seeds ───
     case 'db:seed': {
       const { dbSeed } = await import('./commands/db-seed')
       await dbSeed(args[0])
       break
     }
 
-    // ─── Generar migración ───
     case 'make:migration': {
       const migName = args[0]
-      if (!migName) { console.log('Uso: bun arckode.ts make:migration <nombre>'); return }
+      if (!migName) { console.log('Uso: arckode make:migration <nombre>'); return }
       const { makeMigration } = await import('./commands/make-migration')
       await makeMigration(migName, join(process.cwd(), 'src'))
       break
     }
 
-    // ─── Nuevo frontend SPA ───
     case 'new:frontend': {
       const feName = args[0] ?? 'frontend'
       const dest = join(process.cwd(), feName)
+      const { mkdir, cp } = await import('node:fs/promises')
       await mkdir(dest, { recursive: true })
-      // Copiar templates del frontend
-      const { cp } = await import('node:fs/promises')
       const templateDir = join(import.meta.dirname, '..', 'templates', 'frontend')
       await cp(templateDir, dest, { recursive: true })
       console.log(`✅ Frontend SPA creado en ${dest}`)
-      console.log(`   cd ${feName}`)
-      console.log(`   npm install`)
-      console.log(`   npm run dev`)
       break
     }
 
-    // ─── Generar módulo frontend ───
     case 'make:page': {
       const pageName = args[0]
-      if (!pageName) { console.log('Uso: bun arckode.ts make:page <Nombre>'); return }
+      if (!pageName) { console.log('Uso: arckode make:page <Nombre>'); return }
       const { makeFrontendModule } = await import('./commands/make-frontend-module')
       await makeFrontendModule(pageName, join(process.cwd(), 'src'))
       break
     }
 
-    // ─── Generar API clients ───
     case 'generate:api': {
       const fePath = args[0] ?? join(process.cwd(), '..', 'frontend')
       const { generateApiClient } = await import('./commands/generate-api-client')
@@ -364,182 +132,67 @@ data/
       break
     }
 
-    // ─── Listar rutas (análisis estático) ───
     case 'routes': {
-      const { readdir, readFile, stat } = await import('node:fs/promises')
-      const { existsSync } = await import('node:fs')
-      const modulesPath = join(process.cwd(), 'src', 'modules')
-
-      if (!existsSync(modulesPath)) {
-        console.log('❌ No se encuentra src/modules/')
-        break
-      }
-
-      const methods = ['get', 'post', 'put', 'patch', 'delete'] as const
-      const methodColors: Record<string, string> = {
-        get: '\x1b[32m',
-        post: '\x1b[33m',
-        put: '\x1b[34m',
-        patch: '\x1b[35m',
-        delete: '\x1b[31m',
-      }
-      const reset = '\x1b[0m'
-
-      // Recolecta todos los .ts de un directorio recursivamente
-      async function collectTsFiles(dir: string): Promise<string[]> {
-        const files: string[] = []
-        if (!existsSync(dir)) return files
-        for (const entry of await readdir(dir)) {
-          const full = join(dir, entry)
-          const s = await stat(full)
-          if (s.isDirectory()) files.push(...await collectTsFiles(full))
-          else if (entry.endsWith('.ts') && !entry.endsWith('.test.ts') && !entry.endsWith('.d.ts')) files.push(full)
-        }
-        return files
-      }
-
-      // Extrae rutas de un bloque de código fuente — deduplica por método+path
-      function extractRoutes(src: string, seen: Set<string>): string[] {
-        const found: string[] = []
-        for (const method of methods) {
-          // Soporta comillas simples, dobles y backticks sin interpolación
-          const re = new RegExp(`router\\.${method}\\s*\\(\\s*['"\`]([^'"\`\${}]+)['"\`]`, 'g')
-          let match: RegExpExecArray | null
-          while ((match = re.exec(src)) !== null) {
-            const key = `${method}:${match[1]}`
-            if (seen.has(key)) continue
-            seen.add(key)
-            const color = methodColors[method]
-            found.push(`  ${color}${method.toUpperCase().padEnd(7)}${reset} ${match[1]}`)
-          }
-        }
-        return found
-      }
-
-      console.log('\n📋 Rutas registradas (análisis estático)\n')
-
-      const moduleDirs = await readdir(modulesPath)
-      let total = 0
-      const globalSeen = new Set<string>()
-
-      for (const mod of moduleDirs) {
-        const modDir = join(modulesPath, mod)
-        const s = await stat(modDir).catch(() => null)
-        if (!s?.isDirectory()) continue
-
-        const files = await collectTsFiles(modDir)
-        const seen = new Set<string>()
-        const routes: string[] = []
-
-        for (const file of files) {
-          const src = await readFile(file, 'utf-8')
-          routes.push(...extractRoutes(src, seen))
-        }
-
-        // Marcar en el set global para no duplicar con composition-root
-        for (const key of seen) globalSeen.add(key)
-
-        if (routes.length > 0) {
-          console.log(`[${mod}]`)
-          routes.forEach(r => console.log(r))
-          console.log()
-          total += routes.length
-        }
-      }
-
-      // Rutas globales en composition-root (no registradas por ningún módulo)
-      const crPath = join(process.cwd(), 'src', 'composition-root.ts')
-      if (existsSync(crPath)) {
-        const src = await readFile(crPath, 'utf-8')
-        const globalRoutes: string[] = []
-        for (const method of methods) {
-          // Soporta comillas simples, dobles y backticks sin interpolación
-          const re = new RegExp(`router\\.${method}\\s*\\(\\s*['"\`]([^'"\`\${}]+)['"\`]`, 'g')
-          let match: RegExpExecArray | null
-          while ((match = re.exec(src)) !== null) {
-            const key = `${method}:${match[1]}`
-            if (globalSeen.has(key)) continue
-            globalSeen.add(key)
-            const color = methodColors[method]
-            globalRoutes.push(`  ${color}${method.toUpperCase().padEnd(7)}${reset} ${match[1]}`)
-          }
-        }
-        if (globalRoutes.length > 0) {
-          console.log('[global]')
-          globalRoutes.forEach(r => console.log(r))
-          console.log()
-          total += globalRoutes.length
-        }
-      }
-
-      console.log(`Total: ${total} ruta(s)`)
+      const { routes } = await import('./commands/routes')
+      await routes(process.cwd())
       break
     }
 
-    // ─── Ejecutar migraciones ───
     case 'db:migrate': {
-      const direction = args[0] === 'down' ? 'down' : 'up'
       const { dbMigrate } = await import('./commands/db-migrate')
-      await dbMigrate(direction)
+      const validActions = ['up', 'down', 'fresh', 'reset', 'refresh', 'status'] as const
+      const action = (args[0] ?? 'up') as typeof validActions[number]
+      if (!(validActions as readonly string[]).includes(action)) {
+        console.error(`❌ Acción desconocida: "${args[0]}"\n   Opciones: ${validActions.join(' | ')}`)
+        break
+      }
+      await dbMigrate(action)
       break
     }
 
     default: {
-      console.log(`
+      printHelp()
+    }
+  }
+}
+
+function printHelp(): void {
+  console.log(`
 ╔═══════════════════════════════════════════╗
 ║        Arckode Framework — Tooling         ║
 ║  Para IA · Modular · SOLID · Predictible ║
 ╚═══════════════════════════════════════════╝
 
 BACKEND:
-  arckode new <proyecto>              Crear proyecto backend completo
-  arckode make:auth                   Generar autenticación (login, register, JWT)
-  arckode make:module <Nombre>        Generar módulo completo (+ migration + seed + tests)
-  arckode make:connector <n> <m1> <m2> Conectar módulos
-  arckode make:seed <Nombre>          Generar seed
-  arckode make:migration <nombre>     Generar migración
-  arckode make:helper <nombre>        Generar helper puro en shared/helpers/
+  arckode new <proyecto>                     Crear proyecto backend completo
+  arckode make:auth                          Generar autenticación (login, register, JWT)
+  arckode make:module <Nombre>               Generar módulo completo
+  arckode make:connector <n> <m1> <m2>      Conectar módulos
+  arckode make:seed <Nombre>                 Generar seed
+  arckode make:migration <nombre>            Generar migración
+  arckode make:helper <nombre>               Generar helper puro
   arckode make:adapter <Adapter> <Interfaz>  Generar adapter de librería externa
 
-FRONTEND (SPA separado):
-  arckode new:frontend [nombre]       Crear proyecto frontend Vue 3 + Vite + TypeScript
-  arckode make:page <Nombre>          Generar módulo frontend (api, composable, components, page, router)
-  arckode generate:api [frontend]     Generar API clients desde modelos del backend
-
-MONOLITO:
-  Usar new y después new:frontend dentro del proyecto. El servidor sirve API + frontend.
-
 BASE DE DATOS:
-  arckode db:migrate                  Ejecutar migraciones pendientes (src/migrations/)
-  arckode db:migrate down             Revertir la última migración aplicada
-  arckode db:seed                     Listar o ejecutar seeds disponibles
+  arckode db:migrate                         Aplicar migraciones pendientes
+  arckode db:migrate down                    Revertir la última migración
+  arckode db:migrate fresh                   Drop all + re-migrar desde cero
+  arckode db:migrate reset                   Revertir TODAS las migraciones
+  arckode db:migrate refresh                 Reset + migrate (desarrollo)
+  arckode db:migrate status                  Ver estado de cada migración
+  arckode db:seed                            Listar seeds disponibles
+  arckode db:seed --all                      Ejecutar todos los seeds
+  arckode db:seed <nombre>                   Ejecutar un seed específico
+
+FRONTEND:
+  arckode new:frontend [nombre]              Crear proyecto frontend Vue 3 + Vite
+  arckode make:page <Nombre>                 Generar módulo frontend
+  arckode generate:api [frontend]            Generar API clients
 
 ANÁLISIS:
-  arckode analyze                     Analizar arquitectura (detecta violaciones)
-  arckode routes                      Listar todas las rutas (análisis estático)
-
-Ejemplo completo (SPA separado):
-  arckode new mi-api                  # Backend
-  cd mi-api
-  arckode make:auth                   # Auth
-  arckode make:module Productos       # CRUD
-  arckode make:connector pedidos productos
-  bun run src/composition-root.ts   # Iniciar API
-
-  # En otra terminal:
-  arckode new:frontend frontend       # Frontend SPA
-  cd frontend
-  npm install && npm run dev        # Iniciar en :5173
-
-Ejemplo completo (Monolito):
-  arckode nuevo monito-app
-  cd monito-app
-  arckode make:auth
-  arckode make:module Productos
-  # El composition-root ya incluye serveStatic para el frontend
+  arckode analyze                            Analizar arquitectura
+  arckode routes                             Listar todas las rutas
 `)
-    }
-  }
 }
 
 main().catch(console.error)