tryassay 0.20.3 → 0.21.1

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

@@ -7,6 +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 { PlannerAgent } from './agents/planner-agent.js';
 import { CodeAgent } from './agents/code-agent.js';
 import { MessageBus } from './message-bus.js';
@@ -17,6 +18,8 @@ import { IntegrationVerifier } from './integration-verifier.js';
 import { CheckLoop } from './check-loop.js';
 import { CheckStore } from './check-store.js';
 import { FailureClassifier } from './failure-classifier.js';
+import { PlanRefiner } from './plan-refiner.js';
+import { FunctionalTester } from './functional-tester.js';
 // ── Default safety policy ───────────────────────────────────
 const DEFAULT_SAFETY = {
     formalOverridesConsensus: true,
@@ -35,11 +38,32 @@ export class AppCreateOrchestrator extends EventEmitter {
     options;
     auditTrail = [];
     startTime = 0;
+    planSummaryCache = null;
+    approvalResolve = null;
+    answersResolve = null;
     constructor(description, options) {
         super();
         this.description = description;
         this.options = options;
     }
+    /** Get the current plan summary (available after planning phase). */
+    getPlanSummary() {
+        return this.planSummaryCache;
+    }
+    /** Approve or reject the plan. Resolves the blocked pipeline. */
+    approvePlan(result) {
+        if (this.approvalResolve) {
+            this.approvalResolve(result);
+            this.approvalResolve = null;
+        }
+    }
+    /** Submit answers to plan questions. Resolves the waiting questioning loop. */
+    submitAnswers(answers) {
+        if (this.answersResolve) {
+            this.answersResolve(answers);
+            this.answersResolve = null;
+        }
+    }
     /** Run the full app creation pipeline. */
     async run() {
         this.startTime = Date.now();
@@ -49,19 +73,94 @@ 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: planning
+        // Phase: plan questioning (refine requirements BEFORE planning)
+        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 = [];
+                try {
+                    questions = await planner.generateQuestions(this.description.description);
+                }
+                catch (err) {
+                    this.audit('task_status_change', {
+                        phase: 'plan_questioning',
+                        round,
+                        error: err instanceof Error ? err.message : String(err),
+                        reason: 'question_generation_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',
+                    });
+                    break;
+                }
+                // Emit questions to frontend
+                this.emitPhase({
+                    phase: 'plan_questioning',
+                    questions,
+                    round,
+                    confidence: currentConfidence,
+                });
+                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;
+                });
+                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;
+                }
+            }
+            // 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');
+            }
+        }
+        // Phase: planning (now with refined requirements)
         this.emitPhase({ phase: 'planning' });
