vibetachyon 1.1.0

package/README.md

@@ -0,0 +1,83 @@
+# 🚀 VibeTachyon MCP v1.0
+### The "God-Tier" Frontend AI Copilot Engine
+
+VibeTachyon is not just another MCP server. It is a high-performance **Autonomous Frontend Engineering System** designed to transform any AI (Claude, GPT, Gemini) into a God-Tier developer. Built on top of the VibeCodes ecosystem, it bridges the gap between design (Figma), **data architecture (Prisma, Drizzle, SQL)**, and pixel-perfect execution.
+
+---
+
+## 💎 Elite Features
+
+### 🧠 The Self-Healing Matrix
+*   **AST Auto-Correction:** Uses `self_heal_typescript_errors` to run local `tsc` checks. If the AI generates a bug, Tachyon catches the AST error and forces the AI to fix it before you even see it.
+*   **Vision QA Loop:** Use `initiate_visual_qa` to perform pixel-perfect audits. Paste a screenshot, and Tachyon will autonomously patch Tailwind margins, padding, and alignment.
+
+### 🎨 Design-to-Code Bridge
+*   **Figma Transcription:** `fetch_figma_design` pulls raw JSON nodes directly from Figma API and maps them to clean Tailwind/React code.
+*   **Theme Cloning:** `get_vibe_colors` and `learn_user_preferences` scan your local `globals.css` and `.prettierrc` to clone your exact coding style and color palette.
+
+### 🛡️ "Accept-All" Guardrails (Zero friction)
+*   **Framework Agnostic:** Dynamically detects if you are using **Next.js** or **Vite**. It automatically translates `<Image>` to `<img>` and `Link` to `<a>` to prevent framework mismatches.
+*   **Dependency Resolver:** `analyze_and_install_deps` identifies missing packages (framer-motion, lucide, etc.) and generates the exact install command.
+
+### 📈 Enterprise Standards
+*   **VibeSec Penetration Tester:** `run_security_penetration` automatically scans newly generated code for XSS vectors, SQL Injection risks, and hardcoded Secrets. If a vulnerability is found, it blocks delivery and forces the AI to rewrite the logic safely.
+*   **VibePilot CLI:** `update_terminal_status` gives the AI a literal "face" in your terminal. It writes chalk-colored progress bars and statuses (e.g. `🧠 Compiling AST Fixes...`) to `stderr` so you can visually watch the bot think.
+*   **VibeSpeed Local (Lighthouse):** `initiate_vibespeed_audit` runs an automated headless Lighthouse test on localhost. If the Performance score is <90, the Copilot forces itself to refactor the page (lazy loading, optimized images) until it passes.
+*   **Data Intelligence:** `analyze_business_logic` scans for **Prisma, Drizzle, or raw TS models** to ground UI generation in your real data structure. No hard dependencies.
+*   **Telemetry Engine:** `enforce_telemetry_tracking` forces the injection of `data-vibe-tracking` attributes for instant PostHog/GA integration.
+*   **i18n Globalization:** `enforce_i18n_standards` forbids hardcoded strings, forcing text extraction for easy translation.
+*   **SEO Heuristics:** `enforce_seo_metadata` injects framework-native SEO/OpenGraph tags for maximum ranking.
+
+---
+
+## 🛠️ Toolset Overview
+
+| Category | Tools | Description |
+| :--- | :--- | :--- |
+| **Search** | `search_vibecodes_snippets`, `compose_landing_page` | Semantic RAG search for UI and full-page composition. |
+| **Analysis** | `scan_local_architecture`, `analyze_business_logic` | Scans `package.json`, Prisma schemas, and API routes. |
+| **Styling** | `get_vibe_colors`, `patch_tailwind_config` | Real-time theme extraction and Tailwind config patching. |
+| **QA** | `self_heal_typescript_errors`, `initiate_visual_qa` | Autonomous AST error fixing and AI Vision validation. |
+| **Guardrails** | `enforce_atomic_design`, `audit_a11y_wcag`, `enforce_seo_metadata` | Enforces 150-line limits, WCAG compliance, and SEO tags. |
+| **Integration** | `fetch_figma_design`, `generate_local_assets` | Connects Figma designs and localizes remote assets. |
+
+---
+
+## 🚀 Getting Started (Automatic Installation)
+
+The easiest way to get VibeTachyon running in your IDE is via our interactive installer.
+
+### 1. Run the Installer
+In your project terminal, run:
+```bash
+npx vibetachyon@latest
+```
+
+### 2. Follow the Prompts
+1.  **Select your IDE:** Cursor, Windsurf, Claude Desktop, VS Code (Cline/Roo), etc.
+2.  **Authenticate:** Paste your **VibeCodes MAX Token**.
+3.  **Done:** The installer will autonomously inject the MCP configuration into your IDE's global settings.
+
+### 3. Manual Configuration (Optional)
+If you prefer manual setup, add this to your MCP config file:
+```json
+{
+  "mcpServers": {
+    "vibetachyon": {
+      "command": "npx",
+      "args": ["-y", "vibetachyon@latest", "server"],
+      "env": {
+        "VIBECODES_TOKEN": "YOUR_TOKEN_HERE"
+      }
+    }
+  }
+}
+```
+
+---
+
+## 📜 Coding Philosophy
+VibeTachyon enforces **Atomic Design** and **Framework Awareness**. It treats the code as a living organism that must be performant (minified snippets), accessible (WCAG), and measurable (Telemetry).
+
+**Made with 💙 by Davi Ravieri.**
+"Make it work, make it beautiful, make it God-Tier."

package/dist/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = require("@clack/prompts");
+const picocolors_1 = __importDefault(require("picocolors"));
+const mcp_server_js_1 = require("./mcp-server.js");
+const installer_js_1 = require("./installer.js");
+async function main() {
+    const args = process.argv.slice(2);
+    // Run as MCP Server if "server" is passed as argument
+    if (args[0] === 'server') {
+        await (0, mcp_server_js_1.startMcpServer)();
+        return;
+    }
+    // CLI Interactive Mode
+    console.log();
+    (0, prompts_1.intro)(picocolors_1.default.bgBlue(picocolors_1.default.white(' ⚡ VibeTachyon MCP CLI ')));
+    const action = await (0, prompts_1.select)({
+        message: 'What would you like to do with VibeTachyon?',
+        options: [
+            { value: 'install', label: 'Install/Sync VibeTachyon on my Code Agents (Cursor, Windsurf, Claude)' },
+            { value: 'exit', label: 'Exit' }
+        ]
+    });
+    if ((0, prompts_1.isCancel)(action) || action === 'exit') {
+        (0, prompts_1.outro)('Aborted.');
+        process.exit(0);
+    }
+    if (action === 'install') {
+        await (0, installer_js_1.runInstallFlow)();
+    }
+}
+main().catch(console.error);

