refine-mcp 0.1.0

package/dist/setup.js

@@ -0,0 +1,429 @@
+#!/usr/bin/env node
+/**
+ * Setup wizard: npx @refine.build/mcp setup
+ *
+ * 1. Pede token (ou abre browser)
+ * 2. Detecta IDE (Claude Code, Cursor, Windsurf)
+ * 3. Gera config pro IDE detectado
+ * 4. Copia CLAUDE.md pro projeto se nao existe
+ * 5. Confirma setup
+ */
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+function detectIDE() {
+    const cwd = process.cwd();
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    // Cursor: .cursor/ dir exists
+    if (existsSync(join(cwd, ".cursor"))) {
+        return { ide: "cursor", label: "Cursor" };
+    }
+    // Windsurf: check config path
+    if (existsSync(join(home, ".codeium", "windsurf"))) {
+        return { ide: "windsurf", label: "Windsurf" };
+    }
+    // Gemini CLI / Antigravity: .gemini/ dir or GEMINI.md
+    if (existsSync(join(cwd, ".gemini")) || existsSync(join(cwd, "GEMINI.md"))) {
+        return { ide: "gemini", label: "Gemini CLI / Antigravity" };
+    }
+    // Replit: replit.nix or .replit
+    if (existsSync(join(cwd, "replit.nix")) || existsSync(join(cwd, ".replit"))) {
+        return { ide: "replit", label: "Replit" };
+    }
+    // Claude Code: check if CLAUDE.md exists
+    if (existsSync(join(cwd, "CLAUDE.md"))) {
+        return { ide: "claude-code", label: "Claude Code" };
+    }
+    // Codex: AGENTS.md is sufficient (OpenAI Codex reads AGENTS.md natively)
+    // Detected last since AGENTS.md might have been created by us
+    return { ide: "unknown", label: "Desconhecido" };
+}
+// --- Geração de config ---
+function generateClaudeCodeCommand(token) {
+    return `claude mcp add refine -- npx -y @refine.build/mcp --token ${token}`;
+}
+function generateCursorConfig(token) {
+    const config = {
+        mcpServers: {
+            refine: {
+                command: "npx",
+                args: ["-y", "@refine.build/mcp", "--token", token],
+            },
+        },
+    };
+    return JSON.stringify(config, null, 2);
+}
+function generateWindsurfConfig(token) {
+    const config = {
+        mcpServers: {
+            refine: {
+                command: "npx",
+                args: ["-y", "@refine.build/mcp", "--token", token],
+            },
+        },
+    };
+    return JSON.stringify(config, null, 2);
+}
+function generateWindowsConfig(token) {
+    const config = {
+        mcpServers: {
+            refine: {
+                command: "cmd",
+                args: ["/c", "npx", "-y", "@refine.build/mcp", "--token", token],
+            },
+        },
+    };
+    return JSON.stringify(config, null, 2);
+}
+// --- AGENTS.md (padrao universal) ---
+const AGENTS_MD_CONTENT = `# AGENTS.md — refine.build Product Builder Pipeline
+
+> Este arquivo e lido automaticamente por Claude Code, Cursor, Windsurf, Codex, Gemini CLI, Replit, Aider, Zed, Warp, RooCode e outros agentes compatíveis com o padrao AGENTS.md.
+
+## Pipeline
+
+Este projeto segue o pipeline de 13 skills do Product Builder (refine.build).
+O MCP server @refine.build/mcp esta configurado e sincroniza o progresso automaticamente.
+
+## Tools MCP disponiveis
+
+- **refine_checkin** — Escaneia o projeto e detecta a etapa ativa. Chame no inicio de cada sessao e apos mudancas significativas.
+- **refine_get_skill** — Retorna a skill ativa, fase e o que fazer.
+- **refine_complete_skill** — Marca a skill atual como concluida e desbloqueia a proxima.
+- **refine_get_prompt** — Retorna o system prompt completo da skill pra conduzir o trabalho.
+
+## Regras
+
+1. No inicio de cada sessao, chame refine_checkin para verificar a skill ativa.
+2. Apos criar ou modificar arquivos significativos (paginas, componentes, features, configuracoes), chame refine_checkin novamente.
+3. Quando o builder disser que terminou uma etapa, chame refine_complete_skill.
+4. Antes de iniciar uma nova skill, chame refine_get_prompt para obter as instrucoes completas.
+5. Sempre informe ao builder em qual skill ele esta e o que falta fazer.
+
+## Roadmap-first: nunca implemente sem mapear
+
+Quando o builder pedir para criar algo novo, corrigir um bug ou adicionar uma feature:
+1. Abra docs/roadmap.md e verifique se ja existe uma task mapeada para isso.
+2. Se ja existe, siga a task normalmente.
+3. Se NAO existe, antes de qualquer codigo:
+   - Proponha a task ao builder com: titulo, complexidade (simples/media/complexa), arquivos envolvidos e notas.
+   - Espere o builder aprovar.
+   - Insira a task no roadmap.md na fase correta, com o proximo TASK number disponivel.
+   - So entao implemente.
+4. Ao concluir, marque [x] na task do roadmap.md. O checkin sincroniza o progresso automaticamente.
+`;
+// --- Regras do pipeline (IDE-specific, fallback) ---
+const CLAUDE_MD_RULES = `## Refine.build — Product Builder Pipeline
+Este projeto segue o pipeline de 13 skills do Product Builder.
+Use os tools do MCP refine para manter o progresso sincronizado.
+
+### Regras:
+1. No inicio de cada sessao, chame refine_checkin para verificar a skill ativa.
+2. Apos criar ou modificar arquivos significativos (paginas, componentes, features, configuracoes), chame refine_checkin novamente.
+3. Quando o builder disser que terminou uma etapa, chame refine_complete_skill.
+4. Antes de iniciar uma nova skill, chame refine_get_prompt para obter as instrucoes completas.
+5. Sempre informe ao builder em qual skill ele esta e o que falta fazer.
+
+### Roadmap-first: nunca implemente sem mapear
+Quando o builder pedir para criar algo novo, corrigir um bug ou adicionar uma feature:
+1. Abra docs/roadmap.md e verifique se ja existe uma task mapeada para isso.
+2. Se ja existe, siga a task normalmente.
+3. Se NAO existe, antes de qualquer codigo:
+   - Proponha a task ao builder com: titulo, complexidade (simples/media/complexa), arquivos envolvidos e notas.
+   - Espere o builder aprovar.
+   - Insira a task no roadmap.md na fase correta, com o proximo TASK number disponivel.
+   - So entao implemente.
+4. Ao concluir, marque [x] na task do roadmap.md. O checkin sincroniza o progresso automaticamente.
+`;
+const CURSOR_RULES = `You are working on a project that follows the Product Builder 19-skill pipeline.
+The refine MCP server is connected. Use its tools:
+- Call refine_checkin at session start and after significant file changes.
+- Call refine_complete_skill when a phase is done.
+- Call refine_get_prompt before starting a new skill.
+- Always tell the builder which skill they're on and what's next.
+
+ROADMAP-FIRST RULE:
+When the builder asks to create, fix or add anything:
+1. Check docs/roadmap.md for an existing task.
+2. If none exists, propose a task (title, complexity, files, notes) and wait for approval.
+3. Insert the task in roadmap.md before writing any code.
+4. After completing, mark [x] in roadmap.md. The MCP checkin syncs progress automatically.
+`;
+// --- Lovable Knowledge text (TASK-088F) ---
+function printLovableKnowledgeInstructions() {
+    const text = generateLovableKnowledgeText();
+    console.log("");
+    console.log("  Lovable nao le AGENTS.md, entao cole o texto abaixo em:");
+    console.log("  Settings > Knowledge (limite: 10.000 chars)");
+    console.log("");
+    console.log("  --- INICIO DO TEXTO ---");
+    console.log(text);
+    console.log("  --- FIM DO TEXTO ---");
+    console.log("");
+    // Tentar copiar pro clipboard
+    try {
+        if (process.platform === "darwin") {
+            execSync("pbcopy", { input: text });
+            console.log("  Texto copiado pro clipboard!");
+        }
+        else if (process.platform === "linux") {
+            execSync("xclip -selection clipboard", { input: text });
+            console.log("  Texto copiado pro clipboard!");
+        }
+    }
+    catch {
+        // Clipboard nao disponivel, ok
+    }
+    console.log("");
+}
+function generateLovableKnowledgeText() {
+    // Versao compacta das regras, otimizada pro limite de 10k chars do Lovable
+    return `# refine.build — Product Builder Pipeline
+
+Este projeto segue o pipeline de 13 skills do Product Builder (refine.build).
+
+## Regras
+
+1. Antes de criar algo, verifique docs/roadmap.md pra tasks existentes.
+2. Se nao existe task, proponha: titulo, complexidade, arquivos, notas. Espere aprovacao.
+3. Insira a task no roadmap.md antes de codar.
+4. Ao concluir, marque [x] na task do roadmap.md.
+
+## Skills do Pipeline (ordem)
+
+1. Product Strategy — Coleta de ideia, validacao, hook cycle
+2. Identity — Nome, personalidade, tom visual
+3. Design System — Tokens, cores, tipografia, componentes
+4. Page Builder — Construir telas seguindo specs do PRD
+5. Feature Dev — Conectar backend, CRUD, funcionalidades
+6. Quality Auditor — Testes, responsividade, schema sync
+7. Ship — Deploy, seguranca, performance, pre-launch
+
+## Convenções
+
+- Imports: usar @/ alias pra src/
+- Styling: apenas tokens semanticos do design system
+- Componentes: shadcn/ui como base
+- Backend: Convex (mutations/queries). Auth check em tudo
+- Testes: Vitest. Testar logica, nao UI
+`;
+}
+// --- Readline helper ---
+function ask(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer.trim()));
+    });
+}
+// --- Main ---
+async function main() {
+    const cwd = process.cwd();
+    const isWindows = process.platform === "win32";
+    console.log("");
+    console.log("  refine.build — Setup MCP");
+    console.log("  ========================");
+    console.log("");
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    // 1. Token
+    let token = "";
+    const argIndex = process.argv.indexOf("--token");
+    if (argIndex !== -1 && process.argv[argIndex + 1]) {
+        token = process.argv[argIndex + 1];
+        console.log(`  Token: ${token.slice(0, 8)}...`);
+    }
+    else {
+        console.log("  Gere seu token em: https://refine.build/account/mcp");
+        console.log("");
+        token = await ask(rl, "  Cole seu token: ");
+        if (!token) {
+            console.log("\n  Token obrigatorio. Abortando.");
+            rl.close();
+            process.exit(1);
+        }
+    }
+    // 2. Detectar IDE
+    const detected = detectIDE();
+    console.log(`\n  IDE detectado: ${detected.label}`);
+    let ide = detected.ide;
+    if (ide === "unknown") {
+        console.log("  Nao consegui detectar automaticamente.");
+        console.log("  1) Claude Code");
+        console.log("  2) Cursor");
+        console.log("  3) Windsurf");
+        console.log("  4) Codex (OpenAI)");
+        console.log("  5) Gemini CLI / Antigravity");
+        console.log("  6) Replit");
+        console.log("  7) Lovable");
+        const choice = await ask(rl, "\n  Qual IDE? (1-7): ");
+        const ideMap = {
+            "1": "claude-code",
+            "2": "cursor",
+            "3": "windsurf",
+            "4": "codex",
+            "5": "gemini",
+            "6": "replit",
+            "7": "lovable",
+        };
+        ide = ideMap[choice] ?? "unknown";
+        if (ide === "unknown") {
+            console.log("\n  Opcao invalida. Abortando.");
+            rl.close();
+            process.exit(1);
+        }
+    }
+    // 3. Gerar config
+    console.log("");
+    switch (ide) {
+        case "claude-code": {
+            const cmd = generateClaudeCodeCommand(token);
+            console.log("  Execute este comando no terminal:");
+            console.log("");
+            console.log(`  ${cmd}`);
+            console.log("");
+            break;
+        }
+        case "cursor": {
+            const configPath = join(cwd, ".cursor", "mcp.json");
+            const config = generateCursorConfig(token);
+            const shouldWrite = await ask(rl, `  Criar ${configPath}? (s/n): `);
+            if (shouldWrite.toLowerCase() === "s") {
+                mkdirSync(join(cwd, ".cursor"), { recursive: true });
+                if (existsSync(configPath)) {
+                    console.log(`  Arquivo ja existe. Adicione manualmente:`);
+                    console.log("");
+                    console.log(config);
+                }
+                else {
+                    writeFileSync(configPath, config, "utf-8");
+                    console.log(`  Criado: ${configPath}`);
+                }
+            }
+            else {
+                console.log("\n  Adicione ao .cursor/mcp.json:");
+                console.log("");
+                console.log(config);
+            }
+            console.log("");
+            break;
+        }
+        case "windsurf": {
+            const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+            const configPath = join(home, ".codeium", "windsurf", "mcp_config.json");
+            const config = isWindows ? generateWindowsConfig(token) : generateWindsurfConfig(token);
+            console.log(`  Adicione ao ${configPath}:`);
+            console.log("");
+            console.log(config);
+            console.log("");
+            break;
+        }
+        case "codex": {
+            // Codex usa AGENTS.md (gerado no step 4) + nao suporta MCP nativo
+            console.log("  Codex le o AGENTS.md automaticamente (gerado no proximo passo).");
+            console.log("  MCP nao suportado nativamente pelo Codex — regras via AGENTS.md.");
+            console.log("");
+            break;
+        }
+        case "gemini": {
+            console.log("  Gemini CLI le o AGENTS.md automaticamente.");
+            console.log("");
+            break;
+        }
+        case "replit": {
+            console.log("  Replit suporta MCP nativo.");
+            console.log("  Va em: Integrations > MCP Servers > Add MCP server");
+            console.log(`  Nome: refine`);
+            console.log(`  URL: https://mcp.refine.build/sse?token=${token}`);
+            console.log("");
+            console.log("  Replit Agent tambem le o AGENTS.md (gerado no proximo passo).");
+            console.log("");
+            break;
+        }
+        case "lovable": {
+            console.log("  Lovable suporta MCP nativo (planos pagos).");
+            console.log("  Va em: Settings > Connectors > Personal Connectors > New MCP server");
+            console.log(`  Nome: refine`);
+            console.log(`  URL: https://mcp.refine.build/sse?token=${token}`);
+            console.log("  Auth: Bearer token");
+            console.log("");
+            console.log("  Lovable NAO le AGENTS.md. Cole as regras em Project Knowledge:");
+            printLovableKnowledgeInstructions();
+            break;
+        }
+    }
+    // 4. Gerar AGENTS.md (padrao universal)
+    const agentsMdPath = join(cwd, "AGENTS.md");
+    let rulesCreated = false;
+    if (!existsSync(agentsMdPath)) {
+        writeFileSync(agentsMdPath, AGENTS_MD_CONTENT, "utf-8");
+        console.log("  Criado: AGENTS.md (padrao universal, lido por todos os agentes)");
+        rulesCreated = true;
+    }
+    else {
+        console.log("  AGENTS.md ja existe (nao sobrescrito).");
+    }
+    // 5. Copiar regras IDE-specific como complemento
+    const claudeMdPath = join(cwd, "CLAUDE.md");
+    const cursorRulesPath = join(cwd, ".cursorrules");
+    const windsurfRulesPath = join(cwd, ".windsurfrules");
+    if (!existsSync(claudeMdPath)) {
+        writeFileSync(claudeMdPath, CLAUDE_MD_RULES, "utf-8");
+        console.log("  Criado: CLAUDE.md");
+        rulesCreated = true;
+    }
+    else {
+        console.log("  CLAUDE.md ja existe (nao sobrescrito).");
+    }
+    if (ide === "cursor" && !existsSync(cursorRulesPath)) {
+        writeFileSync(cursorRulesPath, CURSOR_RULES, "utf-8");
+        console.log("  Criado: .cursorrules");
+        rulesCreated = true;
+    }
+    if (ide === "windsurf" && !existsSync(windsurfRulesPath)) {
+        writeFileSync(windsurfRulesPath, CURSOR_RULES, "utf-8");
+        console.log("  Criado: .windsurfrules");
+        rulesCreated = true;
+    }
+    // Gemini: GEMINI.md + .agent/rules/refine.md
+    if (ide === "gemini") {
+        const geminiMdPath = join(cwd, "GEMINI.md");
+        if (!existsSync(geminiMdPath)) {
+            writeFileSync(geminiMdPath, AGENTS_MD_CONTENT, "utf-8");
+            console.log("  Criado: GEMINI.md");
+            rulesCreated = true;
+        }
+        const agentRulesDir = join(cwd, ".agent", "rules");
+        const agentRulePath = join(agentRulesDir, "refine.md");
+        if (!existsSync(agentRulePath)) {
+            mkdirSync(agentRulesDir, { recursive: true });
+            writeFileSync(agentRulePath, AGENTS_MD_CONTENT, "utf-8");
+            console.log("  Criado: .agent/rules/refine.md");
+            rulesCreated = true;
+        }
+    }
+    // Replit: replit.md
+    if (ide === "replit") {
+        const replitMdPath = join(cwd, "replit.md");
+        if (!existsSync(replitMdPath)) {
+            writeFileSync(replitMdPath, AGENTS_MD_CONTENT, "utf-8");
+            console.log("  Criado: replit.md");
+            rulesCreated = true;
+        }
+    }
+    // 6. Confirmar
+    console.log("");
+    console.log("  ========================");
+    console.log("  MCP configurado!");
+    if (rulesCreated) {
+        console.log("  Regras do pipeline copiadas pro projeto.");
+    }
+    console.log("  A IA do seu IDE agora sincroniza com o refine.build.");
+    console.log("");
+    rl.close();
+}
+main().catch((error) => {
+    console.error("Erro no setup:", error);
+    process.exit(1);
+});

