@visualprd/mcp-server 1.1.0

package/dist/services/visualprd-client.js

@@ -0,0 +1,805 @@
+"use strict";
+/**
+ * VisualPRD API Client
+ *
+ * Connects to VisualPRD's Firestore backend to fetch project data,
+ * update build prompt status, and manage dynamic steps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisualPRDClient = void 0;
+const app_1 = require("firebase-admin/app");
+const firestore_1 = require("firebase-admin/firestore");
+class VisualPRDClient {
+    db;
+    config;
+    projectDataCache = null;
+    cacheTimestamp = 0;
+    CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+    constructor(config) {
+        this.config = config;
+        // Initialize Firebase Admin if not already initialized
+        let app;
+        if ((0, app_1.getApps)().length === 0) {
+            // Use service account from environment or config
+            const serviceAccount = process.env.GOOGLE_APPLICATION_CREDENTIALS
+                ? undefined // Will use default credentials
+                : {
+                    projectId: process.env.FIREBASE_PROJECT_ID || 'visualprd-app',
+                    privateKey: process.env.FIREBASE_PRIVATE_KEY?.replace(/\\n/g, '\n'),
+                    clientEmail: process.env.FIREBASE_CLIENT_EMAIL,
+                };
+            app = (0, app_1.initializeApp)(serviceAccount
+                ? { credential: (0, app_1.cert)(serviceAccount) }
+                : { projectId: process.env.FIREBASE_PROJECT_ID || 'visualprd-app' });
+        }
+        else {
+            app = (0, app_1.getApps)()[0];
+        }
+        this.db = (0, firestore_1.getFirestore)(app);
+    }
+    // ============================================================================
+    // PROJECT DATA LOADING
+    // ============================================================================
+    /**
+     * Load full project data including all entities
+     */
+    async loadProjectData(forceRefresh = false) {
+        // Check cache first
+        if (!forceRefresh &&
+            this.projectDataCache &&
+            Date.now() - this.cacheTimestamp < this.CACHE_TTL_MS) {
+            return this.projectDataCache;
+        }
+        const projectId = this.config.projectId;
+        const projectRef = this.db.collection('projects').doc(projectId);
+        // Load project document
+        const projectDoc = await projectRef.get();
+        if (!projectDoc.exists) {
+            throw new Error(`Project ${projectId} not found`);
+        }
+        const projectData = projectDoc.data();
+        // Load all subcollections in parallel
+        const [pages, schemas, endpoints, techStack, buildPrompts] = await Promise.all([
+            this.loadPages(projectRef),
+            this.loadSchemas(projectRef),
+            this.loadEndpoints(projectRef),
+            this.loadTechStack(projectRef),
+            this.loadBuildPrompts(projectRef),
+        ]);
+        // Construct full project data
+        const fullData = {
+            projectId,
+            projectName: projectData.name || projectData.projectName || 'Untitled Project',
+            description: projectData.description,
+            pages,
+            schemas,
+            endpoints,
+            techStack,
+            designSystem: projectData.designSystem || this.extractDesignSystem(projectData),
+            buildPrompts,
+            version: this.detectVersion(projectData),
+            createdAt: projectData.createdAt?.toDate?.() || new Date(),
+            updatedAt: projectData.updatedAt?.toDate?.() || new Date(),
+        };
+        // Update cache
+        this.projectDataCache = fullData;
+        this.cacheTimestamp = Date.now();
+        return fullData;
+    }
+    async loadPages(projectRef) {
+        const pagesSnapshot = await projectRef.collection('pages').get();
+        return pagesSnapshot.docs.map((doc) => ({
+            id: doc.id,
+            ...doc.data(),
+        }));
+    }
+    async loadSchemas(projectRef) {
+        const schemasSnapshot = await projectRef.collection('databaseSchemas').get();
+        return schemasSnapshot.docs.map((doc) => ({
+            id: doc.id,
+            ...doc.data(),
+        }));
+    }
+    async loadEndpoints(projectRef) {
+        const endpointsSnapshot = await projectRef.collection('apiEndpoints').get();
+        return endpointsSnapshot.docs.map((doc) => ({
+            id: doc.id,
+            ...doc.data(),
+        }));
+    }
+    async loadTechStack(projectRef) {
+        const techSnapshot = await projectRef.collection('techStack').get();
+        return techSnapshot.docs.map((doc) => ({
+            id: doc.id,
+            ...doc.data(),
+        }));
+    }
+    async loadBuildPrompts(projectRef) {
+        // First, check if this is v9-mega format (category-based structure)
+        const projectDoc = await projectRef.get();
+        const projectData = projectDoc.data();
+        if (projectData?.generationVersion === 'v9-mega' || projectData?.version === 'v9-mega') {
+            // V9-mega format: Load from category documents with instructions array
+            return this.loadBuildPromptsV9Mega(projectRef);
+        }
+        // Legacy format: Individual documents ordered by 'order' field
+        const promptsSnapshot = await projectRef
+            .collection('buildPrompts')
+            .orderBy('order', 'asc')
+            .get();
+        return promptsSnapshot.docs.map((doc) => {
+            const data = doc.data();
+            return {
+                promptId: doc.id,
+                order: data.order || 0,
+                title: data.title || data.stepTitle || 'Untitled Step',
+                category: data.category || 'feature',
+                instruction: data.instruction || data.promptText || '',
+                expectedOutcome: data.expectedOutcome,
+                testCriteria: data.testCriteria || [],
+                estimatedMinutes: data.estimatedMinutes,
+                completed: data.completed || data.status === 'completed',
+                completedAt: data.completedAt?.toDate?.(),
+                completionNotes: data.completionNotes,
+                filesCreated: data.filesCreated || [],
+                dependsOn: data.dependsOn || data.dependencies || [],
+                relatedDocuments: {
+                    pages: data.relatedPages || data.relatedDocuments?.pages || [],
+                    schemas: data.relatedSchemas || data.relatedDocuments?.schemas || [],
+                    endpoints: data.relatedEndpoints || data.relatedDocuments?.endpoints || [],
+                    techStack: data.relatedTechStack || data.relatedDocuments?.techStack || [],
+                },
+                isInjected: data.isInjected || false,
+                injectedBy: data.injectedBy,
+                injectedReason: data.injectedReason,
+            };
+        });
+    }
+    /**
+     * Load build prompts from v9-mega format (category documents with instructions array)
+     */
+    async loadBuildPromptsV9Mega(projectRef) {
+        const categoriesSnapshot = await projectRef
+            .collection('buildPrompts')
+            .orderBy('order', 'asc')
+            .get();
+        const allPrompts = [];
+        for (const categoryDoc of categoriesSnapshot.docs) {
+            const categoryData = categoryDoc.data();
+            const categoryId = categoryDoc.id;
+            const categoryTitle = categoryData.categoryTitle || categoryData.title || categoryId;
+            const instructions = categoryData.instructions || [];
+            for (const instruction of instructions) {
+                allPrompts.push({
+                    promptId: instruction.id || `${categoryId}-${instruction.promptNumber}`,
+                    order: instruction.promptNumber || 0,
+                    title: instruction.title || 'Untitled Step',
+                    category: categoryId,
+                    instruction: instruction.instruction || '',
+                    expectedOutcome: instruction.expectedOutcome,
+                    // V2 structured test criteria
+                    testCriteria: instruction.testCriteria || [],
+                    estimatedMinutes: instruction.estimatedMinutes,
+                    completed: instruction.completed || false,
+                    completedAt: instruction.completedAt?.toDate?.(),
+                    completionNotes: instruction.completionNotes,
+                    filesCreated: instruction.filesCreated || [],
+                    dependsOn: instruction.dependsOn || [],
+                    relatedDocuments: instruction.relatedDocuments || {
+                        pages: [],
+                        schemas: [],
+                        endpoints: [],
+                        techStack: [],
+                    },
+                    // V2 specific fields
+                    verificationPrompt: instruction.verificationPrompt,
+                    categoryTitle: categoryTitle,
+                    priority: instruction.priority,
+                    flaggedForReview: instruction.flaggedForReview || false,
+                    flaggedAt: instruction.flaggedAt?.toDate?.(),
+                    flaggedReason: instruction.flaggedReason,
+                    isInjected: instruction.isInjected || false,
+                    injectedBy: instruction.injectedBy,
+                    injectedReason: instruction.injectedReason,
+                });
+            }
+        }
+        // Sort by promptNumber/order across all categories
+        allPrompts.sort((a, b) => a.order - b.order);
+        return allPrompts;
+    }
+    detectVersion(projectData) {
+        if (projectData.version === 'v9-mega' || projectData.generationVersion === 'v9-mega') {
+            return 'v9-mega';
+        }
+        if (projectData.version === 'v2' || projectData.hasFeaturePlans) {
+            return 'v2';
+        }
+        return 'v1';
+    }
+    extractDesignSystem(projectData) {
+        // Try to extract design system from various possible locations
+        if (projectData.designSystem)
+            return projectData.designSystem;
+        if (projectData.design?.designSystem)
+            return projectData.design.designSystem;
+        // Build from individual fields if available
+        if (projectData.colorPalette || projectData.typography) {
+            return {
+                colorPalette: projectData.colorPalette,
+                typography: projectData.typography,
+                spacing: projectData.spacing,
+                borderRadius: projectData.borderRadius,
+                shadows: projectData.shadows,
+                breakpoints: projectData.breakpoints,
+                componentPatterns: projectData.componentPatterns,
+            };
+        }
+        return undefined;
+    }
+    // ============================================================================
+    // BUILD PROMPT OPERATIONS
+    // ============================================================================
+    /**
+     * Get the next incomplete build prompt with all dependencies met
+     */
+    async getNextBuildPrompt() {
+        const projectData = await this.loadProjectData();
+        const prompts = projectData.buildPrompts;
+        // Find first incomplete prompt with all dependencies met
+        for (const prompt of prompts) {
+            if (prompt.completed)
+                continue;
+            const allDepsMet = (prompt.dependsOn || []).every((depId) => {
+                const dep = prompts.find((p) => p.promptId === depId || p.title === depId);
+                return dep?.completed === true;
+            });
+            if (allDepsMet) {
+                return prompt;
+            }
+        }
+        return null;
+    }
+    /**
+     * Mark a build prompt as complete
+     */
+    async markPromptComplete(promptId, completionData) {
+        const projectRef = this.db.collection('projects').doc(this.config.projectId);
+        const promptRef = projectRef.collection('buildPrompts').doc(promptId);
+        try {
+            await promptRef.update({
+                completed: true,
+                status: 'completed',
+                completedAt: firestore_1.FieldValue.serverTimestamp(),
+                completionNotes: completionData.completionNotes || '',
+                filesCreated: completionData.filesCreated || [],
+                testResults: completionData.testResults,
+                updatedAt: firestore_1.FieldValue.serverTimestamp(),
+            });
+            // Invalidate cache
+            this.projectDataCache = null;
+            return true;
+        }
+        catch (error) {
+            console.error('Error marking prompt complete:', error);
+            return false;
+        }
+    }
+    /**
+     * Uncheck/revert a build prompt
+     */
+    async uncheckPrompt(promptId) {
+        const projectRef = this.db.collection('projects').doc(this.config.projectId);
+        const promptRef = projectRef.collection('buildPrompts').doc(promptId);
+        try {
+            await promptRef.update({
+                completed: false,
+                status: 'pending',
+                completedAt: null,
+                updatedAt: firestore_1.FieldValue.serverTimestamp(),
+            });
+            this.projectDataCache = null;
+            return true;
+        }
+        catch (error) {
+            console.error('Error unchecking prompt:', error);
+            return false;
+        }
+    }
+    /**
+     * Inject a new dynamic build prompt
+     */
+    async injectBuildPrompt(insertAfterPromptId, newPrompt) {
+        const projectRef = this.db.collection('projects').doc(this.config.projectId);
+        try {
+            // Get current prompts to determine order
+            const projectData = await this.loadProjectData();
+            const insertAfterPrompt = projectData.buildPrompts.find((p) => p.promptId === insertAfterPromptId);
+            if (!insertAfterPrompt) {
+                throw new Error(`Prompt ${insertAfterPromptId} not found`);
+            }
+            // Calculate new order (insert between current and next)
+            const currentOrder = insertAfterPrompt.order;
+            const nextPrompt = projectData.buildPrompts.find((p) => p.order > currentOrder);
+            const newOrder = nextPrompt
+                ? (currentOrder + nextPrompt.order) / 2
+                : currentOrder + 1;
+            // Create new prompt document
+            const newPromptRef = await projectRef.collection('buildPrompts').add({
+                order: newOrder,
+                title: newPrompt.title,
+                category: newPrompt.category,
+                instruction: newPrompt.instruction,
+                expectedOutcome: `Complete the ${newPrompt.title} task as described`,
+                testCriteria: [],
+                estimatedMinutes: newPrompt.estimatedMinutes || 30,
+                completed: false,
+                status: 'pending',
+                dependsOn: newPrompt.dependsOn || [insertAfterPromptId],
+                relatedDocuments: newPrompt.relatedDocuments || {},
+                isInjected: true,
+                injectedBy: 'mcp_intelligence',
+                injectedReason: newPrompt.reason,
+                createdAt: firestore_1.FieldValue.serverTimestamp(),
+                updatedAt: firestore_1.FieldValue.serverTimestamp(),
+            });
+            // Invalidate cache
+            this.projectDataCache = null;
+            // Return the created prompt
+            const createdDoc = await newPromptRef.get();
+            return {
+                promptId: newPromptRef.id,
+                ...createdDoc.data(),
+            };
+        }
+        catch (error) {
+            console.error('Error injecting build prompt:', error);
+            return null;
+        }
+    }
+    // ============================================================================
+    // ENTITY LOOKUPS
+    // ============================================================================
+    /**
+     * Get a specific page by ID or name
+     */
+    async getPage(identifier) {
+        const projectData = await this.loadProjectData();
+        const normalized = this.normalize(identifier);
+        return (projectData.pages.find((p) => p.id === identifier ||
+            this.normalize(p.pageName) === normalized ||
+            this.normalize(p.id) === normalized) || null);
+    }
+    /**
+     * Get a specific schema by ID or collection name
+     */
+    async getSchema(identifier) {
+        const projectData = await this.loadProjectData();
+        const normalized = this.normalize(identifier);
+        return (projectData.schemas.find((s) => s.id === identifier ||
+            this.normalize(s.collectionName) === normalized ||
+            this.normalize(s.id) === normalized) || null);
+    }
+    /**
+     * Get a specific endpoint by ID or name
+     */
+    async getEndpoint(identifier) {
+        const projectData = await this.loadProjectData();
+        const normalized = this.normalize(identifier);
+        return (projectData.endpoints.find((e) => e.id === identifier ||
+            this.normalize(e.name) === normalized ||
+            this.normalize(e.id) === normalized ||
+            e.path === identifier) || null);
+    }
+    /**
+     * Get a specific tech stack item by ID or name
+     */
+    async getTechStackItem(identifier) {
+        const projectData = await this.loadProjectData();
+        const normalized = this.normalize(identifier);
+        return (projectData.techStack.find((t) => t.id === identifier ||
+            this.normalize(t.name) === normalized ||
+            this.normalize(t.id) === normalized) || null);
+    }
+    /**
+     * Get multiple entities by their references
+     */
+    async resolveEntityReferences(refs) {
+        const projectData = await this.loadProjectData();
+        const resolvePages = (refs?.pages || [])
+            .map((ref) => {
+            const normalized = this.normalize(ref);
+            return projectData.pages.find((p) => p.id === ref ||
+                this.normalize(p.pageName) === normalized ||
+                this.normalize(p.id) === normalized);
+        })
+            .filter(Boolean);
+        const resolveSchemas = (refs?.schemas || [])
+            .map((ref) => {
+            const normalized = this.normalize(ref);
+            return projectData.schemas.find((s) => s.id === ref ||
+                this.normalize(s.collectionName) === normalized ||
+                this.normalize(s.id) === normalized);
+        })
+            .filter(Boolean);
+        const resolveEndpoints = (refs?.endpoints || [])
+            .map((ref) => {
+            const normalized = this.normalize(ref);
+            return projectData.endpoints.find((e) => e.id === ref ||
+                this.normalize(e.name) === normalized ||
+                this.normalize(e.id) === normalized);
+        })
+            .filter(Boolean);
+        // Handle "tech-stack" meaning all tech stack items
+        let resolveTechStack = [];
+        const techRefs = refs?.techStack || [];
+        if (techRefs.some((ref) => this.normalize(ref) === 'tech-stack' || this.normalize(ref) === 'techstack')) {
+            resolveTechStack = [...projectData.techStack];
+        }
+        else {
+            resolveTechStack = techRefs
+                .map((ref) => {
+                const normalized = this.normalize(ref);
+                return projectData.techStack.find((t) => t.id === ref ||
+                    this.normalize(t.name) === normalized ||
+                    this.normalize(t.id) === normalized);
+            })
+                .filter(Boolean);
+        }
+        return {
+            pages: resolvePages,
+            schemas: resolveSchemas,
+            endpoints: resolveEndpoints,
+            techStack: resolveTechStack,
+        };
+    }
+    // ============================================================================
+    // SESSION MANAGEMENT
+    // ============================================================================
+    /**
+     * Create or update MCP session
+     */
+    async updateSession(sessionId, data) {
+        const sessionRef = this.db
+            .collection('projects')
+            .doc(this.config.projectId)
+            .collection('mcpSessions')
+            .doc(sessionId);
+        await sessionRef.set({
+            ...data,
+            lastActivityAt: firestore_1.FieldValue.serverTimestamp(),
+        }, { merge: true });
+    }
+    /**
+     * Log a tool call for analytics
+     */
+    async logToolCall(sessionId, toolName, request, response, durationMs, intelligenceUsed) {
+        const sessionRef = this.db
+            .collection('projects')
+            .doc(this.config.projectId)
+            .collection('mcpSessions')
+            .doc(sessionId);
+        await sessionRef.update({
+            toolCalls: firestore_1.FieldValue.arrayUnion({
+                toolName,
+                timestamp: new Date().toISOString(),
+                request,
+                response: this.truncateForStorage(response),
+                durationMs,
+                intelligenceUsed,
+            }),
+            lastActivityAt: firestore_1.FieldValue.serverTimestamp(),
+        });
+    }
+    /**
+     * Log an error for debugging
+     */
+    async logError(sessionId, promptId, error, diagnosis) {
+        const errorLogRef = this.db
+            .collection('projects')
+            .doc(this.config.projectId)
+            .collection('mcpErrorLogs')
+            .doc();
+        await errorLogRef.set({
+            sessionId,
+            promptId,
+            error,
+            diagnosis,
+            timestamp: firestore_1.FieldValue.serverTimestamp(),
+        });
+    }
+    // ============================================================================
+    // UTILITY METHODS
+    // ============================================================================
+    normalize(str) {
+        return str
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, '')
+            .trim();
+    }
+    truncateForStorage(obj, maxLength = 10000) {
+        const str = JSON.stringify(obj);
+        if (str.length <= maxLength)
+            return obj;
+        return {
+            truncated: true,
+            preview: str.substring(0, maxLength),
+            originalLength: str.length,
+        };
+    }
+    /**
+     * Get build progress statistics
+     */
+    async getBuildProgress() {
+        const projectData = await this.loadProjectData();
+        const prompts = projectData.buildPrompts;
+        const totalSteps = prompts.length;
+        const completedSteps = prompts.filter((p) => p.completed).length;
+        const currentStep = completedSteps + 1;
+        const percentComplete = totalSteps > 0 ? Math.round((completedSteps / totalSteps) * 100) : 0;
+        // Estimate remaining time based on incomplete prompts
+        const incompletePrompts = prompts.filter((p) => !p.completed);
+        const estimatedTimeRemaining = incompletePrompts.reduce((total, p) => total + (p.estimatedMinutes || 30), 0);
+        return {
+            totalSteps,
+            completedSteps,
+            currentStep,
+            percentComplete,
+            estimatedTimeRemaining,
+        };
+    }
+    /**
+     * Get the design system
+     */
+    async getDesignSystem() {
+        const projectData = await this.loadProjectData();
+        return projectData.designSystem;
+    }
+    /**
+     * Clear cache (force refresh on next load)
+     */
+    clearCache() {
+        this.projectDataCache = null;
+        this.cacheTimestamp = 0;
+    }
+    // ============================================================================
+    // V2 METHODS - Autonomous Validation Workflow
+    // ============================================================================
+    /**
+     * Get next incomplete build instruction with V2 format (structured testCriteria)
+     * For v9-mega projects only
+     */
+    async getNextBuildInstructionV2() {
+        const projectData = await this.loadProjectData();
+        if (projectData.version !== 'v9-mega') {
+            console.warn('getNextBuildInstructionV2 called on non-v9-mega project');
+            return null;
+        }
+        const prompts = projectData.buildPrompts;
+        // Find first incomplete, unflagged prompt with all dependencies met
+        for (const prompt of prompts) {
+            if (prompt.completed)
+                continue;
+            if (prompt.flaggedForReview)
+                continue;
+            const allDepsMet = (prompt.dependsOn || []).every((depId) => {
+                const dep = prompts.find((p) => p.promptId === depId || p.title === depId);
+                return dep?.completed === true;
+            });
+            if (allDepsMet) {
+                // Convert to V2 format
+                return this.promptToInstructionV2(prompt);
+            }
+        }
+        return null;
+    }
+    /**
+     * Convert BuildPrompt to BuildInstructionV2 format
+     */
+    promptToInstructionV2(prompt) {
+        return {
+            id: prompt.promptId,
+            promptNumber: prompt.order,
+            title: prompt.title,
+            category: prompt.category,
+            categoryTitle: prompt.categoryTitle || prompt.category,
+            instruction: prompt.instruction,
+            verificationPrompt: prompt.verificationPrompt || '',
+            testCriteria: this.normalizeTestCriteria(prompt.testCriteria),
+            relatedDocuments: {
+                pages: prompt.relatedDocuments?.pages || [],
+                schemas: prompt.relatedDocuments?.schemas || [],
+                endpoints: prompt.relatedDocuments?.endpoints || [],
+                techStack: prompt.relatedDocuments?.techStack || [],
+            },
+            estimatedMinutes: prompt.estimatedMinutes || 30,
+            priority: prompt.priority || 'medium',
+            completed: prompt.completed,
+            completedAt: prompt.completedAt,
+            flaggedForReview: prompt.flaggedForReview,
+            flaggedAt: prompt.flaggedAt,
+            flaggedReason: prompt.flaggedReason,
+        };
+    }
+    /**
+     * Normalize test criteria to V2 format
+     * Handles both string[] (old format) and TestCriterionV2[] (new format)
+     */
+    normalizeTestCriteria(criteria) {
+        if (!criteria || criteria.length === 0) {
+            return [];
+        }
+        // Check if already in V2 format
+        if (typeof criteria[0] === 'object' && 'criterion' in criteria[0]) {
+            return criteria;
+        }
+        // Convert string[] to TestCriterionV2[]
+        return criteria.map((c, idx) => ({
+            criterion: c,
+            type: 'functional',
+            verification: `Verify: ${c}`,
+            expectedResult: 'Criterion is met',
+        }));
+    }
+    /**
+     * Mark an instruction as complete in v9-mega format
+     * Updates the instruction within its category document
+     */
+    async markInstructionCompleteV2(promptId, completionData) {
+        const projectRef = this.db.collection('projects').doc(this.config.projectId);
+        try {
+            // Find which category contains this instruction
+            const categoriesSnapshot = await projectRef.collection('buildPrompts').get();
+            for (const categoryDoc of categoriesSnapshot.docs) {
+                const categoryData = categoryDoc.data();
+                const instructions = categoryData.instructions || [];
+                const instructionIndex = instructions.findIndex((inst) => inst.id === promptId);
+                if (instructionIndex !== -1) {
+                    // Update the instruction within the array
+                    instructions[instructionIndex] = {
+                        ...instructions[instructionIndex],
+                        completed: true,
+                        completedAt: new Date(),
+                        completionNotes: completionData.completionNotes || '',
+                        filesCreated: completionData.filesCreated || [],
+                        validationSummary: completionData.validationSummary,
+                    };
+                    await categoryDoc.ref.update({
+                        instructions,
+                        updatedAt: firestore_1.FieldValue.serverTimestamp(),
+                    });
+                    // Invalidate cache
+                    this.projectDataCache = null;
+                    return true;
+                }
+            }
+            console.error(`Instruction ${promptId} not found in any category`);
+            return false;
+        }
+        catch (error) {
+            console.error('Error marking instruction complete:', error);
+            return false;
+        }
+    }
+    /**
+     * Flag an instruction for human review (after max retry attempts)
+     */
+    async flagInstructionForReview(promptId, reason, validationHistory) {
+        const projectRef = this.db.collection('projects').doc(this.config.projectId);
+        try {
+            const categoriesSnapshot = await projectRef.collection('buildPrompts').get();
+            for (const categoryDoc of categoriesSnapshot.docs) {
+                const categoryData = categoryDoc.data();
+                const instructions = categoryData.instructions || [];
+                const instructionIndex = instructions.findIndex((inst) => inst.id === promptId);
+                if (instructionIndex !== -1) {
+                    instructions[instructionIndex] = {
+                        ...instructions[instructionIndex],
+                        flaggedForReview: true,
+                        flaggedAt: new Date(),
+                        flaggedReason: reason,
+                        validationHistory,
+                    };
+                    await categoryDoc.ref.update({
+                        instructions,
+                        updatedAt: firestore_1.FieldValue.serverTimestamp(),
+                    });
+                    this.projectDataCache = null;
+                    return true;
+                }
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('Error flagging instruction:', error);
+            return false;
+        }
+    }
+    /**
+     * Get V2 build progress with flagged counts
+     */
+    async getBuildProgressV2() {
+        const projectData = await this.loadProjectData();
+        const prompts = projectData.buildPrompts;
+        const total = prompts.length;
+        const completed = prompts.filter((p) => p.completed).length;
+        const flagged = prompts.filter((p) => p.flaggedForReview).length;
+        const remaining = total - completed - flagged;
+        const completionPercentage = total > 0 ? Math.round((completed / total) * 100) : 0;
+        // Get next step
+        let nextStep;
+        for (const prompt of prompts) {
+            if (prompt.completed || prompt.flaggedForReview)
+                continue;
+            const allDepsMet = (prompt.dependsOn || []).every((depId) => {
+                const dep = prompts.find((p) => p.promptId === depId || p.title === depId);
+                return dep?.completed === true;
+            });
+            if (allDepsMet) {
+                nextStep = this.promptToInstructionV2(prompt);
+                break;
+            }
+        }
+        let message;
+        if (completed === total) {
+            message = '🎉 All build steps completed! Project is ready for deployment.';
+        }
+        else if (flagged > 0) {
+            message = `⚠️ ${flagged} step(s) flagged for human review. ${remaining} steps remaining.`;
+        }
+        else {
+            message = `📊 ${completed}/${total} steps completed (${completionPercentage}%). ${remaining} remaining.`;
+        }
+        return {
+            total,
+            completed,
+            flagged,
+            remaining,
+            completionPercentage,
+            nextStep,
+            message,
+        };
+    }
+    /**
+     * Log a V2 validation event for analytics
+     */
+    async logValidationEvent(sessionId, promptId, event) {
+        const eventRef = this.db
+            .collection('projects')
+            .doc(this.config.projectId)
+            .collection('mcpValidationLogs')
+            .doc();
+        await eventRef.set({
+            sessionId,
+            promptId,
+            ...event,
+            timestamp: firestore_1.FieldValue.serverTimestamp(),
+        });
+    }
+    /**
+     * Get user's BYOK configuration if available
+     */
+    async getUserBYOKConfig(userId) {
+        try {
+            const userDoc = await this.db.collection('users').doc(userId).get();
+            if (!userDoc.exists)
+                return null;
+            const userData = userDoc.data();
+            const byokConfig = userData?.byokConfig;
+            if (!byokConfig?.apiKey) {
+                return { hasCustomKey: false };
+            }
+            return {
+                hasCustomKey: true,
+                encryptedApiKey: byokConfig.apiKey,
+                preferredModel: byokConfig.preferredModel,
+            };
+        }
+        catch (error) {
+            console.error('Error fetching BYOK config:', error);
+            return null;
+        }
+    }
+}
+exports.VisualPRDClient = VisualPRDClient;
+//# sourceMappingURL=visualprd-client.js.map