refine-mcp 0.1.0

package/dist/detection/file-tree.js

@@ -0,0 +1,174 @@
+/**
+ * Scan do file tree do projeto do builder + deteccao de skill por sinais.
+ * Modulo puro, sem dependencias externas alem de glob e fs.
+ */
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { glob } from "glob";
+export const IGNORE_DIRS = ["node_modules", ".git", "dist", "build", ".next"];
+export async function scanFileTree(cwd) {
+    const ignorePattern = IGNORE_DIRS.map((d) => `**/${d}/**`);
+    const [pages, tests, convexFiles] = await Promise.all([
+        glob("**/{pages,app}/**/*.{tsx,jsx}", {
+            cwd,
+            ignore: ignorePattern,
+            maxDepth: 4,
+        }),
+        glob("**/*.{test,spec}.{ts,tsx,js,jsx}", {
+            cwd,
+            ignore: ignorePattern,
+            maxDepth: 4,
+        }),
+        glob("convex/*.ts", {
+            cwd,
+            ignore: [...ignorePattern, "convex/schema.ts", "convex/_generated/**", "convex/auth.ts"],
+        }),
+    ]);
+    // Contar CSS vars em globals.css
+    let cssVarCount = 0;
+    let colorVarCount = 0;
+    const globalsCandidates = ["globals.css", "src/globals.css", "app/globals.css", "src/index.css"];
+    for (const candidate of globalsCandidates) {
+        const fullPath = join(cwd, candidate);
+        if (existsSync(fullPath)) {
+            try {
+                const content = await readFile(fullPath, "utf-8");
+                for (const line of content.split("\n")) {
+                    const trimmed = line.trim();
+                    if (trimmed.startsWith("--")) {
+                        cssVarCount++;
+                        if (trimmed.startsWith("--color-")) {
+                            colorVarCount++;
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignora erro de leitura
+            }
+            break;
+        }
+    }
+    // Parsear roadmap.md para extrair progresso de tasks
+    const roadmapTasks = await parseRoadmapProgress(cwd);
+    const hasPackageJson = existsSync(join(cwd, "package.json"));
+    const hasConvex = existsSync(join(cwd, "convex"));
+    const hasTailwind = existsSync(join(cwd, "tailwind.config.ts")) ||
+        existsSync(join(cwd, "tailwind.config.js")) ||
+        existsSync(join(cwd, "postcss.config.ts")) ||
+        existsSync(join(cwd, "postcss.config.js")) ||
+        existsSync(join(cwd, "postcss.config.mjs"));
+    const hasVercelConfig = existsSync(join(cwd, "vercel.json")) || existsSync(join(cwd, ".vercel"));
+    return {
+        pages,
+        tests,
+        mutations: convexFiles,
+        cssVarCount,
+        colorVarCount,
+        hasPackageJson,
+        hasConvex,
+        hasTailwind,
+        hasVercelConfig,
+        roadmapTasks,
+    };
+}
+/**
+ * Parseia roadmap.md (ou docs/roadmap.md) e extrai progresso de tasks.
+ * Busca checkboxes `- [x]` e `- [ ]` com padrão TASK-NNN.
+ */
+async function parseRoadmapProgress(cwd) {
+    const candidates = ["docs/roadmap.md", "roadmap.md"];
+    let content = null;
+    for (const candidate of candidates) {
+        const fullPath = join(cwd, candidate);
+        if (existsSync(fullPath)) {
+            try {
+                content = await readFile(fullPath, "utf-8");
+            }
+            catch {
+                // Ignora erro de leitura
+            }
+            break;
+        }
+    }
+    if (!content)
+        return null;
+    const lines = content.split("\n");
+    let currentPhase = "";
+    const byPhase = {};
+    const tasksDone = [];
+    let total = 0;
+    let done = 0;
+    const phaseRegex = /^##\s+Fase\s+\d+/;
+    const taskDoneRegex = /^- \[x\]\s+.*\*\*(TASK-\d+[A-Z]?)\*\*/;
+    const taskTodoRegex = /^- \[ \]\s+.*\*\*(TASK-\d+[A-Z]?)\*\*/;
+    for (const line of lines) {
+        // Detectar heading de fase
+        if (phaseRegex.test(line)) {
+            // Extrair nome da fase (ex: "Fase 8: MCP Server")
+            const match = line.match(/^##\s+(Fase\s+\d+[A-Z]?(?::\s*.+)?)/);
+            currentPhase = match ? match[1].trim() : line.replace(/^##\s+/, "").trim();
+            if (!byPhase[currentPhase]) {
+                byPhase[currentPhase] = { total: 0, done: 0 };
+            }
+            continue;
+        }
+        // Parar antes da seção exploratória (V2)
+        if (line.startsWith("## Futuro:"))
+            break;
+        // Task marcada como done
+        const doneMatch = line.match(taskDoneRegex);
+        if (doneMatch) {
+            total++;
+            done++;
+            tasksDone.push(doneMatch[1]);
+            if (currentPhase && byPhase[currentPhase]) {
+                byPhase[currentPhase].total++;
+                byPhase[currentPhase].done++;
+            }
+            continue;
+        }
+        // Task pendente
+        const todoMatch = line.match(taskTodoRegex);
+        if (todoMatch) {
+            total++;
+            if (currentPhase && byPhase[currentPhase]) {
+                byPhase[currentPhase].total++;
+            }
+        }
+    }
+    return { total, done, tasksDone, byPhase };
+}
+/**
+ * Detecta a skill inferida como "mais avancada concluida" baseado nos sinais do file tree.
+ * Percorre da prioridade mais alta pra mais baixa.
+ */
+export function detectSkill(summary) {
+    // Prioridade 8: vercel config -> ship em progresso
+    if (summary.hasVercelConfig)
+        return "ship";
+    // Prioridade 7: >3 test files -> ship em progresso (preparando producao)
+    if (summary.tests.length > 3)
+        return "ship";
+    // Prioridade 6: >3 convex mutations -> feature-dev em progresso
+    if (summary.mutations.length > 3)
+        return "feature-dev";
+    // Prioridade 5: >2 pages -> page-builder em progresso
+    if (summary.pages.length > 2)
+        return "page-builder";
+    // Prioridade 4: >20 CSS vars -> design-system concluido
+    if (summary.cssVarCount > 20)
+        return "design-system";
+    // Prioridade 3: >5 color vars -> identity concluido
+    if (summary.colorVarCount > 5)
+        return "identity";
+    // Prioridade 2: package.json + convex + tailwind -> onboarding (stack pronto)
+    if (summary.hasPackageJson && summary.hasConvex && summary.hasTailwind)
+        return "onboarding";
+    // Prioridade 1: package.json existe -> pre-setup
+    if (summary.hasPackageJson)
+        return "pre-setup";
+    // Prioridade 0: nada
+    return "none";
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * @refine.build/mcp — MCP Server
+ *
+ * Conecta a IA do builder (Claude Code, Cursor, Windsurf) ao refine.build.
+ * O builder instala uma vez, a IA guia ate o lancamento.
+ *
+ * Uso: npx @refine.build/mcp --token SEU_TOKEN
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * @refine.build/mcp — MCP Server
+ *
+ * Conecta a IA do builder (Claude Code, Cursor, Windsurf) ao refine.build.
+ * O builder instala uma vez, a IA guia ate o lancamento.
+ *
+ * Uso: npx @refine.build/mcp --token SEU_TOKEN
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerPrompts } from "./prompts/index.js";
+import { registerResources } from "./resources/index.js";
+import { registerCheckinTool } from "./tools/checkin.js";
+import { registerCompleteSkillTool } from "./tools/complete.js";
+import { registerGetPromptTool } from "./tools/get-prompt.js";
+import { registerGetSkillTool } from "./tools/get-skill.js";
+import { registerRefineRunTool } from "./tools/refine-run.js";
+import { getConfig } from "./utils/config.js";
+const config = getConfig();
+if (!config.token) {
+    console.error("Erro: Token nao fornecido. Use --token SEU_TOKEN ou defina REFINE_TOKEN.");
+    console.error("Gere seu token em: https://refine.build/account/mcp");
+    process.exit(1);
+}
+const server = new McpServer({
+    name: "refine-mcp-server",
+    version: "0.1.0",
+});
+// Register MCP tools
+registerCheckinTool(server);
+registerGetSkillTool(server);
+registerCompleteSkillTool(server);
+registerGetPromptTool(server);
+registerRefineRunTool(server);
+// Register MCP prompts (slash commands)
+registerPrompts(server);
+// Register MCP resources (project context via @refine:prd, etc.)
+registerResources(server);
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("refine-build MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/prompts/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP Prompts (slash commands) para o refine.build.
+ *
+ * Nota: MCP Prompts nao sao sugeridos automaticamente pela IA (bug conhecido).
+ * A automacao real vem dos tools + regras no CLAUDE.md.
+ * Estes prompts servem como atalhos manuais: /refine:status, /refine:next, etc.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerPrompts(server: McpServer): void;

package/dist/prompts/index.js

@@ -0,0 +1,125 @@
+/**
+ * MCP Prompts (slash commands) para o refine.build.
+ *
+ * Nota: MCP Prompts nao sao sugeridos automaticamente pela IA (bug conhecido).
+ * A automacao real vem dos tools + regras no CLAUDE.md.
+ * Estes prompts servem como atalhos manuais: /refine:status, /refine:next, etc.
+ */
+import { z } from "zod";
+export function registerPrompts(server) {
+    // /refine:status — chama checkin + mostra progresso
+    server.registerPrompt("refine:status", {
+        title: "Status do Fluxo",
+        description: "Mostra progresso atual do projeto no fluxo guiado do refine.build.",
+    }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "Chame a tool refine_checkin para verificar o status do meu projeto no refine.build.",
+                        "Mostre: etapa ativa, fase, progresso geral e o que preciso fazer agora.",
+                        "Se houver discrepancia entre o que o servidor diz e o que voce detecta no codigo, mencione.",
+                    ].join("\n"),
+                },
+            },
+        ],
+    }));
+    // /refine:next — mostra proxima skill + oferece iniciar
+    server.registerPrompt("refine:next", {
+        title: "Proxima Etapa",
+        description: "Mostra a proxima etapa do fluxo e oferece iniciar com o prompt completo.",
+    }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "Chame refine_get_skill para ver a etapa ativa do meu projeto.",
+                        "Depois chame refine_get_prompt com o ID da etapa ativa para obter as instrucoes completas.",
+                        "Me mostre um resumo do que essa skill faz e pergunte se posso comecar.",
+                    ].join("\n"),
+                },
+            },
+        ],
+    }));
+    // /refine:complete — marca skill atual como concluida
+    server.registerPrompt("refine:complete", {
+        title: "Completar Etapa",
+        description: "Marca a etapa ativa como concluida e avanca para a proxima.",
+    }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "Chame refine_get_skill para descobrir qual e a etapa ativa.",
+                        "Liste os arquivos relevantes que foram criados ou modificados nessa etapa.",
+                        "Pergunte se posso marcar como concluida.",
+                        "Se eu confirmar, chame refine_complete_skill com o skillId correto e a lista de arquivos como evidencia.",
+                    ].join("\n"),
+                },
+            },
+        ],
+    }));
+    // /refine:skill <nome> — puxa prompt especifico
+    server.registerPrompt("refine:skill", {
+        title: "Prompt de Skill",
+        description: "Busca o prompt completo de uma skill especifica para conduzir no IDE.",
+        argsSchema: {
+            skill: z
+                .string()
+                .describe("ID da skill (ex: page-builder, onboarding, motion, feature-dev)"),
+        },
+    }, ({ skill }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        `Chame refine_get_prompt com skill="${skill}" para obter as instrucoes completas.`,
+                        "Use o prompt retornado como guia para conduzir essa skill fase por fase.",
+                        "Comece pela Fase 1 e siga a ordem indicada no prompt.",
+                    ].join("\n"),
+                },
+            },
+        ],
+    }));
+    // /refine:help — lista comandos
+    server.registerPrompt("refine:help", {
+        title: "Ajuda Refine",
+        description: "Lista todos os comandos disponiveis do refine.build MCP.",
+    }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "Mostre a lista de comandos do refine.build MCP disponíveis:",
+                        "",
+                        "**Slash Commands (Prompts):**",
+                        "- `/refine:status` — Verifica progresso do projeto no fluxo",
+                        "- `/refine:next` — Mostra proxima etapa e oferece iniciar",
+                        "- `/refine:complete` — Marca etapa ativa como concluida",
+                        "- `/refine:skill <nome>` — Busca prompt de uma etapa especifica",
+                        "- `/refine:help` — Esta lista",
+                        "",
+                        "**Tools (chamados automaticamente):**",
+                        "- `refine_checkin` — Escaneia projeto e detecta etapa ativa",
+                        "- `refine_get_skill` — Retorna etapa ativa + contexto do plano",
+                        "- `refine_complete_skill` — Marca etapa como concluida",
+                        "- `refine_get_prompt` — Retorna prompt completo de uma etapa",
+                        "- `refine_run` — Executa auditoria automatizada (security, schema, design-system, responsive, pre-deploy, performance, ux-laws, consistency, motion-audit, auth-check, env-check, taste-review, product-check, refactor-audit, pivot-audit, debug, product, placeholders)",
+                        "",
+                        "**Dica:** No inicio de cada sessao, chame `refine_checkin` automaticamente.",
+                    ].join("\n"),
+                },
+            },
+        ],
+    }));
+}

