tryassay 0.21.2 → 0.22.1

package/dist/runtime/app-create-orchestrator.js

@@ -7,7 +7,7 @@ import { EventEmitter } from 'node:events';
 import { mkdir, writeFile, readFile, readdir, stat } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { execSync } from 'node:child_process';
+import { safeExecSync } from './safe-executor.js';
 import { PlannerAgent } from './agents/planner-agent.js';
 import { CodeAgent } from './agents/code-agent.js';
 import { MessageBus } from './message-bus.js';
@@ -20,6 +20,8 @@ import { CheckStore } from './check-store.js';
 import { FailureClassifier } from './failure-classifier.js';
 import { PlanRefiner } from './plan-refiner.js';
 import { FunctionalTester } from './functional-tester.js';
+import { SupabaseProvisioner } from './supabase-provisioner.js';
+import { ModelRouter } from './model-router.js';
 // ── Default safety policy ───────────────────────────────────
 const DEFAULT_SAFETY = {
     formalOverridesConsensus: true,
@@ -41,10 +43,14 @@ export class AppCreateOrchestrator extends EventEmitter {
     planSummaryCache = null;
     approvalResolve = null;
     answersResolve = null;
+    chatResolve = null;
+    conversationHistory = [];
+    modelRouter;
     constructor(description, options) {
         super();
         this.description = description;
         this.options = options;
+        this.modelRouter = new ModelRouter(options.models);
     }
     /** Get the current plan summary (available after planning phase). */
     getPlanSummary() {
@@ -64,6 +70,13 @@ export class AppCreateOrchestrator extends EventEmitter {
             this.answersResolve = null;
         }
     }
+    /** Submit a chat message. Resolves the waiting conversation loop. */
+    submitChatMessage(message, cardAnswers) {
+        if (this.chatResolve) {
+            this.chatResolve({ message, cardAnswers });
+            this.chatResolve = null;
+        }
+    }
     /** Run the full app creation pipeline. */
     async run() {
         this.startTime = Date.now();
@@ -73,72 +86,166 @@ export class AppCreateOrchestrator extends EventEmitter {
         await mkdir(projectPath, { recursive: true });
         await mkdir(join(projectPath, '.assay'), { recursive: true });
         this.audit('task_status_change', { phase: 'initializing', projectPath });
-        // Phase: plan questioning (refine requirements BEFORE planning)
+        // Phase: chat-based requirements gathering (replaces quiz-style rounds)
         let refinedRequirements = '';
         if (!this.options.skipPlanQuestions && !this.options.autoApprove) {
             const messageBus = new MessageBus();
-            const planner = new PlannerAgent(messageBus, { model: this.options.models?.planner });
-            const maxRounds = 3;
-            let currentConfidence = 0;
-            const allAnswers = [];
-            for (let round = 1; round <= maxRounds; round++) {
-                // Generate questions from the user prompt (no plan yet)
-                let questions = [];
+            const planner = new PlannerAgent(messageBus, { model: this.modelRouter.selectModel('planning', 'planner') });
+            const maxTurns = 20; // Safety valve
+            this.conversationHistory = [];
+            // Initial turn — architect responds to the raw prompt
+            let response;
+            try {
+                response = await planner.converse(this.description.description, []);
+            }
+            catch (err) {
+                this.audit('task_status_change', {
+                    phase: 'chat',
+                    error: err instanceof Error ? err.message : String(err),
+                    reason: 'initial_converse_failed',
+                });
+                // Fall through to planning with no refinement
+                response = { message: '', readiness: { confidence: 1, ready: true, gaps: [], summary: '' } };
+            }
+            // Add architect's first message to history
+            const firstArchitectMsg = {
+                role: 'architect',
+                content: response.message,
+                cards: response.cards,
+            };
+            this.conversationHistory.push(firstArchitectMsg);
+            // Emit first chat message
+            this.emitPhase({
+                phase: 'chat_message',
+                message: response.message,
+                cards: response.cards,
+                readiness: response.readiness,
+            });
+            this.audit('task_status_change', {
+                phase: 'chat',
+                turn: 1,
+                ready: response.readiness.ready,
+                confidence: response.readiness.confidence,
+                gaps: response.readiness.gaps,
+            });
+            // Conversation loop
+            let turn = 1;
+            while (!response.readiness.ready && turn < maxTurns) {
+                // Wait for user message
+                const userInput = await new Promise((resolve) => {
+                    this.chatResolve = resolve;
+                });
+                // Check for build signal
+                if (userInput.message === '__START_BUILD__') {
+                    break;
+                }
+                turn++;
+                // Add user message to history
+                const userMsg = {
+                    role: 'user',
+                    content: userInput.message,
+                    cardAnswers: userInput.cardAnswers,
+                };
+                this.conversationHistory.push(userMsg);
+                // Get architect's response
                 try {
-                    questions = await planner.generateQuestions(this.description.description);
+                    response = await planner.converse(this.description.description, this.conversationHistory);
                 }
                 catch (err) {
                     this.audit('task_status_change', {
-                        phase: 'plan_questioning',
-                        round,
+                        phase: 'chat',
+                        turn,
                         error: err instanceof Error ? err.message : String(err),
-                        reason: 'question_generation_failed',
+                        reason: 'converse_failed',
                     });
-                    break; // Skip questioning, proceed to planning
-                }
-                if (questions.length === 0) {
-                    this.audit('task_status_change', {
-                        phase: 'plan_questioning',
-                        round,
-                        questionsGenerated: 0,
-                        reason: 'no_questions',
+                    // Show error in chat
+                    this.emitPhase({
+                        phase: 'chat_message',
+                        message: 'Something went wrong. Try sending your message again.',
+                        readiness: { confidence: 0, ready: false, gaps: ['Internal error'], summary: '' },
                     });
-                    break;
+                    continue;
                 }
-                // Emit questions to frontend
+                // Add architect's response to history
+                const architectMsg = {
+                    role: 'architect',
+                    content: response.message,
+                    cards: response.cards,
+                };
+                this.conversationHistory.push(architectMsg);
+                // Emit chat message to frontend
                 this.emitPhase({
-                    phase: 'plan_questioning',
-                    questions,
-                    round,
-                    confidence: currentConfidence,
+                    phase: 'chat_message',
+                    message: response.message,
+                    cards: response.cards,
+                    readiness: response.readiness,
                 });
                 this.audit('task_status_change', {
-                    phase: 'plan_questioning',
-                    round,
-                    questionsGenerated: questions.length,
-                });
-                // Wait for answers from frontend
-                const answers = await new Promise((resolve) => {
-                    this.answersResolve = resolve;
+                    phase: 'chat',
+                    turn,
+                    ready: response.readiness.ready,
+                    confidence: response.readiness.confidence,
+                    gaps: response.readiness.gaps,
+                    summary: response.readiness.summary,
                 });
-                allAnswers.push(...answers);
-                // Update confidence based on answers received
-                this.emitPhase({ phase: 'plan_refining', round });
-                currentConfidence = Math.min(0.5 + (allAnswers.length * 0.15), 1.0);
-                this.audit('task_status_change', {
-                    phase: 'plan_refining',
-                    round,
-                    confidence: currentConfidence,
-                    answersReceived: answers.length,
-                });
-                if (currentConfidence >= 0.95) {
-                    break;
+            }
+            // If ready, wait for "Start Building" click (user may keep chatting)
+            if (response.readiness.ready) {
+                let readyTurns = 0;
+                while (readyTurns < 10) {
+                    const userInput = await new Promise((resolve) => {
+                        this.chatResolve = resolve;
+                    });
+                    if (userInput.message === '__START_BUILD__') {
+                        break;
+                    }
+                    readyTurns++;
+                    // User is still chatting — continue conversation
+                    const userMsg = {
+                        role: 'user',
+                        content: userInput.message,
+                        cardAnswers: userInput.cardAnswers,
+                    };
+                    this.conversationHistory.push(userMsg);
+                    try {
+                        response = await planner.converse(this.description.description, this.conversationHistory);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const architectMsg = {
+                        role: 'architect',
+                        content: response.message,
+                        cards: response.cards,
+                    };
+                    this.conversationHistory.push(architectMsg);
+                    this.emitPhase({
+                        phase: 'chat_message',
+                        message: response.message,
+                        cards: response.cards,
+                        readiness: response.readiness,
+                    });
+                    // Nudge after many ready turns
+                    if (readyTurns >= 5 && response.readiness.ready) {
+                        this.emitPhase({
+                            phase: 'chat_message',
+                            message: "I've had enough context for a while now — click Start Building whenever you're ready, or keep refining.",
+                            readiness: response.readiness,
+                        });
+                    }
                 }
             }
-            // Build refined requirements string from all answers
-            if (allAnswers.length > 0) {
-                refinedRequirements = '\n\nREFINED REQUIREMENTS (from user selections):\n' +
-                    allAnswers.map(a => `- ${a.questionId}: ${a.selectedOptions.join(', ')}${a.customText ? ` (${a.customText})` : ''}`).join('\n');
+            // Build refined requirements from conversation history
+            const userMessages = this.conversationHistory.filter(m => m.role === 'user');
+            if (userMessages.length > 0) {
+                refinedRequirements = '\n\nREFINED REQUIREMENTS (from conversation):\n' +
+                    userMessages.map(m => {
+                        let line = `- User: ${m.content}`;
+                        if (m.cardAnswers && m.cardAnswers.length > 0) {
+                            line += ` [Selections: ${m.cardAnswers.map(a => `${a.questionId}=${a.selectedOptions.join(', ')}`).join('; ')}]`;
+                        }
+                        return line;
+                    }).join('\n');
             }
         }
         // Phase: planning (now with refined requirements)
@@ -319,9 +426,50 @@ export class AppCreateOrchestrator extends EventEmitter {
                 }
             }
         }
-        // Post-build: reconcile dependencies and generate env file
+        // Post-build: reconcile dependencies, provision Supabase if needed, generate env file
         await this.reconcileDependencies(projectPath);
-        await this.generateEnvFile(projectPath, plan);
+        let supabaseResult;
+        if (this.description.techStack.database === 'supabase') {
+            const orgId = this.options.supabaseOrgId || process.env.SUPABASE_ORG_ID || 'rxngiskxlcbwzpyuaihh';
+            const region = this.options.supabaseRegion || process.env.SUPABASE_REGION || 'us-east-1';
+            this.emitPhase({ phase: 'provisioning_supabase' });
+            const provisioner = new SupabaseProvisioner({
+                orgId,
+                region,
+                projectName: `assay-${this.slugify(this.description.name)}`,
+            });
+            supabaseResult = await provisioner.provision();
+            this.audit('task_status_change', {
+                phase: 'provisioning_supabase',
+                status: supabaseResult.status,
+                projectRef: supabaseResult.projectRef,
+                durationMs: supabaseResult.durationMs,
+                error: supabaseResult.error,
+            });
+            if (supabaseResult.status === 'success') {
+                // Push migrations if the scaffolding generated any
+                const migrationsDir = join(projectPath, 'supabase', 'migrations');
+                if (await this.fileExists(migrationsDir)) {
+                    this.emitPhase({ phase: 'supabase_migrations' });
+                    const migResult = provisioner.pushMigrations(projectPath, supabaseResult.projectRef);
+                    this.audit('task_status_change', {
+                        phase: 'supabase_migrations',
+                        status: migResult.success ? 'completed' : 'failed',
+                        error: migResult.error,
+                    });
+                }
+                // Save project ref for cleanup
+                const assayDir = join(projectPath, '.assay');
+                await mkdir(assayDir, { recursive: true });
+                await writeFile(join(assayDir, 'supabase-project.json'), JSON.stringify({
+                    projectRef: supabaseResult.projectRef,
+                    url: supabaseResult.url,
+                    region,
+                    createdAt: new Date().toISOString(),
+                }, null, 2), 'utf-8');
+            }
+        }
+        await this.generateEnvFile(projectPath, plan, supabaseResult);
         // Phase: build verification (install, build, start, health check with repair loop)
         let buildVerification = null;
         if (!this.options.skipBuildVerification) {
@@ -429,7 +577,7 @@ export class AppCreateOrchestrator extends EventEmitter {
     // ── Planning Phase ─────────────────────────────────────────
     async runPlanningPhase(projectPath) {
         const messageBus = new MessageBus();
-        const planner = new PlannerAgent(messageBus, { model: this.options.models?.planner });
+        const planner = new PlannerAgent(messageBus, { model: this.modelRouter.selectModel('planning', 'planner') });
         const maxRetries = this.options.maxRetries ?? 3;
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             const result = await planner.executeTask({
@@ -447,7 +595,10 @@ export class AppCreateOrchestrator extends EventEmitter {
                     ...(this.description.constraints ?? []),
                 ],
                 dependencies: [],
-                contextRefs: [],
+                contextRefs: this.options.documents?.map(doc => ({
+                    summary: `Attached document: ${doc.name}`,
+                    content: doc.content,
+                })) ?? [],
             });
             if (result.status === 'completed' && result.artifacts.length > 0) {
                 try {
@@ -545,7 +696,7 @@ Create the project foundation files. Do NOT implement features — only the base
 Include a .env.local file with placeholder values for all required environment variables so the app can start without crashing.`;
         // Direct mode: single CodeAgent call for scaffolding (bypasses full team)
         const messageBus = new MessageBus();
-        const codeAgent = new CodeAgent(messageBus, { model: this.options.models?.code });
+        const codeAgent = new CodeAgent(messageBus, { model: this.modelRouter.selectModel('scaffolding', 'code') });
         try {
             const result = await codeAgent.executeTask({
                 taskId: `scaffold-${randomUUID().slice(0, 8)}`,
@@ -772,7 +923,7 @@ Include a .env.local file with placeholder values for all required environment v
     async buildFeatureDirect(projectPath, plan, feature, completedFeatures) {
         const goal = this.buildFeatureGoal(plan, feature, completedFeatures);
         const messageBus = new MessageBus();
-        const codeAgent = new CodeAgent(messageBus, { model: this.options.models?.code });
+        const codeAgent = new CodeAgent(messageBus, { model: this.modelRouter.selectModel('code_generation', 'code') });
         try {
             const result = await codeAgent.executeTask({
                 taskId: `direct-${feature.id}-${randomUUID().slice(0, 8)}`,
@@ -1019,26 +1170,50 @@ ${importNote}`;
     // ── Post-Build: Environment File Generation ─────────────
     /**
      * Generate .env.local from the architecture plan's deployConfig.envVars.
-     * Only creates the file if it doesn't already exist.
+     * When real Supabase credentials are available, overwrites any existing
+     * placeholder file and emits code_generated so WebContainer receives it.
      */
-    async generateEnvFile(projectPath, plan) {
+    async generateEnvFile(projectPath, plan, supabaseResult) {
         const envPath = join(projectPath, '.env.local');
-        // Don't overwrite if scaffolding already created one
-        if (await this.fileExists(envPath))
+        const hasRealCreds = supabaseResult?.status === 'success';
+        // Don't overwrite if scaffolding already created one — unless we have real credentials
+        if (!hasRealCreds && await this.fileExists(envPath))
             return;
         const envVars = plan.deployConfig?.envVars;
         if (!envVars || envVars.length === 0)
             return;
         const lines = [
             '# Generated by Assay Verified App Creator',
-            '# Replace placeholder values with real credentials before running.',
+            hasRealCreds
+                ? '# Real Supabase credentials — auto-provisioned by Assay'
+                : '# Replace placeholder values with real credentials before running.',
             '',
         ];
         for (const varName of envVars) {
-            lines.push(`${varName}=${this.getEnvPlaceholder(varName)}`);
-        }
-        await writeFile(envPath, lines.join('\n') + '\n', 'utf-8');
-        this.audit('env_file_generated', { path: '.env.local', vars: envVars.length });
+            const realValue = hasRealCreds ? this.getSupabaseEnvValue(varName, supabaseResult) : undefined;
+            lines.push(`${varName}=${realValue ?? this.getEnvPlaceholder(varName)}`);
+        }
+        const content = lines.join('\n') + '\n';
+        await writeFile(envPath, content, 'utf-8');
+        this.audit('env_file_generated', { path: '.env.local', vars: envVars.length, hasRealCreds });
+        // Emit code_generated so .env.local reaches WebContainer via SSE
+        this.audit('code_generated', {
+            path: '.env.local',
+            language: 'env',
+            content,
+        });
+    }
+    /** Map env var names to real Supabase provisioned values. */
+    getSupabaseEnvValue(varName, result) {
+        const name = varName.toUpperCase();
+        if (name.includes('SUPABASE_URL') || name === 'NEXT_PUBLIC_SUPABASE_URL')
+            return result.url;
+        if (name.includes('SUPABASE') && name.includes('ANON') && name.includes('KEY'))
+            return result.anonKey;
+        if (name.includes('SUPABASE') && name.includes('SERVICE') && name.includes('KEY'))
+            return result.serviceRoleKey;
+        // Don't return values for non-Supabase env vars
+        return undefined;
     }
     /** Return a sensible placeholder value for known env var patterns. */
     getEnvPlaceholder(varName) {
@@ -1132,7 +1307,8 @@ ${importNote}`;
         return name
             .toLowerCase()
             .replace(/[^a-z0-9]+/g, '-')
-            .replace(/^-+|-+$/g, '');
+            .replace(/^-+|-+$/g, '')
+            .slice(0, 40);
     }
     /** Get framework-specific directory convention instruction for agent prompts. */
     getDirectoryConvention() {
@@ -1539,31 +1715,33 @@ The renderer process communicates with main via contextBridge APIs exposed in sr
             return []; // No tsconfig — skip
         }
         try {
-            execSync('npx tsc --noEmit --pretty false', {
+            const tscResult = safeExecSync('npx', ['tsc', '--noEmit', '--pretty', 'false'], {
                 cwd: projectPath,
                 timeout: 60_000,
-                stdio: ['pipe', 'pipe', 'pipe'],
             });
-            return [{
-                    type: 'typescript_compiles',
-                    description: 'TypeScript compiles without errors',
-                    verdict: 'PASS',
-                    evidence: 'npx tsc --noEmit exited with code 0',
-                }];
+            if (tscResult.exitCode === 0) {
+                return [{
+                        type: 'typescript_compiles',
+                        description: 'TypeScript compiles without errors',
+                        verdict: 'PASS',
+                        evidence: 'npx tsc --noEmit exited with code 0',
+                    }];
+            }
+            {
+                const output = tscResult.stderr || tscResult.stdout;
+                const errorLines = output.split('\n').filter(l => l.includes('error TS'));
+                return [{
+                        type: 'typescript_compiles',
+                        description: 'TypeScript compiles without errors',
+                        verdict: 'FAIL',
+                        evidence: errorLines.length > 0
+                            ? `tsc --noEmit failed with ${errorLines.length} error(s): ${errorLines.slice(0, 5).join('; ')}${errorLines.length > 5 ? ` ... and ${errorLines.length - 5} more` : ''}`
+                            : `tsc --noEmit failed: ${output.slice(0, 500)}`,
+                    }];
+            }
         }
-        catch (err) {
-            const stderr = err?.stderr?.toString() ?? '';
-            const stdout = err?.stdout?.toString() ?? '';
-            const output = stderr || stdout;
-            const errorLines = output.split('\n').filter(l => l.includes('error TS'));
-            return [{
-                    type: 'typescript_compiles',
-                    description: 'TypeScript compiles without errors',
-                    verdict: 'FAIL',
-                    evidence: errorLines.length > 0
-                        ? `tsc --noEmit failed with ${errorLines.length} error(s): ${errorLines.slice(0, 5).join('; ')}${errorLines.length > 5 ? ` ... and ${errorLines.length - 5} more` : ''}`
-                        : `tsc --noEmit failed: ${output.slice(0, 500)}`,
-                }];
+        catch {
+            return []; // Unexpected error — skip
         }
     }
     /**