vireum-spec-cli 0.1.0 → 0.2.0

package/dist/commands/retrofit.js

@@ -0,0 +1,540 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRetrofit = runRetrofit;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("@inquirer/prompts");
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function runRetrofit() {
+    console.log(chalk_1.default.hex('#2D7DD2').bold('\n  Vireum Spec — Retrofit\n'));
+    console.log(chalk_1.default.gray('  Gera o spec a partir de um projeto ja em andamento\n'));
+    const cwd = process.cwd();
+    const specDir = path.join(cwd, '.spec');
+    if (fs.existsSync(path.join(specDir, 'briefing.md'))) {
+        const sobrescrever = await (0, prompts_1.confirm)({
+            message: 'Ja existe um spec neste projeto. Deseja sobrescrever?',
+            default: false,
+        });
+        if (!sobrescrever)
+            process.exit(0);
+    }
+    // ── Analise automatica ─────────────────────────────────────────────────────
+    const spinner = (0, ora_1.default)('Analisando projeto...').start();
+    await sleep(800);
+    const analise = analisarProjeto(cwd);
+    spinner.succeed(`Projeto analisado — ${analise.arquivos} arquivos encontrados`);
+    console.log('');
+    console.log(chalk_1.default.hex('#2D7DD2').bold('  O que foi detectado automaticamente:\n'));
+    if (analise.stack.frontend)
+        console.log(chalk_1.default.green(`  ✓ Frontend: ${analise.stack.frontend}`));
+    if (analise.stack.backend)
+        console.log(chalk_1.default.green(`  ✓ Backend: ${analise.stack.backend}`));
+    if (analise.stack.banco)
+        console.log(chalk_1.default.green(`  ✓ Banco: ${analise.stack.banco}`));
+    if (analise.stack.orm)
+        console.log(chalk_1.default.green(`  ✓ ORM: ${analise.stack.orm}`));
+    if (analise.stack.auth)
+        console.log(chalk_1.default.green(`  ✓ Auth: ${analise.stack.auth}`));
+    if (analise.features.length)
+        console.log(chalk_1.default.green(`  ✓ ${analise.features.length} rota(s)/feature(s) detectada(s)`));
+    if (analise.readme)
+        console.log(chalk_1.default.green(`  ✓ README encontrado`));
+    console.log('');
+    // ── Perguntas sobre o que nao foi inferido ─────────────────────────────────
+    console.log(chalk_1.default.hex('#2D7DD2').bold('  Perguntas sobre o que nao foi possivel inferir:\n'));
+    const projeto = await (0, prompts_1.input)({
+        message: 'Nome do projeto:',
+        default: analise.nome || path.basename(cwd),
+    });
+    const cliente = await (0, prompts_1.input)({ message: 'Nome do cliente:' });
+    const objetivo = await (0, prompts_1.input)({
+        message: 'Objetivo principal do projeto:',
+        default: analise.descricao || '',
+    });
+    const problema = await (0, prompts_1.input)({ message: 'Qual problema o sistema resolve?' });
+    const prioridade = await (0, prompts_1.input)({
+        message: 'O que ja esta funcionando / qual e a prioridade atual?',
+    });
+    const usuarios = await (0, prompts_1.input)({ message: 'Quem usa o sistema?' });
+    const regras = await (0, prompts_1.input)({
+        message: 'Principais regras de negocio (separadas por virgula):',
+    });
+    const fase = await (0, prompts_1.select)({
+        message: 'Em qual fase o projeto esta?',
+        choices: [
+            { name: 'MVP em desenvolvimento', value: 'MVP em desenvolvimento' },
+            { name: 'MVP concluido', value: 'MVP concluido' },
+            { name: 'Producao — evolucao ativa', value: 'Producao — evolucao ativa' },
+            { name: 'Manutencao', value: 'Manutencao' },
+        ],
+    });
+    const multiTenant = await (0, prompts_1.confirm)({
+        message: 'Projeto multi-tenant?',
+        default: false,
+    });
+    const lgpd = await (0, prompts_1.confirm)({
+        message: 'Requer conformidade com LGPD?',
+        default: false,
+    });
+    const featuresAtivas = await (0, prompts_1.input)({
+        message: 'Liste as funcionalidades JA implementadas (separadas por virgula):',
+        default: analise.features.join(', '),
+    });
+    const featuresPendentes = await (0, prompts_1.input)({
+        message: 'Liste as funcionalidades PENDENTES ou em desenvolvimento:',
+    });
+    const riscos = await (0, prompts_1.input)({
+        message: 'Riscos tecnicos identificados:',
+    });
+    // ── Gerar arquivos ─────────────────────────────────────────────────────────
+    console.log('');
+    const dados = {
+        projeto, cliente, objetivo, problema, prioridade,
+        usuarios, regras, fase, multiTenant, lgpd,
+        featuresAtivas: featuresAtivas.split(',').map(f => f.trim()).filter(Boolean),
+        featuresPendentes: featuresPendentes.split(',').map(f => f.trim()).filter(Boolean),
+        riscos, analise,
+        data: new Date().toLocaleDateString('pt-BR'),
+    };
+    if (!fs.existsSync(specDir))
+        fs.mkdirSync(specDir, { recursive: true });
+    const tasksDir = path.join(specDir, 'tasks');
+    if (!fs.existsSync(tasksDir))
+        fs.mkdirSync(tasksDir, { recursive: true });
+    const arquivos = [
+        { nome: 'briefing.md', conteudo: gerarBriefing(dados), msg: 'Gerando briefing.md...' },
+        { nome: 'requirements.md', conteudo: gerarRequirements(dados), msg: 'Gerando requirements.md...' },
+        { nome: 'architecture.md', conteudo: gerarArchitecture(dados), msg: 'Gerando architecture.md...' },
+        { nome: 'users.md', conteudo: gerarUsers(dados), msg: 'Gerando users.md...' },
+        { nome: 'risks.md', conteudo: gerarRisks(dados), msg: 'Gerando risks.md...' },
+        { nome: 'rules.md', conteudo: gerarRules(dados), msg: 'Gerando rules.md...' },
+        { nome: 'INDEX.md', conteudo: gerarIndex(dados), msg: 'Gerando INDEX.md...' },
+        { nome: 'changelog.md', conteudo: gerarChangelog(dados), msg: 'Gerando changelog.md...' },
+    ];
+    for (const arq of arquivos) {
+        const s = (0, ora_1.default)(arq.msg).start();
+        await sleep(400);
+        fs.writeFileSync(path.join(specDir, arq.nome), arq.conteudo, 'utf-8');
+        s.succeed(arq.nome);
+    }
+    // tasks
+    const s1 = (0, ora_1.default)('Gerando tasks...').start();
+    await sleep(400);
+    fs.writeFileSync(path.join(tasksDir, 'active.md'), gerarTasksActive(dados), 'utf-8');
+    fs.writeFileSync(path.join(tasksDir, 'backlog.md'), gerarTasksBacklog(dados), 'utf-8');
+    fs.writeFileSync(path.join(tasksDir, 'done.md'), gerarTasksDone(dados), 'utf-8');
+    s1.succeed('tasks/ gerado');
+    console.log(chalk_1.default.green.bold('\n✅ Retrofit concluido!\n'));
+    console.log(chalk_1.default.gray('  Spec gerado em .spec/ a partir do projeto existente\n'));
+    console.log(chalk_1.default.gray('  Proximos passos:'));
+    console.log(chalk_1.default.gray('  1. Revise os arquivos gerados em .spec/'));
+    console.log(chalk_1.default.gray('  2. Execute: ') + chalk_1.default.white('vireum-spec setup') + chalk_1.default.gray(' para configurar o protocolo da IA'));
+    console.log(chalk_1.default.gray('  3. Execute: ') + chalk_1.default.white('vireum-spec prioritize') + chalk_1.default.gray(' para organizar as tasks pendentes\n'));
+}
+// ── ANALISADOR ────────────────────────────────────────────────────────────────
+function analisarProjeto(cwd) {
+    const resultado = {
+        nome: '',
+        descricao: '',
+        arquivos: 0,
+        readme: false,
+        features: [],
+        stack: {
+            frontend: '',
+            backend: '',
+            banco: '',
+            orm: '',
+            auth: '',
+            cache: '',
+        },
+    };
+    // package.json
+    const pkgPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            resultado.nome = pkg.name || '';
+            resultado.descricao = pkg.description || '';
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            // Frontend
+            if (deps['next'])
+                resultado.stack.frontend = 'Next.js';
+            else if (deps['react'])
+                resultado.stack.frontend = 'React';
+            else if (deps['vue'])
+                resultado.stack.frontend = 'Vue';
+            else if (deps['nuxt'])
+                resultado.stack.frontend = 'Nuxt';
+            // Backend
+            if (deps['fastify'])
+                resultado.stack.backend = 'Node.js + Fastify';
+            else if (deps['express'])
+                resultado.stack.backend = 'Node.js + Express';
+            else if (deps['@nestjs/core'])
+                resultado.stack.backend = 'NestJS';
+            // Banco
+            if (deps['pg'] || deps['postgres'])
+                resultado.stack.banco = 'PostgreSQL';
+            else if (deps['mysql2'])
+                resultado.stack.banco = 'MySQL';
+            else if (deps['better-sqlite3'])
+                resultado.stack.banco = 'SQLite';
+            else if (deps['mongoose'])
+                resultado.stack.banco = 'MongoDB';
+            // ORM
+            if (deps['prisma'] || deps['@prisma/client'])
+                resultado.stack.orm = 'Prisma';
+            else if (deps['typeorm'])
+                resultado.stack.orm = 'TypeORM';
+            else if (deps['drizzle-orm'])
+                resultado.stack.orm = 'Drizzle';
+            // Auth
+            if (deps['jsonwebtoken'])
+                resultado.stack.auth = 'JWT';
+            else if (deps['next-auth'])
+                resultado.stack.auth = 'NextAuth';
+            else if (deps['@clerk/nextjs'])
+                resultado.stack.auth = 'Clerk';
+            // Cache
+            if (deps['ioredis'] || deps['redis'])
+                resultado.stack.cache = 'Redis';
+            if (deps['bullmq'])
+                resultado.stack.cache = 'Redis + BullMQ';
+        }
+        catch { }
+    }
+    // README
+    const readmePath = path.join(cwd, 'README.md');
+    if (fs.existsSync(readmePath)) {
+        resultado.readme = true;
+        const readme = fs.readFileSync(readmePath, 'utf-8');
+        const desc = readme.split('\n').find(l => l.trim() && !l.startsWith('#'));
+        if (desc)
+            resultado.descricao = resultado.descricao || desc.trim();
+    }
+    // Rotas — procura em src/
+    const srcDir = path.join(cwd, 'src');
+    if (fs.existsSync(srcDir)) {
+        resultado.features = extrairRotas(srcDir);
+        resultado.arquivos = contarArquivos(srcDir);
+    }
+    return resultado;
+}
+function extrairRotas(dir) {
+    const rotas = [];
+    const exts = ['.ts', '.js'];
+    function walk(d) {
+        if (!fs.existsSync(d))
+            return;
+        for (const entry of fs.readdirSync(d)) {
+            const full = path.join(d, entry);
+            const stat = fs.statSync(full);
+            if (stat.isDirectory() && !entry.includes('node_modules')) {
+                walk(full);
+            }
+            else if (exts.includes(path.extname(entry))) {
+                const content = fs.readFileSync(full, 'utf-8');
+                const matches = content.match(/\.(get|post|put|patch|delete|route)\(['"`]([^'"`]+)/gi);
+                if (matches) {
+                    matches.forEach(m => {
+                        const rota = m.replace(/\.(get|post|put|patch|delete|route)\(['"`]/i, '').trim();
+                        if (rota && !rotas.includes(rota))
+                            rotas.push(rota);
+                    });
+                }
+            }
+        }
+    }
+    walk(dir);
+    return rotas.slice(0, 20);
+}
+function contarArquivos(dir) {
+    let count = 0;
+    function walk(d) {
+        if (!fs.existsSync(d))
+            return;
+        for (const entry of fs.readdirSync(d)) {
+            const full = path.join(d, entry);
+            if (fs.statSync(full).isDirectory() && !entry.includes('node_modules'))
+                walk(full);
+            else
+                count++;
+        }
+    }
+    walk(dir);
+    return count;
+}
+// ── GERADORES ─────────────────────────────────────────────────────────────────
+function gerarBriefing(d) {
+    return `# Briefing — ${d.projeto}
+
+> Gerado via vireum-spec retrofit em ${d.data}
+> Projeto pre-existente — informacoes inferidas e complementadas
+
+## Informacoes Gerais
+- **Projeto:** ${d.projeto}
+- **Cliente:** ${d.cliente}
+- **Data do retrofit:** ${d.data}
+- **Fase:** ${d.fase}
+
+## Objetivo
+**Objetivo principal:** ${d.objetivo}
+**Problema que resolve:** ${d.problema}
+**Estado atual / prioridade:** ${d.prioridade}
+
+## Usuarios
+${d.usuarios}
+
+## Funcionalidades Implementadas
+${d.featuresAtivas.map((f) => `- [x] ${f}`).join('\n') || '- (nao informado)'}
+
+## Funcionalidades Pendentes
+${d.featuresPendentes.map((f) => `- [ ] ${f}`).join('\n') || '- (nao informado)'}
+
+## Regras de Negocio
+${d.regras || '(nao informado)'}
+
+## Stack Detectada
+- Frontend: ${d.analise.stack.frontend || 'nao detectado'}
+- Backend: ${d.analise.stack.backend || 'nao detectado'}
+- Banco: ${d.analise.stack.banco || 'nao detectado'}
+- ORM: ${d.analise.stack.orm || 'nao detectado'}
+- Auth: ${d.analise.stack.auth || 'nao detectado'}
+
+## Riscos
+${d.riscos || '(nenhum identificado)'}
+
+## Conformidade
+- Multi-tenant: ${d.multiTenant ? 'Sim' : 'Nao'}
+- LGPD: ${d.lgpd ? 'Sim' : 'Nao'}
+`;
+}
+function gerarRequirements(d) {
+    const implementadas = d.featuresAtivas.map((f, i) => `- [x] R-${String(i + 1).padStart(3, '0')} ${f} — JA IMPLEMENTADO`).join('\n');
+    const pendentes = d.featuresPendentes.map((f, i) => `- [ ] R-${String(d.featuresAtivas.length + i + 1).padStart(3, '0')} ${f}`).join('\n');
+    return `# Requirements — ${d.projeto}
+
+> Gerado via vireum-spec retrofit em ${d.data}
+
+## Objetivo
+${d.objetivo}
+
+## Funcionalidades Implementadas
+${implementadas || '- (nao informado)'}
+
+## Funcionalidades Pendentes (MVP)
+${pendentes || '- (nao informado)'}
+
+## Funcionalidades Fase 2
+> Preencher apos vireum-spec prioritize
+
+## Regras de Negocio
+${d.regras || '> A detalhar'}
+
+## Rotas Detectadas Automaticamente
+${d.analise.features.map((r) => `- ${r}`).join('\n') || '- (nenhuma detectada)'}
+`;
+}
+function gerarArchitecture(d) {
+    const tenant = d.multiTenant
+        ? '\n## Multi-Tenancy\n- Ativo — nunca fazer query sem filtro de tenantId' : '';
+    return `# Architecture — ${d.projeto}
+
+> Gerado via vireum-spec retrofit em ${d.data}
+> Stack inferida automaticamente — revisar e complementar
+
+## Stack
+- Frontend: ${d.analise.stack.frontend || 'A confirmar'}
+- Backend: ${d.analise.stack.backend || 'A confirmar'}
+- Banco de dados: ${d.analise.stack.banco || 'A confirmar'}
+- ORM: ${d.analise.stack.orm || 'A confirmar'}
+- Cache / Filas: ${d.analise.stack.cache || 'A confirmar'}
+- Auth: ${d.analise.stack.auth || 'A confirmar'}
+${tenant}
+
+## Decisoes Arquiteturais
+> Registre aqui decisoes tomadas antes do retrofit
+
+| Data | Decisao | Alternativas descartadas | Motivo |
+|------|---------|--------------------------|--------|
+|      |         |                          |        |
+
+## MCPs Ativos
+> Configurar via vireum-spec setup
+`;
+}
+function gerarUsers(d) {
+    return `# Users — ${d.projeto}
+
+> Gerado via vireum-spec retrofit em ${d.data}
+
+## Publico Principal
+${d.usuarios}
+
+## Tipos de Usuario e Acesso
+> Detalhar apos analise do codigo existente
+
+## Jornadas Principais
+> A mapear com base nas rotas detectadas
+`;
+}
+function gerarRisks(d) {
+    return `# Risks — ${d.projeto}
+
+> Gerado via vireum-spec retrofit em ${d.data}
+
+## Riscos Identificados
+- Tecnico: ${d.riscos || 'Nenhum informado'}
+${d.lgpd ? '- LGPD requerida — revisar tratamento de dados pessoais existente' : ''}
+${d.multiTenant ? '- Multi-tenant — auditar queries existentes para garantir isolamento' : ''}
+
+## Riscos de Retrofit
+- Spec gerado pode nao refletir 100% da realidade do codigo — revisar arquivos gerados
+- Funcionalidades nao listadas no briefing podem existir no codigo — auditar
+
+## Riscos Identificados Durante o Desenvolvimento
+| Data | Risco | Impacto | Mitigacao |
+|------|-------|---------|-----------|
+|      |       |         |           |
+`;
+}
+function gerarRules(d) {
+    const extras = [];
+    if (d.lgpd)
+        extras.push('- Nunca armazenar dados pessoais sem consentimento (LGPD)');
+    if (d.multiTenant)
+        extras.push('- Nunca fazer query sem filtro de tenantId');
+    return `# Rules — ${d.projeto}
+
+> Gerado via vireum-spec retrofit em ${d.data}
+> Complementar com regras especificas do projeto apos revisao do codigo
+
+## Regras do Projeto
+${extras.length ? extras.join('\n') : '- A definir apos revisao do codigo existente'}
+`;
+}
+function gerarIndex(d) {
+    const pendentes = d.featuresPendentes.map((f, i) => {
+        const prefix = f.replace(/\s+/g, '_').toUpperCase().slice(0, 8);
+        return `- [ ] [${prefix}-T${String(i + 1).padStart(3, '0')}] ${f}`;
+    }).join('\n');
+    return `# INDEX — ${d.projeto}
+
+> Gerado via vireum-spec retrofit em ${d.data}
+> Arquivo de entrada — sempre carregado pela IA no inicio de cada sessao
+
+## Projeto
+- **Cliente:** ${d.cliente}
+- **Fase atual:** ${d.fase}
+- **Retrofit em:** ${d.data}
+
+## Estado Atual
+${pendentes || '- Nenhuma task pendente mapeada ainda'}
+
+## Arquivos de contexto disponiveis
+Nao carregue automaticamente. Carregue apenas quando a task exigir:
+
+- Escopo e features → leia \`.spec/requirements.md\`
+- Decisoes tecnicas → leia \`.spec/architecture.md\`
+- Perfis e permissoes → leia \`.spec/users.md\`
+- Riscos → leia \`.spec/risks.md\`
+- Tarefas ativas → leia \`.spec/tasks/active.md\`
+- Historico → leia \`.spec/changelog.md\`
+
+## Resumo do Objetivo
+${d.objetivo}
+`;
+}
+function gerarChangelog(d) {
+    return `# Changelog — ${d.projeto}
+
+> Registro de decisoes, mudancas e causa raiz de bugs.
+
+## ${d.data} — Retrofit realizado
+- Spec gerado a partir de projeto pre-existente via vireum-spec retrofit
+- Stack detectada automaticamente: ${[
+        d.analise.stack.frontend,
+        d.analise.stack.backend,
+        d.analise.stack.banco,
+    ].filter(Boolean).join(', ') || 'a confirmar'}
+- Fase no momento do retrofit: ${d.fase}
+`;
+}
+function gerarTasksActive(d) {
+    if (d.featuresPendentes.length === 0) {
+        return `# Tasks — Active\n\n> Nenhuma task pendente mapeada no retrofit.\n> Execute vireum-spec prioritize para organizar.\n`;
+    }
+    const tasks = d.featuresPendentes.map((f, i) => {
+        const prefix = f.replace(/\s+/g, '_').toUpperCase().slice(0, 8);
+        const num = String(i + 1).padStart(3, '0');
+        return `## [${prefix}-T${num}] ${f}
+- **Origem:** retrofit — funcionalidade pendente
+- **Camada:** A definir
+- **Complexidade:** A definir
+- **Criterios de aceitacao:**
+  - (definir antes de implementar)
+- **Status:** [ ] Nao iniciada
+`;
+    }).join('\n');
+    return `# Tasks — Active
+
+> Tasks pendentes identificadas no retrofit.
+> Revise e complemente os criterios de aceitacao antes de comecar.
+
+---
+
+${tasks}`;
+}
+function gerarTasksBacklog(d) {
+    return `# Tasks — Backlog\n\n> Preencher apos priorizacao via vireum-spec prioritize.\n`;
+}
+function gerarTasksDone(d) {
+    const done = d.featuresAtivas.map((f) => `- [x] ${f} — pre-existente ao retrofit`).join('\n');
+    return `# Tasks — Done
+
+> Funcionalidades ja implementadas antes do retrofit.
+
+## ${d.data} — Retrofit
+${done || '- (nenhuma listada)'}
+`;
+}
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}

package/dist/index.js

@@ -14,6 +14,7 @@ const health_1 = require("./commands/health");
 const brief_1 = require("./commands/brief");
 const verify_mcps_1 = require("./commands/verify-mcps");
 const skills_1 = require("./commands/skills");
+const retrofit_1 = require("./commands/retrofit");
 const program = new commander_1.Command();
 program
     .name('vireum-spec')
@@ -51,5 +52,9 @@ program
     .command('skills')
     .description('Instala as skills do framework no cliente de IA')
     .action(async () => { await (0, skills_1.runSkills)(); });
+program
+    .command('retrofit')
+    .description('Gera o spec a partir de um projeto ja em andamento')
+    .action(async () => { await (0, retrofit_1.runRetrofit)(); });
 console.log(chalk_1.default.hex('#2D7DD2').bold('\n  Vireum Spec Framework\n'));
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vireum-spec-cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Spec Driven Development framework by Vireum Desenvolvimento",
   "main": "dist/index.js",
   "bin": {