package/dist/resources/identity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resource refine://identity — Brand identity do projeto ativo.
+ * A IA do IDE referencia via @refine:identity pra definir cores, fontes e personalidade.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerIdentityResource(server: McpServer): void;

package/dist/resources/identity.js

@@ -0,0 +1,30 @@
+/**
+ * Resource refine://identity — Brand identity do projeto ativo.
+ * A IA do IDE referencia via @refine:identity pra definir cores, fontes e personalidade.
+ */
+import { apiGet } from "../utils/api.js";
+export function registerIdentityResource(server) {
+    server.registerResource("refine-identity", "refine://identity", {
+        title: "Brand Identity",
+        description: "Brand identity do projeto: personalidade, paleta de cores, tipografia e motion",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const response = await apiGet("/api/mcp/project-context", { resource: "identity" });
+        if (!response.ok || !response.data) {
+            return {
+                contents: [
+                    { uri: uri.href, text: `Erro ao buscar identity: ${response.error ?? "Sem resposta"}` },
+                ],
+            };
+        }
+        const data = response.data;
+        if (data.empty) {
+            return {
+                contents: [{ uri: uri.href, text: String(data.message) }],
+            };
+        }
+        return {
+            contents: [{ uri: uri.href, text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/resources/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Registra todos os MCP Resources do refine.build.
+ * Resources permitem a IA do IDE referenciar dados do projeto via @refine:prd, etc.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerResources(server: McpServer): void;

package/dist/resources/index.js

@@ -0,0 +1,14 @@
+/**
+ * Registra todos os MCP Resources do refine.build.
+ * Resources permitem a IA do IDE referenciar dados do projeto via @refine:prd, etc.
+ */
+import { registerIdentityResource } from "./identity.js";
+import { registerPrdResource } from "./prd.js";
+import { registerRoadmapResource } from "./roadmap.js";
+import { registerTokensResource } from "./tokens.js";
+export function registerResources(server) {
+    registerPrdResource(server);
+    registerIdentityResource(server);
+    registerTokensResource(server);
+    registerRoadmapResource(server);
+}

package/dist/resources/prd.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resource refine://prd — PRD completo do projeto ativo.
+ * A IA do IDE referencia via @refine:prd pra ter contexto do produto.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerPrdResource(server: McpServer): void;

package/dist/resources/prd.js

@@ -0,0 +1,30 @@
+/**
+ * Resource refine://prd — PRD completo do projeto ativo.
+ * A IA do IDE referencia via @refine:prd pra ter contexto do produto.
+ */
+import { apiGet } from "../utils/api.js";
+export function registerPrdResource(server) {
+    server.registerResource("refine-prd", "refine://prd", {
+        title: "PRD do Projeto",
+        description: "PRD completo do projeto ativo: produto, comportamento, design, estrutura e dados",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const response = await apiGet("/api/mcp/project-context", { resource: "prd" });
+        if (!response.ok || !response.data) {
+            return {
+                contents: [
+                    { uri: uri.href, text: `Erro ao buscar PRD: ${response.error ?? "Sem resposta"}` },
+                ],
+            };
+        }
+        const data = response.data;
+        if (data.empty) {
+            return {
+                contents: [{ uri: uri.href, text: String(data.message) }],
+            };
+        }
+        return {
+            contents: [{ uri: uri.href, text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/resources/roadmap.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resource refine://roadmap — Roadmap com fases, tasks e status do projeto ativo.
+ * A IA do IDE referencia via @refine:roadmap pra saber proxima task.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRoadmapResource(server: McpServer): void;

package/dist/resources/roadmap.js

@@ -0,0 +1,30 @@
+/**
+ * Resource refine://roadmap — Roadmap com fases, tasks e status do projeto ativo.
+ * A IA do IDE referencia via @refine:roadmap pra saber proxima task.
+ */
+import { apiGet } from "../utils/api.js";
+export function registerRoadmapResource(server) {
+    server.registerResource("refine-roadmap", "refine://roadmap", {
+        title: "Roadmap do Projeto",
+        description: "Roadmap com fases, tasks e status (todo/doing/done) e progresso por fase",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const response = await apiGet("/api/mcp/project-context", { resource: "roadmap" });
+        if (!response.ok || !response.data) {
+            return {
+                contents: [
+                    { uri: uri.href, text: `Erro ao buscar roadmap: ${response.error ?? "Sem resposta"}` },
+                ],
+            };
+        }
+        const data = response.data;
+        if (data.empty) {
+            return {
+                contents: [{ uri: uri.href, text: String(data.message) }],
+            };
+        }
+        return {
+            contents: [{ uri: uri.href, text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/resources/tokens.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resource refine://tokens — Design tokens + CSS do projeto ativo.
+ * A IA do IDE referencia via @refine:tokens pra aplicar variaveis CSS no projeto.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTokensResource(server: McpServer): void;

package/dist/resources/tokens.js

@@ -0,0 +1,30 @@
+/**
+ * Resource refine://tokens — Design tokens + CSS do projeto ativo.
+ * A IA do IDE referencia via @refine:tokens pra aplicar variaveis CSS no projeto.
+ */
+import { apiGet } from "../utils/api.js";
+export function registerTokensResource(server) {
+    server.registerResource("refine-tokens", "refine://tokens", {
+        title: "Design Tokens",
+        description: "Design tokens do projeto: variaveis CSS, espacamento, borders, shadows e component list",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const response = await apiGet("/api/mcp/project-context", { resource: "tokens" });
+        if (!response.ok || !response.data) {
+            return {
+                contents: [
+                    { uri: uri.href, text: `Erro ao buscar tokens: ${response.error ?? "Sem resposta"}` },
+                ],
+            };
+        }
+        const data = response.data;
+        if (data.empty) {
+            return {
+                contents: [{ uri: uri.href, text: String(data.message) }],
+            };
+        }
+        return {
+            contents: [{ uri: uri.href, text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/setup.d.ts

@@ -0,0 +1,11 @@
+#!/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
+ */
+export {};