-        const plan = await this.runPlanningPhase(projectPath);
+        // Enrich the description with user's answers before planning
+        if (refinedRequirements) {
+            this.description = {
+                ...this.description,
+                description: this.description.description + refinedRequirements,
+            };
+        }
+        let plan = await this.runPlanningPhase(projectPath);
         if (!plan) {
             this.emitPhase({ phase: 'failed', reason: 'Planning failed after retries' });
-            return this.makeResult('failed', projectPath, null, [], null, null, null);
+            return this.makeResult('failed', projectPath, null, [], null, null, null, null);
         }
         // Phase: verifying_plan
         this.emitPhase({ phase: 'verifying_plan' });
         const planValid = this.verifyPlanStructure(plan);
         if (!planValid) {
             this.emitPhase({ phase: 'failed', reason: 'Plan verification failed — invalid structure' });
-            return this.makeResult('failed', projectPath, plan, [], null, null, null);
+            return this.makeResult('failed', projectPath, plan, [], null, null, null, null);
         }
         this.audit('verification_completed', {
             phase: 'verifying_plan',
@@ -69,6 +168,57 @@ export class AppCreateOrchestrator extends EventEmitter {
             schema: plan.schema.length,
             apiRoutes: plan.apiRoutes.length,
         });
+        // Phase: requirements_refining (Plan Approval Gate)
+        {
+            this.emitPhase({ phase: 'requirements_refining' });
+            const refiner = new PlanRefiner(this.description);
+            const summary = refiner.generateSummary(plan);
+            this.planSummaryCache = summary;
+            if (this.options.autoApprove) {
+                // Auto-approve: validate heuristics, only pause if validation fails
+                const validation = refiner.validatePlan(plan);
+                this.audit('task_status_change', {
+                    phase: 'requirements_refining',
+                    mode: 'auto_approve',
+                    valid: validation.valid,
+                    warnings: validation.warnings,
+                });
+                if (!validation.valid) {
+                    // Validation failed — fall through to interactive approval
+                    this.emitPhase({ phase: 'awaiting_approval', planSummary: summary });
+                    const approvalResult = await new Promise((resolve) => {
+                        this.approvalResolve = resolve;
+                    });
+                    if (approvalResult.decision === 'rejected') {
+                        this.emitPhase({ phase: 'failed', reason: approvalResult.reason });
+                        return this.makeResult('failed', projectPath, plan, [], null, null, null, null);
+                    }
+                    if (approvalResult.decision === 'approved_with_modifications') {
+                        plan = refiner.applyModifications(plan, approvalResult.modifications);
+                    }
+                }
+                // Auto-approve with valid heuristics — proceed
+            }
+            else {
+                // Interactive mode: wait for human approval
+                this.emitPhase({ phase: 'awaiting_approval', planSummary: summary });
+                const approvalResult = await new Promise((resolve) => {
+                    this.approvalResolve = resolve;
+                });
+                this.audit('task_status_change', {
+                    phase: 'requirements_refining',
+                    mode: 'interactive',
+                    decision: approvalResult.decision,
+                });
+                if (approvalResult.decision === 'rejected') {
+                    this.emitPhase({ phase: 'failed', reason: approvalResult.reason });
+                    return this.makeResult('failed', projectPath, plan, [], null, null, null, null);
+                }
+                if (approvalResult.decision === 'approved_with_modifications') {
+                    plan = refiner.applyModifications(plan, approvalResult.modifications);
+                }
+            }
+        }
         // Write plan to disk
         await writeFile(join(projectPath, '.assay', 'architecture-plan.json'), JSON.stringify(plan, null, 2), 'utf-8');
         // Phase: scaffolding
@@ -227,6 +377,36 @@ export class AppCreateOrchestrator extends EventEmitter {
                 }
             }
         }
+        // Phase: functional testing (HTTP-level tests with repair loop)
+        let functionalTestResult = null;
+        if (!this.options.skipFunctionalTesting && !this.options.skipBuildVerification) {
+            const maxFunctionalAttempts = this.options.maxBuildRepairAttempts ?? 3;
+            this.emitPhase({ phase: 'functional_testing', attempt: 1, maxAttempts: maxFunctionalAttempts });
+            const functionalTester = new FunctionalTester(projectPath, plan, {
+                maxRepairAttempts: maxFunctionalAttempts,
+                codeModel: this.options.models?.code,
+                framework: this.description.techStack.framework,
+            });
+            functionalTestResult = await functionalTester.test();
+            // Emit repair phases if repairs happened
+            for (const repair of functionalTestResult.repairAttempts) {
+                this.emitPhase({
+                    phase: 'functional_repairing',
+                    attempt: repair.attempt,
+                    maxAttempts: maxFunctionalAttempts,
+                    failureCount: repair.failures.length,
+                });
+            }
+            this.audit('verification_completed', {
+                phase: 'functional_testing',
+                status: functionalTestResult.status,
+                passedCount: functionalTestResult.passedCount,
+                failedCount: functionalTestResult.failedCount,
+                repairAttempts: functionalTestResult.repairAttempts.length,
+                serverPort: functionalTestResult.serverPort,
+                totalDurationMs: functionalTestResult.totalDurationMs,
+            });
+        }
         // Phase: cross-verifying
         this.emitPhase({ phase: 'cross_verifying' });
         const crossVerification = await this.runCrossVerification(projectPath, plan);
