@yakuzaa/jade 0.1.1 → 0.1.5

package/cli.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * cli.js — Entry point do comando `jade`
+ *
+ * Comandos disponíveis:
+ *   jade init <nome>              → cria estrutura de projeto
+ *   jade compilar <arquivo.jd>    → compila + gera index.html + runtime.js
+ *   jade servir [pasta] [porta]   → servidor estático para testar no browser
+ *   jade --version                → exibe versão
+ *   jade --help                   → exibe ajuda
+ */
+
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dir = dirname(fileURLToPath(import.meta.url));
+
+function versao() {
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(__dir, 'package.json'), 'utf-8'));
+    return pkg.version ?? '?';
+  } catch {
+    return '?';
+  }
+}
+
+const AJUDA = `
+jade ${versao()} — JADE DSL em português
+
+Comandos:
+  jade init <nome>                  Cria projeto JADE com estrutura completa
+  jade compilar <arquivo.jd> [-o]   Compila e gera artefatos para o browser
+  jade servir [pasta] [porta]       Inicia servidor local para testar no browser
+
+Opções do compilar:
+  -o <prefixo>    Prefixo de saída (padrão: dist/<nome>)
+  --so-wasm       Gera apenas .wasm/.wat, sem HTML
+
+Exemplos:
+  jade init meu-projeto
+  jade compilar src/app.jd
+  jade compilar src/app.jd -o dist/app
+  jade servir dist
+  jade servir dist 8080
+
+Documentação: https://gabrielsymb.github.io/jade-language
+`;
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(AJUDA);
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(`jade ${versao()}`);
+    process.exit(0);
+  }
+
+  const comando = args[0];
+
+  if (comando === 'init') {
+    const { init } = await import('./commands/init.js');
+    await init(args[1]);
+    return;
+  }
+
+  if (comando === 'compilar') {
+    const { compilar } = await import('./commands/compilar.js');
+    await compilar(args.slice(1));
+    return;
+  }
+
+  if (comando === 'servir') {
+    const { servir } = await import('./commands/servir.js');
+    const pasta = args[1] ?? 'dist';
+    const porta = parseInt(args[2] ?? '3000', 10);
+    await servir(pasta, porta);
+    return;
+  }
+
+  console.error(`\x1b[1;31merro\x1b[0m: comando desconhecido "${comando}".`);
+  console.error(`\x1b[2mdica: jade --help para ver os comandos disponíveis.\x1b[0m\n`);
+  process.exit(1);
+}
+
+main().catch((e) => {
+  console.error(`\x1b[1;31merro interno\x1b[0m: ${e?.message ?? e}`);
+  process.exit(2);
+});

package/commands/compilar.js

