@creative-ia/cortex 1.0.5

package/dist/tools/advance-process.js

@@ -0,0 +1,128 @@
+/**
+ * Tool: advance_process
+ * Orquestrador inteligente que detecta a fase atual do processo
+ * e avança para o próximo artefato automaticamente.
+ *
+ * Também expõe generate_features, generate_user_stories, generate_tasks
+ * como funções granulares reutilizáveis.
+ */
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { decomposeEpic } from "./decompose-epic.js";
+// ============================================================
+// PROCESS STATE DETECTOR
+// ============================================================
+async function detectProcessState(processDir) {
+    const state = {
+        hasStakeholder: false,
+        hasParecer: false,
+        hasEpicos: false,
+        epicIds: [],
+        decomposedEpics: [],
+        pendingEpics: [],
+        totalFeatures: 0,
+        totalUserStories: 0,
+        totalTasks: 0,
+    };
+    try {
+        const files = await readdir(processDir);
+        state.hasStakeholder = files.some((f) => f.startsWith("01-stakeholder"));
+        state.hasParecer = files.some((f) => f.startsWith("02-parecer"));
+        state.hasEpicos = files.some((f) => f.startsWith("03-epicos") && f.endsWith(".md"));
+        // Parse epic IDs from the epicos markdown
+        if (state.hasEpicos) {
+            const epicFile = files.find((f) => f.startsWith("03-epicos") && f.endsWith(".md"));
+            if (epicFile) {
+                const content = await readFile(join(processDir, epicFile), "utf-8");
+                const matches = content.match(/## EP-\d{2}/g) || [];
+                state.epicIds = matches.map((m) => m.replace("## ", ""));
+            }
+        }
+        // Check which epics have been decomposed
+        const epicsDir = join(processDir, "epics");
+        if (existsSync(epicsDir)) {
+            const epicFiles = await readdir(epicsDir);
+            state.decomposedEpics = epicFiles
+                .filter((f) => f.endsWith(".md"))
+                .map((f) => {
+                // EPIC-001.md → "001" → parseInt → 1 → "EP-01"
+                const num = parseInt(f.replace("EPIC-", "").replace(".md", ""), 10);
+                return `EP-${num.toString().padStart(2, "0")}`;
+            });
+        }
+        state.pendingEpics = state.epicIds.filter((ep) => !state.decomposedEpics.includes(ep));
+        // Count features, user stories, tasks
+        const featDir = join(processDir, "features");
+        if (existsSync(featDir)) {
+            state.totalFeatures = (await readdir(featDir)).filter((f) => f.endsWith(".md")).length;
+        }
+        const usDir = join(processDir, "user-stories");
+        if (existsSync(usDir)) {
+            state.totalUserStories = (await readdir(usDir)).filter((f) => f.endsWith(".md")).length;
+        }
+        const taskDir = join(processDir, "tasks");
+        if (existsSync(taskDir)) {
+            state.totalTasks = (await readdir(taskDir)).filter((f) => f.endsWith(".md")).length;
+        }
+    }
+    catch { /* ignore */ }
+    return state;
+}
+// ============================================================
+// ADVANCE PROCESS — main orchestrator
+// ============================================================
+export async function advanceProcess(params) {
+    const { processId, processDir, epicId } = params;
+    if (!existsSync(processDir)) {
+        return `Erro: Diretório do processo não encontrado: ${processDir}`;
+    }
+    const state = await detectProcessState(processDir);
+    // If no epicos markdown exists, can't advance
+    if (!state.hasEpicos) {
+        const missing = [];
+        if (!state.hasStakeholder)
+            missing.push("01-stakeholder");
+        if (!state.hasParecer)
+            missing.push("02-parecer");
+        if (!state.hasEpicos)
+            missing.push("03-epicos");
+        return [
+            `Processo ${processId} — Estado atual:`,
+            ``,
+            `Artefatos faltantes: ${missing.join(", ")}`,
+            ``,
+            `O processo precisa ter o markdown de épicos (03-epicos*.md) para avançar na decomposição.`,
+            `Use create_process ou gere o stakeholder/parecer/épicos primeiro.`,
+        ].join("\n");
+    }
+    // If specific epic requested, decompose it
+    if (epicId) {
+        if (state.decomposedEpics.includes(epicId)) {
+            return `${epicId} já foi decomposto. Use outro épico ou verifique os artefatos em epics/, features/, user-stories/, tasks/.`;
+        }
+        return await decomposeEpic({ processId, epicId, processDir });
+    }
+    // Auto-detect: decompose next pending epic
+    if (state.pendingEpics.length > 0) {
+        const nextEpic = state.pendingEpics[0];
+        const result = await decomposeEpic({ processId, epicId: nextEpic, processDir });
+        const remaining = state.pendingEpics.length - 1;
+        const footer = remaining > 0
+            ? `\n\nPróximos épicos pendentes (${remaining}): ${state.pendingEpics.slice(1).join(", ")}`
+            : `\n\nTodos os épicos foram decompostos.`;
+        return result + footer;
+    }
+    // All epics decomposed — show summary
+    return [
+        `Processo ${processId} — Decomposição completa.`,
+        ``,
+        `Épicos: ${state.epicIds.length} (todos decompostos)`,
+        `Features: ${state.totalFeatures}`,
+        `User Stories: ${state.totalUserStories}`,
+        `Tasks: ${state.totalTasks}`,
+        ``,
+        `Todos os épicos já foram decompostos em features, user stories e tasks.`,
+        `Próximo passo sugerido: gerar HTMLs via generate_report ou avançar para design/QA strategy.`,
+    ].join("\n");
+}

package/dist/tools/analyze-code.d.ts

@@ -0,0 +1,7 @@
+interface AnalyzeRequest {
+    code: string;
+    language?: string;
+    filename?: string;
+}
+export declare function analyzeCode(params: AnalyzeRequest): Promise<string>;
+export {};

package/dist/tools/analyze-code.js

@@ -0,0 +1,131 @@
+/**
+ * Tool: analyze_code
+ * Analisa um trecho de código contra os padrões L1-L4.
+ * Retorna violações encontradas com sugestões de correção.
+ */
+import { loadCodeStandards } from "../knowledge/loader.js";
+export async function analyzeCode(params) {
+    const standards = (await loadCodeStandards());
+    const lines = params.code.split("\n");
+    const violations = [];
+    const l1 = standards.levels?.L1_fundamentals?.rules || {};
+    // L1-001: File size
+    if (l1.file_size && lines.length > l1.file_size.max_lines) {
+        violations.push({
+            ruleId: "L1-001", rule: "File size",
+            severity: "error",
+            message: `File has ${lines.length} lines (max ${l1.file_size.max_lines})`,
+            suggestion: "Extract modules or helper classes to reduce file size.",
+        });
+    }
+    else if (l1.file_size && lines.length > l1.file_size.warn_at) {
+        violations.push({
+            ruleId: "L1-001", rule: "File size",
+            severity: "warning",
+            message: `File has ${lines.length} lines (warn at ${l1.file_size.warn_at})`,
+            suggestion: "Consider splitting before it grows further.",
+        });
+    }
+    // L1-003: Cyclomatic complexity (heuristic — count branching keywords)
+    const branchKeywords = /\b(if|else if|case|catch|&&|\|\||for|while|do)\b/g;
+    let fnStart = -1;
+    let fnName = "";
+    let branchCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fnMatch = line.match(/(?:function|const|let|var)\s+(\w+)|(\w+)\s*\(/);
+        if (fnMatch && (line.includes("function") || line.includes("=>"))) {
+            if (fnStart >= 0 && branchCount > (l1.cyclomatic_complexity?.max || 10)) {
+                violations.push({
+                    ruleId: "L1-003", rule: "Cyclomatic complexity",
+                    severity: "error",
+                    message: `Function '${fnName}' has complexity ~${branchCount} (max ${l1.cyclomatic_complexity?.max || 10})`,
+                    suggestion: "Use early returns, guard clauses, or strategy pattern.",
+                });
+            }
+            fnStart = i;
+            fnName = fnMatch[1] || fnMatch[2] || "anonymous";
+            branchCount = 1;
+        }
+        const matches = line.match(branchKeywords);
+        if (matches)
+            branchCount += matches.length;
+    }
+    // L1-005: Function params
+    const paramRegex = /(?:function\s+\w+|(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?)\s*\(([^)]*)\)/g;
+    let paramMatch;
+    while ((paramMatch = paramRegex.exec(params.code)) !== null) {
+        const paramList = paramMatch[1].split(",").filter((p) => p.trim());
+        if (paramList.length > (l1.function_params?.max || 4)) {
+            violations.push({
+                ruleId: "L1-005", rule: "Function params",
+                severity: "error",
+                message: `Function has ${paramList.length} params (max ${l1.function_params?.max || 4})`,
+                suggestion: "Group into a typed config object.",
+            });
+        }
+    }
+    // L1-006: Nesting depth
+    let maxDepth = 0;
+    let currentDepth = 0;
+    for (const line of lines) {
+        currentDepth += (line.match(/{/g) || []).length;
+        currentDepth -= (line.match(/}/g) || []).length;
+        if (currentDepth > maxDepth)
+            maxDepth = currentDepth;
+    }
+    if (maxDepth > (l1.nesting_depth?.max || 3) + 1) {
+        violations.push({
+            ruleId: "L1-006", rule: "Nesting depth",
+            severity: "error",
+            message: `Max nesting depth: ${maxDepth - 1} (max ${l1.nesting_depth?.max || 3})`,
+            suggestion: "Invert conditions, use early returns, extract functions.",
+        });
+    }
+    // L1-008: Magic numbers
+    const magicRegex = /(?<!=)\s(\d+)(?!\s*[;:}\])]|\s*\/\/)/g;
+    const allowed = new Set((l1.no_magic_numbers?.allowed || [0, 1, -1, 2, 100]).map(String));
+    let magicMatch;
+    while ((magicMatch = magicRegex.exec(params.code)) !== null) {
+        if (!allowed.has(magicMatch[1]) && !magicMatch[1].startsWith("0x")) {
+            violations.push({
+                ruleId: "L1-008", rule: "Magic number",
+                severity: "warning",
+                message: `Magic number '${magicMatch[1]}' found. Extract to named constant.`,
+                suggestion: `const MEANINGFUL_NAME = ${magicMatch[1]};`,
+            });
+            break; // Report only first occurrence
+        }
+    }
+    // L1-009: Commented code
+    const commentedCodeRegex = /^\s*\/\/\s*(const|let|var|function|if|for|while|return|import|export)\b/;
+    for (let i = 0; i < lines.length; i++) {
+        if (commentedCodeRegex.test(lines[i])) {
+            violations.push({
+                ruleId: "L1-009", rule: "Commented code",
+                severity: "warning",
+                message: `Line ${i + 1}: Commented-out code detected.`,
+                suggestion: "Remove dead code. Use git history to recover if needed.",
+            });
+            break;
+        }
+    }
+    // Format output
+    if (violations.length === 0) {
+        return "No violations found. Code complies with L1-L4 standards.";
+    }
+    const errors = violations.filter((v) => v.severity === "error");
+    const warnings = violations.filter((v) => v.severity === "warning");
+    const out = [
+        `## Analysis Result: ${violations.length} issue(s) found`,
+        `Errors: ${errors.length} | Warnings: ${warnings.length}`,
+        "",
+    ];
+    for (const v of violations) {
+        out.push(`[${v.severity.toUpperCase()}] ${v.ruleId} — ${v.rule}`);
+        out.push(`  ${v.message}`);
+        out.push(`  Fix: ${v.suggestion}`);
+        out.push("");
+    }
+    return out.join("\n");
+}