package/dist/tools/checkin.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tool refine_checkin: escaneia file tree do builder e detecta skill ativa.
+ * Chama automaticamente no inicio de cada sessao.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerCheckinTool(server: McpServer): void;

package/dist/tools/checkin.js

@@ -0,0 +1,72 @@
+/**
+ * Tool refine_checkin: escaneia file tree do builder e detecta skill ativa.
+ * Chama automaticamente no inicio de cada sessao.
+ */
+import { z } from "zod";
+import { detectSkill, scanFileTree } from "../detection/file-tree.js";
+import { apiPost } from "../utils/api.js";
+export function registerCheckinTool(server) {
+    server.registerTool("refine_checkin", {
+        description: "Escaneia o projeto do builder e detecta a etapa ativa no fluxo guiado do refine.build. Chame no inicio de cada sessao.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: z.object({
+            projectId: z.string().optional().describe("ID do projeto no refine.build (opcional)"),
+        }),
+    }, async ({ projectId }) => {
+        const cwd = process.cwd();
+        // 1. Scan file tree
+        const summary = await scanFileTree(cwd);
+        // 2. Detect skill
+        const detectedSkill = detectSkill(summary);
+        // 3. POST pro backend
+        const response = await apiPost("/api/mcp/checkin", {
+            projectId,
+            fileTreeSummary: summary,
+            detectedSkill,
+        });
+        if (!response.ok || !response.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Erro no checkin: ${response.error ?? "Sem resposta do servidor"}`,
+                    },
+                ],
+            };
+        }
+        const d = response.data;
+        if (d.error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${d.error}${d.hint ? `. ${d.hint}` : ""}`,
+                    },
+                ],
+            };
+        }
+        // 4. Formatar resposta pra IA do IDE
+        const lines = [
+            `Etapa ativa: ${d.skillName} (fase ${d.skillPhase})`,
+            `O que fazer: ${d.skillDescription}`,
+            d.nextSkill ? `Proxima etapa: ${d.nextSkill}` : "Ultima etapa do fluxo!",
+            `Progresso: ${d.progressPercent}% (${d.completedSkills}/${d.totalSkills} etapas)`,
+            `Projeto: ${d.projectId}`,
+            "",
+            `Deteccao local: ${detectedSkill} | Scan: ${summary.pages.length} paginas, ${summary.tests.length} testes, ${summary.mutations.length} mutations, ${summary.cssVarCount} CSS vars`,
+        ];
+        // Adicionar progresso do roadmap.md se disponivel
+        if (summary.roadmapTasks) {
+            const rt = summary.roadmapTasks;
+            const pct = rt.total > 0 ? Math.round((rt.done / rt.total) * 100) : 0;
+            lines.push(`Roadmap: ${rt.done}/${rt.total} tasks (${pct}%)`);
+        }
+        const text = lines.join("\n");
+        return { content: [{ type: "text", text }] };
+    });
+}