@@ -0,0 +1,105 @@
+/**
+ * commands/compilar.js — Compila e gera artefatos browser em um único passo
+ *
+ * Uso: jade compilar <arquivo.jd> [-o prefixo] [--so-wasm]
+ *
+ *   jade compilar src/app.jd                → dist/app.wasm + index.html + runtime.js
+ *   jade compilar src/app.jd -o saida/app   → saida/app.wasm + ...
+ *   jade compilar src/app.jd --so-wasm      → apenas .wasm/.wat (sem HTML)
+ *
+ * Roda jadec como subprocesso e, em caso de sucesso, chama gerarHTML_dist.
+ * Chamado por: jade/cli.js
+ */
+
+import { spawn } from 'child_process';
+import { resolve, basename, dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { gerarHTML_dist } from './html.js';
+
+const require = createRequire(import.meta.url);
+
+const azul    = (s) => `\x1b[34m${s}\x1b[0m`;
+const dim     = (s) => `\x1b[2m${s}\x1b[0m`;
+const vermelho = (s) => `\x1b[1;31m${s}\x1b[0m`;
+
+// ── Localiza o binário jadec ──────────────────────────────────────────────────
+
+function localizarJadec() {
+  // 1. jadec no PATH (instalação global)
+  // 2. node_modules/.bin/jadec (instalação local)
+  // 3. monorepo (desenvolvimento)
+  const candidatos = [
+    // local project node_modules
+    join(process.cwd(), 'node_modules', '.bin', 'jadec'),
+    // monorepo
+    resolve(fileURLToPath(import.meta.url), '..', '..', '..', 'jade-compiler', 'dist', 'cli.js'),
+  ];
+
+  for (const c of candidatos) {
+    if (existsSync(c)) return c;
+  }
+
+  return 'jadec'; // assume no PATH
+}
+
+// ── Executa jadec como subprocesso ───────────────────────────────────────────
+
+function rodarJadec(args) {
+  return new Promise((res, rej) => {
+    const jadec = localizarJadec();
+
+    // Se for um .js (caminho direto), roda com node
+    const cmd  = jadec.endsWith('.js') ? 'node' : jadec;
+    const argv = jadec.endsWith('.js') ? [jadec, ...args] : args;
+
+    const proc = spawn(cmd, argv, { stdio: 'inherit' });
+    proc.on('close', code => code === 0 ? res() : rej(new Error(`jadec saiu com código ${code}`)));
+    proc.on('error', rej);
+  });
+}
+
+// ── Comando principal ─────────────────────────────────────────────────────────
+
+export async function compilar(args) {
+  if (!args || args.length === 0) {
+    console.error(`\n${vermelho('erro')}: informe o arquivo a compilar.`);
+    console.error(`  Uso: ${azul('jade compilar')} <arquivo.jd>\n`);
+    process.exit(1);
+  }
+
+  const arquivo = args.find(a => !a.startsWith('-'));
+  if (!arquivo) {
+    console.error(`\n${vermelho('erro')}: nenhum arquivo .jd encontrado nos argumentos.\n`);
+    process.exit(1);
+  }
+
+  const soWasm = args.includes('--so-wasm');
+
+  // Determina o prefixo de saída
+  const oIdx = args.indexOf('-o');
+  let prefixo;
+  if (oIdx !== -1 && args[oIdx + 1]) {
+    prefixo = resolve(args[oIdx + 1]);
+  } else {
+    // padrão: dist/<nome-do-arquivo>
+    const nome = basename(arquivo, '.jd');
+    prefixo = resolve(process.cwd(), 'dist', nome);
+  }
+
+  // Repassa todos os args para jadec (-o já incluído ou adicionado)
+  const jadecArgs = [...args];
+  if (oIdx === -1) {
+    jadecArgs.push('-o', prefixo);
+  }
+
+  // Executa jadec
+  await rodarJadec(jadecArgs);
+
+  // Geração de HTML (a menos que --so-wasm)
+  if (!soWasm) {
+    const nomeProjeto = basename(arquivo, '.jd');
+    await gerarHTML_dist({ prefixo, nome: nomeProjeto });
+  }
+}

package/commands/html.js

@@ -0,0 +1,218 @@
+/**
+ * commands/html.js — Gera os artefatos HTML para o browser
+ *
+ * Dado um prefixo de saída (ex: dist/app), gera:
+ *   dist/index.html   — shell PWA com bootstrap que carrega WASM + UI
+ *   dist/runtime.js   — runtime JADE copiado do pacote instalado
+ *   dist/manifest.json
+ *   dist/sw.js
+ *
+ * Chamado por: commands/compilar.js após compilação bem-sucedida.
+ * Não depende de bundler no projeto do usuário.
+ */
+
+import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from 'fs';
+import { resolve, dirname, join, basename } from 'path';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+// ── Cores ─────────────────────────────────────────────────────────────────────
+
+const verde  = (s) => `\x1b[1;32m${s}\x1b[0m`;
+const azul   = (s) => `\x1b[34m${s}\x1b[0m`;
+const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
+const amarelo = (s) => `\x1b[1;33m${s}\x1b[0m`;
+const ok     = () => verde('✓');
+const aviso  = () => amarelo('⚠');
+
+// ── Localiza o browser.js do runtime instalado ────────────────────────────────
+
+function localizarRuntime() {
+  // Tenta via require.resolve (funciona quando @yakuzaa/jade-runtime está instalado)
+  try {
+    const pkgPath = require.resolve('@yakuzaa/jade-runtime/package.json');
+    const pkgDir  = dirname(pkgPath);
+    const browser = join(pkgDir, 'dist', 'browser.js');
+    if (existsSync(browser)) return browser;
+  } catch {
+    // não instalado via npm — tenta caminho relativo ao monorepo
+  }
+
+  // Fallback: monorepo local (desenvolvimento)
+  const mono = resolve(dirname(new URL(import.meta.url).pathname), '..', '..', 'jade-runtime', 'dist', 'browser.js');
+  if (existsSync(mono)) return mono;
+
+  return null;
+}
+
+// ── Bootstrap JS inline no index.html ────────────────────────────────────────
+
+function bootstrap(wasmFile, uiFile) {
+  return `
+    import { JadeRuntime, UIEngine } from './runtime.js';
+
+    async function iniciar() {
+      const runtime = new JadeRuntime();
+      const ui = new UIEngine(runtime.getMemory());
+
+      // Carrega o módulo WASM compilado
+      const resposta = await fetch('./${wasmFile}');
+      await runtime.load(resposta);
+
+      // Carrega descritores de tela gerados pelo compilador
+      const telas = await fetch('./${uiFile}').then(r => r.json()).catch(() => []);
+
+      const container = document.getElementById('app');
+
+      if (telas.length > 0) {
+        // renderizarTela: lê o descriptor do compilador e decide O COMO automaticamente
+        ui.renderizarTela(telas[0], container);
+      } else {
+        container.innerHTML = '<p style="font-family:sans-serif;padding:2rem">App JADE carregado. Nenhuma tela declarada.</p>';
+      }
+    }
+
+    iniciar().catch(e => {
+      document.getElementById('app').innerHTML =
+        \`<p style="font-family:sans-serif;color:#dc2626;padding:2rem">
+          <strong>Erro ao iniciar:</strong> \${e.message}
+        </p>\`;
+      console.error('[JADE]', e);
+    });
+  `.trim();
+}
+
+// ── HTML shell ────────────────────────────────────────────────────────────────
+
+function gerarHTML(nome, wasmFile, uiFile, corTema = '#2563eb') {
+  return `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">
+  <meta name="theme-color" content="${corTema}">
+  <meta name="mobile-web-app-capable" content="yes">
+  <meta name="apple-mobile-web-app-capable" content="yes">
+  <title>${nome}</title>
+  <link rel="manifest" href="manifest.json">
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, -apple-system, sans-serif; background: #f9fafb; }
+    #app { min-height: 100dvh; }
+    #jade-carregando {
+      display: flex; align-items: center; justify-content: center;
+      min-height: 100dvh; font-family: sans-serif; color: #6b7280;
+    }
+  </style>
+</head>
+<body>
+  <div id="jade-carregando">Carregando...</div>
+  <div id="app" style="display:none"></div>
+  <script type="module">
+    ${bootstrap(wasmFile, uiFile)}
+
+    // Remove tela de carregamento quando o app montar
+    const obs = new MutationObserver(() => {
+      if (document.getElementById('app').children.length > 0) {
+        document.getElementById('jade-carregando').remove();
+        document.getElementById('app').style.display = '';
+        obs.disconnect();
+      }
+    });
+    obs.observe(document.getElementById('app'), { childList: true });
+
+    if ('serviceWorker' in navigator) {
+      navigator.serviceWorker.register('./sw.js').catch(() => {});
+    }
+  </script>
+</body>
+</html>`;
+}
+
+// ── manifest.json ─────────────────────────────────────────────────────────────
+
+function gerarManifest(nome) {
+  return JSON.stringify({
+    name: nome,
+    short_name: nome.slice(0, 12),
+    display: 'standalone',
+    start_url: '/',
+    scope: '/',
+    theme_color: '#2563eb',
+    background_color: '#ffffff',
+    icons: [
+      { src: 'icon-192.png', sizes: '192x192', type: 'image/png' },
+      { src: 'icon-512.png', sizes: '512x512', type: 'image/png' },
+    ],
+  }, null, 2);
+}
+
+// ── service worker ────────────────────────────────────────────────────────────
+
+function gerarSW(nome, wasmFile) {
+  const cache = `jade-${nome.toLowerCase().replace(/\s+/g, '-')}-v1`;
+  return `const CACHE = '${cache}';
+const ARQUIVOS = ['/', '/index.html', '/${wasmFile}', '/runtime.js', '/manifest.json'];
+
+self.addEventListener('install', e => {
+  e.waitUntil(caches.open(CACHE).then(c => c.addAll(ARQUIVOS).catch(() => {})));
+  self.skipWaiting();
+});
+
+self.addEventListener('activate', e => {
+  e.waitUntil(
+    caches.keys().then(ks =>
+      Promise.all(ks.filter(k => k.startsWith('jade-') && k !== CACHE).map(k => caches.delete(k)))
+    )
+  );
+  self.clients.claim();
+});
+
+self.addEventListener('fetch', e => {
+  if (e.request.method !== 'GET') return;
+  e.respondWith(
+    caches.match(e.request).then(hit => hit ?? fetch(e.request).then(res => {
+      if (res.ok) caches.open(CACHE).then(c => c.put(e.request, res.clone()));
+      return res;
+    })).catch(() => new Response('<h1>Sem conexão</h1>', { headers: { 'Content-Type': 'text/html' } }))
+  );
+});`;
+}
+
+// ── Comando principal ─────────────────────────────────────────────────────────
+
+export async function gerarHTML_dist({ prefixo, nome }) {
+  const distDir   = dirname(resolve(prefixo));
+  const baseName  = basename(prefixo);
+  const wasmFile  = `${baseName}.wasm`;
+  const uiFile    = `${baseName}.jade-ui.json`;
+
+  mkdirSync(distDir, { recursive: true });
+
+  console.log(`\n  ${dim('gerando artefatos para o browser...')}`);
+
+  // 1. Copia runtime.js
+  const runtimeSrc = localizarRuntime();
+  if (runtimeSrc) {
+    copyFileSync(runtimeSrc, join(distDir, 'runtime.js'));
+    console.log(`  ${ok()} runtime.js ${dim('(jade-runtime browser bundle)')}`);
+  } else {
+    console.warn(`  ${aviso()} runtime.js não encontrado — execute 'npm run build:browser' no jade-runtime`);
+  }
+
+  // 2. index.html
+  const html = gerarHTML(nome, wasmFile, uiFile);
+  writeFileSync(join(distDir, 'index.html'), html, 'utf-8');
+  console.log(`  ${ok()} index.html`);
+
+  // 3. manifest.json
+  writeFileSync(join(distDir, 'manifest.json'), gerarManifest(nome), 'utf-8');
+  console.log(`  ${ok()} manifest.json`);
+
+  // 4. sw.js
+  writeFileSync(join(distDir, 'sw.js'), gerarSW(nome, wasmFile), 'utf-8');
+  console.log(`  ${ok()} sw.js`);
+
+  console.log(`\n  ${azul('→')} para abrir no browser: ${verde('jade servir ' + distDir)}\n`);
+}

package/commands/init.js

@@ -0,0 +1,157 @@
+/**
+ * commands/init.js — Implementação do `jade init <nome-projeto>`
+ *
+ * Cria a estrutura completa de um projeto JADE com arquivos de exemplo funcionais.
+ * Análogo ao create-react-app, npm create svelte, npm create vue.
+ *
+ * Chamado por: jade/cli.js
+ * Templates:   jade/templates/index.js
+ */
+
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join, resolve } from 'path';
+import * as T from '../templates/index.js';
+
+// ── Utilitários de output ─────────────────────────────────────────────────────
+
+const verde  = (s) => `\x1b[1;32m${s}\x1b[0m`;
+const azul   = (s) => `\x1b[34m${s}\x1b[0m`;
+const amarelo = (s) => `\x1b[1;33m${s}\x1b[0m`;
+const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
+const negrito = (s) => `\x1b[1m${s}\x1b[0m`;
+const ok  = () => verde('✓');
+const err = () => `\x1b[1;31m✗\x1b[0m`;
+
+// ── Estrutura de pastas e arquivos ────────────────────────────────────────────
+
+/**
+ * Cada entrada: [caminhRelativo, conteudo | null]
+ * null = pasta vazia (cria apenas o diretório)
+ */
+function estrutura(nome) {
+  return [
+    // Módulos
+    ['src/modulos',                                   null],
+    ['src/modulos/estoque.jd',                        T.moduloEstoque()],
+
+    // Serviços
+    ['src/servicos',                                  null],
+    ['src/servicos/estoqueService.jd',                T.estoqueService()],
+
+    // Entidades
+    ['src/entidades',                                 null],
+    ['src/entidades/Produto.jd',                      T.Produto()],
+    ['src/entidades/Cliente.jd',                      T.Cliente()],
+
+    // Eventos
+    ['src/eventos',                                   null],
+    ['src/eventos/ProdutoCriado.jd',                  T.ProdutoCriado()],
+
+    // UI
+    ['src/ui',                                        null],
+    ['src/ui/telas',                                  null],
+    ['src/ui/telas/ListaProdutos.jd',                 T.telaProdutos()],
+    ['src/ui/telas/Principal.jd',                     T.telaPrincipal()],
+    ['src/ui/componentes',                            null],
+
+    // Config
+    ['config',                                        null],
+    ['config/jade.config.json',                       T.jadeConfig(nome)],
+    ['config/database.json',                          T.databaseConfig()],
+    ['config/deploy.json',                            T.deployConfig()],
+
+    // Dist (vazia, nunca commitar)
+    ['dist',                                          null],
+
+    // Aux
+    ['docs',                                          null],
+    ['tests',                                         null],
+
+    // Raiz
+    ['package.json',                                  T.packageJson(nome)],
+    ['.gitignore',                                    T.gitignore()],
+    ['README.md',                                     T.readme(nome)],
+  ];
+}
+
+// ── Funções auxiliares ────────────────────────────────────────────────────────
+
+function criarArquivo(caminho, conteudo) {
+  writeFileSync(caminho, conteudo, 'utf-8');
+}
+
+function criarPasta(caminho) {
+  mkdirSync(caminho, { recursive: true });
+}
+
+function label(relativo) {
+  // Formata o caminho para exibição: pastas terminam com /
+  return relativo.includes('.') ? relativo : relativo + '/';
+}
+
+// ── Comando principal ─────────────────────────────────────────────────────────
+
+export async function init(nome) {
+  // Validação do nome
+  if (!nome || typeof nome !== 'string' || nome.trim() === '') {
+    console.error(`\n${err()} Nome do projeto é obrigatório.\n`);
+    console.error(`  Uso: ${azul('jade init')} ${amarelo('<nome-projeto>')}\n`);
+    process.exit(1);
+  }
+
+  nome = nome.trim();
+
+  // Verifica se o nome é válido (sem caracteres especiais problemáticos)
+  if (!/^[a-zA-Z0-9À-ÿ_-]+$/.test(nome)) {
+    console.error(`\n${err()} Nome inválido: ${amarelo(nome)}`);
+    console.error(`  Use apenas letras, números, hífens e underscores.\n`);
+    process.exit(1);
+  }
+
+  const destino = resolve(process.cwd(), nome);
+
+  // Não sobrescrever projeto existente
+  if (existsSync(destino)) {
+    console.error(`\n${err()} A pasta ${amarelo(nome)} já existe.`);
+    console.error(`  Escolha outro nome ou remova a pasta existente.\n`);
+    process.exit(1);
+  }
+
+  console.log(`\n${azul('JADE')} — criando projeto ${negrito(nome)}...\n`);
+
+  const itens = estrutura(nome);
+  const erros = [];
+
+  for (const [relativo, conteudo] of itens) {
+    const caminho = join(destino, relativo);
+    const exibir  = label(relativo);
+
+    try {
+      if (conteudo === null) {
+        criarPasta(caminho);
+      } else {
+        // Garante que a pasta pai existe antes de criar o arquivo
+        criarPasta(join(caminho, '..'));
+        criarArquivo(caminho, conteudo);
+      }
+      console.log(`  ${ok()} ${dim(exibir)}`);
+    } catch (e) {
+      erros.push({ relativo, erro: e.message });
+      console.error(`  ${err()} ${exibir} — ${e.message}`);
+    }
+  }
+
+  if (erros.length > 0) {
+    console.error(`\n${err()} ${erros.length} erro(s) durante a criação. Verifique as permissões da pasta.\n`);
+    process.exit(1);
+  }
+
+  // ── Sucesso ──────────────────────────────────────────────────────────────
+
+  console.log(`\n${verde(`Projeto "${nome}" criado com sucesso!`)}\n`);
+  console.log(`${dim('Próximos passos:')}`);
+  console.log(`  ${azul('cd')} ${nome}`);
+  console.log(`  ${azul('npm install')}`);
+  console.log(`  ${azul('jadec')} src/modulos/estoque.jd ${dim('--check')}`);
+  console.log(`  ${dim('# abrir dist/index.html no navegador após compilar')}\n`);
+}