package/dist/tools/analyze-docs.d.ts

@@ -0,0 +1,8 @@
+interface AnalyzeDocsRequest {
+    docsDir: string;
+    processId?: string;
+    processDir?: string;
+    maxFiles?: number;
+}
+export declare function analyzeDocs(params: AnalyzeDocsRequest): Promise<string>;
+export {};

package/dist/tools/analyze-docs.js

@@ -0,0 +1,147 @@
+/**
+ * Tool #24: analyze_docs
+ *
+ * Analisa um diretorio de documentacao, extrai texto de todos os arquivos
+ * suportados (PDF, DOCX, PPTX, XLSX, MD, TXT, JSON, YAML, HTML) e gera
+ * um resumo estruturado com requisitos, regras de negocio, endpoints,
+ * entidades e fluxos identificados.
+ *
+ * Usa officeparser para PDF/DOCX/PPTX/XLSX (zero dependencias externas).
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, extname } from "node:path";
+import { parseOffice } from "officeparser";
+// Extensoes suportadas
+const TEXT_EXTS = new Set([".md", ".txt", ".json", ".yaml", ".yml", ".html", ".htm", ".xml", ".csv", ".swagger", ".openapi", ".graphql", ".gql", ".proto", ".sql", ".env", ".cfg", ".ini", ".toml"]);
+const OFFICE_EXTS = new Set([".pdf", ".docx", ".pptx", ".xlsx", ".odt", ".odp", ".ods"]);
+const ALL_EXTS = new Set([...TEXT_EXTS, ...OFFICE_EXTS]);
+const MAX_TEXT_PER_FILE = 50_000; // 50KB de texto por arquivo
+const DEFAULT_MAX_FILES = 50;
+/**
+ * Le todos os arquivos suportados de um diretorio (recursivo, max depth 3).
+ */
+async function readDocsDir(dir, maxFiles, depth = 0) {
+    if (depth > 3)
+        return [];
+    const docs = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (docs.length >= maxFiles)
+            break;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+            const sub = await readDocsDir(fullPath, maxFiles - docs.length, depth + 1);
+            docs.push(...sub);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const ext = extname(entry.name).toLowerCase();
+        if (!ALL_EXTS.has(ext))
+            continue;
+        try {
+            const fileStat = await stat(fullPath);
+            // Pular arquivos > 10MB
+            if (fileStat.size > 10 * 1024 * 1024)
+                continue;
+            let text = "";
+            let truncated = false;
+            if (TEXT_EXTS.has(ext)) {
+                text = await readFile(fullPath, "utf-8");
+            }
+            else if (OFFICE_EXTS.has(ext)) {
+                const parsed = await parseOffice(fullPath);
+                text = typeof parsed === "string" ? parsed : String(parsed);
+            }
+            if (text.length > MAX_TEXT_PER_FILE) {
+                text = text.slice(0, MAX_TEXT_PER_FILE);
+                truncated = true;
+            }
+            if (text.trim().length > 0) {
+                docs.push({
+                    name: entry.name,
+                    ext,
+                    size: fileStat.size,
+                    text: text.trim(),
+                    truncated,
+                });
+            }
+        }
+        catch {
+            // Pular arquivos que nao conseguimos ler
+        }
+    }
+    return docs;
+}
+/**
+ * Gera resumo estruturado dos documentos analisados.
+ */
+function generateSummary(docs, docsDir) {
+    const lines = [];
+    lines.push(`# Analise de Documentacao`);
+    lines.push(``);
+    lines.push(`**Diretorio:** ${docsDir}`);
+    lines.push(`**Arquivos analisados:** ${docs.length}`);
+    lines.push(``);
+    // Tabela de arquivos
+    lines.push(`## Arquivos Encontrados`);
+    lines.push(``);
+    lines.push(`| Arquivo | Formato | Tamanho | Caracteres |`);
+    lines.push(`|---------|---------|---------|------------|`);
+    for (const doc of docs) {
+        const sizeKB = (doc.size / 1024).toFixed(1);
+        const chars = doc.text.length.toLocaleString();
+        const trunc = doc.truncated ? " (truncado)" : "";
+        lines.push(`| ${doc.name} | ${doc.ext} | ${sizeKB} KB | ${chars}${trunc} |`);
+    }
+    lines.push(``);
+    // Conteudo de cada arquivo
+    lines.push(`## Conteudo Extraido`);
+    lines.push(``);
+    for (const doc of docs) {
+        lines.push(`### ${doc.name}`);
+        lines.push(``);
+        lines.push("```");
+        lines.push(doc.text);
+        lines.push("```");
+        lines.push(``);
+    }
+    return lines.join("\n");
+}
+export async function analyzeDocs(params) {
+    const { docsDir, processId, processDir, maxFiles } = params;
+    const limit = maxFiles || DEFAULT_MAX_FILES;
+    // Verificar se o diretorio existe
+    try {
+        const dirStat = await stat(docsDir);
+        if (!dirStat.isDirectory()) {
+            return `Erro: '${docsDir}' nao e um diretorio.`;
+        }
+    }
+    catch {
+        return `Erro: Diretorio '${docsDir}' nao encontrado.`;
+    }
+    // Ler documentos
+    const docs = await readDocsDir(docsDir, limit);
+    if (docs.length === 0) {
+        return `Nenhum arquivo suportado encontrado em '${docsDir}'.\n\nFormatos suportados: ${[...ALL_EXTS].join(", ")}`;
+    }
+    // Gerar resumo
+    const summary = generateSummary(docs, docsDir);
+    // Se tem processDir, salvar o artefato
+    if (processDir) {
+        const { writeFile, mkdir } = await import("node:fs/promises");
+        const outputDir = processDir;
+        await mkdir(outputDir, { recursive: true });
+        const outputFile = join(outputDir, "analise-documentacao.md");
+        await writeFile(outputFile, summary, "utf-8");
+        return summary + `\n\n---\nArtefato salvo em: ${outputFile}`;
+    }
+    return summary;
+}