@@ -241,9 +421,10 @@ export class AppCreateOrchestrator extends EventEmitter {
         const anyCompleted = featureResults.some(r => r.status === 'completed');
         const buildOk = !buildVerification || buildVerification.status === 'pass' || buildVerification.status === 'repaired' || buildVerification.status === 'skipped';
         const integrationOk = !integrationVerification || integrationVerification.verdict === 'PASS';
-        const finalStatus = allCompleted && buildOk && integrationOk ? 'completed' : anyCompleted ? 'partial' : 'failed';
+        const functionalOk = !functionalTestResult || functionalTestResult.status === 'pass' || functionalTestResult.status === 'repaired' || functionalTestResult.status === 'skipped';
+        const finalStatus = allCompleted && buildOk && integrationOk && functionalOk ? 'completed' : anyCompleted ? 'partial' : 'failed';
         this.emitPhase({ phase: 'completed' });
-        return this.makeResult(finalStatus, projectPath, plan, featureResults, buildVerification, integrationVerification, crossVerification);
+        return this.makeResult(finalStatus, projectPath, plan, featureResults, buildVerification, integrationVerification, crossVerification, functionalTestResult);
     }
     // ── Planning Phase ─────────────────────────────────────────
     async runPlanningPhase(projectPath) {
@@ -385,6 +566,7 @@ Include a .env.local file with placeholder values for all required environment v
                 try {
                     await mkdir(dirname(absPath), { recursive: true });
                     await writeFile(absPath, artifact.content, 'utf-8');
+                    this.audit('code_generated', { path: artifact.path, language: artifact.language || this.inferLanguage(artifact.path), content: artifact.content });
                 }
                 catch {
                     // Best-effort write
@@ -431,6 +613,7 @@ Include a .env.local file with placeholder values for all required environment v
                 await mkdir(dirname(absPath), { recursive: true });
                 await writeFile(absPath, handoff.artifact.content, 'utf-8');
                 filesCreated.push(path);
+                this.audit('code_generated', { path, language: handoff.artifact.language || this.inferLanguage(path), content: handoff.artifact.content });
             }
             catch {
                 // Best-effort write
@@ -516,6 +699,27 @@ Include a .env.local file with placeholder values for all required environment v
                 });
             }
         }
+        // Check 6: Link integrity — href targets in generated code resolve to actual pages
+        const linkChecks = await this.checkLinkIntegrity(projectPath, plan);
+        checks.push(...linkChecks);
+        // Check 7: Import paths resolve to actual files
+        const importChecks = await this.checkImportResolution(projectPath);
+        checks.push(...importChecks);
+        // Check 8: Package dependencies complete
+        const pkgChecks = await this.checkPackageDepsComplete(projectPath);
+        checks.push(...pkgChecks);
+        // Check 9: No self-fetch in server components
+        const selfFetchChecks = await this.checkNoSelfFetch(projectPath);
+        checks.push(...selfFetchChecks);
+        // Check 10: TypeScript compiles
+        const tsChecks = await this.checkTypescriptCompiles(projectPath);
+        checks.push(...tsChecks);
+        // Check 11: Environment variables complete
+        const envChecks = await this.checkEnvVarsComplete(projectPath);
+        checks.push(...envChecks);
+        // Check 12: Asset references valid
+        const assetChecks = await this.checkAssetRefsValid(projectPath);
+        checks.push(...assetChecks);
         const passedCount = checks.filter(c => c.verdict === 'PASS').length;
         const failedCount = checks.filter(c => c.verdict === 'FAIL').length;
         return {
@@ -599,6 +803,7 @@ Include a .env.local file with placeholder values for all required environment v
                     await mkdir(dirname(absPath), { recursive: true });
                     await writeFile(absPath, artifact.content, 'utf-8');
                     filesCreated.push(artifact.path);
+                    this.audit('code_generated', { path: artifact.path, language: artifact.language || this.inferLanguage(artifact.path), content: artifact.content });
                 }
                 catch {
                     // Best-effort write
@@ -892,7 +1097,7 @@ ${importNote}`;
         };
         this.emit('progress', progress);
     }
-    makeResult(status, projectPath, plan, featureResults, buildVerification, integrationVerification, crossVerification) {
+    makeResult(status, projectPath, plan, featureResults, buildVerification, integrationVerification, crossVerification, functionalTestResult) {
         return {
             status,
             projectPath,
@@ -901,6 +1106,7 @@ ${importNote}`;
             buildVerification,
             integrationVerification,
             crossVerification,
+            functionalTestResult,
             totalDurationMs: Date.now() - this.startTime,
             auditTrail: this.auditTrail,
         };
