@creative-ia/cortex 1.0.5

package/dist/index.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+/**
+ * Creative IA 50 — MCP Server
+ *
+ * Expõe skills, knowledge e code standards como tools MCP protegidas.
+ * O conteúdo intelectual (skills, knowledge) NUNCA é exposto diretamente.
+ * Clientes recebem apenas respostas processadas pelas tools.
+ *
+ * License validation via DynamoDB (LocalStack ou AWS).
+ * Knowledge storage via S3 (LocalStack ou AWS).
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { validateLicense, canAccessDomain } from "./config/license.js";
+import { isCloudProxyEnabled, callCloudTool } from "./config/cloud-proxy.js";
+import { withTelemetry, reportTelemetry } from "./config/telemetry.js";
+import { getCodeStandards } from "./tools/get-code-standards.js";
+import { analyzeCode } from "./tools/analyze-code.js";
+import { getArchitectureGuidance } from "./tools/get-architecture.js";
+import { initProcess } from "./tools/init-process.js";
+import { validateProcess } from "./tools/validate-process.js";
+import { validateIdea } from "./tools/validate-idea.js";
+import { generateReport } from "./tools/generate-report.js";
+import { saveKnowledge, getKnowledge, searchKnowledge, deleteKnowledgeEntry, listDomains, } from "./tools/knowledge-crud.js";
+import { getConfig } from "./tools/config-registry.js";
+import { logEvent, searchLogs, insightsQuery } from "./tools/logs-query.js";
+import { semanticSearch } from "./tools/semantic-search.js";
+import { createProcess } from "./tools/create-process.js";
+import { updateProcess } from "./tools/update-process.js";
+import { decomposeEpic } from "./tools/decompose-epic.js";
+import { advanceProcess } from "./tools/advance-process.js";
+import { generateWiki } from "./tools/generate-wiki.js";
+import { reverseEngineer } from "./tools/reverse-engineer.js";
+import { analyzeDocs } from "./tools/analyze-docs.js";
+const CLOUD_MODE = isCloudProxyEnabled();
+const server = new McpServer({
+    name: "creative-ia50",
+    version: "1.0.0",
+});
+// --- Helper: license gate ---
+async function licenseGate(licenseKey, toolName) {
+    const check = await validateLicense(licenseKey, toolName);
+    if (!check.valid)
+        return { denied: `Access denied: ${check.reason}` };
+    return { license: check.license };
+}
+// --- Helper: cloud proxy wrapper ---
+// Quando CLOUD_MODE esta ativo, delega a tool para o endpoint nuvem via HTTPS.
+// Elimina necessidade de credenciais AWS no cliente.
+function cloudResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+async function proxyToCloud(toolName, args) {
+    const start = Date.now();
+    try {
+        const text = await callCloudTool(toolName, args);
+        const durationMs = Date.now() - start;
+        reportTelemetry({ tool: toolName, status: "success", durationMs, summary: `cloud proxy` });
+        return cloudResult(text);
+    }
+    catch (err) {
+        const durationMs = Date.now() - start;
+        reportTelemetry({ tool: toolName, status: "error", durationMs, error: err.message });
+        return cloudResult(`Error: ${err.message}`);
+    }
+}
+// Lista de tools que dependem de AWS e devem ser proxied quando em CLOUD_MODE
+const CLOUD_TOOLS = new Set([
+    "get_code_standards", "analyze_code", "get_architecture_guidance",
+    "validate_idea", "init_process", "validate_process",
+    "save_knowledge", "get_knowledge", "search_knowledge",
+    "delete_knowledge", "list_knowledge_domains",
+    "get_config", "log_event", "search_logs", "insights_query",
+    "semantic_search", "update_process",
+]);
+// --- Tool: get_code_standards ---
+server.tool("get_code_standards", "Returns code standards rules (L1-L4) for the requested level, language, or specific rule ID.", {
+    licenseKey: z.string().describe("Client license key"),
+    level: z.string().optional().describe("L1, L2, L3, L4, or all"),
+    language: z.string().optional().describe("typescript, java, or all"),
+    ruleId: z.string().optional().describe("Specific rule ID (e.g. L1-001)"),
+}, async ({ licenseKey, level, language, ruleId }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("get_code_standards", { licenseKey, level, language, ruleId });
+    const gate = await licenseGate(licenseKey, "get_code_standards");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await getCodeStandards({ level, language, ruleId });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: analyze_code ---
+server.tool("analyze_code", "Analyzes code against L1-L4 standards. Returns violations with fix suggestions.", {
+    licenseKey: z.string().describe("Client license key"),
+    code: z.string().describe("Source code to analyze"),
+    language: z.string().optional().describe("typescript or java"),
+    filename: z.string().optional().describe("Filename for context"),
+}, async ({ licenseKey, code, language, filename }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("analyze_code", { licenseKey, code, language, filename });
+    const gate = await licenseGate(licenseKey, "analyze_code");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await analyzeCode({ code, language, filename });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: get_architecture_guidance ---
+server.tool("get_architecture_guidance", "Returns architecture guidance for a specific stack (BFF, Backend, Frontend).", {
+    licenseKey: z.string().describe("Client license key"),
+    stack: z.string().describe("bff, backend, or frontend"),
+    topic: z.string().optional().describe("layers, folders, errors, api, di, or all"),
+}, async ({ licenseKey, stack, topic }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("get_architecture_guidance", { licenseKey, stack, topic });
+    const gate = await licenseGate(licenseKey, "get_architecture_guidance");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await getArchitectureGuidance({ stack, topic });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: init_process ---
+server.tool("init_process", "Initializes a new process with UUID, checklist, and mandatory workflow.", {
+    licenseKey: z.string().describe("Client license key"),
+    title: z.string().describe("Process title"),
+    stakeholder: z.string().optional().describe("Stakeholder name"),
+    description: z.string().optional().describe("Process description"),
+}, async ({ licenseKey, title, stakeholder, description }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("init_process", { licenseKey, title, stakeholder, description });
+    const gate = await licenseGate(licenseKey, "init_process");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await initProcess({ title, stakeholder, description });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: validate_process ---
+server.tool("validate_process", "Validates if a process follows the mandatory workflow and has all required artifacts.", {
+    licenseKey: z.string().describe("Client license key"),
+    processId: z.string().describe("Process UUID"),
+    artifacts: z.array(z.string()).describe("List of artifact filenames in the process"),
+}, async ({ licenseKey, processId, artifacts }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("validate_process", { licenseKey, processId, artifacts });
+    const gate = await licenseGate(licenseKey, "validate_process");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await validateProcess({ processId, artifacts });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: validate_idea ---
+server.tool("validate_idea", "Analyzes a business idea against the company knowledge base (domains, integrations, architecture, past processes) and returns a feasibility report. The knowledge base is never exposed — only the processed analysis is returned.", {
+    licenseKey: z.string().describe("Client license key"),
+    idea: z.string().describe("Business idea in natural language (e.g. 'Preciso construir uma jornada de Credito Consignado INSS no app')"),
+    context: z.string().optional().describe("Additional context about the idea"),
+}, async ({ licenseKey, idea, context }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("validate_idea", { licenseKey, idea, context });
+    const gate = await licenseGate(licenseKey, "validate_idea");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await validateIdea({ idea, context });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: generate_report ---
+server.tool("generate_report", "Generates a branded HTML report on the client machine from processed content. The HTML template is proprietary (never exposed as source). Output goes to ~/creative-reports/ or a custom directory.", {
+    licenseKey: z.string().describe("Client license key"),
+    title: z.string().describe("Report title"),
+    content: z.string().describe("Report content (output from other tools like validate_idea)"),
+    reportType: z.string().describe("Report type: feasibility, analysis, architecture, process"),
+    outputDir: z.string().optional().describe("Custom output directory (default: ~/creative-reports/)"),
+}, async ({ licenseKey, title, content, reportType, outputDir }) => {
+    const gate = await licenseGate(licenseKey, "generate_report");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await withTelemetry("generate_report", () => generateReport({ title, content, reportType, outputDir }), (r) => `report=${reportType} title=${title.slice(0, 50)}`, { reportType });
+    return { content: [{ type: "text", text: result }] };
+});
+// =============================================================================
+// Knowledge CRUD Tools — Memória organizacional persistente via DynamoDB
+// =============================================================================
+// --- Tool: save_knowledge ---
+server.tool("save_knowledge", "Salva ou atualiza um registro de conhecimento organizacional no DynamoDB. Domains: decisions, changelog, troubleshooting, glossary, integrations, lessons-learned, pending, ports, stakeholders, environments.", {
+    licenseKey: z.string().describe("Client license key"),
+    domain: z.string().describe("Knowledge domain (decisions, changelog, troubleshooting, glossary, integrations, lessons-learned, pending, ports, stakeholders, environments)"),
+    id: z.string().describe("Unique ID within domain (e.g. ADR-001, TASK-030, TS-005)"),
+    title: z.string().describe("Entry title"),
+    content: z.string().describe("Entry content (markdown)"),
+    tags: z.array(z.string()).optional().describe("Tags for search/filtering"),
+    metadata: z.record(z.unknown()).optional().describe("Additional structured metadata"),
+}, async ({ licenseKey, domain, id, title, content, tags, metadata }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("save_knowledge", { licenseKey, domain, id, title, content, tags, metadata });
+    const gate = await licenseGate(licenseKey, "save_knowledge");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    if (!canAccessDomain(gate.license, domain))
+        return { content: [{ type: "text", text: `Access denied: domain '${domain}' not allowed for this license` }] };
+    const result = await saveKnowledge({ domain, id, title, content, tags, metadata });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: get_knowledge ---
+server.tool("get_knowledge", "Recupera conhecimento organizacional. Sem ID retorna todos os registros do domain.", {
+    licenseKey: z.string().describe("Client license key"),
+    domain: z.string().describe("Knowledge domain"),
+    id: z.string().optional().describe("Specific entry ID (omit to list all in domain)"),
+    limit: z.number().optional().describe("Max entries to return (default 50)"),
+}, async ({ licenseKey, domain, id, limit }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("get_knowledge", { licenseKey, domain, id, limit });
+    const gate = await licenseGate(licenseKey, "get_knowledge");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    if (!canAccessDomain(gate.license, domain))
+        return { content: [{ type: "text", text: `Access denied: domain '${domain}' not allowed for this license` }] };
+    const result = await getKnowledge({ domain, id, limit });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: search_knowledge ---
+server.tool("search_knowledge", "Busca textual no conhecimento organizacional. Busca em título, conteúdo e tags.", {
+    licenseKey: z.string().describe("Client license key"),
+    query: z.string().describe("Search text"),
+    domain: z.string().optional().describe("Limit search to specific domain"),
+    tag: z.string().optional().describe("Search by tag (uses GSI)"),
+    limit: z.number().optional().describe("Max results (default 20)"),
+}, async ({ licenseKey, query, domain, tag, limit }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("search_knowledge", { licenseKey, query, domain, tag, limit });
+    const gate = await licenseGate(licenseKey, "search_knowledge");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    if (domain && !canAccessDomain(gate.license, domain))
+        return { content: [{ type: "text", text: `Access denied: domain '${domain}' not allowed for this license` }] };
+    const result = await searchKnowledge({ query, domain, tag, limit, license: gate.license });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: delete_knowledge ---
+server.tool("delete_knowledge", "Remove um registro de conhecimento organizacional.", {
+    licenseKey: z.string().describe("Client license key"),
+    domain: z.string().describe("Knowledge domain"),
+    id: z.string().describe("Entry ID to delete"),
+}, async ({ licenseKey, domain, id }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("delete_knowledge", { licenseKey, domain, id });
+    const gate = await licenseGate(licenseKey, "delete_knowledge");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    if (!canAccessDomain(gate.license, domain))
+        return { content: [{ type: "text", text: `Access denied: domain '${domain}' not allowed for this license` }] };
+    const result = await deleteKnowledgeEntry({ domain, id });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: list_knowledge_domains ---
+server.tool("list_knowledge_domains", "Lista todos os domains de conhecimento e quantidade de registros em cada um.", {
+    licenseKey: z.string().describe("Client license key"),
+}, async ({ licenseKey }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("list_knowledge_domains", { licenseKey });
+    const gate = await licenseGate(licenseKey, "list_knowledge_domains");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await listDomains(gate.license);
+    return { content: [{ type: "text", text: result }] };
+});
+// =============================================================================
+// Fase 3 — SSM Config Registry + CloudWatch Logs
+// =============================================================================
+// --- Tool: get_config ---
+server.tool("get_config", "Lê configuração do MCP Server via SSM Parameter Store. Sem key retorna todas as configs.", {
+    licenseKey: z.string().describe("Client license key"),
+    key: z.string().optional().describe("Config key (e.g. 'version', 'features'). Omit to list all."),
+}, async ({ licenseKey, key }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("get_config", { licenseKey, key });
+    const gate = await licenseGate(licenseKey, "get_config");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await getConfig({ key });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: log_event ---
+server.tool("log_event", "Registra um evento de log no CloudWatch Logs do MCP Server.", {
+    licenseKey: z.string().describe("Client license key"),
+    level: z.string().describe("Log level: info, warn, error, debug"),
+    message: z.string().describe("Log message"),
+    meta: z.record(z.unknown()).optional().describe("Additional metadata"),
+}, async ({ licenseKey, level, message, meta }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("log_event", { licenseKey, level, message, meta });
+    const gate = await licenseGate(licenseKey, "log_event");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await logEvent({ level, message, meta });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: search_logs ---
+server.tool("search_logs", "Busca logs no CloudWatch por pattern. Default: últimas 24h.", {
+    licenseKey: z.string().describe("Client license key"),
+    pattern: z.string().optional().describe("Filter pattern (CloudWatch syntax)"),
+    hours: z.number().optional().describe("Hours to look back (default: 24)"),
+    limit: z.number().optional().describe("Max results (default: 50)"),
+}, async ({ licenseKey, pattern, hours, limit }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("search_logs", { licenseKey, pattern, hours, limit });
+    const gate = await licenseGate(licenseKey, "search_logs");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await searchLogs({ pattern, hours, limit });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: insights_query ---
+server.tool("insights_query", "Executa uma query CloudWatch Insights nos logs do MCP Server.", {
+    licenseKey: z.string().describe("Client license key"),
+    query: z.string().describe("CloudWatch Insights query (e.g. 'fields @timestamp, @message | filter level = \"error\"')"),
+    hours: z.number().optional().describe("Hours to look back (default: 24)"),
+    limit: z.number().optional().describe("Max results (default: 50)"),
+}, async ({ licenseKey, query, hours, limit }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("insights_query", { licenseKey, query, hours, limit });
+    const gate = await licenseGate(licenseKey, "insights_query");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await insightsQuery({ query, hours, limit });
+    return { content: [{ type: "text", text: result }] };
+});
+// =============================================================================
+// Fase 4 — Semantic Search via Bedrock Embeddings
+// =============================================================================
+// --- Tool: semantic_search ---
+server.tool("semantic_search", "Busca semântica no knowledge base usando Bedrock Titan Embeddings. Encontra registros por significado, não apenas texto exato.", {
+    licenseKey: z.string().describe("Client license key"),
+    query: z.string().describe("Natural language search query"),
+    domain: z.string().optional().describe("Limit to specific domain (omit to search all)"),
+    limit: z.number().optional().describe("Max results (default: 5)"),
+}, async ({ licenseKey, query, domain, limit }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("semantic_search", { licenseKey, query, domain, limit });
+    const gate = await licenseGate(licenseKey, "semantic_search");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    if (domain && !canAccessDomain(gate.license, domain))
+        return { content: [{ type: "text", text: `Access denied: domain '${domain}' not allowed for this license` }] };
+    const result = await semanticSearch({ query, domain, limit, license: gate.license });
+    return { content: [{ type: "text", text: result }] };
+});
+// =============================================================================
+// Fase 5 — Process Lifecycle + Wiki + Reverse Engineer (filesystem tools)
+// =============================================================================
+// --- Tool: create_process ---
+server.tool("create_process", "Cria esqueleto de processo: recebe frase em linguagem natural, inicializa no DynamoDB e retorna arquivos locais (README, 01-stakeholder, knowledge.json, orchestration.json).", {
+    licenseKey: z.string().describe("Client license key"),
+    prompt: z.string().describe("Frase em linguagem natural descrevendo o processo"),
+    stakeholder: z.string().optional().describe("Nome do stakeholder ou squad"),
+}, async ({ licenseKey, prompt, stakeholder }) => {
+    const gate = await licenseGate(licenseKey, "create_process");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await withTelemetry("create_process", () => createProcess({ prompt, stakeholder }), (r) => `prompt=${prompt.slice(0, 80)}`, { stakeholder });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: update_process ---
+server.tool("update_process", "Acrescenta informações a um processo existente (tech stack, decisões, status de fases, notas).", {
+    licenseKey: z.string().describe("Client license key"),
+    processId: z.string().describe("UUID do processo (ex: 'ddb8715d')"),
+    updates: z.object({
+        tech_stack: z.record(z.string()).optional().describe("Mapa chave-valor do tech stack"),
+        decisions: z.array(z.object({
+            title: z.string().describe("Título da decisão"),
+            decision: z.string().describe("Decisão tomada"),
+            rationale: z.string().optional().describe("Justificativa"),
+        })).optional().describe("Novas decisões técnicas a adicionar"),
+        phase_status: z.record(z.string()).optional().describe("Atualização de status de fases"),
+        notes: z.string().optional().describe("Nota ou observação a adicionar"),
+        stakeholder: z.string().optional().describe("Atualizar stakeholder"),
+    }).describe("Objeto com as atualizações a aplicar"),
+    listProcesses: z.boolean().optional().describe("Se true, lista processos acessíveis"),
+}, async ({ licenseKey, processId, updates, listProcesses }) => {
+    if (CLOUD_MODE)
+        return proxyToCloud("update_process", { licenseKey, processId, updates, listProcesses });
+    const gate = await licenseGate(licenseKey, "update_process");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await updateProcess({ processId, updates, listProcesses });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: decompose_epic ---
+server.tool("decompose_epic", "Decompõe um épico (EP-XX) em artefatos completos: EPIC.md + Features + User Stories + Tasks.", {
+    licenseKey: z.string().describe("Client license key"),
+    processId: z.string().describe("UUID do processo (ex: '5b650020')"),
+    epicId: z.string().describe("ID do épico a decompor (ex: 'EP-01', 'EP-02')"),
+    processDir: z.string().describe("Caminho absoluto do diretório do processo"),
+}, async ({ licenseKey, processId, epicId, processDir }) => {
+    const gate = await licenseGate(licenseKey, "decompose_epic");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await withTelemetry("decompose_epic", () => decomposeEpic({ processId, epicId, processDir }), (r) => `process=${processId} epic=${epicId}`, { processId, epicId });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: advance_process ---
+server.tool("advance_process", "Orquestrador inteligente: detecta a fase atual do processo e avança para o próximo artefato.", {
+    licenseKey: z.string().describe("Client license key"),
+    processId: z.string().describe("UUID do processo (ex: '5b650020')"),
+    processDir: z.string().describe("Caminho absoluto do diretório do processo"),
+    epicId: z.string().optional().describe("ID do épico específico (ex: 'EP-01')"),
+}, async ({ licenseKey, processId, processDir, epicId }) => {
+    const gate = await licenseGate(licenseKey, "advance_process");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await withTelemetry("advance_process", () => advanceProcess({ processId, processDir, epicId }), (r) => `process=${processId}${epicId ? ` epic=${epicId}` : ""}`, { processId, epicId });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Tool: generate_wiki ---
+server.tool("generate_wiki", "Gera/atualiza wiki navegável do processo: index.html, pages/, styles.css, loader.js e server.cjs.", {
+    licenseKey: z.string().describe("Client license key"),
+    processId: z.string().describe("UUID do processo (ex: '5b650020')"),
+    processDir: z.string().describe("Caminho absoluto do diretório do processo"),
+}, async ({ licenseKey, processId, processDir }) => {
+    const gate = await licenseGate(licenseKey, "generate_wiki");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await withTelemetry("generate_wiki", () => generateWiki({ processId, processDir }), (r) => `process=${processId}`, { processId });
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+// --- Tool: reverse_engineer ---
+server.tool("reverse_engineer", "Analisa repositório local ou remoto (Git URL) e gera artefato .md de engenharia reversa: stack, módulos, dependências, APIs, padrões de arquitetura e métricas. Para repos remotos, configure tokens nas env vars do mcp.json (GITHUB_TOKEN, GITLAB_TOKEN, BITBUCKET_TOKEN, AZURE_DEVOPS_TOKEN).", {
+    licenseKey: z.string().describe("Client license key"),
+    repoDir: z.string().describe("Caminho absoluto do repositório local OU URL Git remota (https://github.com/org/repo.git)"),
+    processId: z.string().optional().describe("UUID do processo (se vinculado a um processo existente)"),
+    processDir: z.string().optional().describe("Caminho absoluto do diretório do processo"),
+    outputFilename: z.string().optional().describe("Nome do arquivo de saída (default: engenharia-reversa-{repo}.md)"),
+}, async ({ licenseKey, repoDir, processId, processDir, outputFilename }) => {
+    const gate = await licenseGate(licenseKey, "reverse_engineer");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await withTelemetry("reverse_engineer", () => reverseEngineer({ repoDir, processId, processDir, outputFilename }), (r) => `repo=${repoDir.split("/").pop() || repoDir}`, { repoDir, processId });
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+// --- Tool: analyze_docs ---
+server.tool("analyze_docs", "Analisa um diretório de documentação, extrai texto de todos os arquivos suportados (PDF, DOCX, PPTX, XLSX, MD, TXT, JSON, YAML, HTML) e gera um resumo estruturado com o conteúdo extraído. Útil para alimentar processos de arquitetura a partir de documentação existente.", {
+    licenseKey: z.string().describe("Client license key"),
+    docsDir: z.string().describe("Caminho absoluto do diretório com os documentos"),
+    processId: z.string().optional().describe("UUID do processo (se vinculado a um processo existente)"),
+    processDir: z.string().optional().describe("Caminho absoluto do diretório do processo (para salvar o artefato)"),
+    maxFiles: z.number().optional().describe("Máximo de arquivos a analisar (default: 50)"),
+}, async ({ licenseKey, docsDir, processId, processDir, maxFiles }) => {
+    const gate = await licenseGate(licenseKey, "analyze_docs");
+    if ("denied" in gate)
+        return { content: [{ type: "text", text: gate.denied }] };
+    const result = await withTelemetry("analyze_docs", () => analyzeDocs({ docsDir, processId, processDir, maxFiles }), (r) => `dir=${docsDir.split("/").pop() || docsDir}`, { docsDir, processId });
+    return { content: [{ type: "text", text: result }] };
+});
+// --- Start server ---
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Creative IA 50 MCP Server running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/knowledge/dynamo-store.d.ts

@@ -0,0 +1,17 @@
+export interface KnowledgeEntry {
+    domain: string;
+    id: string;
+    title: string;
+    content: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export declare function putEntry(entry: KnowledgeEntry): Promise<void>;
+export declare function getEntry(domain: string, id: string): Promise<KnowledgeEntry | null>;
+export declare function queryByDomain(domain: string, limit?: number): Promise<KnowledgeEntry[]>;
+export declare function searchByTag(tag: string, limit?: number): Promise<KnowledgeEntry[]>;
+export declare function searchByText(domain: string, text: string, limit?: number): Promise<KnowledgeEntry[]>;
+export declare function deleteEntry(domain: string, id: string): Promise<void>;
+export declare function countByDomain(domain: string): Promise<number>;

package/dist/knowledge/dynamo-store.js

@@ -0,0 +1,85 @@
+/**
+ * Knowledge DynamoDB Store — CRUD de conhecimento organizacional.
+ *
+ * Tabela: creative-ia50-knowledge
+ * PK: domain (ex: "decisions", "changelog", "troubleshooting", "glossary")
+ * SK: id (ex: "ADR-001", "TASK-030", "TS-005", "TERM-001")
+ *
+ * Suporta LocalStack e AWS real via USE_LOCALSTACK env var.
+ */
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, PutCommand, GetCommand, QueryCommand, DeleteCommand, } from "@aws-sdk/lib-dynamodb";
+const isLocal = process.env.USE_LOCALSTACK === "true";
+const ddb = DynamoDBDocumentClient.from(new DynamoDBClient({
+    region: process.env.AWS_REGION || "sa-east-1",
+    ...(isLocal && {
+        endpoint: "http://localhost:4566",
+        credentials: { accessKeyId: "test", secretAccessKey: "test" },
+    }),
+}));
+const TABLE = process.env.KNOWLEDGE_TABLE || "creative-ia50-knowledge";
+// --- PUT (create or update) ---
+export async function putEntry(entry) {
+    await ddb.send(new PutCommand({
+        TableName: TABLE,
+        Item: {
+            ...entry,
+            primary_tag: entry.tags?.[0] || "untagged",
+            updated_at: new Date().toISOString(),
+        },
+    }));
+}
+// --- GET single entry ---
+export async function getEntry(domain, id) {
+    const res = await ddb.send(new GetCommand({ TableName: TABLE, Key: { domain, id } }));
+    return res.Item || null;
+}
+// --- QUERY by domain (list all entries in a domain) ---
+export async function queryByDomain(domain, limit) {
+    const res = await ddb.send(new QueryCommand({
+        TableName: TABLE,
+        KeyConditionExpression: "#d = :domain",
+        ExpressionAttributeNames: { "#d": "domain" },
+        ExpressionAttributeValues: { ":domain": domain },
+        ScanIndexForward: false,
+        ...(limit && { Limit: limit }),
+    }));
+    return res.Items || [];
+}
+// --- SEARCH by tag (uses GSI tag-index) ---
+export async function searchByTag(tag, limit) {
+    // Scan with filter — for small datasets this is fine.
+    // For large scale, use a GSI on tags (flattened).
+    const res = await ddb.send(new QueryCommand({
+        TableName: TABLE,
+        IndexName: "tag-index",
+        KeyConditionExpression: "primary_tag = :tag",
+        ExpressionAttributeValues: { ":tag": tag },
+        ...(limit && { Limit: limit }),
+    }));
+    return res.Items || [];
+}
+// --- SEARCH by text (simple contains on title + content) ---
+export async function searchByText(domain, text, limit) {
+    const all = await queryByDomain(domain, 500);
+    const lower = text.toLowerCase();
+    const filtered = all.filter((e) => e.title.toLowerCase().includes(lower) ||
+        e.content.toLowerCase().includes(lower) ||
+        (e.tags && e.tags.some((t) => t.toLowerCase().includes(lower))));
+    return limit ? filtered.slice(0, limit) : filtered;
+}
+// --- DELETE ---
+export async function deleteEntry(domain, id) {
+    await ddb.send(new DeleteCommand({ TableName: TABLE, Key: { domain, id } }));
+}
+// --- COUNT entries in a domain ---
+export async function countByDomain(domain) {
+    const res = await ddb.send(new QueryCommand({
+        TableName: TABLE,
+        KeyConditionExpression: "#d = :domain",
+        ExpressionAttributeNames: { "#d": "domain" },
+        ExpressionAttributeValues: { ":domain": domain },
+        Select: "COUNT",
+    }));
+    return res.Count || 0;
+}