package/commands/servir.js

@@ -0,0 +1,109 @@
+/**
+ * commands/servir.js — Servidor estático local para apps JADE
+ *
+ * Uso: jade servir [pasta] [porta]
+ *   jade servir           → serve ./dist na porta 3000
+ *   jade servir dist      → serve ./dist na porta 3000
+ *   jade servir dist 8080 → serve ./dist na porta 8080
+ *
+ * Usa apenas Node.js built-in (http, fs, path) — zero dependências extras.
+ * Necessário para PWA: service worker não funciona com file://
+ *
+ * Chamado por: jade/cli.js
+ */
+
+import { createServer } from 'http';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { join, extname, resolve } from 'path';
+
+const MIME = {
+  '.html' : 'text/html; charset=utf-8',
+  '.js'   : 'application/javascript; charset=utf-8',
+  '.mjs'  : 'application/javascript; charset=utf-8',
+  '.wasm' : 'application/wasm',
+  '.json' : 'application/json; charset=utf-8',
+  '.css'  : 'text/css; charset=utf-8',
+  '.png'  : 'image/png',
+  '.jpg'  : 'image/jpeg',
+  '.svg'  : 'image/svg+xml',
+  '.ico'  : 'image/x-icon',
+  '.txt'  : 'text/plain; charset=utf-8',
+};
+
+const verde   = (s) => `\x1b[1;32m${s}\x1b[0m`;
+const azul    = (s) => `\x1b[34m${s}\x1b[0m`;
+const dim     = (s) => `\x1b[2m${s}\x1b[0m`;
+const amarelo = (s) => `\x1b[1;33m${s}\x1b[0m`;
+const vermelho = (s) => `\x1b[1;31m${s}\x1b[0m`;
+
+export async function servir(pasta = 'dist', porta = 3000) {
+  const raiz = resolve(process.cwd(), pasta);
+
+  if (!existsSync(raiz)) {
+    console.error(`\n${vermelho('erro')}: pasta '${pasta}' não encontrada.`);
+    console.error(`  ${dim('dica: compile primeiro com')} jadec app.jd -o dist/app\n`);
+    process.exit(1);
+  }
+
+  const server = createServer((req, res) => {
+    // Normaliza URL: remove query string e decodifica
+    let caminho = decodeURIComponent(req.url?.split('?')[0] ?? '/');
+
+    // Rota raiz → index.html
+    if (caminho === '/') caminho = '/index.html';
+
+    const arquivo = join(raiz, caminho);
+
+    // Proteção contra path traversal
+    if (!arquivo.startsWith(raiz)) {
+      res.writeHead(403);
+      res.end('Proibido');
+      return;
+    }
+
+    if (!existsSync(arquivo) || statSync(arquivo).isDirectory()) {
+      // SPA fallback → index.html
+      const index = join(raiz, 'index.html');
+      if (existsSync(index)) {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(readFileSync(index));
+      } else {
+        res.writeHead(404);
+        res.end('404 — arquivo não encontrado');
+      }
+      return;
+    }
+
+    const ext  = extname(arquivo).toLowerCase();
+    const tipo = MIME[ext] ?? 'application/octet-stream';
+    const dados = readFileSync(arquivo);
+
+    // Headers para PWA e WASM
+    res.writeHead(200, {
+      'Content-Type': tipo,
+      'Cross-Origin-Opener-Policy': 'same-origin',
+      'Cross-Origin-Embedder-Policy': 'require-corp',
+    });
+    res.end(dados);
+  });
+
+  server.listen(porta, '127.0.0.1', () => {
+    console.log(`\n${azul('JADE')} — servidor iniciado\n`);
+    console.log(`  ${verde('→')} ${azul(`http://localhost:${porta}`)}`);
+    console.log(`  ${dim(`servindo: ${raiz}`)}`);
+    console.log(`\n  ${dim('Ctrl+C para encerrar')}\n`);
+  });
+
+  server.on('error', (e) => {
+    if (e.code === 'EADDRINUSE') {
+      console.error(`\n${vermelho('erro')}: porta ${porta} em uso.`);
+      console.error(`  ${dim(`dica: tente outra porta → jade servir ${pasta} ${porta + 1}`)}\n`);
+    } else {
+      console.error(`\n${vermelho('erro')}: ${e.message}\n`);
+    }
+    process.exit(1);
+  });
+
+  // Não encerra — aguarda Ctrl+C
+  await new Promise(() => {});
+}

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@yakuzaa/jade",
-  "version": "0.1.1",
-  "description": "JADE — DSL empresarial em português compilada para WebAssembly. Instala compilador + runtime.",
+  "version": "0.1.5",
+  "description": "Jade DSL — linguagem empresarial em português compilada para WebAssembly. Instala compilador + runtime + CLI.",
   "type": "module",
+  "bin": {
+    "jade": "cli.js"
+  },
   "files": [
+    "cli.js",
+    "commands/",
+    "templates/",
     "postinstall.js",
     "README.md"
   ],
@@ -11,17 +17,20 @@
     "postinstall": "node postinstall.js"
   },
   "dependencies": {
-    "@yakuzaa/jade-compiler": "0.1.1",
-    "@yakuzaa/jade-runtime": "0.1.1"
+    "@yakuzaa/jade-compiler": "^0.1.6",
+    "@yakuzaa/jade-runtime": "^0.1.5"
   },
   "keywords": [
     "jade",
+    "jade-dsl",
     "dsl",
     "compiler",
     "runtime",
     "webassembly",
     "portuguese",
-    "enterprise"
+    "enterprise",
+    "erp",
+    "mobile-first"
   ],
   "author": "yakuzaa",
   "license": "MIT",