package/dist/tools/config-registry.d.ts

@@ -0,0 +1,3 @@
+export declare function getConfig(params: {
+    key?: string;
+}): Promise<string>;

package/dist/tools/config-registry.js

@@ -0,0 +1,20 @@
+/**
+ * Tool MCP: get_config — Lê configuração do MCP Server via SSM Parameter Store.
+ */
+import { getParam, getAllParams } from "../config/ssm-store.js";
+export async function getConfig(params) {
+    if (params.key) {
+        const value = await getParam(params.key);
+        if (!value)
+            return `❌ Parâmetro não encontrado: ${params.key}`;
+        return `**${params.key}**: ${value}`;
+    }
+    const all = await getAllParams();
+    if (Object.keys(all).length === 0)
+        return "Nenhum parâmetro configurado.";
+    const lines = ["## MCP Server Config (SSM)\n"];
+    for (const [k, v] of Object.entries(all)) {
+        lines.push(`- **${k}**: ${v}`);
+    }
+    return lines.join("\n");
+}

package/dist/tools/create-process.d.ts

@@ -0,0 +1,6 @@
+interface CreateProcessRequest {
+    prompt: string;
+    stakeholder?: string;
+}
+export declare function createProcess(params: CreateProcessRequest): Promise<string>;
+export {};