refine-mcp 0.1.0

package/dist/detection/concern-map.js

@@ -0,0 +1,236 @@
+/**
+ * Concern Map — regras determinísticas de seleção de arquivos por tipo de refine.
+ * Zero tokens de LLM. Cada tipo de refine tem patterns genéricos + stack-specific.
+ */
+import { glob } from "glob";
+import { IGNORE_DIRS } from "./file-tree.js";
+// ---------------------------------------------------------------------------
+// Ignore dirs (extends file-tree IGNORE_DIRS)
+// ---------------------------------------------------------------------------
+const IGNORE_DIRS_EXTENDED = [
+    ...IGNORE_DIRS,
+    ".vercel",
+    "coverage",
+    "test-results",
+    "playwright-report",
+];
+const IGNORE_PATTERN = IGNORE_DIRS_EXTENDED.map((d) => `**/${d}/**`);
+// ---------------------------------------------------------------------------
+// Concern Maps
+// ---------------------------------------------------------------------------
+const CONCERN_MAPS = {
+    security: {
+        generic: [
+            "**/.env*",
+            "**/middleware.*",
+            "**/auth/**",
+            "**/*secret*",
+            "**/*token*",
+            "**/*password*",
+            "**/*api-key*",
+        ],
+        stackSpecific: {
+            convex: ["convex/schema.ts", "convex/auth.ts", "convex/http.ts", "convex/*.ts"],
+            supabase: ["**/supabase/**", "**/policies.sql"],
+            prisma: ["prisma/schema.prisma"],
+            firebase: ["**/firestore.rules", "**/storage.rules"],
+        },
+    },
+    schema: {
+        generic: ["**/*schema*", "**/*model*", "**/migration*"],
+        stackSpecific: {
+            convex: ["convex/schema.ts"],
+            prisma: ["prisma/schema.prisma"],
+            drizzle: ["**/drizzle/**"],
+            supabase: ["**/supabase/migrations/**"],
+        },
+    },
+    "design-system": {
+        generic: [
+            "**/tailwind.config*",
+            "**/globals.css",
+            "**/index.css",
+            "**/theme*",
+            "**/ui/**",
+            "**/styleguide*",
+            "**/design-system*",
+        ],
+        stackSpecific: {},
+    },
+    responsive: {
+        generic: [
+            "**/tailwind.config*",
+            "**/globals.css",
+            "**/index.css",
+            "**/components/**/*.{tsx,jsx}",
+            "**/pages/**/*.{tsx,jsx}",
+        ],
+        stackSpecific: {},
+    },
+    "pre-deploy": {
+        generic: [
+            "package.json",
+            "**/.env*",
+            "**/config*",
+            "tsconfig*",
+            "**/vite.config*",
+            "**/next.config*",
+            "**/vercel.json",
+            "**/.vercelignore",
+        ],
+        stackSpecific: {
+            convex: ["convex/*.ts"],
+        },
+    },
+    performance: {
+        generic: [
+            "package.json",
+            "**/vite.config*",
+            "**/next.config*",
+            "**/pages/**/*.{tsx,jsx}",
+            "**/app/**/*.{tsx,jsx}",
+            "**/components/**/*.{tsx,jsx}",
+            "**/tailwind.config*",
+            "**/index.css",
+            "**/globals.css",
+        ],
+        stackSpecific: {
+            convex: ["convex/*.ts"],
+        },
+    },
+    "ux-laws": {
+        generic: [
+            "**/pages/**/*.{tsx,jsx}",
+            "**/app/**/*.{tsx,jsx}",
+            "**/components/**/*.{tsx,jsx}",
+            "**/index.css",
+            "**/globals.css",
+        ],
+        stackSpecific: {},
+    },
+    consistency: {
+        generic: [
+            "**/components/**/*.{tsx,jsx}",
+            "**/pages/**/*.{tsx,jsx}",
+            "**/app/**/*.{tsx,jsx}",
+            "**/layout*",
+            "**/index.css",
+            "**/globals.css",
+        ],
+        stackSpecific: {},
+    },
+    "motion-audit": {
+        generic: [
+            "**/components/**/*.{tsx,jsx}",
+            "**/pages/**/*.{tsx,jsx}",
+            "**/lib/motion*",
+            "**/animations*",
+            "**/index.css",
+            "**/globals.css",
+        ],
+        stackSpecific: {},
+    },
+    "auth-check": {
+        generic: ["**/.env*", "**/auth*", "**/login*", "**/signup*", "**/middleware*", "**/session*"],
+        stackSpecific: {
+            convex: ["convex/auth.ts", "convex/http.ts", "convex/schema.ts", "convex/*.ts"],
+            supabase: ["**/supabase/**"],
+            firebase: ["**/firestore.rules"],
+        },
+    },
+    "env-check": {
+        generic: ["**/.env*", "**/config*", "package.json", "**/vite.config*", "**/next.config*"],
+        stackSpecific: {
+            convex: ["convex/http.ts"],
+        },
+    },
+    "taste-review": {
+        generic: [
+            "**/pages/**/*.{tsx,jsx}",
+            "**/app/**/*.{tsx,jsx}",
+            "**/components/**/*.{tsx,jsx}",
+            "**/index.css",
+            "**/globals.css",
+        ],
+        stackSpecific: {},
+    },
+    "product-check": {
+        generic: ["**/pages/**/*.{tsx,jsx}", "**/app/**/*.{tsx,jsx}", "**/components/**/*.{tsx,jsx}"],
+        stackSpecific: {},
+    },
+    "refactor-audit": {
+        generic: ["**/*.{ts,tsx,js,jsx}", "package.json", "tsconfig*"],
+        stackSpecific: {
+            convex: ["convex/*.ts"],
+        },
+    },
+    "pivot-audit": {
+        generic: ["**/docs/**", "**/*.md", "**/schema*", "**/prompts/**", "**/lib/**", "package.json"],
+        stackSpecific: {
+            convex: ["convex/schema.ts", "convex/lib/**"],
+        },
+    },
+    debug: {
+        generic: [
+            "**/pages/**/*.{tsx,jsx}",
+            "**/components/**/*.{tsx,jsx}",
+            "**/lib/**/*.{ts,tsx}",
+            "**/hooks/**/*.{ts,tsx}",
+            "**/*.{test,spec}.{ts,tsx}",
+        ],
+        stackSpecific: {
+            convex: ["convex/*.ts"],
+        },
+    },
+    product: {
+        generic: [
+            "**/pages/**/*.{tsx,jsx}",
+            "**/app/**/*.{tsx,jsx}",
+            "**/components/**/*.{tsx,jsx}",
+            "**/docs/**",
+            "**/*.md",
+        ],
+        stackSpecific: {},
+    },
+    placeholders: {
+        generic: [
+            "**/pages/**/*.{tsx,jsx}",
+            "**/components/**/*.{tsx,jsx}",
+            "**/lib/**/*.{ts,tsx}",
+            "**/hooks/**/*.{ts,tsx}",
+            "**/*.{test,spec}.{ts,tsx}",
+        ],
+        stackSpecific: {
+            convex: ["convex/*.ts"],
+        },
+    },
+};
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+/**
+ * Seleciona arquivos relevantes para um tipo de refine, baseado em patterns
+ * determinísticos (genéricos + stack-specific).
+ */
+export async function selectFiles(refineType, stack, cwd) {
+    const map = CONCERN_MAPS[refineType];
+    // Fallback: for refine types without a specific concern map, scan all source files
+    const fallbackPatterns = ["**/*.{ts,tsx,js,jsx}", "**/*.css", "**/package.json"];
+    const patterns = map ? [...map.generic, ...(map.stackSpecific[stack] ?? [])] : fallbackPatterns;
+    const allFiles = new Set();
+    const results = await Promise.all(patterns.map((pattern) => glob(pattern, {
+        cwd,
+        ignore: IGNORE_PATTERN,
+        nodir: true,
+    })));
+    for (const files of results) {
+        for (const file of files) {
+            allFiles.add(file);
+        }
+    }
+    return {
+        files: [...allFiles].sort(),
+        patterns,
+        stack,
+    };
+}