@@ -917,6 +1123,11 @@ ${importNote}`;
         this.auditTrail.push(entry);
         this.emit('audit', entry);
     }
+    inferLanguage(filePath) {
+        const ext = filePath.split('.').pop()?.toLowerCase() || '';
+        const map = { ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript', json: 'json', css: 'css', html: 'html', md: 'markdown', sql: 'sql', py: 'python' };
+        return map[ext] || 'text';
+    }
     slugify(name) {
         return name
             .toLowerCase()
@@ -1015,5 +1226,478 @@ The renderer process communicates with main via contextBridge APIs exposed in sr
         }
         return false;
     }
+    // ── Link Integrity Check ──────────────────────────────────
+    /**
+     * Scan generated page files for href/Link targets and verify
+     * each internal route has a corresponding page file.
+     * Catches hallucinated links like href="/categories" when
+     * no /categories/page.tsx exists.
+     */
+    async checkLinkIntegrity(projectPath, plan) {
+        const checks = [];
+        const framework = this.description.techStack.framework.toLowerCase();
+        // Build set of known routes from the plan
+        const knownRoutes = new Set();
+        for (const page of plan.pages) {
+            knownRoutes.add(page.path);
+        }
+        // Collect all page files to scan
+        const pageFiles = [];
+        for (const page of plan.pages) {
+            const filePath = this.pageToFilePath(page.path, page.component, this.description.techStack.framework);
+            pageFiles.push(join(projectPath, filePath));
+        }
+        // Also scan layout files which often contain nav links
+        const layoutCandidates = framework.includes('next')
+            ? ['app/layout.tsx', 'app/layout.jsx', 'app/page.tsx', 'app/page.jsx',
+                'components/nav.tsx', 'components/navbar.tsx', 'components/header.tsx',
+                'components/sidebar.tsx', 'components/layout.tsx',
+                'src/components/nav.tsx', 'src/components/navbar.tsx', 'src/components/header.tsx']
+            : ['src/App.tsx', 'src/App.jsx', 'src/components/Nav.tsx', 'src/components/Navbar.tsx',
+                'src/components/Header.tsx', 'src/components/Sidebar.tsx', 'src/components/Layout.tsx'];
+        for (const candidate of layoutCandidates) {
+            pageFiles.push(join(projectPath, candidate));
+        }
+        // Regex patterns to extract internal href targets
+        // Matches: href="/path", href='/path', to="/path", to='/path'
+        const hrefPattern = /(?:href|to)=["'](\/([\w\-/]*)?)["']/g;
+        // Also match Next.js Link component: <Link href="/path">
+        const linkPattern = /<Link[^>]*\s+href=["'](\/([\w\-/]*)?)["']/g;
+        const seenLinks = new Set();
+        for (const filePath of pageFiles) {
+            let content;
+            try {
+                content = await readFile(filePath, 'utf-8');
+            }
+            catch {
+                continue; // File doesn't exist, skip
+            }
+            // Extract all href targets
+            for (const pattern of [hrefPattern, linkPattern]) {
+                pattern.lastIndex = 0; // Reset regex state
+                let match;
+                while ((match = pattern.exec(content)) !== null) {
+                    const target = match[1];
+                    if (!target || target === '/' || target === '#')
+                        continue;
+                    // Skip external links, anchors, api routes, auth routes
+                    if (target.startsWith('/api/') || target.startsWith('/auth/'))
+                        continue;
+                    if (target.includes('://') || target.startsWith('mailto:'))
+                        continue;
+                    // Normalize: strip trailing slash
+                    const normalized = target.endsWith('/') ? target.slice(0, -1) : target;
+                    if (seenLinks.has(normalized))
+                        continue;
+                    seenLinks.add(normalized);
+                    // Check if this route has a page file
+                    const expectedPath = this.pageToFilePath(normalized, '', this.description.techStack.framework);
+                    const exists = await this.fileExists(join(projectPath, expectedPath));
+                    // Also check if it might be a dynamic route (e.g., /categories/[slug])
+                    // by looking for [param] directories
+                    let dynamicMatch = false;
+                    if (!exists && framework.includes('next')) {
+                        // For /categories, check if app/categories/page.tsx OR app/categories/[slug]/page.tsx exists
+                        // The link might be to a listing page that was never created
+                        const segments = normalized.split('/').filter(Boolean);
+                        if (segments.length === 1) {
+                            // Single-segment route like /categories — check if only a dynamic child exists
+                            try {
+                                const dirPath = join(projectPath, 'app', segments[0]);
+                                const entries = await readdir(dirPath);
+                                const hasDynamicChild = entries.some(e => e.startsWith('['));
+                                if (hasDynamicChild && !entries.includes('page.tsx') && !entries.includes('page.jsx')) {
+                                    // Directory exists with dynamic routes but no index page — this IS the bug
+                                    dynamicMatch = false; // Intentionally false: missing index page is a real failure
+                                }
+                            }
+                            catch {
+                                // Directory doesn't exist at all
+                            }
+                        }
+                    }
+                    const passed = exists || dynamicMatch;
+                    const sourceFile = filePath.replace(projectPath + '/', '');
+                    checks.push({
+                        type: 'link_integrity',
+                        description: `Link href="${normalized}" in ${sourceFile} resolves to a page`,
+                        verdict: passed ? 'PASS' : 'FAIL',
+                        evidence: passed
+                            ? `Page exists: ${expectedPath}`
+                            : `No page at ${expectedPath} — link target has no route handler`,
+                    });
+                }
+            }
+        }
+        return checks;
+    }
+    /**
+     * Check A1: Verify all import paths resolve to actual files.
+     * Catches: broken relative imports, unresolvable @/ aliases.
+     */
+    async checkImportResolution(projectPath) {
+        const checks = [];
+        const sourceFiles = await this.collectFiles(projectPath, ['.ts', '.tsx', '.js', '.jsx']);
+        // Read tsconfig paths for alias resolution
+        const { readTsConfigPaths } = await import('./fs-helpers.js');
+        const paths = await readTsConfigPaths(projectPath);
+        for (const filePath of sourceFiles) {
+            let content;
+            try {
+                content = await readFile(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const importRegex = /(?:import\s+(?:[\s\S]*?)\s+from\s+|import\s+|require\s*\(\s*)['"]([^'"]+)['"]/g;
+            let match;
+            while ((match = importRegex.exec(content)) !== null) {
+                const importPath = match[1];
+                // Skip external packages (no . or @ prefix, or @scoped packages)
+                if (!importPath.startsWith('.') && !importPath.startsWith('@/') && !importPath.startsWith('~/'))
+                    continue;
+                // Skip @scoped npm packages like @supabase/ssr
+                if (importPath.startsWith('@') && !importPath.startsWith('@/'))
+                    continue;
+                const relFile = filePath.replace(projectPath + '/', '');
+                if (importPath.startsWith('.')) {
+                    // Relative import — use resolveImport from fs-helpers
+                    const { resolveImport } = await import('./fs-helpers.js');
+                    const resolved = resolveImport(filePath, importPath, sourceFiles);
+                    if (!resolved) {
+                        checks.push({
+                            type: 'import_path_valid',
+                            description: `Import '${importPath}' in ${relFile} resolves to file`,
+                            verdict: 'FAIL',
+                            evidence: `Import '${importPath}' in ${relFile} does not resolve to any file`,
+                        });
+                    }
+                }
+                else if (importPath.startsWith('@/') || importPath.startsWith('~/')) {
+                    // Alias import — resolve via tsconfig paths
+                    let resolved = false;
+                    const prefix = importPath.startsWith('@/') ? '@/*' : '~/*';
+                    const aliasTargets = paths[prefix];
+                    if (aliasTargets && aliasTargets.length > 0) {
+                        const suffix = importPath.slice(2); // strip @/ or ~/
+                        for (const target of aliasTargets) {
+                            const targetDir = target.replace('*', '');
+                            const base = join(projectPath, targetDir, suffix);
+                            const extensions = ['', '.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js', '/index.jsx'];
+                            for (const ext of extensions) {
+                                try {
+                                    await stat(base + ext);
+                                    resolved = true;
+                                    break;
+                                }
+                                catch {
+                                    // continue
+                                }
+                            }
+                            if (resolved)
+                                break;
+                        }
+                    }
+                    if (!resolved) {
+                        checks.push({
+                            type: 'import_path_valid',
+                            description: `Import '${importPath}' in ${relFile} resolves via tsconfig alias`,
+                            verdict: 'FAIL',
+                            evidence: `Import '${importPath}' in ${relFile} — alias not configured or target missing`,
+                        });
+                    }
+                }
+            }
+        }
+        return checks;
+    }
+    /**
+     * Check A2: Verify all imported packages exist in package.json.
+     * Also detects invalid alias entries (e.g. "@/lib": "latest").
+     */
+    async checkPackageDepsComplete(projectPath) {
+        const checks = [];
+        const pkgPath = join(projectPath, 'package.json');
+        let pkg;
+        try {
+            pkg = JSON.parse(await readFile(pkgPath, 'utf-8'));
+        }
+        catch {
+            return checks; // No package.json
+        }
+        const deps = (pkg.dependencies ?? {});
+        const devDeps = (pkg.devDependencies ?? {});
+        const allDeps = new Set([...Object.keys(deps), ...Object.keys(devDeps)]);
+        // Check for invalid alias entries in package.json
+        for (const key of allDeps) {
+            if (key.startsWith('@/') || key.startsWith('./') || key.startsWith('~/')) {
+                checks.push({
+                    type: 'package_deps_complete',
+                    description: `Package "${key}" is a valid npm package name`,
+                    verdict: 'FAIL',
+                    evidence: `"${key}" in package.json is a path alias, not a valid npm package`,
+                });
+            }
+        }
+        // Collect imports from source files
+        const sourceFiles = await this.collectFiles(projectPath, ['.ts', '.tsx', '.js', '.jsx']);
+        const importedPackages = new Set();
+        for (const filePath of sourceFiles) {
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                const importRegex = /(?:import\s+.*?\s+from\s+['"]|import\s+['"]|require\s*\(\s*['"])([^./~][^'"]*)['"]/g;
+                let match;
+                while ((match = importRegex.exec(content)) !== null) {
+                    const raw = match[1];
+                    // Skip @/ aliases — they're not packages
+                    if (raw.startsWith('@/'))
+                        continue;
+                    const pkgName = raw.startsWith('@')
+                        ? raw.split('/').slice(0, 2).join('/')
+                        : raw.split('/')[0];
+                    importedPackages.add(pkgName);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        const builtins = new Set([
+            'node:events', 'node:fs', 'node:path', 'node:crypto', 'node:url', 'node:http', 'node:https',
+            'node:stream', 'node:util', 'node:os', 'node:child_process', 'node:buffer', 'node:assert',
+            'events', 'fs', 'path', 'crypto', 'url', 'http', 'https', 'stream', 'util', 'os',
+            'child_process', 'buffer', 'assert', 'fs/promises',
+            'react', 'react-dom', 'react-dom/client', 'next', 'electron',
+        ]);
+        for (const importedPkg of importedPackages) {
+            if (builtins.has(importedPkg))
+                continue;
+            if (allDeps.has(importedPkg))
+                continue;
+            if (importedPkg.startsWith('next/'))
+                continue;
+            checks.push({
+                type: 'package_deps_complete',
+                description: `Package "${importedPkg}" is listed in package.json`,
+                verdict: 'FAIL',
+                evidence: `"${importedPkg}" is imported but not in package.json dependencies`,
+            });
+        }
+        return checks;
+    }
+    /**
+     * Check A3: Detect server components that fetch their own API routes (deadlock risk).
+     * Only applies to Next.js apps.
+     */
+    async checkNoSelfFetch(projectPath) {
+        const checks = [];
+        const framework = this.description.techStack.framework.toLowerCase();
+        if (!framework.includes('next'))
+            return checks;
+        const appDir = join(projectPath, 'app');
+        let appFiles;
+        try {
+            appFiles = await this.collectFiles(appDir, ['.ts', '.tsx', '.js', '.jsx']);
+        }
+        catch {
+            return checks;
+        }
+        const selfFetchPattern = /fetch\s*\(\s*['"`](?:\/api\/|https?:\/\/localhost)/;
+        for (const filePath of appFiles) {
+            let content;
+            try {
+                content = await readFile(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            // Client components can self-fetch — skip
+            if (content.includes("'use client'") || content.includes('"use client"'))
+                continue;
+            if (selfFetchPattern.test(content)) {
+                const relFile = filePath.replace(projectPath + '/', '');
+                checks.push({
+                    type: 'no_self_fetch',
+                    description: `Server component ${relFile} does not self-fetch API routes`,
+                    verdict: 'FAIL',
+                    evidence: `${relFile} is a server component that fetches /api/ or localhost — this causes a deadlock in Next.js`,
+                });
+            }
+        }
+        return checks;
+    }
+    /**
+     * Check A4: Verify TypeScript compiles without errors.
+     * Uses `npx tsc --noEmit` with 60s timeout.
+     */
+    async checkTypescriptCompiles(projectPath) {
+        const tsconfigPath = join(projectPath, 'tsconfig.json');
+        try {
+            await stat(tsconfigPath);
+        }
+        catch {
+            return []; // No tsconfig — skip
+        }
+        try {
+            execSync('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',
+                }];
+        }
+        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)}`,
+                }];
+        }
+    }
+    /**
+     * Check A5: Verify all referenced environment variables are defined in .env files.
+     */
+    async checkEnvVarsComplete(projectPath) {
+        const checks = [];
+        const sourceFiles = await this.collectFiles(projectPath, ['.ts', '.tsx', '.js', '.jsx']);
+        // Standard exclusions — always available at runtime
+        const standardVars = new Set([
+            'NODE_ENV', 'PORT', 'HOME', 'PATH', 'PWD', 'USER', 'CI',
+            'HOSTNAME', 'VERCEL', 'NEXT_RUNTIME', 'NODE_PATH', 'NODE_OPTIONS',
+            'VERCEL_URL', 'NEXT_PUBLIC_VERCEL_URL', 'NEXT_PUBLIC_VERCEL_ENV',
+        ]);
+        // Collect all referenced env vars
+        const referencedVars = new Set();
+        const processEnvPattern = /process\.env\.([A-Z_][A-Z0-9_]+)/g;
+        const importMetaPattern = /import\.meta\.env\.([A-Z_][A-Z0-9_]+)/g;
+        for (const filePath of sourceFiles) {
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                let match;
+                while ((match = processEnvPattern.exec(content)) !== null) {
+                    referencedVars.add(match[1]);
+                }
+                processEnvPattern.lastIndex = 0;
+                while ((match = importMetaPattern.exec(content)) !== null) {
+                    referencedVars.add(match[1]);
+                }
+                importMetaPattern.lastIndex = 0;
+            }
+            catch {
+                continue;
+            }
+        }
+        // Collect defined env vars from all .env* files
+        const definedVars = new Set();
+        try {
+            const entries = await readdir(projectPath);
+            for (const entry of entries) {
+                if (entry.startsWith('.env')) {
+                    try {
+                        const content = await readFile(join(projectPath, entry), 'utf-8');
+                        for (const line of content.split('\n')) {
+                            const trimmed = line.trim();
+                            if (trimmed && !trimmed.startsWith('#')) {
+                                const eqIdx = trimmed.indexOf('=');
+                                if (eqIdx > 0) {
+                                    definedVars.add(trimmed.slice(0, eqIdx).trim());
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+        catch {
+            // Can't read directory
+        }
+        for (const varName of referencedVars) {
+            if (standardVars.has(varName))
+                continue;
+            if (definedVars.has(varName))
+                continue;
+            checks.push({
+                type: 'env_vars_complete',
+                description: `Environment variable ${varName} is defined in .env file`,
+                verdict: 'FAIL',
+                evidence: `${varName} is referenced in source code but not defined in any .env* file`,
+            });
+        }
+        return checks;
+    }
+    /**
+     * Check A6: Verify asset references (images, CSS, icons) point to existing files.
+     */
+    async checkAssetRefsValid(projectPath) {
+        const checks = [];
+        const framework = this.description.techStack.framework.toLowerCase();
+        // Determine public asset directory
+        let publicDir;
+        if (framework.includes('electron')) {
+            publicDir = join(projectPath, 'src', 'renderer', 'assets');
+        }
+        else {
+            publicDir = join(projectPath, 'public');
+        }
+        const sourceFiles = await this.collectFiles(projectPath, ['.ts', '.tsx', '.js', '.jsx', '.html', '.css']);
+        // Patterns for asset references
+        const assetPatterns = [
+            /(?:src|href)=["'](\/[^"']+\.(?:png|jpg|jpeg|gif|svg|webp|ico|css))["']/g,
+            /url\(["']?(\/[^"')]+\.(?:png|jpg|jpeg|gif|svg|webp|ico|woff2?|ttf|eot))["']?\)/g,
+        ];
+        const checkedPaths = new Set();
+        for (const filePath of sourceFiles) {
+            let content;
+            try {
+                content = await readFile(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            for (const pattern of assetPatterns) {
+                pattern.lastIndex = 0;
+                let match;
+                while ((match = pattern.exec(content)) !== null) {
+                    const assetPath = match[1];
+                    // Skip external URLs and data URIs
+                    if (assetPath.includes('://') || assetPath.startsWith('//') || assetPath.startsWith('data:'))
+                        continue;
+                    if (checkedPaths.has(assetPath))
+                        continue;
+                    checkedPaths.add(assetPath);
+                    // Resolve against public directory (strip leading /)
+                    const resolved = join(publicDir, assetPath.slice(1));
+                    try {
+                        await stat(resolved);
+                    }
+                    catch {
+                        const relFile = filePath.replace(projectPath + '/', '');
+                        checks.push({
+                            type: 'asset_refs_valid',
+                            description: `Asset ${assetPath} referenced in ${relFile} exists`,
+                            verdict: 'FAIL',
+                            evidence: `${assetPath} referenced in ${relFile} not found at ${resolved.replace(projectPath + '/', '')}`,
+                        });
+                    }
+                }
+            }
+        }
+        return checks;
+    }
 }
 //# sourceMappingURL=app-create-orchestrator.js.map