dartmind 17.0.0

package/dist/bridges/MCPBridge.js

@@ -0,0 +1,766 @@
+/**
+ * FlutterAI MCPBridge - v8 Integration Layer
+ *
+ * This bridge wraps the actual v8 modules (GhostProtocol, PackageGate,
+ * PerformanceGate, AtomicWriter) for use by MCP servers.
+ *
+ * CRITICAL: This imports REAL v8 implementations - no reimplementation!
+ */
+import { createClient } from '@supabase/supabase-js';
+// ============================================================================
+// V8 MODULE IMPORTS
+// ============================================================================
+import GhostProtocol, { ThreatLevel } from '../security/GhostProtocol.js';
+import { PackageGate } from '../gates/PackageGate.js';
+import { PerformanceGate, FrameBudgetAnalyzer } from '../gates/PerformanceGate.js';
+import { AtomicWriter } from '../gates/AtomicWriter.js';
+import { GateId } from '../core/types.js';
+// ============================================================================
+// SUPABASE CLIENT (SINGLETON)
+// ============================================================================
+let supabaseClient = null;
+// V15: No hardcoded Supabase URL - require environment variable
+function getSupabase() {
+    if (!supabaseClient) {
+        const url = process.env.FLUTTERAI_SUPABASE_URL || process.env.SUPABASE_URL;
+        const key = process.env.FLUTTERAI_SUPABASE_KEY || process.env.SUPABASE_ANON_KEY || process.env.SUPABASE_KEY;
+        if (!url) {
+            throw new Error('FLUTTERAI_SUPABASE_URL or SUPABASE_URL environment variable required');
+        }
+        if (!key) {
+            throw new Error('FLUTTERAI_SUPABASE_KEY or SUPABASE_ANON_KEY environment variable required');
+        }
+        supabaseClient = createClient(url, key);
+    }
+    return supabaseClient;
+}
+export class SecurityBridge {
+    ghostProtocol;
+    constructor(config) {
+        this.ghostProtocol = new GhostProtocol(config);
+    }
+    /**
+     * Scan a prompt for injection attacks
+     */
+    async scanPrompt(prompt) {
+        try {
+            const result = await this.ghostProtocol.scanPrompt(prompt);
+            return {
+                success: true,
+                data: this.transformScanResult(result)
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Prompt scan failed'
+            };
+        }
+    }
+    /**
+     * Scan code for security vulnerabilities
+     */
+    async scanCode(code) {
+        try {
+            const result = await this.ghostProtocol.scanCode(code);
+            return {
+                success: true,
+                data: this.transformScanResult(result)
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Code scan failed'
+            };
+        }
+    }
+    /**
+     * Scan code with additional patterns from database
+     */
+    async scanCodeWithDB(code, patternType) {
+        try {
+            // First, run GhostProtocol scan
+            const ghostResult = await this.ghostProtocol.scanCode(code);
+            // Then, check against database security rules
+            const dbIssues = await this.checkDatabaseSecurityRules(code, patternType);
+            // Merge results
+            const mergedResult = this.transformScanResult(ghostResult);
+            // Add database-detected issues
+            for (const issue of dbIssues) {
+                mergedResult.threats.push({
+                    id: `db-${issue.id}`,
+                    category: issue.category,
+                    severity: issue.severity,
+                    match: issue.match,
+                    location: { line: issue.line, column: 0, context: issue.context },
+                    mitigation: issue.fix
+                });
+            }
+            // Recalculate threat level if needed
+            if (dbIssues.some(i => i.severity === 'critical')) {
+                mergedResult.threatLevel = ThreatLevel.CRITICAL;
+                mergedResult.safe = false;
+            }
+            else if (dbIssues.some(i => i.severity === 'high') && mergedResult.threatLevel === ThreatLevel.SAFE) {
+                mergedResult.threatLevel = ThreatLevel.HIGH;
+                mergedResult.safe = false;
+            }
+            return {
+                success: true,
+                data: mergedResult
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Code scan with DB failed'
+            };
+        }
+    }
+    /**
+     * Check code against database security rules
+     */
+    async checkDatabaseSecurityRules(code, patternType) {
+        const issues = [];
+        try {
+            const supabase = getSupabase();
+            // Fetch security rules
+            let query = supabase
+                .from('security_rules')
+                .select('*')
+                .eq('is_active', true);
+            if (patternType) {
+                query = query.eq('pattern_type', patternType);
+            }
+            const { data: rules, error } = await query;
+            if (error || !rules) {
+                console.warn('[SecurityBridge] Could not fetch security rules:', error?.message);
+                return issues;
+            }
+            const lines = code.split('\n');
+            for (const rule of rules) {
+                try {
+                    const regex = new RegExp(rule.pattern, rule.flags || 'gi');
+                    for (let i = 0; i < lines.length; i++) {
+                        const match = lines[i].match(regex);
+                        if (match) {
+                            issues.push({
+                                id: rule.id,
+                                category: rule.category || 'security',
+                                severity: rule.severity || 'high',
+                                match: match[0],
+                                line: i + 1,
+                                context: lines[i].trim(),
+                                fix: rule.fix_suggestion || 'Review and fix security issue'
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Invalid regex, skip
+                }
+            }
+            // Also check anti-patterns
+            const { data: antiPatterns } = await supabase
+                .from('anti_patterns')
+                .select('*')
+                .eq('is_active', true);
+            if (antiPatterns) {
+                for (const pattern of antiPatterns) {
+                    try {
+                        const regex = new RegExp(pattern.pattern, 'gi');
+                        for (let i = 0; i < lines.length; i++) {
+                            const match = lines[i].match(regex);
+                            if (match) {
+                                issues.push({
+                                    id: pattern.id,
+                                    category: 'anti_pattern',
+                                    severity: pattern.severity || 'warning',
+                                    match: match[0],
+                                    line: i + 1,
+                                    context: lines[i].trim(),
+                                    fix: pattern.fix_suggestion || pattern.description
+                                });
+                            }
+                        }
+                    }
+                    catch {
+                        // Invalid regex, skip
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn('[SecurityBridge] Database check failed:', error);
+        }
+        return issues;
+    }
+    /**
+     * Transform GhostProtocol ScanResult to our format
+     */
+    transformScanResult(result) {
+        return {
+            safe: result.safe,
+            threatLevel: result.threatLevel,
+            threats: result.threats.map((t) => ({
+                id: t.id,
+                category: t.pattern.category,
+                severity: t.pattern.severity,
+                match: t.match,
+                location: t.location,
+                mitigation: t.pattern.mitigation
+            })),
+            compliance: result.compliance,
+            scanDuration: result.scanDuration
+        };
+    }
+    /**
+     * Get statistics from GhostProtocol
+     */
+    getStats() {
+        return this.ghostProtocol.getStats();
+    }
+    /**
+     * Whitelist an input
+     */
+    whitelist(input) {
+        this.ghostProtocol.whitelist(input);
+    }
+    /**
+     * Enable/disable Ghost Protocol
+     */
+    enable() {
+        this.ghostProtocol.enable();
+    }
+    disable() {
+        this.ghostProtocol.disable();
+    }
+}
+export class PackageBridge {
+    packageGate;
+    constructor() {
+        this.packageGate = new PackageGate();
+    }
+    /**
+     * Verify a single package exists on pub.dev
+     */
+    async verifyPackage(packageName) {
+        try {
+            const result = await this.packageGate.verifyPackage(packageName);
+            return {
+                success: true,
+                data: {
+                    exists: result.exists,
+                    name: packageName,
+                    version: result.package?.latest?.version,
+                    score: result.package?.score
+                }
+            };
+        }
+        catch (error) {
+            // FAIL-CLOSED: On error, assume package doesn't exist
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Package verification failed',
+                data: {
+                    exists: false,
+                    name: packageName
+                }
+            };
+        }
+    }
+    /**
+     * Verify multiple packages
+     */
+    async verifyPackages(packageNames) {
+        try {
+            const results = await this.packageGate.verifyPackages(packageNames);
+            return {
+                success: true,
+                data: results
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Batch verification failed'
+            };
+        }
+    }
+    /**
+     * Run full package gate on a project
+     */
+    async runGate(projectPath) {
+        try {
+            const result = await this.packageGate.run(projectPath);
+            return {
+                success: result.passed,
+                data: result,
+                metadata: {
+                    gate: GateId.PACKAGE,
+                    score: result.score
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Package gate failed'
+            };
+        }
+    }
+    /**
+     * Get package info
+     */
+    async getPackageInfo(packageName) {
+        try {
+            const info = await this.packageGate.getPackageInfo(packageName);
+            return {
+                success: info !== null,
+                data: info
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to get package info'
+            };
+        }
+    }
+    /**
+     * Clear package cache
+     */
+    clearCache() {
+        this.packageGate.clearCache();
+    }
+}
+export class PerformanceBridge {
+    projectPath;
+    performanceGate = null;
+    frameBudgetAnalyzer;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+        this.frameBudgetAnalyzer = new FrameBudgetAnalyzer();
+    }
+    /**
+     * Initialize the performance gate (required before analysis)
+     */
+    async initialize() {
+        this.performanceGate = new PerformanceGate(this.projectPath);
+        await this.performanceGate.initialize();
+    }
+    /**
+     * Run full performance analysis
+     */
+    async analyzePerformance() {
+        try {
+            if (!this.performanceGate) {
+                await this.initialize();
+            }
+            const result = await this.performanceGate.run();
+            return {
+                success: result.passed,
+                data: {
+                    passed: result.passed,
+                    score: result.score,
+                    issues: result.issues,
+                    frameBudgetViolations: [],
+                    constCandidates: result.metadata?.constCandidatesFound || 0,
+                    metadata: result.metadata
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Performance analysis failed'
+            };
+        }
+    }
+    /**
+     * Analyze a specific code snippet for performance issues
+     */
+    analyzeCode(code, filePath = 'unknown.dart') {
+        try {
+            // Use FrameBudgetAnalyzer for code analysis
+            const violations = this.frameBudgetAnalyzer.analyzeCode(code, filePath);
+            return {
+                success: true,
+                data: {
+                    issues: [],
+                    frameBudgetViolations: violations.map(v => ({
+                        file: v.file,
+                        line: v.line,
+                        estimatedMs: v.estimatedMs,
+                        severity: v.severity,
+                        suggestion: v.suggestion
+                    }))
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Code analysis failed'
+            };
+        }
+    }
+    /**
+     * Auto-fix const candidates (requires initialized gate)
+     */
+    async autoFixConst() {
+        try {
+            if (!this.performanceGate) {
+                await this.initialize();
+            }
+            // Use the actual v8 API: autoFixConst()
+            const result = await this.performanceGate.autoFixConst();
+            return {
+                success: result.verificationPassed,
+                data: {
+                    verificationPassed: result.verificationPassed,
+                    filesAnalyzed: result.filesAnalyzed,
+                    candidatesFound: result.candidatesFound,
+                    fixesApplied: result.fixesApplied,
+                    fixesFailed: result.fixesFailed,
+                    transactionId: result.transactionId,
+                    errors: result.errors
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Auto-fix failed'
+            };
+        }
+    }
+    /**
+     * Find const candidates without applying fixes (dry run)
+     */
+    async findConstCandidates() {
+        try {
+            if (!this.performanceGate) {
+                await this.initialize();
+            }
+            const candidates = await this.performanceGate.findConstCandidates();
+            return {
+                success: true,
+                data: candidates
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to find const candidates'
+            };
+        }
+    }
+    /**
+     * Get const usage statistics for the project
+     */
+    async getConstStatistics() {
+        try {
+            if (!this.performanceGate) {
+                await this.initialize();
+            }
+            const stats = await this.performanceGate.getConstStatistics();
+            return {
+                success: true,
+                data: stats
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to get const statistics'
+            };
+        }
+    }
+    /**
+     * Undo the last const promotion operation
+     */
+    async undoConstPromotion() {
+        try {
+            if (!this.performanceGate) {
+                await this.initialize();
+            }
+            const result = await this.performanceGate.undoConstPromotion();
+            return {
+                success: result,
+                data: result
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to undo const promotion'
+            };
+        }
+    }
+}
+export class AtomicBridge {
+    atomicWriter;
+    projectPath;
+    initialized = false;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+        this.atomicWriter = new AtomicWriter(projectPath);
+    }
+    /**
+     * Initialize the atomic writer
+     */
+    async initialize() {
+        if (!this.initialized) {
+            await this.atomicWriter.initialize();
+            this.initialized = true;
+        }
+    }
+    /**
+     * Start a new transaction
+     */
+    async beginTransaction(goal) {
+        try {
+            await this.initialize();
+            const transactionId = this.atomicWriter.startTransaction(goal);
+            return {
+                success: true,
+                data: { transactionId }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to start transaction'
+            };
+        }
+    }
+    /**
+     * Stage a file for writing
+     */
+    async stageFile(relativePath, content) {
+        try {
+            await this.initialize();
+            await this.atomicWriter.stageWrite(relativePath, content);
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to stage file'
+            };
+        }
+    }
+    /**
+     * Stage a file deletion
+     */
+    async stageDelete(relativePath) {
+        try {
+            await this.initialize();
+            await this.atomicWriter.stageDelete(relativePath);
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to stage deletion'
+            };
+        }
+    }
+    /**
+     * Verify staged changes before commit
+     */
+    async verify() {
+        try {
+            await this.initialize();
+            const result = await this.atomicWriter.verify();
+            return {
+                success: result.passed,
+                data: result
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Verification failed'
+            };
+        }
+    }
+    /**
+     * Commit all staged changes
+     */
+    async commitTransaction(goal) {
+        try {
+            await this.initialize();
+            const transaction = await this.atomicWriter.commit(goal);
+            return {
+                success: true,
+                data: {
+                    filesWritten: transaction.files.map(f => f.path),
+                    backupPath: `.fai/transactions/${transaction.id}.json`,
+                    transactionId: transaction.id
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Commit failed'
+            };
+        }
+    }
+    /**
+     * Rollback staged changes (before commit)
+     */
+    async rollback() {
+        try {
+            await this.initialize();
+            await this.atomicWriter.rollback();
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Rollback failed'
+            };
+        }
+    }
+    /**
+     * Undo a committed transaction
+     */
+    async undoTransaction(transactionId) {
+        try {
+            await this.initialize();
+            await this.atomicWriter.undoTransaction(transactionId);
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Undo failed'
+            };
+        }
+    }
+    /**
+     * Undo transactions by goal name (semantic undo)
+     */
+    async undoByGoal(goalName) {
+        try {
+            await this.initialize();
+            const undone = await this.atomicWriter.undoByGoal(goalName);
+            return {
+                success: true,
+                data: { undoneTransactions: undone }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Undo by goal failed'
+            };
+        }
+    }
+    /**
+     * Get transaction history
+     */
+    async getTransactionHistory() {
+        try {
+            await this.initialize();
+            const transactions = await this.atomicWriter.listTransactions();
+            return {
+                success: true,
+                data: transactions.map(tx => ({
+                    id: tx.id,
+                    goal: tx.goal,
+                    timestamp: tx.timestamp,
+                    fileCount: tx.files.length,
+                    state: tx.state
+                }))
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to get history'
+            };
+        }
+    }
+    /**
+     * Get diff for a staged file
+     */
+    getStagedDiff(relativePath) {
+        const diff = this.atomicWriter.getStagedDiff(relativePath);
+        if (diff) {
+            return { success: true, data: diff };
+        }
+        return { success: false, error: 'File not staged' };
+    }
+    /**
+     * Crash recovery
+     */
+    async crashRecovery(exitCode) {
+        try {
+            await this.initialize();
+            const result = await this.atomicWriter.crashRecovery(exitCode);
+            return {
+                success: true,
+                data: result
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Crash recovery failed'
+            };
+        }
+    }
+}
+// ============================================================================
+// SINGLETON FACTORIES
+// ============================================================================
+let securityBridgeInstance = null;
+let packageBridgeInstance = null;
+const performanceBridgeInstances = new Map();
+const atomicBridgeInstances = new Map();
+/**
+ * Get singleton SecurityBridge
+ */
+export function getSecurityBridge() {
+    if (!securityBridgeInstance) {
+        securityBridgeInstance = new SecurityBridge();
+    }
+    return securityBridgeInstance;
+}
+/**
+ * Get singleton PackageBridge
+ */
+export function getPackageBridge() {
+    if (!packageBridgeInstance) {
+        packageBridgeInstance = new PackageBridge();
+    }
+    return packageBridgeInstance;
+}
+/**
+ * Get or create PerformanceBridge for a project
+ */
+export function getPerformanceBridge(projectPath) {
+    if (!performanceBridgeInstances.has(projectPath)) {
+        performanceBridgeInstances.set(projectPath, new PerformanceBridge(projectPath));
+    }
+    return performanceBridgeInstances.get(projectPath);
+}
+/**
+ * Get or create AtomicBridge for a project
+ */
+export function getAtomicBridge(projectPath) {
+    if (!atomicBridgeInstances.has(projectPath)) {
+        atomicBridgeInstances.set(projectPath, new AtomicBridge(projectPath));
+    }
+    return atomicBridgeInstances.get(projectPath);
+}
+// ============================================================================
+// CONVENIENCE EXPORT
+// ============================================================================
+export { GhostProtocol, PackageGate, PerformanceGate, AtomicWriter, ThreatLevel, GateId };
+//# sourceMappingURL=MCPBridge.js.map