driftdetect-mcp 0.1.1 → 0.4.0

package/dist/server.js

@@ -5,7 +5,7 @@
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { PatternStore, ManifestStore, } from 'driftdetect-core';
+import { PatternStore, ManifestStore, HistoryStore, DNAStore, PlaybookGenerator, AIContextBuilder, GENE_IDS, BoundaryStore, } from 'driftdetect-core';
 import { PackManager } from './packs.js';
 import { FeedbackManager } from './feedback.js';
 const PATTERN_CATEGORIES = [
@@ -234,11 +234,178 @@ const TOOLS = [
             required: [],
         },
     },
+    {
+        name: 'drift_trends',
+        description: 'Get pattern trend analysis and regression alerts. Shows how patterns have changed over time. Use this to check codebase health before generating code or to identify patterns that need attention.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                period: {
+                    type: 'string',
+                    enum: ['7d', '30d', '90d'],
+                    description: 'Time period to analyze (default: 7d)',
+                },
+                category: {
+                    type: 'string',
+                    description: `Filter trends by category. Valid: ${PATTERN_CATEGORIES.join(', ')}`,
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['all', 'critical', 'warning'],
+                    description: 'Filter by severity level (default: all)',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['all', 'regressions', 'improvements'],
+                    description: 'Filter by trend type (default: all)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'drift_parser_info',
+        description: 'Get information about parser capabilities and status. Shows which parsers are available (tree-sitter vs regex), their features, and supported frameworks. Use this to understand parsing capabilities before analyzing Python, C#, TypeScript, or Java code.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                language: {
+                    type: 'string',
+                    enum: ['python', 'csharp', 'typescript', 'java', 'all'],
+                    description: 'Language to get parser info for (default: all)',
+                },
+            },
+            required: [],
+        },
+    },
+    // DNA Tools
+    {
+        name: 'drift_dna',
+        description: 'Get the styling DNA profile for the codebase. Shows how components are styled (variants, responsive, states, theming, spacing, animation) with confidence scores and exemplar files.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                gene: {
+                    type: 'string',
+                    enum: ['variant-handling', 'responsive-approach', 'state-styling', 'theming', 'spacing-philosophy', 'animation-approach'],
+                    description: 'Specific gene to query (optional)',
+                },
+                format: {
+                    type: 'string',
+                    enum: ['full', 'summary', 'ai-context'],
+                    description: 'Output format (default: ai-context)',
+                },
+                level: {
+                    type: 'number',
+                    enum: [1, 2, 3, 4],
+                    description: 'AI context detail level 1-4 (default: 3)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'drift_playbook',
+        description: 'Generate or retrieve the styling playbook documentation. Contains conventions, code examples, and patterns to avoid for each styling concern.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                regenerate: {
+                    type: 'boolean',
+                    description: 'Force regeneration of playbook (default: false)',
+                },
+                section: {
+                    type: 'string',
+                    enum: ['variant-handling', 'responsive-approach', 'state-styling', 'theming', 'spacing-philosophy', 'animation-approach'],
+                    description: 'Specific section to retrieve (optional)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'drift_mutations',
+        description: 'Get files that deviate from established styling patterns. Mutations are styling inconsistencies that fragment AI context.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                gene: {
+                    type: 'string',
+                    enum: ['variant-handling', 'responsive-approach', 'state-styling', 'theming', 'spacing-philosophy', 'animation-approach'],
+                    description: 'Filter by gene (optional)',
+                },
+                impact: {
+                    type: 'string',
+                    enum: ['low', 'medium', 'high'],
+                    description: 'Filter by impact level (optional)',
+                },
+                suggest: {
+                    type: 'boolean',
+                    description: 'Include resolution suggestions (default: false)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'drift_dna_check',
+        description: 'Check if code follows the established styling DNA. Use before generating component code to ensure consistency.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: {
+                    type: 'string',
+                    description: 'Code snippet to check against DNA',
+                },
+                file: {
+                    type: 'string',
+                    description: 'File path to check (alternative to code)',
+                },
+                genes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific genes to check (optional, defaults to all)',
+                },
+            },
+            required: [],
+        },
+    },
+    // Data Boundaries Tool
+    {
+        name: 'drift_boundaries',
+        description: 'Get data access boundaries and check for violations. Shows which code accesses which database tables/fields. Use this before generating data access code to understand access rules and restrictions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['overview', 'table', 'file', 'sensitive', 'check', 'rules'],
+                    description: 'Action to perform (default: overview). "overview" shows summary, "table" shows specific table access, "file" shows what data a file accesses, "sensitive" shows sensitive field access, "check" validates against rules, "rules" shows configured boundaries',
+                },
+                table: {
+                    type: 'string',
+                    description: 'Table name (required for "table" action)',
+                },
+                file: {
+                    type: 'string',
+                    description: 'File path or glob pattern (required for "file" action)',
+                },
+                includeViolations: {
+                    type: 'boolean',
+                    description: 'Include boundary violations in response (default: true)',
+                },
+            },
+            required: [],
+        },
+    },
 ];
 export function createDriftMCPServer(config) {
     const server = new Server({ name: 'drift', version: '0.1.0' }, { capabilities: { tools: {} } });
     const patternStore = new PatternStore({ rootDir: config.projectRoot });
     const manifestStore = new ManifestStore(config.projectRoot);
+    const historyStore = new HistoryStore({ rootDir: config.projectRoot });
+    const dnaStore = new DNAStore({ rootDir: config.projectRoot });
+    const boundaryStore = new BoundaryStore({ rootDir: config.projectRoot });
     const packManager = new PackManager(config.projectRoot, patternStore);
     const feedbackManager = new FeedbackManager(config.projectRoot);
     // List available tools
@@ -268,6 +435,20 @@ export function createDriftMCPServer(config) {
                     return await handlePack(packManager, args);
                 case 'drift_feedback':
                     return await handleFeedback(feedbackManager, args);
+                case 'drift_trends':
+                    return await handleTrends(historyStore, args);
+                case 'drift_parser_info':
+                    return await handleParserInfo(args);
+                case 'drift_dna':
+                    return await handleDNA(config.projectRoot, dnaStore, args);
+                case 'drift_playbook':
+                    return await handlePlaybook(config.projectRoot, dnaStore, args);
+                case 'drift_mutations':
+                    return await handleMutations(dnaStore, args);
+                case 'drift_dna_check':
+                    return await handleDNACheck(config.projectRoot, dnaStore, args);
+                case 'drift_boundaries':
+                    return await handleBoundaries(boundaryStore, args);
                 default:
                     return {
                         content: [{ type: 'text', text: `Unknown tool: ${name}` }],
@@ -973,4 +1154,967 @@ async function handleFeedback(feedbackManager, args) {
             };
     }
 }
+async function handleTrends(historyStore, args) {
+    await historyStore.initialize();
+    const period = args.period ?? '7d';
+    const summary = await historyStore.getTrendSummary(period);
+    if (!summary) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: '# No Trend Data Available\n\n' +
+                        'Pattern trends require at least 2 snapshots. Snapshots are created automatically when you run `drift scan`.\n\n' +
+                        'Run a few scans over time to start tracking trends.',
+                }],
+        };
+    }
+    // Filter by category if specified
+    let regressions = summary.regressions;
+    let improvements = summary.improvements;
+    if (args.category) {
+        regressions = regressions.filter(t => t.category === args.category);
+        improvements = improvements.filter(t => t.category === args.category);
+    }
+    // Filter by severity
+    if (args.severity && args.severity !== 'all') {
+        regressions = regressions.filter(t => t.severity === args.severity);
+    }
+    // Filter by type
+    if (args.type === 'regressions') {
+        improvements = [];
+    }
+    else if (args.type === 'improvements') {
+        regressions = [];
+    }
+    // Build output
+    let output = `# Pattern Trends (${period})\n\n`;
+    output += `Period: ${summary.startDate} → ${summary.endDate}\n`;
+    output += `Overall trend: **${summary.overallTrend.toUpperCase()}** (${summary.healthDelta >= 0 ? '+' : ''}${(summary.healthDelta * 100).toFixed(1)}% health)\n\n`;
+    // Summary stats
+    output += `## Summary\n`;
+    output += `- Regressions: ${regressions.length}\n`;
+    output += `- Improvements: ${improvements.length}\n`;
+    output += `- Stable patterns: ${summary.stable}\n\n`;
+    // Critical regressions first
+    const criticalRegressions = regressions.filter(t => t.severity === 'critical');
+    if (criticalRegressions.length > 0) {
+        output += `## ⚠️ Critical Regressions\n\n`;
+        for (const t of criticalRegressions) {
+            output += `### ${t.patternName} (${t.category})\n`;
+            output += `- ${t.details}\n`;
+            output += `- Metric: ${t.metric}\n`;
+            output += `- Change: ${t.changePercent >= 0 ? '+' : ''}${t.changePercent.toFixed(1)}%\n\n`;
+        }
+    }
+    // Warning regressions
+    const warningRegressions = regressions.filter(t => t.severity === 'warning');
+    if (warningRegressions.length > 0) {
+        output += `## ⚡ Warning Regressions\n\n`;
+        for (const t of warningRegressions) {
+            output += `### ${t.patternName} (${t.category})\n`;
+            output += `- ${t.details}\n`;
+            output += `- Metric: ${t.metric}\n`;
+            output += `- Change: ${t.changePercent >= 0 ? '+' : ''}${t.changePercent.toFixed(1)}%\n\n`;
+        }
+    }
+    // Improvements
+    if (improvements.length > 0) {
+        output += `## ✅ Improvements\n\n`;
+        for (const t of improvements) {
+            output += `### ${t.patternName} (${t.category})\n`;
+            output += `- ${t.details}\n`;
+            output += `- Metric: ${t.metric}\n`;
+            output += `- Change: +${t.changePercent.toFixed(1)}%\n\n`;
+        }
+    }
+    // Category breakdown
+    const categoryEntries = Object.entries(summary.categoryTrends);
+    if (categoryEntries.length > 0) {
+        output += `## Category Trends\n\n`;
+        for (const [category, trend] of categoryEntries) {
+            const emoji = trend.trend === 'improving' ? '📈' : trend.trend === 'declining' ? '📉' : '➡️';
+            output += `- ${emoji} **${category}**: ${trend.trend} (confidence: ${trend.avgConfidenceChange >= 0 ? '+' : ''}${(trend.avgConfidenceChange * 100).toFixed(1)}%, compliance: ${trend.complianceChange >= 0 ? '+' : ''}${(trend.complianceChange * 100).toFixed(1)}%)\n`;
+        }
+    }
+    return {
+        content: [{ type: 'text', text: output }],
+    };
+}
+/**
+ * Handle drift_parser_info tool
+ *
+ * Returns information about parser capabilities and status.
+ */
+async function handleParserInfo(args) {
+    const language = args.language ?? 'all';
+    const info = {};
+    // Python parser info
+    if (language === 'python' || language === 'all') {
+        let treeSitterAvailable = false;
+        let loadingError;
+        try {
+            const core = await import('driftdetect-core');
+            // Check if the functions exist (they may not be exported yet)
+            if ('isTreeSitterAvailable' in core && 'getLoadingError' in core) {
+                treeSitterAvailable = core.isTreeSitterAvailable();
+                loadingError = core.getLoadingError() ?? undefined;
+            }
+        }
+        catch {
+            loadingError = 'driftdetect-core not available';
+        }
+        info.python = {
+            treeSitterAvailable,
+            activeParser: treeSitterAvailable ? 'tree-sitter' : 'regex',
+            capabilities: {
+                basicRouteDetection: true,
+                simplePydanticModels: true,
+                pydanticModels: treeSitterAvailable,
+                nestedTypes: treeSitterAvailable,
+                fieldConstraints: treeSitterAvailable,
+                inheritance: treeSitterAvailable,
+                generics: treeSitterAvailable,
+                django: treeSitterAvailable,
+                typeHints: treeSitterAvailable,
+            },
+            supportedFrameworks: treeSitterAvailable
+                ? ['fastapi', 'flask', 'django', 'starlette']
+                : ['fastapi', 'flask'],
+            expectedConfidence: treeSitterAvailable ? 'high (0.7-0.9)' : 'low (0.3-0.5)',
+            loadingError,
+        };
+    }
+    // C# parser info
+    if (language === 'csharp' || language === 'all') {
+        let treeSitterAvailable = false;
+        let loadingError;
+        try {
+            const { isCSharpTreeSitterAvailable, getCSharpLoadingError } = await import('driftdetect-core');
+            treeSitterAvailable = isCSharpTreeSitterAvailable();
+            loadingError = getCSharpLoadingError() ?? undefined;
+        }
+        catch {
+            loadingError = 'C# parser not available';
+        }
+        info.csharp = {
+            treeSitterAvailable,
+            activeParser: treeSitterAvailable ? 'tree-sitter' : 'regex',
+            capabilities: {
+                basicParsing: true,
+                classExtraction: treeSitterAvailable,
+                methodExtraction: treeSitterAvailable,
+                attributeExtraction: treeSitterAvailable,
+                aspNetControllers: treeSitterAvailable,
+                minimalApis: treeSitterAvailable,
+                recordTypes: treeSitterAvailable,
+            },
+            supportedFrameworks: treeSitterAvailable
+                ? ['asp.net-core', 'minimal-apis', 'web-api']
+                : [],
+            loadingError,
+        };
+    }
+    // TypeScript parser info
+    if (language === 'typescript' || language === 'all') {
+        info.typescript = {
+            treeSitterAvailable: true, // TypeScript uses compiler API, always available
+            activeParser: 'typescript-compiler-api',
+            capabilities: {
+                fullAST: true,
+                typeInference: true,
+                interfaces: true,
+                generics: true,
+                decorators: true,
+            },
+            supportedFrameworks: ['express', 'nestjs', 'fastify'],
+        };
+    }
+    // Java parser info
+    if (language === 'java' || language === 'all') {
+        let javaTreeSitterAvailable = false;
+        let javaLoadingError;
+        try {
+            const core = await import('driftdetect-core');
+            // Check if the functions exist (they may not be exported yet)
+            if ('isJavaTreeSitterAvailable' in core && 'getJavaLoadingError' in core) {
+                javaTreeSitterAvailable = core.isJavaTreeSitterAvailable();
+                javaLoadingError = core.getJavaLoadingError() ?? undefined;
+            }
+            else {
+                javaLoadingError = 'Java parser functions not yet available in driftdetect-core';
+            }
+        }
+        catch {
+            javaLoadingError = 'Java parser not available';
+        }
+        info.java = {
+            treeSitterAvailable: javaTreeSitterAvailable,
+            activeParser: javaTreeSitterAvailable ? 'tree-sitter' : 'regex',
+            capabilities: {
+                basicParsing: true,
+                classExtraction: javaTreeSitterAvailable,
+                methodExtraction: javaTreeSitterAvailable,
+                annotationExtraction: javaTreeSitterAvailable,
+                springControllers: javaTreeSitterAvailable,
+                springData: javaTreeSitterAvailable,
+                springSecurity: javaTreeSitterAvailable,
+                recordTypes: javaTreeSitterAvailable,
+            },
+            supportedFrameworks: javaTreeSitterAvailable
+                ? ['spring-boot', 'spring-mvc', 'spring-data', 'spring-security']
+                : [],
+            loadingError: javaLoadingError,
+        };
+    }
+    // PHP parser info
+    if (language === 'php' || language === 'all') {
+        let phpTreeSitterAvailable = false;
+        let phpLoadingError;
+        try {
+            const core = await import('driftdetect-core');
+            // Check if the functions exist
+            if ('isPhpTreeSitterAvailable' in core && 'getPhpLoadingError' in core) {
+                phpTreeSitterAvailable = core.isPhpTreeSitterAvailable();
+                phpLoadingError = core.getPhpLoadingError() ?? undefined;
+            }
+            else {
+                phpLoadingError = 'PHP parser functions not yet available in driftdetect-core';
+            }
+        }
+        catch {
+            phpLoadingError = 'PHP parser not available';
+        }
+        info.php = {
+            treeSitterAvailable: phpTreeSitterAvailable,
+            activeParser: phpTreeSitterAvailable ? 'tree-sitter' : 'regex',
+            capabilities: {
+                basicParsing: true,
+                classExtraction: phpTreeSitterAvailable,
+                methodExtraction: phpTreeSitterAvailable,
+                attributeExtraction: phpTreeSitterAvailable,
+                laravelControllers: phpTreeSitterAvailable,
+                laravelModels: phpTreeSitterAvailable,
+                traitExtraction: phpTreeSitterAvailable,
+                enumExtraction: phpTreeSitterAvailable,
+            },
+            supportedFrameworks: phpTreeSitterAvailable
+                ? ['laravel', 'symfony', 'php8']
+                : ['laravel'],
+            loadingError: phpLoadingError,
+        };
+    }
+    // Build human-readable output
+    let output = '# Parser Information\n\n';
+    if (info.python) {
+        const py = info.python;
+        output += '## Python\n\n';
+        output += `- **Active Parser:** ${py.activeParser}\n`;
+        output += `- **Tree-sitter:** ${py.treeSitterAvailable ? '✓ available' : '✗ not installed'}\n`;
+        output += `- **Expected Confidence:** ${py.expectedConfidence}\n`;
+        output += `- **Supported Frameworks:** ${py.supportedFrameworks.join(', ')}\n\n`;
+        output += '### Capabilities\n\n';
+        for (const [cap, enabled] of Object.entries(py.capabilities)) {
+            const emoji = enabled ? '✓' : '✗';
+            const capName = cap.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+            output += `- ${emoji} ${capName}\n`;
+        }
+        output += '\n';
+        if (py.loadingError) {
+            output += `> ⚠️ Loading error: ${py.loadingError}\n\n`;
+        }
+    }
+    if (info.csharp) {
+        const cs = info.csharp;
+        output += '## C#\n\n';
+        output += `- **Active Parser:** ${cs.activeParser}\n`;
+        output += `- **Tree-sitter:** ${cs.treeSitterAvailable ? '✓ available' : '✗ not installed'}\n`;
+        if (cs.supportedFrameworks.length > 0) {
+            output += `- **Supported Frameworks:** ${cs.supportedFrameworks.join(', ')}\n`;
+        }
+        output += '\n';
+        output += '### Capabilities\n\n';
+        for (const [cap, enabled] of Object.entries(cs.capabilities)) {
+            const emoji = enabled ? '✓' : '✗';
+            const capName = cap.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+            output += `- ${emoji} ${capName}\n`;
+        }
+        output += '\n';
+        if (cs.loadingError) {
+            output += `> ⚠️ Loading error: ${cs.loadingError}\n\n`;
+        }
+    }
+    if (info.typescript) {
+        const ts = info.typescript;
+        output += '## TypeScript/JavaScript\n\n';
+        output += `- **Active Parser:** ${ts.activeParser}\n\n`;
+        output += '### Capabilities\n\n';
+        for (const [cap, enabled] of Object.entries(ts.capabilities)) {
+            const emoji = enabled ? '✓' : '✗';
+            const capName = cap.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+            output += `- ${emoji} ${capName}\n`;
+        }
+        output += '\n';
+    }
+    if (info.java) {
+        const java = info.java;
+        output += '## Java\n\n';
+        output += `- **Active Parser:** ${java.activeParser}\n`;
+        output += `- **Tree-sitter:** ${java.treeSitterAvailable ? '✓ available' : '✗ not installed'}\n`;
+        if (java.supportedFrameworks.length > 0) {
+            output += `- **Supported Frameworks:** ${java.supportedFrameworks.join(', ')}\n`;
+        }
+        output += '\n';
+        output += '### Capabilities\n\n';
+        for (const [cap, enabled] of Object.entries(java.capabilities)) {
+            const emoji = enabled ? '✓' : '✗';
+            const capName = cap.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+            output += `- ${emoji} ${capName}\n`;
+        }
+        output += '\n';
+        if (java.loadingError) {
+            output += `> ⚠️ Loading error: ${java.loadingError}\n\n`;
+        }
+    }
+    if (info.php) {
+        const php = info.php;
+        output += '## PHP\n\n';
+        output += `- **Active Parser:** ${php.activeParser}\n`;
+        output += `- **Tree-sitter:** ${php.treeSitterAvailable ? '✓ available' : '✗ not installed'}\n`;
+        if (php.supportedFrameworks.length > 0) {
+            output += `- **Supported Frameworks:** ${php.supportedFrameworks.join(', ')}\n`;
+        }
+        output += '\n';
+        output += '### Capabilities\n\n';
+        for (const [cap, enabled] of Object.entries(php.capabilities)) {
+            const emoji = enabled ? '✓' : '✗';
+            const capName = cap.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+            output += `- ${emoji} ${capName}\n`;
+        }
+        output += '\n';
+        if (php.loadingError) {
+            output += `> ⚠️ Loading error: ${php.loadingError}\n\n`;
+        }
+    }
+    // Installation tips
+    if ((info.python && !info.python.treeSitterAvailable) || (info.csharp && !info.csharp.treeSitterAvailable) || (info.java && !info.java.treeSitterAvailable) || (info.php && !info.php.treeSitterAvailable)) {
+        output += '## Installation Tips\n\n';
+        if (info.python && !info.python.treeSitterAvailable) {
+            output += 'To enable full Python support (Pydantic, Django, nested types):\n';
+            output += '```bash\npnpm add tree-sitter tree-sitter-python\n```\n\n';
+        }
+        if (info.csharp && !info.csharp.treeSitterAvailable) {
+            output += 'To enable full C# support (ASP.NET, attributes, records):\n';
+            output += '```bash\npnpm add tree-sitter tree-sitter-c-sharp\n```\n\n';
+        }
+        if (info.java && !info.java.treeSitterAvailable) {
+            output += 'To enable full Java support (Spring Boot, annotations, records):\n';
+            output += '```bash\npnpm add tree-sitter tree-sitter-java\n```\n\n';
+        }
+        if (info.php && !info.php.treeSitterAvailable) {
+            output += 'To enable full PHP support (Laravel, Symfony, PHP 8 attributes):\n';
+            output += '```bash\npnpm add tree-sitter tree-sitter-php\n```\n\n';
+        }
+    }
+    return {
+        content: [{ type: 'text', text: output }],
+    };
+}
+// ============================================================================
+// DNA Handler Functions
+// ============================================================================
+/**
+ * Handle drift_dna tool - Get styling DNA profile
+ */
+async function handleDNA(_projectRoot, store, args) {
+    await store.initialize();
+    const profile = await store.load();
+    if (!profile) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: '# No DNA Profile Found\n\n' +
+                        'Run `drift dna scan` to analyze your codebase styling patterns.\n\n' +
+                        'The DNA profile captures how your codebase handles:\n' +
+                        '- Variant handling (primary/secondary buttons, sizes)\n' +
+                        '- Responsive design (mobile-first, breakpoints)\n' +
+                        '- State styling (hover, focus, disabled)\n' +
+                        '- Theming (dark mode, CSS variables)\n' +
+                        '- Spacing philosophy (design tokens, scales)\n' +
+                        '- Animation approach (transitions, motion)',
+                }],
+        };
+    }
+    const format = args.format ?? 'ai-context';
+    // Filter by specific gene if requested
+    if (args.gene && GENE_IDS.includes(args.gene)) {
+        const gene = profile.genes[args.gene];
+        const mutations = profile.mutations.filter(m => m.gene === args.gene);
+        let output = `# Gene: ${gene.name}\n\n`;
+        output += `${gene.description}\n\n`;
+        output += `## Summary\n`;
+        output += `- **Dominant Allele:** ${gene.dominant?.name ?? 'None established'}\n`;
+        output += `- **Confidence:** ${Math.round(gene.confidence * 100)}%\n`;
+        output += `- **Consistency:** ${Math.round(gene.consistency * 100)}%\n\n`;
+        if (gene.alleles.length > 0) {
+            output += `## Alleles Detected\n\n`;
+            for (const allele of gene.alleles) {
+                const marker = allele.isDominant ? ' ← DOMINANT' : '';
+                output += `### ${allele.name}${marker}\n`;
+                output += `- Frequency: ${Math.round(allele.frequency * 100)}% (${allele.fileCount} files)\n`;
+                if (allele.examples.length > 0) {
+                    const ex = allele.examples[0];
+                    if (ex) {
+                        output += `- Example: \`${ex.file}:${ex.line}\`\n`;
+                        output += `\`\`\`\n${ex.code}\n\`\`\`\n`;
+                    }
+                }
+                output += '\n';
+            }
+        }
+        if (gene.exemplars.length > 0) {
+            output += `## Exemplar Files\n`;
+            for (const f of gene.exemplars) {
+                output += `- ${f}\n`;
+            }
+            output += '\n';
+        }
+        if (mutations.length > 0) {
+            output += `## Mutations (${mutations.length})\n\n`;
+            for (const m of mutations.slice(0, 5)) {
+                output += `- **${m.file}:${m.line}** - ${m.actual} (expected: ${m.expected})\n`;
+            }
+            if (mutations.length > 5) {
+                output += `- ... and ${mutations.length - 5} more\n`;
+            }
+        }
+        return { content: [{ type: 'text', text: output }] };
+    }
+    // Full profile output
+    if (format === 'full' || format === 'json') {
+        return {
+            content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }],
+        };
+    }
+    if (format === 'summary') {
+        let output = `# Styling DNA Summary\n\n`;
+        output += `- **Health Score:** ${profile.summary.healthScore}/100\n`;
+        output += `- **Framework:** ${profile.summary.dominantFramework}\n`;
+        output += `- **Genetic Diversity:** ${profile.summary.geneticDiversity.toFixed(2)}\n`;
+        output += `- **Components Analyzed:** ${profile.summary.totalComponentsAnalyzed}\n`;
+        output += `- **Mutations:** ${profile.mutations.length}\n\n`;
+        output += `## Genes\n\n`;
+        output += `| Gene | Dominant | Confidence |\n`;
+        output += `|------|----------|------------|\n`;
+        for (const geneId of GENE_IDS) {
+            const gene = profile.genes[geneId];
+            output += `| ${gene.name} | ${gene.dominant?.name ?? 'None'} | ${Math.round(gene.confidence * 100)}% |\n`;
+        }
+        return { content: [{ type: 'text', text: output }] };
+    }
+    // AI context format (default)
+    const level = (args.level ?? 3);
+    const builder = new AIContextBuilder();
+    const context = builder.build(profile, level);
+    return { content: [{ type: 'text', text: context }] };
+}
+/**
+ * Handle drift_playbook tool - Generate styling playbook
+ */
+async function handlePlaybook(_projectRoot, store, args) {
+    await store.initialize();
+    const profile = await store.load();
+    if (!profile) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: '# No DNA Profile Found\n\n' +
+                        'Run `drift dna scan` first to analyze your codebase styling patterns.',
+                }],
+        };
+    }
+    const generator = new PlaybookGenerator();
+    const playbook = generator.generate(profile);
+    // Filter to specific section if requested
+    if (args.section && GENE_IDS.includes(args.section)) {
+        const gene = profile.genes[args.section];
+        const sectionRegex = new RegExp(`## ${gene.name}[\\s\\S]*?(?=\\n## |$)`, 'i');
+        const match = playbook.match(sectionRegex);
+        if (match) {
+            return { content: [{ type: 'text', text: match[0] }] };
+        }
+    }
+    return { content: [{ type: 'text', text: playbook }] };
+}
+/**
+ * Handle drift_mutations tool - Get styling mutations
+ */
+async function handleMutations(store, args) {
+    await store.initialize();
+    const profile = await store.load();
+    if (!profile) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: '# No DNA Profile Found\n\n' +
+                        'Run `drift dna scan` first to analyze your codebase styling patterns.',
+                }],
+        };
+    }
+    let mutations = profile.mutations;
+    // Filter by gene
+    if (args.gene && GENE_IDS.includes(args.gene)) {
+        mutations = mutations.filter(m => m.gene === args.gene);
+    }
+    // Filter by impact
+    if (args.impact) {
+        const validImpacts = ['low', 'medium', 'high'];
+        if (validImpacts.includes(args.impact)) {
+            mutations = mutations.filter(m => m.impact === args.impact);
+        }
+    }
+    if (mutations.length === 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: '# No Mutations Found\n\n' +
+                        '✓ Your codebase styling is consistent with the established DNA patterns.',
+                }],
+        };
+    }
+    // Group by impact
+    const byImpact = { high: [], medium: [], low: [] };
+    for (const m of mutations)
+        byImpact[m.impact].push(m);
+    let output = `# Styling Mutations (${mutations.length})\n\n`;
+    output += 'Mutations are files that deviate from the established styling DNA.\n\n';
+    if (byImpact.high.length > 0) {
+        output += `## ⚠️ High Impact (${byImpact.high.length})\n\n`;
+        for (const m of byImpact.high) {
+            output += `### ${m.file}:${m.line}\n`;
+            output += `- **Gene:** ${m.gene}\n`;
+            output += `- **Found:** ${m.actual}\n`;
+            output += `- **Expected:** ${m.expected}\n`;
+            if (args.suggest && m.suggestion) {
+                output += `- **Suggestion:** ${m.suggestion}\n`;
+            }
+            output += '\n';
+        }
+    }
+    if (byImpact.medium.length > 0) {
+        output += `## ⚡ Medium Impact (${byImpact.medium.length})\n\n`;
+        for (const m of byImpact.medium.slice(0, 10)) {
+            output += `- **${m.file}:${m.line}** - ${m.actual} → ${m.expected}\n`;
+            if (args.suggest && m.suggestion) {
+                output += `  - 💡 ${m.suggestion}\n`;
+            }
+        }
+        if (byImpact.medium.length > 10) {
+            output += `- ... and ${byImpact.medium.length - 10} more\n`;
+        }
+        output += '\n';
+    }
+    if (byImpact.low.length > 0) {
+        output += `## Low Impact (${byImpact.low.length})\n\n`;
+        for (const m of byImpact.low.slice(0, 5)) {
+            output += `- ${m.file}:${m.line} - ${m.actual}\n`;
+        }
+        if (byImpact.low.length > 5) {
+            output += `- ... and ${byImpact.low.length - 5} more\n`;
+        }
+    }
+    return { content: [{ type: 'text', text: output }] };
+}
+/**
+ * Handle drift_dna_check tool - Check code against DNA
+ */
+async function handleDNACheck(projectRoot, store, args) {
+    await store.initialize();
+    const profile = await store.load();
+    if (!profile) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: '# No DNA Profile Found\n\n' +
+                        'Run `drift dna scan` first to establish styling patterns.',
+                }],
+        };
+    }
+    if (!args.code && !args.file) {
+        // Return DNA conventions for code generation
+        const builder = new AIContextBuilder();
+        const context = builder.build(profile, 3);
+        return {
+            content: [{
+                    type: 'text',
+                    text: '# Styling DNA Conventions\n\n' +
+                        'Use these conventions when generating component code:\n\n' +
+                        context,
+                }],
+        };
+    }
+    // If file is provided, read it
+    let code = args.code ?? '';
+    if (args.file) {
+        try {
+            const fs = await import('node:fs/promises');
+            const path = await import('node:path');
+            code = await fs.readFile(path.join(projectRoot, args.file), 'utf-8');
+        }
+        catch {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: Could not read file "${args.file}"`,
+                    }],
+                isError: true,
+            };
+        }
+    }
+    // Simple pattern matching check against DNA
+    const issues = [];
+    const genesToCheck = args.genes?.filter(g => GENE_IDS.includes(g)) ?? [...GENE_IDS];
+    for (const geneId of genesToCheck) {
+        const gene = profile.genes[geneId];
+        if (!gene.dominant)
+            continue;
+        // Check for non-dominant alleles in the code
+        for (const allele of gene.alleles) {
+            if (allele.isDominant)
+                continue;
+            // Simple heuristic checks based on allele patterns
+            const patterns = {
+                'styled-variants': [/styled\.\w+/, /\$\{props\s*=>/],
+                'inline-conditionals': [/className=\{[^}]*\?[^}]*\}/],
+                'tailwind-desktop-first': [/className="[^"]*\b(lg|xl|2xl):[^"]*\bsm:/],
+                'js-responsive': [/useMediaQuery|useBreakpoint/],
+                'hardcoded': [/style=\{\{[^}]*padding:\s*['"]?\d+px/],
+                'framer-motion': [/<motion\./],
+            };
+            const allelePatterns = patterns[allele.id];
+            if (allelePatterns) {
+                for (const pattern of allelePatterns) {
+                    if (pattern.test(code)) {
+                        issues.push({
+                            gene: gene.name,
+                            issue: `Found ${allele.name} pattern`,
+                            suggestion: `Consider using ${gene.dominant.name} instead`,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (issues.length === 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: '# DNA Check: ✓ Passed\n\n' +
+                        'The code appears to follow the established styling DNA patterns.',
+                }],
+        };
+    }
+    let output = `# DNA Check: ⚠️ ${issues.length} Issue(s) Found\n\n`;
+    for (const issue of issues) {
+        output += `## ${issue.gene}\n`;
+        output += `- **Issue:** ${issue.issue}\n`;
+        output += `- **Suggestion:** ${issue.suggestion}\n\n`;
+    }
+    return { content: [{ type: 'text', text: output }] };
+}
+/**
+ * Handle drift_boundaries tool - Data access boundaries
+ */
+async function handleBoundaries(store, args) {
+    await store.initialize();
+    const action = args.action ?? 'overview';
+    const includeViolations = args.includeViolations ?? true;
+    switch (action) {
+        case 'overview': {
+            const accessMap = store.getAccessMap();
+            const sensitiveFields = store.getSensitiveAccess();
+            let output = '# Data Boundaries Overview\n\n';
+            output += `- **Tables:** ${accessMap.stats.totalTables}\n`;
+            output += `- **Access Points:** ${accessMap.stats.totalAccessPoints}\n`;
+            output += `- **Sensitive Fields:** ${accessMap.stats.totalSensitiveFields}\n`;
+            output += `- **ORM Models:** ${accessMap.stats.totalModels}\n\n`;
+            if (accessMap.stats.totalTables > 0) {
+                output += '## Tables\n\n';
+                const tableEntries = Object.entries(accessMap.tables)
+                    .map(([name, info]) => ({
+                    name,
+                    accessCount: info.accessedBy.length,
+                    hasSensitive: info.sensitiveFields.length > 0,
+                }))
+                    .sort((a, b) => b.accessCount - a.accessCount)
+                    .slice(0, 10);
+                for (const table of tableEntries) {
+                    const sensitive = table.hasSensitive ? ' ⚠️' : '';
+                    output += `- **${table.name}**${sensitive}: ${table.accessCount} access points\n`;
+                }
+                output += '\n';
+            }
+            if (sensitiveFields.length > 0) {
+                output += '## Sensitive Fields\n\n';
+                const fieldCounts = new Map();
+                for (const field of sensitiveFields) {
+                    const key = field.table ? `${field.table}.${field.field}` : field.field;
+                    fieldCounts.set(key, (fieldCounts.get(key) ?? 0) + 1);
+                }
+                const sortedFields = Array.from(fieldCounts.entries())
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 10);
+                for (const [fieldName, count] of sortedFields) {
+                    output += `- **${fieldName}**: ${count} locations\n`;
+                }
+                output += '\n';
+            }
+            if (includeViolations) {
+                const rules = store.getRules();
+                if (rules) {
+                    const violations = store.checkAllViolations();
+                    if (violations.length > 0) {
+                        output += `## ⚠️ Violations (${violations.length})\n\n`;
+                        for (const v of violations.slice(0, 5)) {
+                            output += `- **${v.file}:${v.line}** - ${v.message}\n`;
+                        }
+                        if (violations.length > 5) {
+                            output += `- ... and ${violations.length - 5} more\n`;
+                        }
+                    }
+                    else {
+                        output += '## ✓ No Violations\n\nAll data access follows configured boundaries.\n';
+                    }
+                }
+                else {
+                    output += '## No Rules Configured\n\n';
+                    output += 'Create `.drift/boundaries/rules.json` to enable boundary enforcement.\n';
+                    output += 'Run `drift boundaries init-rules` to generate a starter config.\n';
+                }
+            }
+            return { content: [{ type: 'text', text: output }] };
+        }
+        case 'table': {
+            if (!args.table) {
+                return {
+                    content: [{ type: 'text', text: 'Error: table parameter required for "table" action' }],
+                    isError: true,
+                };
+            }
+            const tableInfo = store.getTableAccess(args.table);
+            if (!tableInfo) {
+                return {
+                    content: [{ type: 'text', text: `Table '${args.table}' not found in access map.` }],
+                };
+            }
+            let output = `# Table: ${args.table}\n\n`;
+            if (tableInfo.model) {
+                output += `**Model:** ${tableInfo.model}\n`;
+            }
+            output += `**Fields:** ${tableInfo.fields.join(', ') || 'none detected'}\n`;
+            output += `**Access Points:** ${tableInfo.accessedBy.length}\n\n`;
+            if (tableInfo.sensitiveFields.length > 0) {
+                output += '## ⚠️ Sensitive Fields\n\n';
+                for (const sf of tableInfo.sensitiveFields) {
+                    output += `- **${sf.field}** (${sf.sensitivityType})\n`;
+                }
+                output += '\n';
+            }
+            output += '## Access Points\n\n';
+            const byFile = new Map();
+            for (const ap of tableInfo.accessedBy) {
+                if (!byFile.has(ap.file))
+                    byFile.set(ap.file, []);
+                byFile.get(ap.file).push(ap);
+            }
+            for (const [file, accessPoints] of byFile) {
+                output += `### ${file}\n`;
+                for (const ap of accessPoints) {
+                    output += `- Line ${ap.line}: **${ap.operation}** ${ap.fields.join(', ')}\n`;
+                }
+                output += '\n';
+            }
+            return { content: [{ type: 'text', text: output }] };
+        }
+        case 'file': {
+            if (!args.file) {
+                return {
+                    content: [{ type: 'text', text: 'Error: file parameter required for "file" action' }],
+                    isError: true,
+                };
+            }
+            const fileAccess = store.getFileAccess(args.file);
+            let output = `# Data Access: ${args.file}\n\n`;
+            if (fileAccess.length === 0) {
+                output += 'No data access detected for this file/pattern.\n';
+            }
+            else {
+                for (const fileInfo of fileAccess) {
+                    output += `## ${fileInfo.file}\n\n`;
+                    output += `**Tables:** ${fileInfo.tables.join(', ')}\n`;
+                    output += `**Access Points:** ${fileInfo.accessPoints.length}\n\n`;
+                    for (const ap of fileInfo.accessPoints) {
+                        output += `- Line ${ap.line}: **${ap.operation}** ${ap.table} ${ap.fields.join(', ')}\n`;
+                    }
+                    output += '\n';
+                }
+            }
+            // Include boundary rules context if available
+            const rules = store.getRules();
+            if (rules && fileAccess.length > 0) {
+                const allTables = new Set(fileAccess.flatMap(f => f.tables));
+                const applicableRules = rules.boundaries.filter(b => b.tables?.some(t => allTables.has(t)) ||
+                    b.fields?.some(f => allTables.has(f.split('.')[0] || '')));
+                if (applicableRules.length > 0) {
+                    output += '## Applicable Boundaries\n\n';
+                    for (const rule of applicableRules) {
+                        output += `- **${rule.id}**: ${rule.description}\n`;
+                        output += `  - Allowed: ${rule.allowedPaths.join(', ')}\n`;
+                    }
+                }
+            }
+            return { content: [{ type: 'text', text: output }] };
+        }
+        case 'sensitive': {
+            const sensitiveFields = store.getSensitiveAccess();
+            let output = '# Sensitive Data Access\n\n';
+            if (sensitiveFields.length === 0) {
+                output += 'No sensitive fields detected.\n';
+                return { content: [{ type: 'text', text: output }] };
+            }
+            // Group by sensitivity type
+            const byType = new Map();
+            for (const field of sensitiveFields) {
+                const type = field.sensitivityType;
+                if (!byType.has(type))
+                    byType.set(type, []);
+                byType.get(type).push(field);
+            }
+            for (const [type, fields] of byType) {
+                output += `## ${type.toUpperCase()} (${fields.length})\n\n`;
+                for (const f of fields) {
+                    const fieldName = f.table ? `${f.table}.${f.field}` : f.field;
+                    output += `- **${fieldName}**\n`;
+                    output += `  - ${f.file}:${f.line}\n`;
+                }
+                output += '\n';
+            }
+            return { content: [{ type: 'text', text: output }] };
+        }
+        case 'check': {
+            const rules = store.getRules();
+            if (!rules) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: '# No Boundary Rules Configured\n\n' +
+                                'Create `.drift/boundaries/rules.json` to enable boundary enforcement.\n' +
+                                'Run `drift boundaries init-rules` to generate a starter config.',
+                        }],
+                };
+            }
+            const violations = store.checkAllViolations();
+            if (violations.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: '# ✓ No Boundary Violations\n\n' +
+                                `Checked ${rules.boundaries.length} rules. All data access follows configured boundaries.`,
+                        }],
+                };
+            }
+            let output = `# ⚠️ Boundary Violations (${violations.length})\n\n`;
+            // Group by severity
+            const errors = violations.filter(v => v.severity === 'error');
+            const warnings = violations.filter(v => v.severity === 'warning');
+            const infos = violations.filter(v => v.severity === 'info');
+            if (errors.length > 0) {
+                output += `## 🔴 Errors (${errors.length})\n\n`;
+                for (const v of errors) {
+                    output += `### ${v.file}:${v.line}\n`;
+                    output += `- **Rule:** ${v.ruleId}\n`;
+                    output += `- **Message:** ${v.message}\n`;
+                    if (v.suggestion) {
+                        output += `- **Suggestion:** ${v.suggestion}\n`;
+                    }
+                    output += '\n';
+                }
+            }
+            if (warnings.length > 0) {
+                output += `## 🟡 Warnings (${warnings.length})\n\n`;
+                for (const v of warnings) {
+                    output += `- **${v.file}:${v.line}** - ${v.message}\n`;
+                }
+                output += '\n';
+            }
+            if (infos.length > 0) {
+                output += `## ℹ️ Info (${infos.length})\n\n`;
+                for (const v of infos.slice(0, 5)) {
+                    output += `- ${v.file}:${v.line} - ${v.message}\n`;
+                }
+                if (infos.length > 5) {
+                    output += `- ... and ${infos.length - 5} more\n`;
+                }
+            }
+            return { content: [{ type: 'text', text: output }] };
+        }
+        case 'rules': {
+            const rules = store.getRules();
+            if (!rules) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: '# No Boundary Rules Configured\n\n' +
+                                'Create `.drift/boundaries/rules.json` to define data access boundaries.\n\n' +
+                                '## Example Rules\n\n' +
+                                '```json\n' +
+                                '{\n' +
+                                '  "version": "1.0",\n' +
+                                '  "sensitivity": {\n' +
+                                '    "critical": ["users.password_hash", "users.ssn"],\n' +
+                                '    "sensitive": ["users.email", "users.phone"],\n' +
+                                '    "general": []\n' +
+                                '  },\n' +
+                                '  "boundaries": [\n' +
+                                '    {\n' +
+                                '      "id": "auth-owns-credentials",\n' +
+                                '      "description": "Only auth module can access credentials",\n' +
+                                '      "fields": ["users.password_hash"],\n' +
+                                '      "allowedPaths": ["**/auth/**"],\n' +
+                                '      "severity": "error"\n' +
+                                '    }\n' +
+                                '  ]\n' +
+                                '}\n' +
+                                '```',
+                        }],
+                };
+            }
+            let output = '# Data Boundary Rules\n\n';
+            output += '## Sensitivity Tiers\n\n';
+            output += `- **Critical:** ${rules.sensitivity.critical.join(', ') || 'none'}\n`;
+            output += `- **Sensitive:** ${rules.sensitivity.sensitive.join(', ') || 'none'}\n`;
+            output += '\n';
+            output += `## Boundaries (${rules.boundaries.length})\n\n`;
+            for (const b of rules.boundaries) {
+                const enabled = b.enabled !== false ? '✓' : '○';
+                output += `### ${enabled} ${b.id}\n`;
+                output += `${b.description}\n\n`;
+                if (b.tables)
+                    output += `- **Tables:** ${b.tables.join(', ')}\n`;
+                if (b.fields)
+                    output += `- **Fields:** ${b.fields.join(', ')}\n`;
+                if (b.operations)
+                    output += `- **Operations:** ${b.operations.join(', ')}\n`;
+                output += `- **Allowed:** ${b.allowedPaths.join(', ')}\n`;
+                output += `- **Severity:** ${b.severity}\n\n`;
+            }
+            return { content: [{ type: 'text', text: output }] };
+        }
+        default:
+            return {
+                content: [{ type: 'text', text: `Unknown action: ${action}` }],
+                isError: true,
+            };
+    }
+}
 //# sourceMappingURL=server.js.map