package/dist/detection/context-extractor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Context Extractor — Full Project Context
+ * Detecta stack, design tokens, schema, componentes, rotas e outputs anteriores.
+ * 100% deterministico, zero tokens de LLM.
+ */
+export interface StackInfo {
+    framework: "nextjs" | "remix" | "vite" | "astro" | "nuxt" | "unknown";
+    database: "convex" | "supabase" | "prisma" | "drizzle" | "firebase" | "django" | "unknown";
+    ui: "tailwind" | "css-modules" | "styled-components" | "emotion" | "unknown";
+    auth: "convex-auth" | "clerk" | "next-auth" | "supabase-auth" | "firebase-auth" | "unknown";
+}
+export interface DesignTokens {
+    colors: Record<string, string>;
+    radius: Record<string, string>;
+    fonts: Record<string, string>;
+    spacing: Record<string, string>;
+    other: Record<string, string>;
+}
+export interface SchemaTable {
+    name: string;
+    fields: Array<{
+        name: string;
+        type: string;
+    }>;
+}
+export interface ComponentInfo {
+    name: string;
+    path: string;
+}
+export interface ProjectContext {
+    stack: StackInfo;
+    designTokens: DesignTokens | null;
+    schema: SchemaTable[] | null;
+    components: ComponentInfo[] | null;
+    routes: string[] | null;
+    brand: null;
+    previousOutputs: Record<string, unknown> | null;
+}
+export declare function extractProjectContext(cwd: string): Promise<ProjectContext>;