package/dist/installer.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInstallFlow = runInstallFlow;
+const prompts_1 = require("@clack/prompts");
+const picocolors_1 = __importDefault(require("picocolors"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function runInstallFlow() {
+    const agent = await (0, prompts_1.select)({
+        message: 'Select your preferred Code Agent to inject VibeTachyon:',
+        options: [
+            { value: 'cursor', label: 'Cursor' },
+            { value: 'windsurf', label: 'Windsurf' },
+            { value: 'claude', label: 'Claude Desktop / Claude Code' },
+            { value: 'gemini', label: 'Gemini CLI / Antigravity' },
+            { value: 'cline', label: 'Cline / Roo Code (VS Code)' },
+            { value: 'copilot', label: 'GitHub Copilot (VS Code)' },
+            { value: 'codex', label: 'Codex CLI' },
+            { value: 'augment', label: 'Augment Code' }
+        ]
+    });
+    if ((0, prompts_1.isCancel)(agent)) {
+        (0, prompts_1.outro)('Aborted.');
+        process.exit(0);
+    }
+    const apiKey = await (0, prompts_1.text)({
+        message: 'Paste your VibeCodes MAX Access Token:',
+        placeholder: 'vcf_...',
+        validate(value) {
+            if (value.length === 0)
+                return 'Token is required!';
+        }
+    });
+    if ((0, prompts_1.isCancel)(apiKey)) {
+        (0, prompts_1.outro)('Aborted.');
+        process.exit(0);
+    }
+    const s = (0, prompts_1.spinner)();
+    s.start(`Connecting to VibeCodes and verifying token...`);
+    try {
+        // NOTE: In a real production environment, this URL would be 'https://vibecodes.com.br/api/vibecodes/mcp/verify'
+        // For development/local testing, you can change this to http://localhost:3000
+        // Use environment variable for the API URL, default to a placeholder
+        // TODO: Replace with your actual production domain once purchased
+        const API_URL = process.env.VIBETACHYON_API_URL || 'http://127.0.0.1:3000/api/vibecodes/mcp/verify';
+        const response = await fetch(API_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ token: apiKey })
+        });
+        const data = await response.json();
+        if (!response.ok || !data.success) {
+            s.stop(picocolors_1.default.red(`Authentication Failed. ${data.error || 'Invalid Token.'}`));
+            process.exit(1);
+        }
+        s.message(picocolors_1.default.green(`✅ Authenticated as ${data.name || 'VibeCodes MAX User'}. Injecting MCP into ${agent}...`));
+    }
+    catch (err) {
+        s.stop(picocolors_1.default.red(`Network Error: Please check your connection or the VibeCodes API.`));
+        process.exit(1);
+    }
+    // Path resolution logic
+    const home = os_1.default.homedir();
+    let mcpConfigPath = '';
+    let configObject = {};
+    // Standard MCP Server definition
+    const serverDefinition = {
+        command: "npx",
+        args: ["-y", "vibetachyon@latest", "server"],
+        env: {
+            VIBECODES_TOKEN: apiKey
+        }
+    };
+    switch (agent) {
+        case 'cursor':
+            mcpConfigPath = path_1.default.join(home, '.cursor', 'mcp.json');
+            configObject = { mcpServers: { vibetachyon: serverDefinition } };
+            break;
+        case 'windsurf':
+            mcpConfigPath = path_1.default.join(home, '.codeium', 'windsurf', 'mcp_config.json');
+            configObject = { mcpServers: { vibetachyon: serverDefinition } };
+            break;
+        case 'claude':
+            mcpConfigPath = path_1.default.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+            configObject = { mcpServers: { vibetachyon: serverDefinition } };
+            break;
+        case 'gemini':
+            mcpConfigPath = path_1.default.join(home, '.gemini', 'antigravity', 'mcp.json');
+            configObject = { mcpServers: { vibetachyon: serverDefinition } };
+            break;
+        case 'cline':
+            mcpConfigPath = path_1.default.join(process.cwd(), '.vscode', 'roo_mcp.json');
+            configObject = { mcpServers: { vibetachyon: serverDefinition } };
+            break;
+        case 'copilot':
+            mcpConfigPath = path_1.default.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'github.copilot', 'mcp.json');
+            configObject = { mcpServers: { vibetachyon: serverDefinition } };
+            break;
+        default:
+            mcpConfigPath = path_1.default.join(home, '.vibetachyon', 'mcp_config.json');
+            configObject = { mcpServers: { vibetachyon: serverDefinition } };
+    }
+    try {
+        // Ensure directory exists
+        const dir = path_1.default.dirname(mcpConfigPath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        // Merge if file exists, or create new
+        let finalConfig = configObject;
+        if (fs_1.default.existsSync(mcpConfigPath)) {
+            try {
+                const existing = JSON.parse(fs_1.default.readFileSync(mcpConfigPath, 'utf8'));
+                if (existing.mcpServers) {
+                    existing.mcpServers.vibetachyon = serverDefinition;
+                    finalConfig = existing;
+                }
+            }
+            catch (e) {
+                // If corrupt, overwrite with our new config
+            }
+        }
+        fs_1.default.writeFileSync(mcpConfigPath, JSON.stringify(finalConfig, null, 2));
+    }
+    catch (err) {
+        s.stop(picocolors_1.default.red(`Error writing configuration: ${err.message}`));
+        process.exit(1);
+    }
+    s.stop(picocolors_1.default.green('Injection completed successfully.'));
+    console.log(picocolors_1.default.gray('\n┌──────────────────────────────────────────────┐'));
+    console.log(picocolors_1.default.gray('│') + picocolors_1.default.bold(picocolors_1.default.cyan(' Server configuration created at: ')));
+    console.log(picocolors_1.default.gray('│') + ' ' + picocolors_1.default.dim(mcpConfigPath));
+    console.log(picocolors_1.default.gray('└──────────────────────────────────────────────┘\n'));
+    (0, prompts_1.outro)(picocolors_1.default.green('🚀 VibeTachyon is ready! Your IDE is now connected to VibeCodes.'));
+}

package/dist/mcp-server.js