package/templates/index.js

@@ -0,0 +1,194 @@
+/**
+ * templates/index.js — Conteúdo dos arquivos gerados pelo `jade init`
+ *
+ * Cada template é uma função que recebe o nome do projeto e retorna a string final.
+ * Mantido aqui para não poluir commands/init.js com strings longas.
+ */
+
+// ── Entidades ────────────────────────────────────────────────────────────────
+
+export const Produto = () => `\
+entidade Produto
+  id: id
+  nome: texto
+  preco: moeda
+  estoque: numero
+fim
+`;
+
+export const Cliente = () => `\
+entidade Cliente
+  id: id
+  nome: texto
+  email: texto
+fim
+`;
+
+// ── Eventos ──────────────────────────────────────────────────────────────────
+
+export const ProdutoCriado = () => `\
+evento ProdutoCriado
+  produtoId: id
+  nome: texto
+fim
+`;
+
+// ── Serviços ─────────────────────────────────────────────────────────────────
+
+export const estoqueService = () => `\
+evento ProdutoCriado
+  produtoId: id
+  nome: texto
+fim
+
+servico estoqueService
+  funcao calcularValor(preco: decimal, quantidade: decimal) -> decimal
+    retornar preco * quantidade
+  fim
+
+  funcao temEstoque(quantidade: numero) -> booleano
+    se quantidade > 0
+      retornar verdadeiro
+    senao
+      retornar falso
+    fim
+  fim
+
+  escutar ProdutoCriado
+  fim
+fim
+`;
+
+// ── Módulos ──────────────────────────────────────────────────────────────────
+
+export const moduloEstoque = () => `\
+modulo estoque
+  importar entidades.Produto
+  importar entidades.Cliente
+  importar eventos.ProdutoCriado
+  importar servicos.estoqueService
+fim
+`;
+
+// ── UI / Telas ────────────────────────────────────────────────────────────────
+
+export const telaProdutos = () => `\
+entidade Produto
+  id: id
+  nome: texto
+  preco: moeda
+  estoque: numero
+fim
+
+tela ListaProdutos "Lista de Produtos"
+  tabela ListaProdutos
+    entidade: Produto
+    filtravel: verdadeiro
+  fim
+fim
+`;
+
+export const telaPrincipal = () => `\
+tela Principal "Página Inicial"
+  cartao BemVindo
+  fim
+fim
+`;
+
+// ── Configurações ─────────────────────────────────────────────────────────────
+
+export const jadeConfig = (nome) => JSON.stringify({
+  projeto: nome,
+  versao: '1.0.0',
+  idioma: 'pt-BR',
+  alvo: 'browser',
+  entrada: 'src/modulos/',
+  saida: 'dist/',
+}, null, 2) + '\n';
+
+export const databaseConfig = () => JSON.stringify({
+  provedor: 'local',
+  banco: 'jade-db',
+  versao: 1,
+  tabelas: ['Produto', 'Cliente'],
+}, null, 2) + '\n';
+
+export const deployConfig = () => JSON.stringify({
+  alvo: 'browser',
+  baseUrl: '/',
+  pwa: true,
+  offlineFirst: true,
+}, null, 2) + '\n';
+
+// ── package.json do projeto gerado ────────────────────────────────────────────
+
+export const packageJson = (nome) => JSON.stringify({
+  name: nome,
+  version: '1.0.0',
+  description: `Projeto JADE — ${nome}`,
+  type: 'module',
+  scripts: {
+    compilar: 'jadec src/modulos/ -o dist/',
+    compilarEAssistir: 'jadec src/modulos/ -o dist/ --watch',
+    verificar: 'jadec src/modulos/ --check',
+  },
+  dependencies: {
+    '@yakuzaa/jade': 'latest',
+    '@yakuzaa/jade-compiler': 'latest',
+    '@yakuzaa/jade-runtime': 'latest',
+  },
+}, null, 2) + '\n';
+
+// ── .gitignore ────────────────────────────────────────────────────────────────
+
+export const gitignore = () => `\
+# Gerado pelo compilador JADE — nunca commitar
+dist/
+
+# Dependências
+node_modules/
+
+# Logs
+*.log
+`;
+
+// ── README ────────────────────────────────────────────────────────────────────
+
+export const readme = (nome) => `\
+# ${nome}
+
+Projeto criado com **JADE** — DSL empresarial em português.
+
+## Primeiros passos
+
+\`\`\`bash
+# Instalar dependências
+npm install
+
+# Compilar o projeto
+npm run compilar
+
+# Abrir no navegador
+dist/index.html
+\`\`\`
+
+## Estrutura
+
+\`\`\`
+src/
+  modulos/     → agrupamentos de funcionalidades
+  servicos/    → lógica de negócio
+  entidades/   → estruturas de dados
+  eventos/     → eventos de domínio
+  ui/telas/    → interfaces declarativas
+config/
+  jade.config.json  → configuração do compilador
+  database.json     → configuração do banco de dados
+  deploy.json       → configuração de deploy
+dist/              → gerado pelo compilador (não commitar)
+\`\`\`
+
+## Documentação
+
+Acesse a documentação completa em: https://gabrielsymb.github.io/jade-language
+`;