package/dist/detection/context-extractor.js

@@ -0,0 +1,390 @@
+/**
+ * Context Extractor — Full Project Context
+ * Detecta stack, design tokens, schema, componentes, rotas e outputs anteriores.
+ * 100% deterministico, zero tokens de LLM.
+ */
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { glob } from "glob";
+import { IGNORE_DIRS } from "./file-tree.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const IGNORE_PATTERN = IGNORE_DIRS.map((d) => `**/${d}/**`);
+async function readFileOrNull(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+async function readPackageJson(cwd) {
+    const raw = await readFileOrNull(join(cwd, "package.json"));
+    if (!raw)
+        return { dependencies: {}, devDependencies: {} };
+    try {
+        const pkg = JSON.parse(raw);
+        return {
+            dependencies: pkg.dependencies ?? {},
+            devDependencies: pkg.devDependencies ?? {},
+        };
+    }
+    catch {
+        return { dependencies: {}, devDependencies: {} };
+    }
+}
+// ---------------------------------------------------------------------------
+// Stack Detection (TASK-130 — existing)
+// ---------------------------------------------------------------------------
+function detectFramework(deps, devDeps) {
+    if ("next" in deps)
+        return "nextjs";
+    if ("@remix-run/react" in deps)
+        return "remix";
+    if ("vite" in devDeps)
+        return "vite";
+    if ("astro" in deps)
+        return "astro";
+    if ("nuxt" in deps)
+        return "nuxt";
+    return "unknown";
+}
+function detectDatabase(deps, cwd) {
+    if ("convex" in deps)
+        return "convex";
+    if ("@supabase/ssr" in deps || "@supabase/supabase-js" in deps)
+        return "supabase";
+    if ("@prisma/client" in deps)
+        return "prisma";
+    if ("drizzle-orm" in deps)
+        return "drizzle";
+    if ("firebase" in deps)
+        return "firebase";
+    if (existsSync(join(cwd, "manage.py")))
+        return "django";
+    return "unknown";
+}
+async function detectUI(deps, devDeps, cwd) {
+    const allDeps = { ...deps, ...devDeps };
+    if ("tailwindcss" in allDeps || "@tailwindcss/vite" in allDeps)
+        return "tailwind";
+    const cssModules = await glob("src/**/*.module.css", {
+        cwd,
+        ignore: IGNORE_PATTERN,
+        maxDepth: 4,
+    });
+    if (cssModules.length > 0)
+        return "css-modules";
+    if ("styled-components" in deps)
+        return "styled-components";
+    if ("@emotion/styled" in deps)
+        return "emotion";
+    return "unknown";
+}
+function detectAuth(deps, database) {
+    if ("@convex-dev/auth" in deps)
+        return "convex-auth";
+    if ("@clerk/nextjs" in deps || "@clerk/clerk-react" in deps)
+        return "clerk";
+    if ("next-auth" in deps)
+        return "next-auth";
+    if ("@supabase/ssr" in deps && database === "supabase")
+        return "supabase-auth";
+    if ("firebase" in deps && database === "firebase")
+        return "firebase-auth";
+    return "unknown";
+}
+// ---------------------------------------------------------------------------
+// TASK-131 — Design Tokens Extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extrai design tokens de globals.css (CSS custom properties).
+ * Categoriza por prefixo: --color-*, --radius-*, --font-*, --space-*.
+ */
+async function extractDesignTokens(cwd) {
+    const candidates = [
+        "src/index.css",
+        "src/globals.css",
+        "globals.css",
+        "app/globals.css",
+        "src/app/globals.css",
+    ];
+    let cssContent = null;
+    for (const candidate of candidates) {
+        cssContent = await readFileOrNull(join(cwd, candidate));
+        if (cssContent)
+            break;
+    }
+    // Also check tailwind.config
+    const twConfigPaths = ["tailwind.config.ts", "tailwind.config.js", "tailwind.config.mjs"];
+    let twContent = null;
+    for (const p of twConfigPaths) {
+        twContent = await readFileOrNull(join(cwd, p));
+        if (twContent)
+            break;
+    }
+    if (!cssContent && !twContent)
+        return null;
+    const tokens = {
+        colors: {},
+        radius: {},
+        fonts: {},
+        spacing: {},
+        other: {},
+    };
+    // Parse CSS custom properties
+    if (cssContent) {
+        const varRegex = /^\s*(--[\w-]+)\s*:\s*(.+?)\s*;/gm;
+        for (const match of cssContent.matchAll(varRegex)) {
+            const [, name, value] = match;
+            if (name.startsWith("--color-") ||
+                name.startsWith("--bg-") ||
+                name.startsWith("--text-") ||
+                name.startsWith("--border-")) {
+                tokens.colors[name] = value;
+            }
+            else if (name.startsWith("--radius-") || name.startsWith("--rounded-")) {
+                tokens.radius[name] = value;
+            }
+            else if (name.startsWith("--font-") ||
+                name.startsWith("--text-") ||
+                name.startsWith("--leading-")) {
+                // --text- pode ser cor ou tipografia; se ja adicionou como cor, pular
+                if (!tokens.colors[name]) {
+                    tokens.fonts[name] = value;
+                }
+            }
+            else if (name.startsWith("--space-") ||
+                name.startsWith("--gap-") ||
+                name.startsWith("--padding-")) {
+                tokens.spacing[name] = value;
+            }
+            else {
+                tokens.other[name] = value;
+            }
+        }
+    }
+    const hasTokens = Object.keys(tokens.colors).length > 0 ||
+        Object.keys(tokens.radius).length > 0 ||
+        Object.keys(tokens.fonts).length > 0 ||
+        Object.keys(tokens.spacing).length > 0;
+    return hasTokens ? tokens : null;
+}
+// ---------------------------------------------------------------------------
+// TASK-132 — Schema Extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extrai schema do ORM/DB detectado.
+ * Convex: parseia convex/schema.ts (defineTable calls).
+ * Prisma: parseia prisma/schema.prisma (model blocks).
+ * Supabase/Drizzle: parseia arquivos de schema.
+ */
+async function extractSchema(cwd, database) {
+    switch (database) {
+        case "convex":
+            return extractConvexSchema(cwd);
+        case "prisma":
+            return extractPrismaSchema(cwd);
+        case "drizzle":
+            return extractDrizzleSchema(cwd);
+        default:
+            return null;
+    }
+}
+async function extractConvexSchema(cwd) {
+    const content = await readFileOrNull(join(cwd, "convex/schema.ts"));
+    if (!content)
+        return null;
+    const tables = [];
+    // Match: tableName: defineTable({ ... })
+    // We capture the table name and the field block
+    const tableRegex = /(\w+):\s*defineTable\(\{([^}]*(?:\{[^}]*\}[^}]*)*)\}\)/g;
+    for (const tableMatch of content.matchAll(tableRegex)) {
+        const [, tableName, fieldsBlock] = tableMatch;
+        const fields = [];
+        // Match field: v.type() or v.optional(v.type())
+        const fieldRegex = /(\w+):\s*(v\.[^,\n]+)/g;
+        for (const fieldMatch of fieldsBlock.matchAll(fieldRegex)) {
+            const [, fieldName, fieldType] = fieldMatch;
+            // Simplify type: v.string() -> string, v.optional(v.string()) -> optional(string)
+            const simplified = fieldType
+                .replace(/v\./g, "")
+                .replace(/\(\)/g, "")
+                .replace(/\(/g, "(")
+                .replace(/\)/g, ")");
+            fields.push({ name: fieldName, type: simplified });
+        }
+        tables.push({ name: tableName, fields });
+    }
+    return tables.length > 0 ? tables : null;
+}
+async function extractPrismaSchema(cwd) {
+    const content = await readFileOrNull(join(cwd, "prisma/schema.prisma"));
+    if (!content)
+        return null;
+    const tables = [];
+    const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g;
+    for (const modelMatch of content.matchAll(modelRegex)) {
+        const [, modelName, body] = modelMatch;
+        const fields = [];
+        for (const line of body.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@@"))
+                continue;
+            const parts = trimmed.split(/\s+/);
+            if (parts.length >= 2 && !parts[0].startsWith("@")) {
+                fields.push({ name: parts[0], type: parts[1] });
+            }
+        }
+        tables.push({ name: modelName, fields });
+    }
+    return tables.length > 0 ? tables : null;
+}
+async function extractDrizzleSchema(cwd) {
+    const candidates = await glob("**/schema.ts", {
+        cwd,
+        ignore: [...IGNORE_PATTERN, "convex/**"],
+        maxDepth: 3,
+    });
+    if (candidates.length === 0)
+        return null;
+    const tables = [];
+    for (const candidate of candidates) {
+        const content = await readFileOrNull(join(cwd, candidate));
+        if (!content)
+            continue;
+        // Match: export const tableName = pgTable("name", { ... }) or sqliteTable etc.
+        const tableRegex = /(?:pgTable|sqliteTable|mysqlTable)\(\s*["'](\w+)["']\s*,\s*\{([^}]+)\}/g;
+        for (const match of content.matchAll(tableRegex)) {
+            const [, tableName, fieldsBlock] = match;
+            const fields = [];
+            const fieldRegex = /(\w+):\s*(\w+)\(/g;
+            for (const fieldMatch of fieldsBlock.matchAll(fieldRegex)) {
+                fields.push({ name: fieldMatch[1], type: fieldMatch[2] });
+            }
+            tables.push({ name: tableName, fields });
+        }
+    }
+    return tables.length > 0 ? tables : null;
+}
+// ---------------------------------------------------------------------------
+// TASK-133 — Component Listing + Route Listing
+// ---------------------------------------------------------------------------
+/**
+ * Lista componentes em src/components/ (name, path).
+ */
+async function extractComponents(cwd) {
+    const componentFiles = await glob("src/components/**/*.{tsx,jsx}", {
+        cwd,
+        ignore: [...IGNORE_PATTERN, "**/*.test.*", "**/*.spec.*", "**/*.stories.*"],
+        maxDepth: 5,
+    });
+    if (componentFiles.length === 0)
+        return null;
+    return componentFiles.map((filePath) => ({
+        name: basename(filePath, extname(filePath)),
+        path: filePath,
+    }));
+}
+/**
+ * Lista rotas do projeto baseado no framework detectado.
+ * Vite: src/pages, Next.js: app/page ou pages/, Remix: app/routes, Astro: src/pages.
+ */
+async function extractRoutes(cwd, framework) {
+    let patterns;
+    switch (framework) {
+        case "nextjs":
+            patterns = ["app/**/page.{tsx,jsx,ts,js}", "pages/**/*.{tsx,jsx,ts,js}"];
+            break;
+        case "remix":
+            patterns = ["app/routes/**/*.{tsx,jsx,ts,js}"];
+            break;
+        case "astro":
+            patterns = ["src/pages/**/*.{astro,tsx,jsx,md,mdx}"];
+            break;
+        default:
+            patterns = [
+                "src/pages/**/*.{tsx,jsx,ts,js}",
+                "src/routes/**/*.{tsx,jsx,ts,js}",
+                "src/app/**/*.{tsx,jsx,ts,js}",
+            ];
+            break;
+    }
+    const allRoutes = [];
+    for (const pattern of patterns) {
+        const files = await glob(pattern, {
+            cwd,
+            ignore: [...IGNORE_PATTERN, "**/_*", "**/components/**"],
+            maxDepth: 5,
+        });
+        allRoutes.push(...files);
+    }
+    return allRoutes.length > 0 ? allRoutes : null;
+}
+// ---------------------------------------------------------------------------
+// TASK-138 — Pipeline .refine/ (previous outputs)
+// ---------------------------------------------------------------------------
+/**
+ * Le outputs de skills anteriores em .refine/ (identity.json, design-system.json, etc).
+ * Retorna mapa de skillName -> output JSON.
+ */
+async function extractPreviousOutputs(cwd) {
+    const refineDir = join(cwd, ".refine");
+    if (!existsSync(refineDir))
+        return null;
+    let entries;
+    try {
+        const dirEntries = await readdir(refineDir);
+        entries = dirEntries.filter((e) => e.endsWith(".json"));
+    }
+    catch {
+        return null;
+    }
+    if (entries.length === 0)
+        return null;
+    const outputs = {};
+    for (const entry of entries) {
+        const raw = await readFileOrNull(join(refineDir, entry));
+        if (!raw)
+            continue;
+        try {
+            const skillName = basename(entry, ".json");
+            outputs[skillName] = JSON.parse(raw);
+        }
+        catch {
+            // Skip malformed JSON
+        }
+    }
+    return Object.keys(outputs).length > 0 ? outputs : null;
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+export async function extractProjectContext(cwd) {
+    const { dependencies, devDependencies } = await readPackageJson(cwd);
+    const framework = detectFramework(dependencies, devDependencies);
+    const database = detectDatabase(dependencies, cwd);
+    const ui = await detectUI(dependencies, devDependencies, cwd);
+    const auth = detectAuth(dependencies, database);
+    // Run all extractions in parallel
+    const [designTokens, schema, components, routes, previousOutputs] = await Promise.all([
+        extractDesignTokens(cwd),
+        extractSchema(cwd, database),
+        extractComponents(cwd),
+        extractRoutes(cwd, framework),
+        extractPreviousOutputs(cwd),
+    ]);
+    return {
+        stack: { framework, database, ui, auth },
+        designTokens,
+        schema,
+        components,
+        routes,
+        brand: null,
+        previousOutputs,
+    };
+}

package/dist/detection/file-tree.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Scan do file tree do projeto do builder + deteccao de skill por sinais.
+ * Modulo puro, sem dependencias externas alem de glob e fs.
+ */
+export interface RoadmapPhaseProgress {
+    total: number;
+    done: number;
+}
+export interface RoadmapTasks {
+    total: number;
+    done: number;
+    tasksDone: string[];
+    byPhase: Record<string, RoadmapPhaseProgress>;
+}
+export interface FileTreeSummary {
+    pages: string[];
+    tests: string[];
+    mutations: string[];
+    cssVarCount: number;
+    colorVarCount: number;
+    hasPackageJson: boolean;
+    hasConvex: boolean;
+    hasTailwind: boolean;
+    hasVercelConfig: boolean;
+    roadmapTasks: RoadmapTasks | null;
+}
+export declare const IGNORE_DIRS: string[];
+export declare function scanFileTree(cwd: string): Promise<FileTreeSummary>;
+/**
+ * Detecta a skill inferida como "mais avancada concluida" baseado nos sinais do file tree.
+ * Percorre da prioridade mais alta pra mais baixa.
+ */
+export declare function detectSkill(summary: FileTreeSummary): string;