arckode-framework 1.0.0

package/cli/index.ts

@@ -0,0 +1,604 @@
+#!/usr/bin/env bun
+// CLI — Arckode Framework Tooling
+// Punto de entrada para generación y análisis
+
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { generateModule, generateConnector } from './generate'
+import { analyzeProject, printAnalysis, buildManifest } from './analyze'
+
+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
+      const dbFlag = args.find(a => a.startsWith('--db='))?.split('=')[1] ?? 'sqlite'
+      const db = ['sqlite', 'mysql', 'postgres'].includes(dbFlag) ? 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 ─────────────────────────────────────────────────────
+      await writeFile(join(base, 'CLAUDE.md'), [
+        `# CLAUDE.md — ${name}`,
+        `## Lee esto ANTES de escribir cualquier línea de código.`,
+        ``,
+        `### PASO 0 — Cargar contexto del sistema`,
+        `1. Leer \`arckode.json\` → saber qué módulos, rutas y modelos ya existen.`,
+        `2. Si no existe: \`bun run analyze --json\` para generarlo.`,
+        `3. Leer \`src/composition-root.ts\` → es la única fuente de verdad del sistema.`,
+        ``,
+        `### Reglas INMUTABLES (no se negocian, no se omiten)`,
+        ``,
+        `| # | Regla | Detectada por |`,
+        `|---|-------|--------------|`,
+        `| 1 | Módulos NO importan de otros módulos → usar conectores | \`arckode analyze\` |`,
+        `| 2 | index.ts es APPEND-ONLY → no eliminar exports | manual |`,
+        `| 3 | Conectores NO tienen lógica de negocio → solo delegan | \`arckode analyze\` |`,
+        `| 4 | Cada tabla pertenece a UN módulo | manual |`,
+        `| 5 | Si no está en composition-root.ts, no existe | \`arckode analyze\` |`,
+        `| 6 | Todo POST/PUT/PATCH requiere validateSchema() | \`arckode analyze\` |`,
+        `| 7 | Controller NO llama al ORM → llama al service | \`arckode analyze\` |`,
+        `| 8 | Service > 200 líneas → dividir | \`arckode analyze\` |`,
+        `| 9 | findById → verificar ownership inmediatamente (IDOR) | \`arckode analyze\` |`,
+        `| 10 | ORM dentro de un loop → N+1 garantizado, prohibido | \`arckode analyze\` |`,
+        `| 11 | Service recibe RepositoryAdapter<T>, no ORM directo | \`arckode analyze\` |`,
+        ``,
+        `### Protocolo de la IA (4 pasos obligatorios)`,
+        ``,
+        `\`\`\``,
+        `PASO 1 — IDENTIFICAR ALCANCE`,
+        `  ¿Toca 1 módulo? → Seguir`,
+        `  ¿Toca 1 conector? → Seguir`,
+        `  ¿Toca 2+ módulos? → DETENERSE. Dividir la tarea.`,
+        ``,
+        `PASO 2 — VERIFICAR REGLAS`,
+        `  ¿Importo de otro módulo? → NO`,
+        `  ¿Modifico index.ts? → Solo append`,
+        `  ¿Pongo lógica en el conector? → NO`,
+        `  ¿Comparto una tabla? → NO`,
+        ``,
+        `PASO 3 — GENERAR`,
+        `  Estructura obligatoria: index.ts, types.ts, sockets.ts,`,
+        `  actions/service.ts, actions/controller.ts,`,
+        `  validators/schema.ts, tests/service.test.ts`,
+        ``,
+        `PASO 4 — VERIFICAR`,
+        `  bun run analyze --json → violations: 0`,
+        `  bun test → 0 fallos`,
+        `\`\`\``,
+        ``,
+        `### DB Adapter activo: \`${db}\``,
+        ``,
+        `### Estructura del proyecto`,
+        `\`\`\``,
+        `src/`,
+        `  composition-root.ts    ← TODO el sistema`,
+        `  modules/               ← módulos independientes (NO se importan entre sí)`,
+        `  connectors/            ← puentes entre módulos (sin lógica de negocio)`,
+        `  shared/helpers/        ← funciones puras sin estado`,
+        `  shared/services/       ← servicios con estado compartidos`,
+        `seeds/                   ← datos de prueba`,
+        `migrations/              ← migraciones de BD`,
+        `\`\`\``,
+        ``,
+        `### Comandos útiles`,
+        `\`\`\`bash`,
+        `bun run dev                      # desarrollo con hot reload`,
+        `bun run analyze                  # verificar arquitectura (consola)`,
+        `bun run analyze --json           # generar/actualizar arckode.json`,
+        `bun arckode make:module Nombre     # generar módulo completo`,
+        `bun arckode make:connector nombre mod1 mod2   # conectar dos módulos`,
+        `bun test                         # correr todos los tests`,
+        `\`\`\``,
+      ].join('\n'))
+
+      // 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. MODELOS (cada módulo es dueño de su ModelDefinition) ─`,
+        `// import { MiModuloModel } from './modules/mi-modulo/types'`,
+        `// orm.define('MiModulo', MiModuloModel)`,
+        ``,
+        `// ─── 4. MIGRAR ───────────────────────────────`,
+        `await orm.migrate()`,
+        ``,
+        `// ─── 5. REGISTRAR ────────────────────────────`,
+        `container.register('config', () => config)`,
+        `container.register('logger', () => logger)`,
+        `container.register('db', () => dbAdapter, () => dbAdapter.close())`,
+        `container.register('orm', () => orm)`,
+        `container.register('cache', () => cache)`,
+        `container.init()`,
+        ``,
+        `// ─── 6. SISTEMA ───────────────────────────────`,
+        `const system = new System({`,
+        `  config, container, logger, orm, router, http, cache, auth,`,
+        `})`,
+        ``,
+        `// Registrar módulos — usar factory functions generadas por arckode make:module:`,
+        `// import { MiModuloModule } from './modules/mi-modulo'`,
+        `// system.addModule(MiModuloModule())`,
+        ``,
+        `// Conectar módulos:`,
+        `// system.addConnector('nombre', (ctx) => {`,
+        `//   const modA = ctx.resolveModule('mod-a')`,
+        `//   ctx.resolveModule('mod-b', { onEvento: async (data) => modA.accion(data) })`,
+        `// })`,
+        ``,
+        `// ─── 7. RUTAS ─────────────────────────────────`,
+        `router.get('/health', async () => ({`,
+        `  status: 200, body: { status: 'ok', uptime: process.uptime() }`,
+        `}))`,
+        ``,
+        `// ─── 8. SEEDS (solo en desarrollo) ────────────`,
+        `if (env.RUN_SEEDS === 'true') {`,
+        `  // await seeds.runAll()`,
+        `}`,
+        ``,
+        `// ─── 9. INICIAR ───────────────────────────────`,
+        `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:json': `bun run node_modules/arckode-framework/cli/index.ts analyze --json`,
+        },
+        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`)
+      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)
+      await generateModule({
+        name,
+        basePath,
+        description: `Módulo de ${name}`,
+        fields: {
+          nombre: { type: 'string', required: true },
+          activo: { type: 'boolean', required: false },
+        },
+      })
+      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 })
+      break
+    }
+
+    // ─── Analizar arquitectura ───
+    case 'analyze': {
+      const basePath = process.cwd()
+      const result = await analyzeProject(basePath)
+
+      if (args.includes('--json')) {
+        const manifest = buildManifest(result)
+        const dest = join(basePath, 'arckode.json')
+        await writeFile(dest, JSON.stringify(manifest, null, 2))
+        const status = result.valid ? '✅ válido' : `❌ ${result.violations.length} violaciones`
+        console.log(`arckode.json generado — ${status}`)
+      } else {
+        printAnalysis(result)
+      }
+      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 }
+      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]
+      if (!adapterName || !interfaceName) {
+        console.log('Uso: bun arckode.ts make:adapter <NombreAdapter> <NombreInterfaz>')
+        console.log('Ejemplo: bun arckode.ts make:adapter Stripe PaymentAdapter')
+        return
+      }
+      const { makeAdapter } = await import('./commands/make-adapter')
+      await makeAdapter(adapterName, interfaceName, join(process.cwd(), 'src'))
+      break
+    }
+
+    // ─── Generar seed ───
+    case 'make:seed': {
+      const seedName = args[0]
+      if (!seedName) { console.log('Uso: bun arckode.ts 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 }
+      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)
+      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 }
+      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')
+      await generateApiClient(process.cwd(), fePath)
+      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)`)
+      break
+    }
+
+    // ─── Ejecutar migraciones ───
+    case 'db:migrate': {
+      const direction = args[0] === 'down' ? 'down' : 'up'
+      const { dbMigrate } = await import('./commands/db-migrate')
+      await dbMigrate(direction)
+      break
+    }
+
+    default: {
+      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 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
+
+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
+`)
+    }
+  }
+}
+
+main().catch(console.error)