vireum-spec-cli 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,11 +1,46 @@
 #!/usr/bin/env node
 "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 });
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const init_1 = require("./commands/init");
 const distill_1 = require("./commands/distill");
 const setup_1 = require("./commands/setup");
@@ -16,15 +51,17 @@ const verify_mcps_1 = require("./commands/verify-mcps");
 const skills_1 = require("./commands/skills");
 const retrofit_1 = require("./commands/retrofit");
 const enrich_1 = require("./commands/enrich");
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
 const program = new commander_1.Command();
 program
     .name('vireum-spec')
     .description('Spec Driven Development framework by Vireum Desenvolvimento')
-    .version('0.1.0');
+    .version(pkg.version);
 program
     .command('init')
     .description('Inicia um novo projeto com briefing interativo')
-    .action(async () => { await (0, init_1.runInit)(); });
+    .option('-t, --type <type>', 'Tipo de projeto: system, web, api, mobile, automation, ai', 'system')
+    .action(async (options) => { await (0, init_1.runInit)(options.type); });
 program
     .command('distill')
     .description('Gera os arquivos de spec a partir do briefing')

package/dist/lib/analyzer.js

@@ -0,0 +1,194 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analisarProjeto = analisarProjeto;
+exports.extrairRotas = extrairRotas;
+exports.contarArquivos = contarArquivos;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function analisarProjeto(cwd) {
+    const resultado = {
+        nome: '',
+        descricao: '',
+        arquivos: 0,
+        readme: false,
+        features: [],
+        stack: {
+            frontend: '',
+            backend: '',
+            banco: '',
+            orm: '',
+            auth: '',
+            cache: '',
+        },
+    };
+    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 };
+            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';
+            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';
+            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';
+            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';
+            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';
+            if (deps['bullmq'])
+                resultado.stack.cache = 'Redis + BullMQ';
+            else if (deps['ioredis'] || deps['redis'])
+                resultado.stack.cache = 'Redis';
+        }
+        catch { }
+    }
+    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();
+    }
+    const pastasCodigo = ['src', 'app', 'pages', 'components', 'server', 'api'];
+    let totalArquivos = 0;
+    const todasRotas = [];
+    for (const pasta of pastasCodigo) {
+        const dir = path.join(cwd, pasta);
+        if (fs.existsSync(dir)) {
+            todasRotas.push(...extrairRotas(dir));
+            totalArquivos += contarArquivos(dir);
+        }
+    }
+    resultado.features = [...new Set(todasRotas)].slice(0, 20);
+    resultado.arquivos = totalArquivos;
+    return resultado;
+}
+function extrairRotas(dir) {
+    const rotas = [];
+    const exts = ['.ts', '.tsx', '.js', '.jsx'];
+    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() &&
+                !['node_modules', '.next', 'dist', '.git'].includes(entry)) {
+                walk(full);
+            }
+            else if (exts.includes(path.extname(entry))) {
+                try {
+                    const content = fs.readFileSync(full, 'utf-8');
+                    const apiMatches = content.match(/\.(get|post|put|patch|delete|route)\(['"`]([^'"`]+)/gi);
+                    if (apiMatches) {
+                        apiMatches.forEach((m) => {
+                            const rota = m
+                                .replace(/\.(get|post|put|patch|delete|route)\(['"`]/i, '')
+                                .trim();
+                            if (rota && !rotas.includes(rota))
+                                rotas.push(rota);
+                        });
+                    }
+                    if (entry === 'page.tsx' || entry === 'page.ts') {
+                        const relativo = path
+                            .relative(dir, full)
+                            .replace(/\\/g, '/')
+                            .replace('/page.tsx', '')
+                            .replace('/page.ts', '');
+                        if (relativo && !rotas.includes(relativo))
+                            rotas.push(`page: /${relativo}`);
+                    }
+                    if (d.includes('pages') &&
+                        (entry.endsWith('.tsx') || entry.endsWith('.ts')) &&
+                        !entry.startsWith('_')) {
+                        const pagina = entry.replace('.tsx', '').replace('.ts', '');
+                        if (!rotas.includes(pagina))
+                            rotas.push(`page: ${pagina}`);
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    walk(dir);
+    return rotas;
+}
+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() &&
+                !['node_modules', '.next', 'dist', '.git'].includes(entry)) {
+                walk(full);
+            }
+            else
+                count++;
+        }
+    }
+    walk(dir);
+    return count;
+}

package/dist/lib/generators-retrofit.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gerarBriefing = gerarBriefing;
+exports.gerarRequirements = gerarRequirements;
+exports.gerarArchitecture = gerarArchitecture;
+exports.gerarUsers = gerarUsers;
+exports.gerarRisks = gerarRisks;
+exports.gerarRules = gerarRules;
+exports.gerarIndex = gerarIndex;
+exports.gerarChangelog = gerarChangelog;
+exports.gerarTasksActive = gerarTasksActive;
+exports.gerarTasksBacklog = gerarTasksBacklog;
+exports.gerarTasksDone = gerarTasksDone;
+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)'}
+`;
+}

package/dist/lib/generators-retrofit.test.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const generators_retrofit_1 = require("./generators-retrofit");
+const mockData = {
+    projeto: 'Retrofit Test',
+    cliente: 'Test Client',
+    objetivo: 'Test objective',
+    problema: 'Test problem',
+    prioridade: 'High',
+    usuarios: 'Test users',
+    regras: 'Test rules',
+    fase: 'MVP em desenvolvimento',
+    multiTenant: false,
+    lgpd: false,
+    featuresAtivas: ['Feature 1', 'Feature 2'],
+    featuresPendentes: ['Feature 3', 'Feature 4'],
+    riscos: 'Test risks',
+    data: '01/01/2025',
+    analise: {
+        nome: 'test-project',
+        descricao: 'Test description',
+        arquivos: 100,
+        readme: true,
+        features: ['route /api/users', 'route /api/posts'],
+        stack: {
+            frontend: 'Next.js',
+            backend: 'Express',
+            banco: 'PostgreSQL',
+            orm: 'Prisma',
+            auth: 'JWT',
+            cache: 'Redis',
+        },
+    },
+};
+(0, vitest_1.describe)('Generators — Retrofit', () => {
+    (0, vitest_1.describe)('gerarBriefing', () => {
+        (0, vitest_1.it)('should generate valid briefing structure', () => {
+            const result = (0, generators_retrofit_1.gerarBriefing)(mockData);
+            (0, vitest_1.expect)(result).toContain('# Briefing — Retrofit Test');
+            (0, vitest_1.expect)(result).toContain('## Informacoes Gerais');
+            (0, vitest_1.expect)(result).toContain('## Objetivo');
+            (0, vitest_1.expect)(result).toContain('## Stack Detectada');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+        (0, vitest_1.it)('should include LGPD warning when applicable', () => {
+            const dataWithLGPD = { ...mockData, lgpd: true };
+            const result = (0, generators_retrofit_1.gerarBriefing)(dataWithLGPD);
+            (0, vitest_1.expect)(result).toContain('LGPD: Sim');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+        (0, vitest_1.it)('should include multi-tenant note', () => {
+            const dataWithTenant = { ...mockData, multiTenant: true };
+            const result = (0, generators_retrofit_1.gerarBriefing)(dataWithTenant);
+            (0, vitest_1.expect)(result).toContain('Multi-tenant: Sim');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+    });
+    (0, vitest_1.describe)('gerarRequirements', () => {
+        (0, vitest_1.it)('should generate requirements with MVP and Phase 2', () => {
+            const result = (0, generators_retrofit_1.gerarRequirements)(mockData);
+            (0, vitest_1.expect)(result).toContain('# Requirements — Retrofit Test');
+            (0, vitest_1.expect)(result).toContain('## Objetivo');
+            (0, vitest_1.expect)(result).toContain('## Funcionalidades Implementadas');
+            (0, vitest_1.expect)(result).toContain('R-001 Feature 1');
+            (0, vitest_1.expect)(result).toContain('## Rotas Detectadas Automaticamente');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+    });
+    (0, vitest_1.describe)('gerarArchitecture', () => {
+        (0, vitest_1.it)('should generate architecture document', () => {
+            const result = (0, generators_retrofit_1.gerarArchitecture)(mockData);
+            (0, vitest_1.expect)(result).toContain('# Architecture — Retrofit Test');
+            (0, vitest_1.expect)(result).toContain('## Stack');
+            (0, vitest_1.expect)(result).toContain('Next.js');
+            (0, vitest_1.expect)(result).toContain('PostgreSQL');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+        (0, vitest_1.it)('should include multi-tenant section when applicable', () => {
+            const dataWithTenant = { ...mockData, multiTenant: true };
+            const result = (0, generators_retrofit_1.gerarArchitecture)(dataWithTenant);
+            (0, vitest_1.expect)(result).toContain('## Multi-Tenancy');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+    });
+    (0, vitest_1.describe)('gerarIndex', () => {
+        (0, vitest_1.it)('should generate INDEX.md with pending tasks', () => {
+            const result = (0, generators_retrofit_1.gerarIndex)(mockData);
+            (0, vitest_1.expect)(result).toContain('# INDEX — Retrofit Test');
+            (0, vitest_1.expect)(result).toContain('## Projeto');
+            (0, vitest_1.expect)(result).toContain('## Estado Atual');
+            (0, vitest_1.expect)(result).toContain('## Arquivos de contexto disponiveis');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+    });
+    (0, vitest_1.describe)('gerarTasksActive', () => {
+        (0, vitest_1.it)('should generate active tasks from pending features', () => {
+            const result = (0, generators_retrofit_1.gerarTasksActive)(mockData);
+            (0, vitest_1.expect)(result).toContain('# Tasks — Active');
+            (0, vitest_1.expect)(result).toContain('Feature 3');
+            (0, vitest_1.expect)(result).toContain('Feature 4');
+            (0, vitest_1.expect)(result).toContain('Criterios de aceitacao');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+        (0, vitest_1.it)('should return empty message when no pending features', () => {
+            const dataEmpty = { ...mockData, featuresPendentes: [] };
+            const result = (0, generators_retrofit_1.gerarTasksActive)(dataEmpty);
+            (0, vitest_1.expect)(result).toContain('Nenhuma task pendente mapeada');
+            (0, vitest_1.expect)(result).toMatchSnapshot();
+        });
+    });
+});