package/dist/tools/complete.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tool refine_complete_skill: marca skill ativa como concluida e avanca pro proximo.
+ * Usar quando o builder diz "terminei" ou quando a IA detecta que a skill foi concluida.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerCompleteSkillTool(server: McpServer): void;

package/dist/tools/complete.js

@@ -0,0 +1,56 @@
+/**
+ * Tool refine_complete_skill: marca skill ativa como concluida e avanca pro proximo.
+ * Usar quando o builder diz "terminei" ou quando a IA detecta que a skill foi concluida.
+ */
+import { z } from "zod";
+import { apiPost } from "../utils/api.js";
+export function registerCompleteSkillTool(server) {
+    server.registerTool("refine_complete_skill", {
+        description: "Marca a etapa ativa como concluida e avanca pra proxima. Use quando o builder completar uma etapa no IDE.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: z.object({
+            skillId: z.string().describe("ID da skill a completar (ex: 'page-builder', 'onboarding')"),
+            projectId: z.string().optional().describe("ID do projeto (opcional, usa o mais recente)"),
+            evidence: z
+                .array(z.string())
+                .optional()
+                .describe("Lista de arquivos criados/modificados como evidencia (opcional)"),
+        }),
+    }, async ({ skillId, projectId, evidence }) => {
+        const body = { skillId };
+        if (projectId)
+            body.projectId = projectId;
+        if (evidence)
+            body.evidence = evidence;
+        const response = await apiPost("/api/mcp/complete-skill", body);
+        if (!response.ok || !response.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Erro ao completar skill: ${response.error ?? "Sem resposta do servidor"}`,
+                    },
+                ],
+            };
+        }
+        const d = response.data;
+        if (d.error) {
+            return {
+                content: [{ type: "text", text: `Erro: ${d.error}` }],
+            };
+        }
+        const lines = [
+            `Skill concluida: ${d.completedSkill}`,
+            d.nextSkill
+                ? `Proxima skill: ${d.nextSkill}`
+                : "Pipeline completo! Todas as skills foram concluidas.",
+            `Progresso: ${d.progressPercent}%`,
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    });
+}

package/dist/tools/get-prompt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tool refine_get_prompt: retorna system prompt completo de uma skill.
+ * Tenta composicao (POST compose-skill com contexto local) primeiro,
+ * fallback pro GET skill-prompt se composicao falhar.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetPromptTool(server: McpServer): void;

package/dist/tools/get-prompt.js

@@ -0,0 +1,68 @@
+/**
+ * Tool refine_get_prompt: retorna system prompt completo de uma skill.
+ * Tenta composicao (POST compose-skill com contexto local) primeiro,
+ * fallback pro GET skill-prompt se composicao falhar.
+ */
+import { z } from "zod";
+import { extractProjectContext } from "../detection/context-extractor.js";
+import { apiGet, apiPost } from "../utils/api.js";
+export function registerGetPromptTool(server) {
+    server.registerTool("refine_get_prompt", {
+        description: "Retorna o system prompt completo de uma etapa do fluxo. Use como instrucao pra conduzir a etapa no IDE do builder.",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: z.object({
+            skill: z.string().describe("ID da skill (ex: 'page-builder', 'onboarding', 'motion')"),
+            projectId: z
+                .string()
+                .optional()
+                .describe("ID do projeto pra injetar contexto do plano de produto (opcional)"),
+        }),
+    }, async ({ skill, projectId }) => {
+        // 1. Tentar composicao
+        const context = await extractProjectContext(process.cwd());
+        const composeBody = { skillName: skill, projectId, context };
+        const composed = await apiPost("/api/mcp/compose-skill", composeBody);
+        if (composed.ok && composed.data?.prompt) {
+            const d = composed.data;
+            const lines = [
+                `Skill: ${d.skillName}`,
+                `Fonte: composed (template v${d.templateVersion}, ${d.craftRulesCount} craft rules)`,
+                "",
+                "---",
+                "",
+                d.prompt,
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        // 2. Fallback: GET prompt cru
+        const params = { skill };
+        if (projectId)
+            params.projectId = projectId;
+        const response = await apiGet("/api/mcp/skill-prompt", params);
+        if (!response.ok || !response.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Erro ao buscar prompt: ${composed.error ?? response.error ?? "Sem resposta do servidor"}`,
+                    },
+                ],
+            };
+        }
+        const d = response.data;
+        const lines = [
+            `Skill: ${d.skillName} (${d.skillId})`,
+            `Fonte: fallback (${d.source})`,
+            "",
+            "---",
+            "",
+            d.prompt,
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    });
+}

package/dist/tools/get-skill.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tool refine_get_skill: retorna skill ativa + metadata + contexto PRD.
+ * A IA do IDE usa isso pra informar o builder onde esta no pipeline.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetSkillTool(server: McpServer): void;