@creative-ia/cortex 1.0.5

package/dist/tools/decompose-epic.js

@@ -0,0 +1,603 @@
+/**
+ * Tool: decompose_epic
+ * Recebe um EP-XX do markdown de épicos e gera a decomposição completa:
+ * EPIC-XXX.md + FEAT-XXX.md[] + US-XXX.md[] + TASK-XXX.md[]
+ *
+ * Lê o markdown de épicos do processo, parseia o EP solicitado,
+ * e gera os artefatos seguindo o padrão do processo 9760b430.
+ */
+import { writeFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+// ============================================================
+// EPIC PARSER — reads EP-XX from epicos markdown
+// ============================================================
+function parseEpicFromMarkdown(content, epicId) {
+    const sections = content.split(/\n## /);
+    const normalizedId = epicId.replace("EP-", "").padStart(2, "0");
+    const prefix = `EP-${normalizedId}`;
+    const epicSection = sections.find((s) => s.trim().startsWith(prefix));
+    if (!epicSection)
+        return null;
+    const lines = epicSection.split("\n");
+    const titleLine = lines[0] || "";
+    const titleMatch = titleLine.match(/EP-\d{2}\s*[—-]\s*(.+)/);
+    const title = titleMatch ? titleMatch[1].trim() : titleLine.trim();
+    let objective = "";
+    let scope = [];
+    let criteria = [];
+    let dependencies = [];
+    let squads = [];
+    let size = "M";
+    let currentBlock = "";
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === "---")
+            continue;
+        if (trimmed.startsWith("**Objetivo:**")) {
+            objective = trimmed.replace("**Objetivo:**", "").trim();
+            currentBlock = "";
+            continue;
+        }
+        if (trimmed.startsWith("**Escopo:**")) {
+            currentBlock = "scope";
+            continue;
+        }
+        if (trimmed.startsWith("**Critérios de aceite:**") || trimmed.startsWith("**Criterios de aceite:**")) {
+            currentBlock = "criteria";
+            continue;
+        }
+        if (trimmed.match(/^\*\*Depend[eê]ncias:\*\*/)) {
+            const val = trimmed.replace(/\*\*Depend[eê]ncias:\*\*/, "").trim();
+            if (val && !val.includes("Nenhuma")) {
+                dependencies = val.split(",").map((d) => d.trim()).filter(Boolean);
+            }
+            currentBlock = "";
+            continue;
+        }
+        if (trimmed.startsWith("**Squads:**")) {
+            squads = trimmed.replace("**Squads:**", "").trim().split("+").map((s) => s.trim()).filter(Boolean);
+            currentBlock = "";
+            continue;
+        }
+        if (trimmed.startsWith("**Estimativa:**")) {
+            size = trimmed.includes("L") ? "L" : "M";
+            currentBlock = "";
+            continue;
+        }
+        if (trimmed.startsWith("- ") && currentBlock === "scope") {
+            scope.push(trimmed.slice(2));
+        }
+        else if ((trimmed.startsWith("- [ ]") || trimmed.startsWith("- [x]")) && currentBlock === "criteria") {
+            criteria.push(trimmed.replace(/^- \[.\]\s*/, ""));
+        }
+        else if (trimmed.startsWith("- ") && currentBlock === "criteria") {
+            criteria.push(trimmed.slice(2));
+        }
+    }
+    return { id: prefix, title, objective, scope, criteria, dependencies, squads, size };
+}
+// ============================================================
+// DECOMPOSITION ENGINE
+// ============================================================
+function decomposeToFeatures(epic, startFeatIdx) {
+    const features = [];
+    // Group scope items into logical features (2-4 scope items per feature)
+    const scopeGroups = [];
+    const chunkSize = Math.max(2, Math.ceil(epic.scope.length / Math.ceil(epic.scope.length / 3)));
+    for (let i = 0; i < epic.scope.length; i += chunkSize) {
+        scopeGroups.push(epic.scope.slice(i, i + chunkSize));
+    }
+    scopeGroups.forEach((group, idx) => {
+        const featNum = (startFeatIdx + idx).toString().padStart(3, "0");
+        const featId = `FEAT-${featNum}`;
+        const title = inferFeatureTitle(group, epic.title);
+        const description = `Implementar ${group.join(", ").toLowerCase()} como parte do épico ${epic.id} (${epic.title}).`;
+        // Generate criteria from scope items
+        const criteria = group.map((s) => `Funcionalidade "${s}" implementada e testada`);
+        features.push({
+            id: featId,
+            epicId: epic.id,
+            title,
+            description,
+            userStories: [], // filled later
+            criteria,
+            priority: idx === 0 ? "Alta" : "Media",
+        });
+    });
+    return features;
+}
+function inferFeatureTitle(scopeItems, epicTitle) {
+    // Try to find a common theme in the scope items
+    const first = scopeItems[0] || epicTitle;
+    if (scopeItems.length === 1)
+        return first;
+    // Use the first item as the main title, simplified
+    const simplified = first
+        .replace(/\(.*?\)/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return simplified.length > 60 ? simplified.slice(0, 57) + "..." : simplified;
+}
+function decomposeToUserStories(feature, epic, startUsIdx) {
+    const stories = [];
+    // Each criterion becomes a user story
+    feature.criteria.forEach((criterion, idx) => {
+        const usNum = (startUsIdx + idx).toString().padStart(3, "0");
+        const usId = `US-${usNum}`;
+        // Determine persona based on content
+        const persona = inferPersona(criterion, epic);
+        stories.push({
+            id: usId,
+            featId: feature.id,
+            epicId: epic.id,
+            title: criterion.replace(/^Funcionalidade "/, "").replace(/" implementada.*/, ""),
+            asA: persona.role,
+            iWant: criterion.toLowerCase(),
+            soThat: persona.benefit,
+            criteria: generateBDDCriteria(criterion),
+            tasks: [], // filled later
+        });
+    });
+    return stories;
+}
+function inferPersona(criterion, epic) {
+    const lower = criterion.toLowerCase();
+    if (lower.includes("api") || lower.includes("integra") || lower.includes("backend"))
+        return { role: "desenvolvedor backend", benefit: "a integração funcione de forma confiável" };
+    if (lower.includes("tela") || lower.includes("app") || lower.includes("mobile") || lower.includes("web"))
+        return { role: "usuário do aplicativo", benefit: "eu possa realizar a operação de forma intuitiva" };
+    if (lower.includes("monitor") || lower.includes("log") || lower.includes("alert") || lower.includes("dashboard"))
+        return { role: "engenheiro de plataforma", benefit: "eu possa monitorar e diagnosticar problemas rapidamente" };
+    if (lower.includes("segur") || lower.includes("certific") || lower.includes("auth"))
+        return { role: "engenheiro de segurança", benefit: "a comunicação seja segura e auditável" };
+    return { role: "usuário do sistema", benefit: "a funcionalidade atenda aos requisitos de negócio" };
+}
+function generateBDDCriteria(criterion) {
+    return [
+        `Dado que o sistema está configurado corretamente`,
+        `Quando a funcionalidade "${criterion}" é executada`,
+        `Então o resultado esperado é obtido sem erros`,
+        `E logs de auditoria são gerados`,
+    ];
+}
+function decomposeToTasks(story, startTaskIdx) {
+    const tasks = [];
+    // Dev task
+    const devNum = (startTaskIdx).toString().padStart(3, "0");
+    tasks.push({
+        id: `TASK-${devNum}`,
+        usId: story.id,
+        featId: story.featId,
+        title: `Implementar ${story.title}`,
+        type: "dev",
+        instructions: [
+            `Criar/atualizar módulos conforme especificação da ${story.id}`,
+            `Implementar lógica de negócio conforme critérios de aceite`,
+            `Integrar com APIs/serviços necessários`,
+            `Implementar tratamento de erros e logging estruturado`,
+        ],
+        files: [],
+        estimate: "4h",
+    });
+    // QA task
+    const qaNum = (startTaskIdx + 1).toString().padStart(3, "0");
+    tasks.push({
+        id: `TASK-${qaNum}`,
+        usId: story.id,
+        featId: story.featId,
+        title: `Testes da ${story.id} — ${story.title}`,
+        type: "qa",
+        instructions: [
+            `Criar testes unitários com cobertura >= 80%`,
+            `Criar testes de integração para fluxos principais`,
+            `Validar critérios de aceite BDD`,
+            `Verificar tratamento de erros e edge cases`,
+        ],
+        files: [],
+        estimate: "3h",
+    });
+    return tasks;
+}
+// ============================================================
+// MARKDOWN GENERATORS
+// ============================================================
+function generateEpicMd(epic, features, processId) {
+    const epicNum = epic.id.replace("EP-", "").padStart(3, "0");
+    const now = new Date().toISOString().split("T")[0];
+    const featTable = features.map((f) => `| ${f.id} | ${f.title} | ${f.priority} | backlog |`).join("\n");
+    const criteriaList = epic.criteria.map((c) => `- [ ] ${c}`).join("\n");
+    const scopeList = epic.scope.map((s) => `- ${s}`).join("\n");
+    const depsText = epic.dependencies.length > 0 ? epic.dependencies.join(", ") : "Nenhuma (épico fundacional)";
+    const squadsText = epic.squads.join(" + ");
+    return `# EPIC-${epicNum}: ${epic.title}
+
+> Processo: ${processId}
+> Autor: Product Manager
+> Data: ${now}
+> Versao: v1.0.0
+
+---
+
+## Metadata
+
+| Campo | Valor |
+|-------|-------|
+| ID | EPIC-${epicNum} |
+| Status | backlog |
+| Prioridade | Alta |
+| Owner | Product Manager |
+| Estimativa | ${epic.size === "L" ? "Grande" : "Médio"} |
+| Processo | ${processId} |
+| Criado em | ${now} |
+
+---
+
+## 1. Objetivo de Negócio (*)
+${epic.objective}
+
+## 2. Escopo (*)
+
+${scopeList}
+
+## 3. Features (*)
+
+| ID | Feature | Prioridade | Status |
+|----|---------|------------|--------|
+${featTable}
+
+## 4. Dependências
+
+${depsText}
+
+## 5. Squads
+
+${squadsText}
+
+## 6. Critérios de Aceite do Épico (*)
+
+${criteriaList}
+
+---
+
+## Changelog
+
+| Versão | Data | Autor | Mudança |
+|--------|------|-------|---------|
+| v1.0.0 | ${now} | Creative IA 50 | Gerado via decompose_epic |
+`;
+}
+function generateFeatureMd(feat, stories, epic, processId) {
+    const now = new Date().toISOString().split("T")[0];
+    const usTable = stories.map((us) => `| ${us.id} | ${us.title} | 5 | Alta | backlog |`).join("\n");
+    const criteriaList = feat.criteria.map((c) => `- [ ] ${c}`).join("\n");
+    return `# ${feat.id}: ${feat.title}
+
+> Processo: ${processId}
+> Autor: Product Manager
+> Data: ${now}
+> Versao: v1.0.0
+
+---
+
+## Metadata
+
+| Campo | Valor |
+|-------|-------|
+| ID | ${feat.id} |
+| Épico | ${epic.id} — ${epic.title} |
+| Status | backlog |
+| Prioridade | ${feat.priority} |
+| Processo | ${processId} |
+| Criado em | ${now} |
+
+---
+
+## 1. Descrição (*)
+${feat.description}
+
+## 2. User Stories (*)
+
+| ID | User Story | Pontos | Prioridade | Status |
+|----|-----------|--------|------------|--------|
+${usTable}
+
+## 3. Critérios de Aceite da Feature (*)
+
+${criteriaList}
+
+## 4. Dependências
+
+| Tipo | Descrição | Status |
+|------|-----------|--------|
+| Épico | ${epic.id} — ${epic.title} | backlog |
+
+---
+
+## Changelog
+
+| Versão | Data | Autor | Mudança |
+|--------|------|-------|---------|
+| v1.0.0 | ${now} | Creative IA 50 | Gerado via decompose_epic |
+`;
+}
+function generateUserStoryMd(us, epic, tasks, processId) {
+    const now = new Date().toISOString().split("T")[0];
+    const taskTable = tasks.map((t) => `| ${t.id} | ${t.title} | ${t.type} | — | ${t.estimate} | backlog |`).join("\n");
+    const criteriaText = us.criteria.map((c, i) => {
+        if (i === 0)
+            return `**Cenário 1: Sucesso**\n- **Dado** ${c}`;
+        if (i === 1)
+            return `- **Quando** ${c}`;
+        if (i === 2)
+            return `- **Então** ${c}`;
+        return `- **E** ${c}`;
+    }).join("\n");
+    return `# ${us.id}: ${us.title}
+
+> Processo: ${processId}
+> Autor: Tech Lead
+> Data: ${now}
+
+---
+
+## Metadata
+
+| Campo | Valor |
+|-------|-------|
+| ID | ${us.id} |
+| Feature | ${us.featId} |
+| Épico | ${epic.id} — ${epic.title} |
+| Status | backlog |
+| Prioridade | Alta |
+| Story Points | 5 |
+| Processo | ${processId} |
+
+---
+
+## 1. User Story (*)
+
+**Como** ${us.asA},
+**Quero** ${us.iWant},
+**Para** ${us.soThat}.
+
+## 2. Critérios de Aceite (*)
+
+${criteriaText}
+
+## 3. Tasks (*)
+
+| ID | Task | Tipo | Assignee | Estimativa | Status |
+|----|------|------|----------|------------|--------|
+${taskTable}
+
+## 4. Definição de Ready (DoR)
+
+- [ ] Critérios de aceite escritos e revisados
+- [ ] Dependências mapeadas e resolvidas
+- [ ] Tasks decompostas com estimativa
+
+## 5. Definição de Done (DoD)
+
+- [ ] Código implementado e revisado (PR aprovado)
+- [ ] Testes unitários passando (cobertura >= 80%)
+- [ ] Critérios de aceite validados
+- [ ] Sem bugs críticos ou bloqueantes
+- [ ] Documentação atualizada
+
+---
+
+## Changelog
+
+| Data | Autor | Mudança |
+|------|-------|---------|
+| ${now} | Creative IA 50 | Gerado via decompose_epic |
+`;
+}
+function generateTaskMd(task, processId) {
+    const now = new Date().toISOString().split("T")[0];
+    const instructionsList = task.instructions.map((i, idx) => `${idx + 1}. ${i}`).join("\n");
+    return `# ${task.id}: ${task.title}
+
+> Processo: ${processId}
+> Autor: Tech Lead
+> Data: ${now}
+
+---
+
+## Metadata
+
+| Campo | Valor |
+|-------|-------|
+| ID | ${task.id} |
+| User Story | ${task.usId} |
+| Feature | ${task.featId} |
+| Tipo | ${task.type} |
+| Status | backlog |
+| Estimativa | ${task.estimate} |
+| Processo | ${processId} |
+
+---
+
+## 1. Objetivo (*)
+
+${task.title}.
+
+## 2. Instruções de Implementação (*)
+
+${instructionsList}
+
+## 3. Critérios de Aceite (*)
+
+- [ ] Funcionalidade implementada conforme especificação
+- [ ] Tratamento de erros implementado
+- [ ] Testes passando (cobertura >= 80%)
+- [ ] Sem warnings de lint/build
+
+## 4. Definition of Done (*)
+
+- [ ] Código implementado conforme instruções
+- [ ] Code review aprovado
+- [ ] Testes escritos e passando
+- [ ] Documentação atualizada
+
+---
+
+## Changelog
+
+| Data | Autor | Mudança |
+|------|-------|---------|
+| ${now} | Creative IA 50 | Gerado via decompose_epic |
+`;
+}
+// ============================================================
+// MAIN FUNCTION — decompose_epic
+// ============================================================
+export async function decomposeEpic(params) {
+    const { processId, epicId, processDir } = params;
+    // 1. Find and read the epicos markdown
+    const possibleFiles = [
+        `03-epicos-${processId}.md`,
+        `03-epicos.md`,
+    ];
+    // Also search for any file starting with 03-epicos
+    let epicsMdPath = "";
+    let epicsMdContent = "";
+    for (const f of possibleFiles) {
+        const p = join(processDir, f);
+        if (existsSync(p)) {
+            epicsMdPath = p;
+            epicsMdContent = await readFile(p, "utf-8");
+            break;
+        }
+    }
+    // Fallback: search for any 03-epicos*.md file
+    if (!epicsMdContent) {
+        const { readdirSync } = await import("node:fs");
+        try {
+            const files = readdirSync(processDir);
+            const epicFile = files.find((f) => f.startsWith("03-epicos") && f.endsWith(".md"));
+            if (epicFile) {
+                epicsMdPath = join(processDir, epicFile);
+                epicsMdContent = await readFile(epicsMdPath, "utf-8");
+            }
+        }
+        catch { /* ignore */ }
+    }
+    if (!epicsMdContent) {
+        return `Erro: Não encontrei o markdown de épicos no processo ${processId}. Esperado: 03-epicos*.md em ${processDir}`;
+    }
+    // 2. Parse the requested epic
+    const epic = parseEpicFromMarkdown(epicsMdContent, epicId);
+    if (!epic) {
+        return `Erro: Épico ${epicId} não encontrado no markdown. Épicos disponíveis: ${(epicsMdContent.match(/## EP-\d{2}/g) || []).join(", ")}`;
+    }
+    // 3. Check existing artifacts to determine starting indices
+    const { readdirSync } = await import("node:fs");
+    let maxFeat = 0, maxUs = 0, maxTask = 0;
+    try {
+        const featDir = join(processDir, "features");
+        if (existsSync(featDir)) {
+            const feats = readdirSync(featDir).filter((f) => f.match(/^FEAT-\d+\.md$/));
+            feats.forEach((f) => {
+                const num = parseInt(f.replace("FEAT-", "").replace(".md", ""), 10);
+                if (num > maxFeat)
+                    maxFeat = num;
+            });
+        }
+    }
+    catch { /* ignore */ }
+    try {
+        const usDir = join(processDir, "user-stories");
+        if (existsSync(usDir)) {
+            const uss = readdirSync(usDir).filter((f) => f.match(/^US-\d+\.md$/));
+            uss.forEach((f) => {
+                const num = parseInt(f.replace("US-", "").replace(".md", ""), 10);
+                if (num > maxUs)
+                    maxUs = num;
+            });
+        }
+    }
+    catch { /* ignore */ }
+    try {
+        const taskDir = join(processDir, "tasks");
+        if (existsSync(taskDir)) {
+            const tasks = readdirSync(taskDir).filter((f) => f.match(/^TASK-\d+\.md$/));
+            tasks.forEach((f) => {
+                const num = parseInt(f.replace("TASK-", "").replace(".md", ""), 10);
+                if (num > maxTask)
+                    maxTask = num;
+            });
+        }
+    }
+    catch { /* ignore */ }
+    // 4. Decompose
+    const features = decomposeToFeatures(epic, maxFeat + 1);
+    let usIdx = maxUs + 1;
+    let taskIdx = maxTask + 1;
+    const allStories = [];
+    const allTasks = [];
+    for (const feat of features) {
+        const stories = decomposeToUserStories(feat, epic, usIdx);
+        usIdx += stories.length;
+        feat.userStories = stories.map((s) => s.id);
+        allStories.push({ feature: feat, stories });
+        for (const story of stories) {
+            const tasks = decomposeToTasks(story, taskIdx);
+            taskIdx += tasks.length;
+            story.tasks = tasks.map((t) => t.id);
+            allTasks.push({ story, tasks });
+        }
+    }
+    // 5. Create directories
+    const dirs = ["epics", "features", "user-stories", "tasks"];
+    for (const d of dirs) {
+        await mkdir(join(processDir, d), { recursive: true });
+    }
+    // 6. Write files
+    const epicNum = epic.id.replace("EP-", "").padStart(3, "0");
+    const filesCreated = [];
+    // Epic
+    const epicPath = join(processDir, "epics", `EPIC-${epicNum}.md`);
+    await writeFile(epicPath, generateEpicMd(epic, features, processId), "utf-8");
+    filesCreated.push(`epics/EPIC-${epicNum}.md`);
+    // Features
+    for (const { feature, stories } of allStories) {
+        const featPath = join(processDir, "features", `${feature.id}.md`);
+        await writeFile(featPath, generateFeatureMd(feature, stories, epic, processId), "utf-8");
+        filesCreated.push(`features/${feature.id}.md`);
+    }
+    // User Stories
+    for (const { story, tasks } of allTasks) {
+        const usPath = join(processDir, "user-stories", `${story.id}.md`);
+        await writeFile(usPath, generateUserStoryMd(story, epic, tasks, processId), "utf-8");
+        filesCreated.push(`user-stories/${story.id}.md`);
+    }
+    // Tasks
+    for (const { tasks } of allTasks) {
+        for (const task of tasks) {
+            const taskPath = join(processDir, "tasks", `${task.id}.md`);
+            await writeFile(taskPath, generateTaskMd(task, processId), "utf-8");
+            filesCreated.push(`tasks/${task.id}.md`);
+        }
+    }
+    // 7. Summary
+    const totalFeats = features.length;
+    const totalUs = allStories.reduce((sum, s) => sum + s.stories.length, 0);
+    const totalTasks = allTasks.reduce((sum, t) => sum + t.tasks.length, 0);
+    const summary = [
+        `Decomposição do ${epic.id} — ${epic.title} concluída.`,
+        ``,
+        `Artefatos gerados:`,
+        `  • 1 épico detalhado (EPIC-${epicNum})`,
+        `  • ${totalFeats} features (${features.map((f) => f.id).join(", ")})`,
+        `  • ${totalUs} user stories`,
+        `  • ${totalTasks} tasks`,
+        ``,
+        `Arquivos criados (${filesCreated.length}):`,
+        ...filesCreated.map((f) => `  ${f}`),
+        ``,
+        `Diretório: ${processDir}`,
+    ].join("\n");
+    return summary;
+}

package/dist/tools/diagrams.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Geradores de Diagramas — CSS puro usando classes bd-* do _base-styles.css
+ * Gera diagramas visuais de workflow, arquitetura, dominios, riscos, integracoes e benchmark.
+ * IP protegido: os templates de diagrama nunca sao expostos ao cliente.
+ */
+interface FaseWorkflow {
+    name: string;
+    status: "concluido" | "ativo" | "pendente";
+    subtitle?: string;
+}
+export declare function renderWorkflowDiagram(phases: FaseWorkflow[]): string;
+export declare function renderArchitectureDiagram(): string;
+interface NoDominio {
+    name: string;
+    type: "core" | "supporting" | "generic";
+    squad: string;
+}
+export declare function renderDomainMap(domains: NoDominio[]): string;
+interface ItemRisco {
+    name: string;
+    probability: "baixa" | "media" | "alta";
+    impact: "baixo" | "medio" | "alto";
+    category?: string;
+}
+export declare function renderRiskMatrix(risks: ItemRisco[]): string;
+interface NoIntegracao {
+    name: string;
+    type: "interno" | "externo" | "gateway";
+    protocol?: string;
+}
+interface LinkIntegracao {
+    from: string;
+    to: string;
+    label?: string;
+    protocol?: string;
+}
+export declare function renderIntegrationFlow(nodes: NoIntegracao[], links: LinkIntegracao[]): string;
+interface Concorrente {
+    nome: string;
+    tipo: "banco" | "fintech" | "financeira" | "cooperativa" | "nosso";
+    indicadores: Record<string, number | string>;
+    destaque?: boolean;
+}
+interface DimensaoBenchmark {
+    nome: string;
+    chave: string;
+    unidade?: string;
+    maiorMelhor: boolean;
+}
+export declare function renderBenchmarkMercado(concorrentes: Concorrente[], dimensoes: DimensaoBenchmark[], titulo?: string, fontes?: string[]): string;
+export {};