package/dist/knowledge/embeddings.d.ts

@@ -0,0 +1,2 @@
+export declare function getEmbedding(text: string): Promise<number[]>;
+export declare function cosineSimilarity(a: number[], b: number[]): number;

package/dist/knowledge/embeddings.js

@@ -0,0 +1,36 @@
+/**
+ * Bedrock Titan Embeddings — Gera embeddings para semantic search.
+ * Model: amazon.titan-embed-text-v2:0 (256 dimensions)
+ * Custo: ~$0.0002 per 1K input tokens
+ */
+import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
+const isLocal = process.env.USE_LOCALSTACK === "true";
+const bedrock = new BedrockRuntimeClient({
+    region: process.env.AWS_REGION || "sa-east-1",
+    ...(isLocal && {
+        endpoint: "http://localhost:4566",
+        credentials: { accessKeyId: "test", secretAccessKey: "test" },
+    }),
+});
+const MODEL_ID = "amazon.titan-embed-text-v2:0";
+const DIMENSIONS = 256;
+export async function getEmbedding(text) {
+    const body = JSON.stringify({ inputText: text.slice(0, 8000), dimensions: DIMENSIONS });
+    const res = await bedrock.send(new InvokeModelCommand({
+        modelId: MODEL_ID,
+        body: new TextEncoder().encode(body),
+        contentType: "application/json",
+        accept: "application/json",
+    }));
+    const output = JSON.parse(new TextDecoder().decode(res.body));
+    return output.embedding;
+}
+export function cosineSimilarity(a, b) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}

package/dist/knowledge/loader.d.ts

@@ -0,0 +1,8 @@
+export declare function loadCodeStandards(): Promise<Record<string, unknown>>;
+export declare function loadDecisions(): Promise<Record<string, unknown>>;
+export declare function loadGlossary(): Promise<Record<string, unknown>>;
+export declare function loadIntegrations(): Promise<Record<string, unknown>>;
+export declare function loadSkill(name: string): Promise<string>;
+export declare function listSkills(): Promise<string[]>;
+export declare function loadIndex(): Promise<Record<string, unknown>>;
+export declare function loadTemplate(name: string): Promise<string>;