@@ -0,0 +1,774 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMcpServer = startMcpServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const supabase_js_1 = require("@supabase/supabase-js");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const execPromise = util_1.default.promisify(child_process_1.exec);
+// Initialize Supabase. Note: These ENV variables will be injected or provided by the installer/user config in the future.
+// For now, we use placeholders expecting them in process.env
+const supabaseUrl = process.env.VIBECODES_SUPABASE_URL || 'https://yhrcxrtzaxamvxtjrdif.supabase.co';
+const supabaseKey = process.env.VIBECODES_SUPABASE_ANON_KEY || 'your-default-anon-key';
+const supabase = (0, supabase_js_1.createClient)(supabaseUrl, supabaseKey);
+/**
+ * Minifies a code snippet by removing comments and extra whitespace to save tokens.
+ */
+function minifySnippet(code) {
+    // Remove multi-line comments
+    let minified = code.replace(/\/\*[\s\S]*?\*\//g, '');
+    // Remove single-line comments (but NOT inside URLs/strings)
+    minified = minified.split('\n').map(line => {
+        // Simple heuristic: if // appears after http: or https:, don't treat as comment
+        const commentIndex = line.indexOf('//');
+        if (commentIndex !== -1 && !line.includes('http://') && !line.includes('https://')) {
+            return line.substring(0, commentIndex).trimEnd();
+        }
+        return line;
+    }).join('\n');
+    // Collapse excess newlines but keep some structure for the LLM
+    return minified.replace(/\n\s*\n/g, '\n').trim();
+}
+async function startMcpServer() {
+    const server = new mcp_js_1.McpServer({
+        name: "VibeTachyon MCP",
+        version: "1.0.0"
+    });
+    // Tool: Searching Snippets
+    // Tool: Searching Snippets
+    server.tool("search_vibecodes_snippets", "Search for UI components in the VibeCodes repository (both public and MCP-exclusive). Returns TSX/HTML/CSS code.", {
+        query: zod_1.z.string().describe("Search query for the UI component (e.g. 'pricing table', 'neon button')"),
+        limit: zod_1.z.number().optional().describe("Max number of results to return (default: 5)"),
+        projectDir: zod_1.z.string().optional().describe("Absolute path to the user's project root. Crucial for auto-formatting code correctly.")
+    }, async ({ query, limit = 5, projectDir }) => {
+        console.error(`[VibeTachyon] Searching Semantic DB for: ${query}`);
+        try {
+            // Use the Advanced RAG Postgres RPC for semantic natural language TSVector search
+            const { data: allResults, error } = await supabase
+                .rpc('search_vibecodes_mcp', {
+                search_query: query,
+                max_limit: limit
+            });
+            if (error) {
+                console.error("[VibeTachyon] Supabase RPC Error:", error);
+                throw error;
+            }
+            if (!allResults || allResults.length === 0) {
+                return {
+                    content: [{ type: "text", text: `No VibeCodes components found for "${query}". Try different semantics.` }]
+                };
+            }
+            const formattedResults = allResults.map((item) => {
+                const srcInfo = item.source_table === 'mcp_exclusive' ? '[⭐ PREMIUM MCP EXCLUSIVE]' : '[🌐 VIBECODES HUB]';
+                const minifiedCode = minifySnippet(item.code);
+                return `### ${item.title} ${srcInfo}\n${item.description || ''}\n\n\`\`\`tsx\n${minifiedCode}\n\`\`\``;
+            }).join('\n\n---\n\n');
+            // --- ZERO FRICTION "ACCEPT-ALL" GUARDRAILS ---
+            const root = projectDir || process.cwd();
+            let frameworkContext = "";
+            try {
+                const pkgPath = path_1.default.join(root, 'package.json');
+                if (await fs_extra_1.default.pathExists(pkgPath)) {
+                    const pkg = await fs_extra_1.default.readJson(pkgPath);
+                    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                    const isVite = !!deps['vite'];
+                    const isNext = !!deps['next'];
+                    frameworkContext += `\n\n=======================================================\n`;
+                    frameworkContext += `[CRITICAL COPILOT DIRECTIVE - ZERO FRICTION GUARANTEE]\n`;
+                    frameworkContext += `You are generating code for a user who will likely click "Accept All". You MUST NOT output incompatible code that breaks their app. `;
+                    frameworkContext += `USER ENVIRONMENT: ${isNext ? 'Next.js' : isVite ? 'Vite/React SPA' : 'React/Other'}.\n\n`;
+                    if (isVite) {
+                        frameworkContext += `🚨 FATAL VITE ERROR PREVENTION:\n- DO NOT use Next.js '<Image>' or 'next/link'.\n- DO NOT use '"use client"'.\n- You MUST implicitly translate the components above into standard '<img>' and '<a>' tags BEFORE writing the final code.\n`;
+                        frameworkContext += `- Tell the user to run this command if animations are used: \`npm install framer-motion lucide-react clsx tailwind-merge\`\n`;
+                    }
+                    else if (isNext) {
+                        frameworkContext += `🚨 NEXT.JS OPTIMIZATION:\n- Use Server Components by default.\n- If the component uses hooks (useState) or onClick, you MUST prepend '"use client";' at the very top of the generated file.\n`;
+                        frameworkContext += `- Ensure image domains are whitelisted (tell them to update next.config.ts if an external src is used).\n`;
+                    }
+                    frameworkContext += `=======================================================\n`;
+                }
+            }
+            catch (e) {
+                // silently fail the context extraction if no pkg json found
+            }
+            return {
+                content: [{ type: "text", text: `🧠 VibeTachyon found ${allResults.length} highly relevant components:\n\n${formattedResults}${frameworkContext}` }]
+            };
+        }
+        catch (error) {
+            console.error("[VibeTachyon] Supabase Search Error:", error);
+            return {
+                content: [{ type: "text", text: `Error searching VibeCodes repository: ${error}` }]
+            };
+        }
+    });
+    // Example Tool: Access VibeCodes Rules
+    server.tool("get_vibecodes_architecture", "Get instructions on how to design and build components adhering to the VibeCodes Neon Blue Design System", {}, async () => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `VibeCodes Design System Rules:\n1. Dark mode natively (backgrounds using hsl).\n2. Glassmorphism: Borders should be white/10 or primary/20.\n3. Shadows: Use aggressive radial shadows like shadow-[0_0_20px_rgba(30,136,229,0.15)].\n4. Use Lucide React icons.\n5. Use Shadcn UI as base but apply custom Vibe themes.`
+                }
+            ]
+        };
+    });
+    // Tool: Scan Local Architecture
+    server.tool("scan_local_architecture", "Scan the user's local project setup (package.json, tsconfig.json, components.json) to understand how to correctly import and structure generated UI components.", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root (e.g. /Users/admin/my-project). Ask the user or find it via terminal if unknown.")
+    }, async ({ projectDir }) => {
+        const root = projectDir || process.cwd();
+        let context = `[VibeTachyon Architecture Scanner] Project Root: ${root}\n\n`;
+        try {
+            // Check components.json (Shadcn UI)
+            const componentsPath = path_1.default.join(root, 'components.json');
+            if (await fs_extra_1.default.pathExists(componentsPath)) {
+                context += `- Detected Shadcn UI (components.json).\n`;
+                const compJson = await fs_extra_1.default.readJson(componentsPath);
+                context += `  - Components Path: ${compJson?.aliases?.components || '@/components'}\n`;
+                context += `  - Utils Path: ${compJson?.aliases?.utils || '@/lib/utils'}\n`;
+            }
+            // Check tsconfig.json (Paths)
+            let tsConfigPath = path_1.default.join(root, 'tsconfig.json');
+            if (!(await fs_extra_1.default.pathExists(tsConfigPath))) {
+                // Try one dir up in case they are inside src
+                tsConfigPath = path_1.default.join(root, '..', 'tsconfig.json');
+            }
+            if (await fs_extra_1.default.pathExists(tsConfigPath)) {
+                context += `- Detected tsconfig.json.\n`;
+                // Note: fs.readJson can throw on comments in tsconfig, so we use readFileSync and strip basic comments or ignore parsing errors gracefully
+                try {
+                    const tsRaw = await fs_extra_1.default.readFile(tsConfigPath, 'utf8');
+                    const tsClean = tsRaw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+                    const tsJson = JSON.parse(tsClean);
+                    if (tsJson?.compilerOptions?.paths) {
+                        context += `  - Aliases available: ${Object.keys(tsJson.compilerOptions.paths).join(', ')}\n`;
+                    }
+                }
+                catch (e) {
+                    context += `  - (Could not parse paths automatically due to complex tsconfig format)\n`;
+                }
+            }
+            // Check dependencies
+            const pkgPath = path_1.default.join(root, 'package.json');
+            if (await fs_extra_1.default.pathExists(pkgPath)) {
+                const pkg = await fs_extra_1.default.readJson(pkgPath);
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                const keyDeps = ['framer-motion', 'lucide-react', 'clsx', 'tailwind-merge', 'next', 'react'];
+                const installed = keyDeps.filter(d => deps[d]);
+                context += `- Key UI Dependencies Installed: ${installed.join(', ')}\n`;
+            }
+            return {
+                content: [{ type: "text", text: `${context}\n\nINSTRUCTION FOR AI: Always respect these paths and aliases when generating TSX code for the user. Do not use generic './components' if an alias like '@/' is available.` }]
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error scanning architecture: ${err}` }]
+            };
+        }
+    });
+    // Tool: Get Vibe Colors
+    server.tool("get_vibe_colors", "Extract local CSS variables from globals.css to ensure generated components match the user's specific dark/light theme native colors.", {
+        cssFilePath: zod_1.z.string().describe("Absolute path to the user's main CSS file (e.g., /Users/admin/my-project/src/app/globals.css). Search for it before utilizing.")
+    }, async ({ cssFilePath }) => {
+        try {
+            if (!(await fs_extra_1.default.pathExists(cssFilePath))) {
+                return {
+                    content: [{ type: "text", text: `Error: Could not find CSS file at ${cssFilePath}. Please provide the correct path (e.g., src/app/globals.css or src/index.css).` }]
+                };
+            }
+            const cssContent = await fs_extra_1.default.readFile(cssFilePath, 'utf-8');
+            // Extract --variable names
+            const matches = cssContent.match(/--[a-zA-Z0-9-]+(?=\s*:)/g);
+            if (!matches || matches.length === 0) {
+                return {
+                    content: [{ type: "text", text: `Scanned ${cssFilePath} but couldn't find explicit CSS variables (like --primary, --background). Instruct AI to stick to standard Tailwind neutral colors.` }]
+                };
+            }
+            const uniqueVars = Array.from(new Set(matches.map(m => m.trim())));
+            return {
+                content: [{
+                        type: "text",
+                        text: `[VibeTachyon Theming Scanner] Found the following CSS variables in the project:\n${uniqueVars.join(', ')}\n\nINSTRUCTION FOR AI: When generating the component, DO NOT hardcode standard colors (like 'bg-blue-500'). Instead, dynamically inject the user's variables using Tailwind semantic semantic classes (like 'bg-background', 'text-primary', 'border-border') to flawlessly match their existing theme layout.`
+                    }]
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error parsing CSS colors: ${err}` }]
+            };
+        }
+    });
+    // Tool: Analyze and Install Deps
+    server.tool("analyze_and_install_deps", "Analyze a list of required npm packages for a UI component and return the exact terminal command the user (or AI Copilot) must run to install the missing dependencies.", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root (where package.json lives)."),
+        requiredDependencies: zod_1.z.array(zod_1.z.string()).describe("List of npm package names requested by the UI component (e.g., ['framer-motion', 'clsx'])")
+    }, async ({ projectDir, requiredDependencies }) => {
+        const root = projectDir || process.cwd();
+        try {
+            const pkgPath = path_1.default.join(root, 'package.json');
+            if (!(await fs_extra_1.default.pathExists(pkgPath))) {
+                return {
+                    content: [{ type: "text", text: `Error: package.json not found in ${root}. Please ensure project directory is correct.` }]
+                };
+            }
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            const localDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            const missingDeps = requiredDependencies.filter(dep => !localDeps[dep]);
+            if (missingDeps.length === 0) {
+                return {
+                    content: [{ type: "text", text: `All required dependencies (${requiredDependencies.join(', ')}) are already installed! Proceed with generating the component.` }]
+                };
+            }
+            // Determine package manager heuristically
+            let installer = 'npm install';
+            if (await fs_extra_1.default.pathExists(path_1.default.join(root, 'bun.lockb')))
+                installer = 'bun add';
+            else if (await fs_extra_1.default.pathExists(path_1.default.join(root, 'yarn.lock')))
+                installer = 'yarn add';
+            else if (await fs_extra_1.default.pathExists(path_1.default.join(root, 'pnpm-lock.yaml')))
+                installer = 'pnpm add';
+            const cmd = `${installer} ${missingDeps.join(' ')}`;
+            return {
+                content: [{ type: "text", text: `[CRITICAL ACTION REQUIRED]\nThe requested component needs packages that are NOT currently installed in this project.\n\nMissing dependencies: ${missingDeps.join(', ')}\n\nINSTRUCTION FOR AI: You MUST execute the following command in the user's terminal to install them, OR ask the user specifically to run it before writing the component code:\n\n\`\`\`bash\n${cmd}\n\`\`\`` }]
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error analyzing dependencies: ${err}` }]
+            };
+        }
+    });
+    // Tool: Resolve Component Tree (Dependency Matrix)
+    server.tool("resolve_component_tree", "Fetch multiple UI components at once (e.g. ['button', 'badge', 'card']). Crucial for resolving dependency trees when a complex component requires smaller sub-components.", {
+        componentNames: zod_1.z.array(zod_1.z.string()).describe("List of component names to fetch (e.g., ['button', 'avatar'])")
+    }, async ({ componentNames }) => {
+        try {
+            let allResults = [];
+            for (const query of componentNames) {
+                const { data, error } = await supabase
+                    .rpc('search_vibecodes_mcp', { search_query: query, max_limit: 1 });
+                if (!error && data && data.length > 0) {
+                    allResults.push(data[0]);
+                }
+            }
+            if (allResults.length === 0) {
+                return { content: [{ type: "text", text: `Could not find any of the requested components in the VibeCodes registry.` }] };
+            }
+            const formattedResults = allResults.map((item) => {
+                return `### Sub-Component: ${item.title}\n\`\`\`tsx\n${item.code}\n\`\`\``;
+            }).join('\n\n---\n\n');
+            return {
+                content: [{ type: "text", text: `[DEPENDENCY MATRIX RESOLVED]\n\nINSTRUCTION FOR AI: The following sub-components are required. Create their files in the appropriate UI folder before integrating the main component.\n\n${formattedResults}` }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error resolving tree: ${err}` }] };
+        }
+    });
+    // Tool: Patch Tailwind Config
+    server.tool("patch_tailwind_config", "Read the user's local tailwind config file to allow the AI to safely inject new keyframes, animations, or colors required by VibeCodes components.", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root.")
+    }, async ({ projectDir }) => {
+        const root = projectDir || process.cwd();
+        try {
+            let tailwindPath = path_1.default.join(root, 'tailwind.config.ts');
+            if (!(await fs_extra_1.default.pathExists(tailwindPath))) {
+                tailwindPath = path_1.default.join(root, 'tailwind.config.js');
+            }
+            if (!(await fs_extra_1.default.pathExists(tailwindPath))) {
+                return { content: [{ type: "text", text: `Error: Could not find tailwind.config.ts or .js in ${root}.` }] };
+            }
+            const tailwindContent = await fs_extra_1.default.readFile(tailwindPath, 'utf8');
+            return {
+                content: [{ type: "text", text: `[TAILWIND AUTO-PATCHER]\n\nHere is the user's current Tailwind configuration:\n\n\`\`\`typescript\n${tailwindContent}\n\`\`\`\n\nINSTRUCTION FOR AI: You must merge the required animations/colors into this configuration. Write the updated complete configuration file back to \`${tailwindPath}\`. DO NOT DELETE existing user configurations.` }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error reading tailwind config: ${err}` }] };
+        }
+    });
+    // Tool: Compose Landing Page
+    server.tool("compose_landing_page", "Macro-composer that autonomously queries the VibeCodes RAG database for a full Landing Page structure (Navbar, Hero, Features, Pricing, Footer).", {
+        themeOrIndustry: zod_1.z.string().describe("The theme, industry, or style of the page (e.g., 'SaaS Finance Dark Mode', 'Dental Clinic Clean')")
+    }, async ({ themeOrIndustry }) => {
+        try {
+            const sections = ['navbar', 'hero section', 'features grid', 'pricing table', 'footer'];
+            let combinedPage = `[VIBEPAGE COMPOSER: ${themeOrIndustry}]\n\nINSTRUCTION FOR AI: Assemble a complete page using the following 5 elite components.\n\n`;
+            for (const section of sections) {
+                const query = `${themeOrIndustry} ${section}`;
+                const { data, error } = await supabase
+                    .rpc('search_vibecodes_mcp', { search_query: query, max_limit: 1 });
+                if (!error && data && data.length > 0) {
+                    combinedPage += `### === ${section.toUpperCase()} ===\n**Title:** ${data[0].title}\n\`\`\`tsx\n${data[0].code}\n\`\`\`\n\n`;
+                }
+            }
+            return { content: [{ type: "text", text: combinedPage }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error composing landing page: ${err}` }] };
+        }
+    });
+    // Tool: Generate Local Assets (Download)
+    server.tool("generate_local_assets", "Downloads a remote image (asset/placeholder) directly into the user's local project public directory.", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root."),
+        imageUrl: zod_1.z.string().describe("URL of the image to download."),
+        filename: zod_1.z.string().describe("Desired filename (e.g., 'hero-bg.webp').")
+    }, async ({ projectDir, imageUrl, filename }) => {
+        const root = projectDir || process.cwd();
+        try {
+            const publicDir = path_1.default.join(root, 'public', 'images', 'vibecodes');
+            await fs_extra_1.default.ensureDir(publicDir);
+            const filePath = path_1.default.join(publicDir, filename);
+            const res = await fetch(imageUrl);
+            if (!res.ok)
+                throw new Error(`Failed to fetch image: ${res.statusText}`);
+            const arrayBuffer = await res.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+            await fs_extra_1.default.writeFile(filePath, buffer);
+            const localPath = `/images/vibecodes/${filename}`;
+            return {
+                content: [{ type: "text", text: `[ASSET GENERATOR]\nSuccessfully downloaded image to local filesystem.\n\nINSTRUCTION FOR AI: You can now use this local path in your React component: \`${localPath}\`` }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error downloading asset: ${err}` }] };
+        }
+    });
+    // Tool: Analyze Business Logic (Backend Wiring)
+    server.tool("analyze_business_logic", "Scans for database schemas (Prisma, Drizzle, SQL, or TS Models) and API route structures to ground UI generation in your real data structure. Crucial for dynamically wiring UI forms and tables directly to the backend logic.", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root.")
+    }, async ({ projectDir }) => {
+        const root = projectDir || process.cwd();
+        try {
+            const prismaPath = path_1.default.join(root, 'prisma', 'schema.prisma');
+            const drizzlePath = path_1.default.join(root, 'db', 'schema.ts');
+            const drizzlePathAlt = path_1.default.join(root, 'src', 'db', 'schema.ts');
+            const drizzlePathSimple = path_1.default.join(root, 'drizzle', 'schema.ts');
+            const modelsPath = path_1.default.join(root, 'src', 'models');
+            let context = `[DATA-BINDING MATRIX INITIATED]\n\n`;
+            // 1. Check Prisma
+            if (await fs_extra_1.default.pathExists(prismaPath)) {
+                const schemaContent = await fs_extra_1.default.readFile(prismaPath, 'utf8');
+                context += `==== [DATA SCHEMA] Prisma Schema Detected ====\n\`\`\`prisma\n${schemaContent}\n\`\`\`\n\n`;
+            }
+            // 2. Check Drizzle
+            // Note: find doesn't support async well, using manual loop
+            for (const p of [drizzlePath, drizzlePathAlt, drizzlePathSimple]) {
+                if (await fs_extra_1.default.pathExists(p)) {
+                    const schemaContent = await fs_extra_1.default.readFile(p, 'utf8');
+                    context += `==== [DATA SCHEMA] Drizzle Schema Detected in ${path_1.default.basename(p)} ====\n\`\`\`typescript\n${schemaContent}\n\`\`\`\n\n`;
+                    break;
+                }
+            }
+            // 3. Check TS Models
+            if (await fs_extra_1.default.pathExists(modelsPath)) {
+                const files = await fs_extra_1.default.readdir(modelsPath);
+                const tsFiles = files.filter(f => f.endsWith('.ts'));
+                if (tsFiles.length > 0) {
+                    context += `==== [DATA SCHEMA] TypeScript Models Found in /src/models ====\n`;
+                    for (const f of tsFiles.slice(0, 5)) { // Max 5 files to avoid token bloat
+                        const content = await fs_extra_1.default.readFile(path_1.default.join(modelsPath, f), 'utf8');
+                        context += `/* ${f} */\n${content}\n\n`;
+                    }
+                }
+            }
+            if (context === `[DATA-BINDING MATRIX INITIATED]\n\n`) {
+                context += `No explicit Prisma, Drizzle, or TS Model schema found. Search for other backend files or ask the user.\n\n`;
+            }
+            const apiDir = path_1.default.join(root, 'src', 'app', 'api');
+            if (await fs_extra_1.default.pathExists(apiDir)) {
+                // Shallow read to hint at existing endpoints
+                const dirs = await fs_extra_1.default.readdir(apiDir);
+                context += `==== API Routes Detected ====\nThe following API endpoint namespaces exist in /src/app/api:\n${dirs.join(', ')}\n\n`;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `${context}INSTRUCTION FOR AI: You must use this specific backend schema to generate TypeScript interfaces (or Zod schemas) for the UI components. Do not invent generic fields; map the UI inputs precisely to the database columns provided above.`
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error analyzing business logic: ${err}` }] };
+        }
+    });
+    // Tool: Learn User Preferences (Shadow Profile)
+    server.tool("learn_user_preferences", "Scan the user's configuration files (.prettierrc, .eslintrc.json) and components to clone their exact coding style (e.g. arrow vs normal functions, semicolons, quotes).", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root.")
+    }, async ({ projectDir }) => {
+        const root = projectDir || process.cwd();
+        try {
+            let prefs = `[VIBETACHYON STYLE CLONING]\n\n`;
+            const prettierPath = path_1.default.join(root, '.prettierrc');
+            if (await fs_extra_1.default.pathExists(prettierPath)) {
+                const prettier = await fs_extra_1.default.readFile(prettierPath, 'utf8');
+                prefs += `User Prettier Config:\n\`\`\`json\n${prettier}\n\`\`\`\n\n`;
+            }
+            else {
+                prefs += `No .prettierrc found. Assume standard Prettier defaults.\n\n`;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `${prefs}INSTRUCTION FOR AI: You MUST forcefully adapt any generated code to respect the styling rules detected above (e.g. single vs double quotes, trailing commas, semicolons). If generating React components, adapt the syntax (Arrow Functions vs Function Declarations) to perfectly match the user's implicit repository style.`
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error learning user preferences: ${err}` }] };
+        }
+    });
+    // Tool: Enforce Atomic Design (AST Refactoring Constraint)
+    server.tool("enforce_atomic_design", "Force the AI Copilot to split large requested features into modular, scalable, atomic React components (e.g., breaking a Dashboard into Sidebar, Header, StatCards) instead of one giant file.", {}, async () => {
+        return {
+            content: [{
+                    type: "text",
+                    text: `[ATOMIC DESIGN CONSTRAINT ENFORCED]\n\nINSTRUCTION FOR AI: You are FORBIDDEN from generating components larger than 150 lines of code. If the user requests a complex page or large feature, you MUST:\n1. Break it down into smaller atomic pieces.\n2. Create separate files for each piece inside 'src/components/features/' or 'src/components/ui/'.\n3. Export each atomic component cleanly.\n4. Compose the final requested page using these atomic imports. DO NOT print a single massive file.`
+                }]
+        };
+    });
+    // Tool: Audit Accessibility (WCAG / A11Y)
+    server.tool("audit_a11y_wcag", "Injects a strict Web Content Accessibility Guidelines (WCAG) heuristic rulebook to ensure universally accessible UI generation.", {}, async () => {
+        return {
+            content: [{
+                    type: "text",
+                    text: `[WCAG A11Y AUDIT MATRIX APPLIED]\n\nINSTRUCTION FOR AI: Every component you generate MUST strictly adhere to these accessibility requirements:\n- Buttons must have clear 'aria-label' if text is visually hidden or iconography-only.\n- Form inputs must have an associated 'id' and '<label htmlFor=\"id\">'.\n- Dialogs/Modals must trap focus and include 'aria-modal=\"true\"' and 'role=\"dialog\"'.\n- Interactive elements must visibly show focus states ('focus:ring-2 focus:ring-primary focus:outline-none').\n- Do not use '<div>' for clickable zones; always use '<button>' or '<a>' with proper 'href'.`
+                }]
+        };
+    });
+    // Tool: Resolve Breaking Changes (Chaos Engineering)
+    server.tool("resolve_breaking_changes", "Helper to resolve framework version mismatches between older copied components (e.g., Next.js 13 Code) and the user's current environment (e.g., Vite, Next.js 15, React 19).", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root.")
+    }, async ({ projectDir }) => {
+        const root = projectDir || process.cwd();
+        try {
+            const pkgPath = path_1.default.join(root, 'package.json');
+            if (!(await fs_extra_1.default.pathExists(pkgPath))) {
+                return { content: [{ type: "text", text: `Error: package.json not found in ${root}.` }] };
+            }
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            let isVite = !!deps['vite'];
+            let isNext = !!deps['next'];
+            let constraints = `[CHAOS RESOLVER APPLIED]\n\n`;
+            constraints += `User Environment Detected:\n`;
+            constraints += `React: ${deps['react'] || 'Unknown'}\n`;
+            constraints += `Framework: ${isNext ? 'Next.js' : isVite ? 'Vite/React SPA' : 'Custom/Other'}\n\n`;
+            constraints += `INSTRUCTION FOR AI: Review your generated code to match the framework:\n`;
+            if (isVite) {
+                constraints += `- The user is on Vite (React SPA). DO NOT use Next.js specific components like <Image> or <Link>. Use standard <img> and <a> (or react-router <Link> if installed).\n`;
+                constraints += `- DO NOT use 'use client' directives. DO NOT use Server Components.\n`;
+            }
+            else if (isNext) {
+                constraints += `- The user is on Next.js. If Next.js 14/15 or React 19, you MUST prefer Server Components by default. Add '\"use client\";' ONLY if hooks (useState, useEffect) or browser APIs are strictly needed.\n`;
+                constraints += `- Replace legacy Next.js Image imports or Link tags with their modern equivalents.\n`;
+            }
+            return { content: [{ type: "text", text: constraints }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error resolving breaking changes: ${err}` }] };
+        }
+    });
+    // Tool: Guarantee Image Domains (UX Protection)
+    server.tool("guarantee_image_domains", "Scans for external image URLs in a component and forces the AI to handle them perfectly depending on whether the user is on Next.js or Vite.", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root.")
+    }, async ({ projectDir }) => {
+        const root = projectDir || process.cwd();
+        try {
+            const pkgPath = path_1.default.join(root, 'package.json');
+            if (!(await fs_extra_1.default.pathExists(pkgPath)))
+                return { content: [{ type: "text", text: "No package.json found." }] };
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            const isNext = !!(pkg.dependencies?.next || pkg.devDependencies?.next);
+            if (isNext) {
+                let configPath = path_1.default.join(root, 'next.config.ts');
+                if (!(await fs_extra_1.default.pathExists(configPath)))
+                    configPath = path_1.default.join(root, 'next.config.mjs');
+                if (!(await fs_extra_1.default.pathExists(configPath)))
+                    configPath = path_1.default.join(root, 'next.config.js');
+                let configContent = "No next.config found.";
+                if (await fs_extra_1.default.pathExists(configPath)) {
+                    configContent = await fs_extra_1.default.readFile(configPath, 'utf8');
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: `[IMAGE DOMAIN WHITELIST PROTOCOL]\nUser Framework: Next.js\nUser's Current Next Config:\n\`\`\`typescript\n${configContent}\n\`\`\`\n\nINSTRUCTION FOR AI: If the component uses '<Image src=\"https://external.com/\" />', it WILL BREAK unless the domain is whitelisted. You MUST update 'images.remotePatterns' in '${path_1.default.basename(configPath)}'.`
+                        }]
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `[IMAGE PROTOCOL]\nUser Framework: Vite/React SPA\n\nINSTRUCTION FOR AI: The user is NOT using Next.js. Do NOT use 'next/image'. Use standard HTML '<img src=\"...\" />'. You do NOT need to whitelist any domains in Vite.`
+                        }]
+                };
+            }
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error guaranteeing image domains: ${err}` }] };
+        }
+    });
+    // Tool: Guarantee Layout Providers (UX Protection)
+    server.tool("guarantee_layout_providers", "Checks the user's root layout or App entry point to ensure Toaster (notifications) and ThemeProvider (dark mode) are present so components render correctly.", {
+        projectDir: zod_1.z.string().describe("Absolute path to the user's project root.")
+    }, async ({ projectDir }) => {
+        const root = projectDir || process.cwd();
+        try {
+            const pkgPath = path_1.default.join(root, 'package.json');
+            if (!(await fs_extra_1.default.pathExists(pkgPath)))
+                return { content: [{ type: "text", text: "No package.json found." }] };
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            const isNext = !!(pkg.dependencies?.next || pkg.devDependencies?.next);
+            let rootPath = '';
+            if (isNext) {
+                const l1 = path_1.default.join(root, 'src', 'app', 'layout.tsx');
+                const l2 = path_1.default.join(root, 'app', 'layout.tsx');
+                if (await fs_extra_1.default.pathExists(l1))
+                    rootPath = l1;
+                else if (await fs_extra_1.default.pathExists(l2))
+                    rootPath = l2;
+            }
+            else {
+                const app1 = path_1.default.join(root, 'src', 'App.tsx');
+                const app2 = path_1.default.join(root, 'src', 'main.tsx');
+                if (await fs_extra_1.default.pathExists(app1))
+                    rootPath = app1;
+                else if (await fs_extra_1.default.pathExists(app2))
+                    rootPath = app2;
+            }
+            if (!rootPath) {
+                return { content: [{ type: "text", text: `Could not find root layout or App.tsx in ${root}. Ensure paths are correct.` }] };
+            }
+            const layoutContent = await fs_extra_1.default.readFile(rootPath, 'utf8');
+            return {
+                content: [{
+                        type: "text",
+                        text: `[ROOT LAYOUT PROVIDER PROTOCOL]\nUser Framework: ${isNext ? 'Next.js' : 'Vite/React SPA'}\nRoot File Detected: ${rootPath}\n\nUser's Current Root Layout/App:\n\`\`\`tsx\n${layoutContent}\n\`\`\`\n\nINSTRUCTION FOR AI: Review the user's root file. If they requested a component that uses Toast notifications (sonner) or Dark Mode (next-themes or context), you MUST ensure the corresponding <Toaster /> or <ThemeProvider> wrappers are present. If missing, boldly instruct them to add it, or patch the root file directly.`
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error guaranteeing layout providers: ${err}` }] };
+        }
+    });
+    // Tool: Fetch Figma Design (Figma Bridge)
+    server.tool("fetch_figma_design", "Connects to the Figma API to extract layout, colors, typography, and structure. Requires FIGMA_ACCESS_TOKEN in env.", {
+        fileKey: zod_1.z.string().describe("The Figma file key from the URL (e.g. figma.com/file/xxxx/...)."),
+        nodeId: zod_1.z.string().describe("The specific node ID of the component (e.g., '1:23').")
+    }, async ({ fileKey, nodeId }) => {
+        try {
+            const figmaToken = process.env.FIGMA_ACCESS_TOKEN;
+            if (!figmaToken) {
+                return { content: [{ type: "text", text: `Error: FIGMA_ACCESS_TOKEN not found in environment. Please instruct the user to set it up to bridge Figma designs.` }] };
+            }
+            // Node fetch requires fetch API available in Node 18+
+            const response = await fetch(`https://api.figma.com/v1/files/${fileKey}/nodes?ids=${nodeId}`, {
+                headers: { 'X-FIGMA-TOKEN': figmaToken }
+            });
+            if (!response.ok) {
+                throw new Error(`Figma API responded with ${response.status}: ${await response.text()}`);
+            }
+            const data = await response.json();
+            const nodeData = data.nodes[nodeId]?.document;
+            if (!nodeData) {
+                return { content: [{ type: "text", text: `Node ${nodeId} not found in Figma file ${fileKey}.` }] };
+            }
+            // Simplistic extraction for context
+            const extractedText = JSON.stringify(nodeData, null, 2);
+            let visualLayoutConstraints = `[FIGMA-TO-CODE BRIDGE APPLIED]\n\n`;
+            visualLayoutConstraints += `Raw Figma JSON Structure Snippet:\n\`\`\`json\n${extractedText.substring(0, 1500)}...\n\`\`\`\n\n`;
+            visualLayoutConstraints += `INSTRUCTION FOR AI: The user wants you to convert this raw Figma JSON node into a physical React component. Analyze the absolute positions, Auto Layout flex constraints, fills (colors), and typography. Map the Figma hex colors to Tailwind utility classes, and map Auto Layout to Tailwind Flexbox. Use 'search_vibecodes_snippets' if you need a specific base (like a Shadcn UI Button) to assemble the final design.`;
+            return { content: [{ type: "text", text: visualLayoutConstraints }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error fetching from Figma: ${err}` }] };
+        }
+    });
+    // Tool: Enforce SEO Metadata
+    server.tool("enforce_seo_metadata", "Forces the AI to inject optimal SEO Metadata, OpenGraph tags, and Title tagging into the generation of any Page component.", {}, async () => {
+        return {
+            content: [{
+                    type: "text",
+                    text: `[SEO RANKING HEURISTIC APPLIED]\n\nINSTRUCTION FOR AI: The user is generating a full web page. You MUST inject perfect SEO metadata native to the framework.\n- If Next.js App Router: Export a 'metadata' constant with 'title', 'description', and 'openGraph' fields.\n- If Vite/React SPA: Use react-helmet-async (or similar) to inject '<title>' and '<meta name=\"description\">' within the component render.\nDO NOT generate a page without SEO tags. It MUST rank well.`
+                }]
+        };
+    });
+    // Tool: Self-Heal TypeScript Errors (AST Check)
+    server.tool("self_heal_typescript_errors", "Runs local TypeScript transpilation (tsc --noEmit) on a specific file to catch hidden bugs. Use this immediately after generating or modifying a complex component to self-correct any AST errors before the user loads the page.", {
+        filePath: zod_1.z.string().describe("Absolute path to the TypeScript/TSX file you want to typecheck.")
+    }, async ({ filePath }) => {
+        try {
+            if (!(await fs_extra_1.default.pathExists(filePath))) {
+                return { content: [{ type: "text", text: `Error: File ${filePath} not found.` }] };
+            }
+            const dir = path_1.default.dirname(filePath);
+            try {
+                // Run a localized TS check. Fallback to npx to ensure it works across setups.
+                const { stdout, stderr } = await execPromise(`npx tsc --noEmit --skipLibCheck --jsx react-jsx ${filePath}`, { cwd: dir, timeout: 15000 });
+                return {
+                    content: [{
+                            type: "text",
+                            text: `[SELF-HEALING NEURAL MATRIX]\nAST Check Passed! Zero TypeScript Errors detected in ${path_1.default.basename(filePath)}.`
+                        }]
+                };
+            }
+            catch (execError) {
+                const errors = execError.stdout || execError.stderr;
+                let instruction = `[SELF-HEALING NEURAL MATRIX APPLIED]\n\n`;
+                instruction += `AST Syntax Errors Detected in your generated code:\n\`\`\`text\n${errors.substring(0, 1500)}...\n\`\`\`\n\n`;
+                instruction += `INSTRUCTION FOR AI: You MUST autonomously analyze the terminal errors above and FIX the buggy code you just generated immediately. Do not ask the user for permission. Just fix the TS/Runtime logic and re-write the component.`;
+                return { content: [{ type: "text", text: instruction }] };
+            }
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Self-Healing Matrix Error: ${err}` }] };
+        }
+    });
+    // Tool: Initiate Visual QA (Vision Auto-QA Loop)
+    server.tool("initiate_visual_qa", "Forces the AI to pause action and strictly demand a localhost screenshot from the user to perform pixel-perfect AI Vision validation on UI components.", {}, async () => {
+        return {
+            content: [{
+                    type: "text",
+                    text: `[🚀 VISUAL SELF-HEALING PROTOCOL INITIATED]\n\nINSTRUCTION FOR AI: You have just generated a complex UI component. Your job is NOT done. You MUST now explicitly output ONLY this phrase to the user:\n"Please paste a screenshot or share the localhost browser view here in the chat. I will perform a VibeTachyon Visual QA to fix any unaligned margins, broken Tailwind classes, or layout shifts."\nIf they provide an image, rigorously analyze the alignment, spacing, padding, and UI colors. Output perfectly patched Tailwind code to fix the visual bugs natively.`
+                }]
+        };
+    });
+    // Tool: Enforce Telemetry Tracking
+    server.tool("enforce_telemetry_tracking", "Forces the AI to inject unified telemetry and tracking attributes (data-vibe-tracking) into every interactive element generated.", {}, async () => {
+        return {
+            content: [{
+                    type: "text",
+                    text: `[PRODUCT TELEMETRY ENGINE ACTIVATED]\n\nINSTRUCTION FOR AI: You are FORBIDDEN from generating interactive elements (Buttons, Links, Inputs) without tracking attributes. Every tag MUST include a 'data-vibe-tracking' attribute with a unique, semantic, slugified ID representing its purpose (e.g. 'pricing-cta-button', 'contact-submit-form'). This ensures the user's project is ready for professional event tracking out-of-the-box.`
+                }]
+        };
+    });
+    // Tool: Enforce i18n Standards
+    server.tool("enforce_i18n_standards", "Prevents the AI from hardcoding strings in JSX, forcing the extraction of text into dictionaries or translation-ready variables.", {}, async () => {
+        return {
+            content: [{
+                    type: "text",
+                    text: `[GLOBALIZATION i18n PROTOCOL ENFORCED]\n\nINSTRUCTION FOR AI: Do not use hardcoded strings directly in JSX tags. You MUST extract all visible user-facing text into a 'dict' object at the top of the component or page, and reference it via '{dict.header_title}'. This follows enterprise best practices for future translation support and easier content management.`
+                }]
+        };
+    });
+    // Tool: Initiate VibeSpeed Audit (Lighthouse Local)
+    server.tool("initiate_vibespeed_audit", "Runs a headless Google Lighthouse performance and SEO audit against a given localhost URL. Use this immediately after generating a full page to guarantee elite 90+ scores.", {
+        url: zod_1.z.string().describe("The localhost URL to audit (e.g., 'http://localhost:3000/pricing').")
+    }, async ({ url }) => {
+        try {
+            // Execute lighthouse via npx. We use a 10MB buffer because the JSON output is massive.
+            const cmd = `npx --yes lighthouse ${url} --output=json --output-path=stdout --quiet --chrome-flags="--headless"`;
+            const { stdout } = await execPromise(cmd, { maxBuffer: 1024 * 1024 * 10 });
+            const report = JSON.parse(stdout);
+            const perf = Math.round(report.categories.performance.score * 100);
+            const a11y = Math.round(report.categories.accessibility.score * 100);
+            const bp = Math.round(report.categories['best-practices'].score * 100);
+            const seo = Math.round(report.categories.seo.score * 100);
+            let result = `[VIBESPEED LIGHTHOUSE AUDIT RESULTS FOR ${url}]\n\n`;
+            result += `Performance: ${perf}/100\n`;
+            result += `Accessibility: ${a11y}/100\n`;
+            result += `Best Practices: ${bp}/100\n`;
+            result += `SEO: ${seo}/100\n\n`;
+            if (perf < 90) {
+                result += `🚨 PERFORMANCE FAILED (<90). Critical Fixes Required:\n`;
+                // Extract top failed audits
+                const failedAudits = Object.values(report.audits)
+                    .filter((a) => a.score !== null && a.score < 0.9 && a.scoreDisplayMode !== 'manual')
+                    .sort((a, b) => a.score - b.score)
+                    .slice(0, 5)
+                    .map((a) => `- ${a.title}: ${a.description} (Score: ${a.score})`);
+                result += failedAudits.join('\n') + '\n\n';
+                result += `INSTRUCTION FOR AI: You MUST autonomously analyze these bottlenecks and REFACTOR the code you just generated. Apply lazy loading (next/dynamic or React.lazy), optimize images (next/image), remove render-blocking bottlenecks, and improve LCP immediately. Do not ask the user for permission. Fix the code.`;
+            }
+            else {
+                result += `✅ VibeSpeed Audit Passed! The page is highly optimized.`;
+            }
+            return { content: [{ type: "text", text: result }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error running VibeSpeed Audit: Ensure you are running a local dev server (e.g. localhost:3000 is open) and you have Chrome installed. Details: ${err.message || err}` }] };
+        }
+    });
+    // Tool: Update Terminal Status (VibePilot CLI)
+    server.tool("update_terminal_status", "Broadcasts a live visual update directly to the user's terminal (stderr) to let them know what complex autonomous task you are currently performing (e.g., '🧠 Compiling AST Fixes...', '🎨 Translating Figma Nodes...'). Call this *before* you execute heavy codebase tasks so the user isn't left waiting blindly.", {
+        status: zod_1.z.string().describe("A short, descriptive action string (e.g., '🧠 Compiling AST Fixes...', '🎨 Cloning CSS Styles...')."),
+        progress: zod_1.z.number().min(0).max(100).describe("Progress percentage (0-100). Default is 50 if unknown.")
+    }, async ({ status, progress }) => {
+        // Write safely to stderr (so we don't break MCP JSON-RPC on stdout)
+        const p = Math.floor(progress / 10);
+        const bar = '█'.repeat(p) + '░'.repeat(10 - p);
+        // ANSI escape codes for coloring
+        const cyan = '\\x1b[36m';
+        const green = '\\x1b[32m';
+        const yellow = '\\x1b[33m';
+        const reset = '\\x1b[0m';
+        const timestamp = new Date().toLocaleTimeString();
+        process.stderr.write(`\n${cyan}┌─ [VibePilot AI] ─────────────────────────────────────────┐${reset}\n`);
+        process.stderr.write(`${cyan}│${reset} 🕒 ${yellow}${timestamp}${reset}\n`);
+        process.stderr.write(`${cyan}│${reset} ⚡ ${status}\n`);
+        process.stderr.write(`${cyan}│${reset} 📊 [${green}${bar}${reset}] ${progress}%\n`);
+        process.stderr.write(`${cyan}└──────────────────────────────────────────────────────────┘${reset}\n\n`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully broadcasted to user terminal: ${status}`
+                }]
+        };
+    });
+    // Tool: Run Security Penetration Test (VibeSec)
+    server.tool("run_security_penetration", "Run an autonomous static AST/Regex security sweep on the file you just generated to catch XSS, SQLi, and Secrets. YOU MUST CALL THIS on every major API Route or Complex UI Form you create to guarantee security.", {
+        filePath: zod_1.z.string().describe("The absolute path to the file you just generated/modified.")
+    }, async ({ filePath }) => {
+        try {
+            if (!(await fs_extra_1.default.pathExists(filePath))) {
+                return { content: [{ type: "text", text: `VibeSec Error: File not found at ${filePath}.` }] };
+            }
+            const content = await fs_extra_1.default.readFile(filePath, 'utf8');
+            const vulnerabilities = [];
+            // 1. XSS Check (React danger)
+            if (content.includes("dangerouslySetInnerHTML")) {
+                vulnerabilities.push("- [XSS CRITICAL] Detected `dangerouslySetInnerHTML`. This is a massive Cross-Site Scripting vector. You MUST use a sanitizer like DOMPurify or avoid it entirely.");
+            }
+            // 2. SQLi Check (Raw interpolation in generic ORMs like Prisma)
+            // Looks for: $executeRaw(`...${var}...`) or query(`...${var}...`)
+            const sqliRegex = /(executeRaw|queryRaw|query).*`.*\$\{.*\}.*`/s;
+            if (sqliRegex.test(content)) {
+                vulnerabilities.push("- [SQLi CRITICAL] Detected raw string interpolation in a database query. This is a severe SQL Injection vulnerability. You MUST use parameterized queries (e.g., $executeRawUnsafe or ORM native findMany).");
+            }
+            // 3. Secrets Check
+            // Looks for hardcoded tokens: sk_test_, pk_test_, eyJ (JWTs)
+            const secretsRegex = /(sk_test_[a-zA-Z0-9]+|pk_test_[a-zA-Z0-9]+|eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+)/;
+            if (secretsRegex.test(content)) {
+                vulnerabilities.push("- [SECRETS LEAK] Detected a hardcoded Token, Stripe Key, or JWT secret in the source code. You MUST replace this with process.env variables immediately.");
+            }
+            if (vulnerabilities.length > 0) {
+                let alert = `[VIBESEC PENETRATION REPORT: FAILED]\n\n🚨 CRITICAL VULNERABILITIES FOUND IN ${path_1.default.basename(filePath)}:\n\n`;
+                alert += vulnerabilities.join('\n\n') + '\n\n';
+                alert += `INSTRUCTION FOR AI: You breached the security protocol. YOU MUST REWRITE THE VULNERABLE CODE IMMEDIATELY using secure boundaries, Zod validation, escaping, or environment variables. DO NOT ask the user for permission. Fix the flaw now!`;
+                return { content: [{ type: "text", text: alert }] };
+            }
+            else {
+                return { content: [{ type: "text", text: `[VIBESEC PENETRATION REPORT: PASSED] ✅ No explicit XSS, SQLi, or hardcoded secrets detected in ${path_1.default.basename(filePath)}.` }] };
+            }
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error running VibeSec Audit: ${err.message || err}` }] };
+        }
+    });
+    // Connect via stdio
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // Log strictly to stderr to not compromise stdio communication
+    console.error("VibeTachyon MCP Server is running...");
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "vibetachyon",
+    "version": "1.1.0",
+    "description": "VibeCodes MCP CLI Installer and Server",
+    "main": "dist/index.js",
+    "bin": {
+        "vibetachyon": "dist/index.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc -w",
+        "start": "node dist/index.js"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "package.json"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "@clack/prompts": "^0.9.1",
+        "@modelcontextprotocol/sdk": "^1.5.0",
+        "@supabase/supabase-js": "^2.98.0",
+        "@types/fs-extra": "^11.0.4",
+        "commander": "^13.1.0",
+        "fs-extra": "^11.3.4",
+        "picocolors": "^1.1.1"
+    },
+    "devDependencies": {
+        "@types/node": "^22.13.5",
+        "typescript": "^5.7.3"
+    }
+}