refine-mcp 0.1.0

package/dist/detection/compressor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Regex-based code compressor — fallback quando concern map retorna > 50k tokens.
+ * Extrai assinaturas, tipos, exports e imports sem corpo de funcao.
+ * Zero dependencias externas. ~60-70% reducao de tokens.
+ */
+export interface CompressedFile {
+    path: string;
+    original_tokens: number;
+    compressed_tokens: number;
+    content: string;
+}
+export interface CompressionResult {
+    files: CompressedFile[];
+    total_original_tokens: number;
+    total_compressed_tokens: number;
+    reduction_percent: number;
+}
+/**
+ * Comprime o conteudo de um arquivo baseado na extensao.
+ * Funcao pura — sem side effects, sem I/O.
+ */
+export declare function compressSource(source: string, filePath: string): string;
+/**
+ * Comprime multiplos arquivos e retorna resultado agregado com metricas de tokens.
+ */
+export declare function compressFiles(filePaths: string[], cwd: string): Promise<CompressionResult>;

package/dist/detection/compressor.js

@@ -0,0 +1,446 @@
+/**
+ * Regex-based code compressor — fallback quando concern map retorna > 50k tokens.
+ * Extrai assinaturas, tipos, exports e imports sem corpo de funcao.
+ * Zero dependencias externas. ~60-70% reducao de tokens.
+ */
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+async function readFileOrNull(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// TS/JS/TSX/JSX Compressor
+// ---------------------------------------------------------------------------
+function compressTypeScript(source) {
+    const lines = source.split("\n");
+    const output = [];
+    let depth = 0;
+    let inBlock = false;
+    let blockType = null;
+    let inExportType = false;
+    let exportTypeDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip empty lines inside blocks being compressed
+        if (inBlock && depth > 0) {
+            // Count braces on this line
+            for (const ch of line) {
+                if (ch === "{")
+                    depth++;
+                if (ch === "}")
+                    depth--;
+            }
+            if (depth <= 0) {
+                // Block closed — emit placeholder
+                depth = 0;
+                inBlock = false;
+                if (blockType === "internal-fn") {
+                    output.push("// ... internal");
+                }
+                else {
+                    output.push("  /* ... */ }");
+                }
+                blockType = null;
+            }
+            continue;
+        }
+        // Track export interface / export type blocks (preserve fully)
+        if (inExportType) {
+            output.push(line);
+            for (const ch of line) {
+                if (ch === "{")
+                    exportTypeDepth++;
+                if (ch === "}")
+                    exportTypeDepth--;
+            }
+            if (exportTypeDepth <= 0) {
+                inExportType = false;
+            }
+            continue;
+        }
+        // Blank lines — preserve between blocks
+        if (trimmed === "") {
+            output.push("");
+            continue;
+        }
+        // Import statements — preserve entirely
+        if (/^import\s/.test(trimmed) || /^import\s/.test(trimmed.replace(/^\/\/.*/, ""))) {
+            output.push(line);
+            // Handle multi-line imports
+            if (!trimmed.includes(";") && !trimmed.endsWith("'") && !trimmed.endsWith('"')) {
+                for (let j = i + 1; j < lines.length; j++) {
+                    i = j;
+                    output.push(lines[j]);
+                    if (lines[j].includes(";") ||
+                        lines[j].trim().endsWith("'") ||
+                        lines[j].trim().endsWith('"'))
+                        break;
+                }
+            }
+            continue;
+        }
+        // Export interface / export type — preserve fully
+        if (/^export\s+(interface|type)\s/.test(trimmed)) {
+            output.push(line);
+            // Single-line type alias
+            if (trimmed.includes(";") || (!trimmed.includes("{") && !trimmed.endsWith("{"))) {
+                continue;
+            }
+            // Multi-line — track brace depth
+            if (trimmed.includes("{")) {
+                inExportType = true;
+                exportTypeDepth = 0;
+                for (const ch of line) {
+                    if (ch === "{")
+                        exportTypeDepth++;
+                    if (ch === "}")
+                        exportTypeDepth--;
+                }
+                if (exportTypeDepth <= 0)
+                    inExportType = false;
+            }
+            else {
+                inExportType = true;
+                exportTypeDepth = 0;
+            }
+            continue;
+        }
+        // Re-exports: export { ... } from "..."
+        if (/^export\s*\{/.test(trimmed)) {
+            output.push(line);
+            if (!trimmed.includes("}")) {
+                for (let j = i + 1; j < lines.length; j++) {
+                    i = j;
+                    output.push(lines[j]);
+                    if (lines[j].includes("}"))
+                        break;
+                }
+            }
+            continue;
+        }
+        // Export default
+        if (/^export\s+default\s/.test(trimmed)) {
+            output.push(line);
+            continue;
+        }
+        // Exported function / async function / arrow function
+        if (/^export\s+(async\s+)?function\s/.test(trimmed) ||
+            /^export\s+const\s+\w+\s*=\s*(async\s+)?\(/.test(trimmed)) {
+            // Emit signature
+            const sigLine = line.replace(/\{[\s\S]*$/, "{").trimEnd();
+            output.push(sigLine.endsWith("{") ? sigLine : `${line.split("{")[0]}{`);
+            if (trimmed.includes("{")) {
+                blockType = "export-fn";
+                inBlock = true;
+                depth = 0;
+                for (const ch of line) {
+                    if (ch === "{")
+                        depth++;
+                    if (ch === "}")
+                        depth--;
+                }
+                if (depth <= 0) {
+                    output.pop();
+                    output.push(line.replace(/\{[\s\S]*\}/, "{ /* ... */ }"));
+                    inBlock = false;
+                    blockType = null;
+                    depth = 0;
+                }
+            }
+            continue;
+        }
+        // Exported class
+        if (/^export\s+(abstract\s+)?class\s/.test(trimmed)) {
+            output.push(line);
+            if (trimmed.includes("{")) {
+                // Parse class body — keep method signatures, skip bodies
+                blockType = "export-class";
+                inBlock = true;
+                depth = 0;
+                for (const ch of line) {
+                    if (ch === "{")
+                        depth++;
+                    if (ch === "}")
+                        depth--;
+                }
+                if (depth <= 0) {
+                    inBlock = false;
+                    blockType = null;
+                    depth = 0;
+                }
+            }
+            continue;
+        }
+        // Exported const/let/var (non-function)
+        if (/^export\s+(const|let|var)\s/.test(trimmed)) {
+            output.push(line);
+            // If multi-line value, skip until semicolon or balanced
+            if (!trimmed.includes(";") && trimmed.includes("{")) {
+                let valDepth = 0;
+                for (const ch of line) {
+                    if (ch === "{")
+                        valDepth++;
+                    if (ch === "}")
+                        valDepth--;
+                }
+                if (valDepth > 0) {
+                    // Truncate — just show declaration
+                    output.pop();
+                    const declPart = line.split("=")[0];
+                    output.push(`${declPart}= { /* ... */ };`);
+                    // Skip until balanced
+                    for (let j = i + 1; j < lines.length; j++) {
+                        for (const ch of lines[j]) {
+                            if (ch === "{")
+                                valDepth++;
+                            if (ch === "}")
+                                valDepth--;
+                        }
+                        i = j;
+                        if (valDepth <= 0)
+                            break;
+                    }
+                }
+            }
+            continue;
+        }
+        // Internal (non-exported) function — replace with comment
+        if (/^(async\s+)?function\s/.test(trimmed) ||
+            /^const\s+\w+\s*=\s*(async\s+)?\(/.test(trimmed)) {
+            if (trimmed.includes("{")) {
+                blockType = "internal-fn";
+                inBlock = true;
+                depth = 0;
+                for (const ch of line) {
+                    if (ch === "{")
+                        depth++;
+                    if (ch === "}")
+                        depth--;
+                }
+                if (depth <= 0) {
+                    output.push("// ... internal");
+                    inBlock = false;
+                    blockType = null;
+                    depth = 0;
+                }
+            }
+            continue;
+        }
+        // JSDoc at top of file (first block comment)
+        if (trimmed.startsWith("/**") && output.filter((l) => l.trim() !== "").length === 0) {
+            output.push(line);
+            if (!trimmed.endsWith("*/")) {
+                for (let j = i + 1; j < lines.length; j++) {
+                    i = j;
+                    output.push(lines[j]);
+                    if (lines[j].trim().endsWith("*/"))
+                        break;
+                }
+            }
+            continue;
+        }
+        // Inline comments inside logic — skip
+        if (trimmed.startsWith("//")) {
+            continue;
+        }
+        // Decorators — preserve
+        if (trimmed.startsWith("@")) {
+            output.push(line);
+        }
+        // Everything else at top level — skip (implementation detail)
+    }
+    return output.join("\n");
+}
+// ---------------------------------------------------------------------------
+// CSS Compressor
+// ---------------------------------------------------------------------------
+function compressCSS(source) {
+    const lines = source.split("\n");
+    const output = [];
+    let inRule = false;
+    let ruleDepth = 0;
+    let hasCustomProp = false;
+    let ruleLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Preserve @import, @charset, @layer
+        if (/^@(import|charset|layer)\b/.test(trimmed)) {
+            output.push(line);
+            continue;
+        }
+        if (inRule) {
+            for (const ch of line) {
+                if (ch === "{")
+                    ruleDepth++;
+                if (ch === "}")
+                    ruleDepth--;
+            }
+            // Check for custom properties
+            if (/^\s*--[\w-]+\s*:/.test(line)) {
+                hasCustomProp = true;
+                ruleLines.push(line);
+            }
+            if (ruleDepth <= 0) {
+                inRule = false;
+                if (hasCustomProp) {
+                    // Emit selector + custom props only
+                    for (const rl of ruleLines)
+                        output.push(rl);
+                    output.push("}");
+                }
+                else {
+                    output.push("  /* ... */ }");
+                }
+                ruleLines = [];
+                hasCustomProp = false;
+            }
+            continue;
+        }
+        // Blank line
+        if (trimmed === "") {
+            output.push("");
+            continue;
+        }
+        // Selector line (opens a rule block)
+        if (trimmed.endsWith("{") || trimmed.includes("{")) {
+            const selector = line.split("{")[0];
+            output.push(`${selector}{`);
+            ruleDepth = 0;
+            for (const ch of line) {
+                if (ch === "{")
+                    ruleDepth++;
+                if (ch === "}")
+                    ruleDepth--;
+            }
+            if (ruleDepth <= 0) {
+                // Single-line rule
+                if (/--[\w-]+\s*:/.test(line)) {
+                    output.pop();
+                    output.push(line);
+                }
+                else {
+                    output.pop();
+                    output.push(`${selector.trimEnd()} { /* ... */ }`);
+                }
+            }
+            else {
+                inRule = true;
+                ruleLines = [];
+                hasCustomProp = false;
+                // Check if the opening line itself has a custom prop
+                if (/--[\w-]+\s*:/.test(line)) {
+                    hasCustomProp = true;
+                }
+            }
+            continue;
+        }
+        // Top-level custom property (outside any rule)
+        if (/^\s*--[\w-]+\s*:/.test(trimmed)) {
+            output.push(line);
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join("\n");
+}
+// ---------------------------------------------------------------------------
+// JSON Compressor
+// ---------------------------------------------------------------------------
+function compressJSON(source) {
+    try {
+        const parsed = JSON.parse(source);
+        if (typeof parsed !== "object" || parsed === null)
+            return source;
+        const truncated = truncateDeep(parsed, 0, 2);
+        return JSON.stringify(truncated, null, 2);
+    }
+    catch {
+        return source;
+    }
+}
+function truncateDeep(value, currentDepth, maxDepth) {
+    if (currentDepth >= maxDepth) {
+        if (Array.isArray(value))
+            return ["..."];
+        if (typeof value === "object" && value !== null)
+            return "...";
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => truncateDeep(item, currentDepth + 1, maxDepth));
+    }
+    if (typeof value === "object" && value !== null) {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = truncateDeep(val, currentDepth + 1, maxDepth);
+        }
+        return result;
+    }
+    return value;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+const TS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
+/**
+ * Comprime o conteudo de um arquivo baseado na extensao.
+ * Funcao pura — sem side effects, sem I/O.
+ */
+export function compressSource(source, filePath) {
+    const ext = extname(filePath).toLowerCase();
+    if (TS_EXTENSIONS.has(ext))
+        return compressTypeScript(source);
+    if (ext === ".css")
+        return compressCSS(source);
+    if (ext === ".json")
+        return compressJSON(source);
+    // Extensao desconhecida — retorna original
+    return source;
+}
+/**
+ * Comprime multiplos arquivos e retorna resultado agregado com metricas de tokens.
+ */
+export async function compressFiles(filePaths, cwd) {
+    const files = [];
+    let totalOriginal = 0;
+    let totalCompressed = 0;
+    for (const filePath of filePaths) {
+        const fullPath = join(cwd, filePath);
+        const content = await readFileOrNull(fullPath);
+        if (content === null)
+            continue;
+        const originalTokens = estimateTokens(content);
+        const compressed = compressSource(content, filePath);
+        const compressedTokens = estimateTokens(compressed);
+        totalOriginal += originalTokens;
+        totalCompressed += compressedTokens;
+        files.push({
+            path: filePath,
+            original_tokens: originalTokens,
+            compressed_tokens: compressedTokens,
+            content: compressed,
+        });
+    }
+    const reductionPercent = totalOriginal > 0 ? Math.round(((totalOriginal - totalCompressed) / totalOriginal) * 100) : 0;
+    return {
+        files,
+        total_original_tokens: totalOriginal,
+        total_compressed_tokens: totalCompressed,
+        reduction_percent: reductionPercent,
+    };
+}

package/dist/detection/concern-map.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export type RefineType = string;
+export type StackDatabase = "convex" | "supabase" | "prisma" | "drizzle" | "firebase" | "django" | "unknown";
+export interface ConcernMapResult {
+    files: string[];
+    patterns: string[];
+    stack: StackDatabase;
+}
+/**
+ * Seleciona arquivos relevantes para um tipo de refine, baseado em patterns
+ * determinísticos (genéricos + stack-specific).
+ */
+export declare function selectFiles(refineType: string, stack: StackDatabase, cwd: string): Promise<ConcernMapResult>;