groupthinking
diff --git a/‎.firebase/.graphqlrc‎
Lines changed: 1 addition & 0 deletions b/‎.firebase/.graphqlrc‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎.firebaserc‎
Lines changed: 7 additions & 0 deletions b/‎.firebaserc‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎.vscode/settings.json‎
Lines changed: 2 additions & 1 deletion b/‎.vscode/settings.json‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎Dockerfile‎
Lines changed: 2 additions & 2 deletions b/‎Dockerfile‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎apps/web/package.json‎
Lines changed: 1 addition & 0 deletions b/‎apps/web/package.json‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎apps/web/src/app/api/extract-events/route.ts‎
Lines changed: 103 additions & 34 deletions b/‎apps/web/src/app/api/extract-events/route.ts‎
Lines changed: 103 additions & 34 deletions
diff --git a/‎apps/web/src/app/api/pipeline/route.ts‎
Lines changed: 163 additions & 0 deletions b/‎apps/web/src/app/api/pipeline/route.ts‎
Lines changed: 163 additions & 0 deletions
@@ -0,0 +1 @@
+{"schema":["../dataconnect/.dataconnect/**/*.gql","../dataconnect/schema/**/*.gql"],"document":["../dataconnect/example/**/*.gql"]}
@@ -0,0 +1,7 @@
+{
+  "projects": {
+    "default": "uvai-730bb"
+  },
+  "targets": {},
+  "etags": {}
+}
@@ -155,3 +155,4 @@ UVAI_Digital_Refinery_Blueprint.pdf
 *.db
 .vercel
 .env*.local
+.next/
@@ -81,5 +81,6 @@
     "dart.enableCompletionCommitCharacters": true,
     "geminicodeassist.codeGenerationPaneViewEnabled": true,
     "geminicodeassist.inlineSuggestions.nextEditPredictions": true,
-    "geminicodeassist.inlineSuggestions.suggestionSpeed": "Fast"
+    "geminicodeassist.inlineSuggestions.suggestionSpeed": "Fast",
+    "geminicodeassist.outlines.automaticOutlineGeneration": true
 }
@@ -49,8 +49,8 @@ COPY --chown=uvai:uvai src/ ./src/
 COPY --chown=uvai:uvai pyproject.toml ./
 
 # Create data directories
-RUN mkdir -p /app/data/enhanced_analysis /app/data/cache /app/logs && \
-    chown -R uvai:uvai /app/data /app/logs
+RUN mkdir -p /app/data/enhanced_analysis /app/data/cache /app/logs /app/generated_projects /app/youtube_processed_videos /tmp/uvai_data && \
+    chown -R uvai:uvai /app/data /app/logs /app/generated_projects /app/youtube_processed_videos /tmp/uvai_data
 
 # Switch to non-root user
 USER uvai
 
@@ -9,6 +9,7 @@
     "lint": "next lint"
   },
   "dependencies": {
+    "@google/genai": "^1.43.0",
     "@google/generative-ai": "^0.24.1",
     "@stripe/stripe-js": "^2.0.0",
     "@supabase/supabase-js": "^2.39.0",
 
@@ -1,20 +1,15 @@
 import OpenAI from 'openai';
-import { GoogleGenerativeAI } from '@google/generative-ai';
+import { Type } from '@google/genai';
 import { NextResponse } from 'next/server';
+import { getGeminiClient, hasGeminiKey } from '@/lib/gemini-client';
 
 let _openai: OpenAI | null = null;
 function getOpenAI() {
   if (!_openai) _openai = new OpenAI();
   return _openai;
 }
 
-let _gemini: GoogleGenerativeAI | null = null;
-function getGemini() {
-  if (!_gemini) _gemini = new GoogleGenerativeAI(process.env.GEMINI_API_KEY || '');
-  return _gemini;
-}
-
-// JSON Schema for structured extraction via Responses API
+// JSON Schema for structured extraction via OpenAI Responses API
 const extractionSchema = {
   type: 'object' as const,
   properties: {
@@ -54,6 +49,43 @@ const extractionSchema = {
   additionalProperties: false,
 };
 
+// Gemini responseSchema using @google/genai Type system
+const geminiResponseSchema = {
+  type: Type.OBJECT,
+  properties: {
+    events: {
+      type: Type.ARRAY,
+      items: {
+        type: Type.OBJECT,
+        properties: {
+          type: { type: Type.STRING, enum: ['action', 'topic', 'insight', 'tool', 'resource'] },
+          title: { type: Type.STRING },
+          description: { type: Type.STRING },
+          timestamp: { type: Type.STRING, nullable: true },
+          priority: { type: Type.STRING, enum: ['high', 'medium', 'low'] },
+        },
+        required: ['type', 'title', 'description', 'priority'],
+      },
+    },
+    actions: {
+      type: Type.ARRAY,
+      items: {
+        type: Type.OBJECT,
+        properties: {
+          title: { type: Type.STRING },
+          description: { type: Type.STRING },
+          category: { type: Type.STRING, enum: ['setup', 'build', 'deploy', 'learn', 'research', 'configure'] },
+          estimatedMinutes: { type: Type.NUMBER, nullable: true },
+        },
+        required: ['title', 'description', 'category'],
+      },
+    },
+    summary: { type: Type.STRING },
+    topics: { type: Type.ARRAY, items: { type: Type.STRING } },
+  },
+  required: ['events', 'actions', 'summary', 'topics'],
+};
+
 const SYSTEM_PROMPT = `You are an expert content analyst. Extract structured data from video transcripts.
 Be specific and practical — no vague or generic items.
 For events: classify type (action/topic/insight/tool/resource) and priority (high/medium/low).
@@ -94,54 +126,91 @@ async function extractWithOpenAI(trimmed: string, videoTitle?: string, videoUrl?
 }
 
 async function extractWithGemini(trimmed: string, videoTitle?: string, videoUrl?: string) {
-  const model = getGemini().getGenerativeModel({
-    model: 'gemini-2.0-flash',
-    generationConfig: {
-      responseMimeType: 'application/json',
+  const ai = getGeminiClient();
+  const response = await ai.models.generateContent({
+    model: 'gemini-3-pro-preview',
+    contents: `${SYSTEM_PROMPT}\n\n${buildUserPrompt(trimmed, videoTitle, videoUrl)}`,
+    config: {
       temperature: 0.3,
+      responseMimeType: 'application/json',
+      responseSchema: geminiResponseSchema,
+      tools: [{ googleSearch: {} }],
     },
   });
-  const result = await model.generateContent(`${SYSTEM_PROMPT}\n\n${buildUserPrompt(trimmed, videoTitle, videoUrl)}`);
-  const text = result.response.text();
+  const text = response.text ?? '';
   return JSON.parse(text);
 }
 
 export async function POST(request: Request) {
   try {
     const { transcript, videoTitle, videoUrl } = await request.json();
 
-    if (!transcript || typeof transcript !== 'string') {
+    // Accept either transcript text OR videoUrl for direct Gemini analysis
+    if ((!transcript || typeof transcript !== 'string') && !videoUrl) {
       return NextResponse.json(
-        { error: 'transcript (string) is required' },
+        { error: 'transcript (string) or videoUrl is required' },
         { status: 400 }
       );
     }
 
-    const trimmed = transcript.slice(0, 8000);
     let parsed;
     let provider = 'openai';
 
-    // Try OpenAI first, fall back to Gemini on quota/auth errors
-    if (process.env.OPENAI_API_KEY) {
-      try {
-        parsed = await extractWithOpenAI(trimmed, videoTitle, videoUrl);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : '';
-        if ((msg.includes('429') || msg.includes('quota') || msg.includes('rate')) && process.env.GEMINI_API_KEY) {
-          console.warn('OpenAI quota hit, falling back to Gemini');
-          parsed = await extractWithGemini(trimmed, videoTitle, videoUrl);
-          provider = 'gemini';
-        } else {
-          throw err;
+    // If we have transcript text, use the existing extraction logic
+    if (transcript && typeof transcript === 'string' && transcript.length > 50) {
+      const trimmed = transcript.slice(0, 8000);
+
+      if (process.env.OPENAI_API_KEY) {
+        try {
+          parsed = await extractWithOpenAI(trimmed, videoTitle, videoUrl);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : '';
+          if ((msg.includes('429') || msg.includes('quota') || msg.includes('rate')) && hasGeminiKey()) {
+            console.warn('OpenAI quota hit, falling back to Gemini');
+            parsed = await extractWithGemini(trimmed, videoTitle, videoUrl);
+            provider = 'gemini';
+          } else {
+            throw err;
+          }
         }
+      } else if (hasGeminiKey()) {
+        parsed = await extractWithGemini(trimmed, videoTitle, videoUrl);
+        provider = 'gemini';
       }
-    } else if (process.env.GEMINI_API_KEY) {
-      parsed = await extractWithGemini(trimmed, videoTitle, videoUrl);
-      provider = 'gemini';
-    } else {
+    }
+
+    // If no transcript but have videoUrl + Gemini, do direct video analysis via Google Search
+    if (!parsed && videoUrl && hasGeminiKey()) {
+      try {
+        const ai = getGeminiClient();
+        const response = await ai.models.generateContent({
+          model: 'gemini-3-pro-preview',
+          contents: `${SYSTEM_PROMPT}\n\nAnalyze this YouTube video and extract structured data.
+Use your Google Search tool to find the video's transcript, description, and chapter content.
+
+Video URL: ${videoUrl}
+${videoTitle ? `Video Title: ${videoTitle}` : ''}
+
+Extract events, actions, summary, and topics from the actual video content found via search.`,
+          config: {
+            temperature: 0.3,
+            responseMimeType: 'application/json',
+            responseSchema: geminiResponseSchema,
+            tools: [{ googleSearch: {} }],
+          },
+        });
+        const text = response.text ?? '';
+        parsed = JSON.parse(text);
+        provider = 'gemini-search';
+      } catch (e) {
+        console.warn('Gemini direct video extraction failed:', e);
+      }
+    }
+
+    if (!parsed) {
       return NextResponse.json({
         success: false,
-        error: 'No AI API key configured. Set OPENAI_API_KEY or GEMINI_API_KEY.',
+        error: 'No AI API key configured or all extraction attempts failed. Set GEMINI_API_KEY.',
         data: { events: [], actions: [], summary: '', topics: [] },
       });
     }
 
@@ -0,0 +1,163 @@
+import { NextResponse } from 'next/server';
+import { publishEvent, EventTypes } from '@/lib/cloudevents';
+import { analyzeVideoWithGemini } from '@/lib/gemini-video-analyzer';
+import { hasGeminiKey } from '@/lib/gemini-client';
+
+const rawBackendUrl = process.env.BACKEND_URL || '';
+const BACKEND_URL = rawBackendUrl.startsWith('http') ? rawBackendUrl : 'http://localhost:8000';
+const BACKEND_AVAILABLE = rawBackendUrl.startsWith('http');
+
+/**
+ * POST /api/pipeline
+ *
+ * End-to-end pipeline: YouTube URL → Video Analysis → Code Generation → Deployment → Live URL
+ *
+ * This is the FULL pipeline that the user's notes describe (PK=999, PK=1021):
+ *   Ingest → Translate → Transport → Execute
+ *
+ * Strategies:
+ *   1. Backend pipeline (FastAPI /api/v1/video-to-software) — full pipeline with agents
+ *   2. Gemini analysis + frontend deployment — when no backend is available
+ */
+export async function POST(request: Request) {
+  let videoUrl: string | undefined;
+  try {
+    const body = await request.json();
+    const { url, project_type = 'web', deployment_target = 'vercel', features } = body;
+    videoUrl = url;
+
+    if (!url) {
+      return NextResponse.json({ error: 'Video URL is required' }, { status: 400 });
+    }
+
+    await publishEvent(EventTypes.VIDEO_RECEIVED, { url, pipeline: 'end-to-end' }, url);
+
+    // ── Strategy 1: Full backend pipeline (FastAPI video-to-software) ──
+    if (BACKEND_AVAILABLE) {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 300_000); // 5 min for full pipeline
+
+        let response: Response;
+        try {
+          response = await fetch(`${BACKEND_URL}/api/v1/video-to-software`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              video_url: url,
+              project_type,
+              deployment_target,
+              features: features || ['responsive_design', 'modern_ui'],
+            }),
+            signal: controller.signal,
+          });
+        } finally {
+          clearTimeout(timeout);
+        }
+
+        if (response.ok) {
+          const result = await response.json();
+
+          await publishEvent(EventTypes.PIPELINE_COMPLETED, {
+            strategy: 'backend-pipeline',
+            success: result.status === 'success',
+            live_url: result.live_url,
+            github_repo: result.github_repo,
+            build_status: result.build_status,
+          }, url);
+
+          return NextResponse.json({
+            id: `pipeline_${Date.now().toString(36)}`,
+            status: result.status || 'complete',
+            pipeline: 'backend',
+            processing_time: result.processing_time,
+            result: {
+              live_url: result.live_url,
+              github_repo: result.github_repo,
+              build_status: result.build_status,
+              video_analysis: result.video_analysis,
+              code_generation: result.code_generation,
+              deployment: result.deployment,
+              features_implemented: result.features_implemented,
+            },
+          });
+        }
+        console.warn(`Backend pipeline returned ${response.status}, falling back`);
+      } catch (e) {
+        console.log('Backend pipeline unavailable:', e);
+      }
+    }
+
+    // ── Strategy 2: Gemini analysis (video intelligence only, no deployment) ──
+    if (hasGeminiKey()) {
+      try {
+        const startTime = Date.now();
+        const analysis = await analyzeVideoWithGemini(url);
+        const elapsed = Date.now() - startTime;
+
+        await publishEvent(EventTypes.PIPELINE_COMPLETED, {
+          strategy: 'gemini-analysis-only',
+          success: true,
+          note: 'Backend unavailable — analysis only, no deployment',
+        }, url);
+
+        return NextResponse.json({
+          id: `pipeline_${Date.now().toString(36)}`,
+          status: 'partial',
+          pipeline: 'gemini-only',
+          processing_time: `${(elapsed / 1000).toFixed(1)}s`,
+          result: {
+            live_url: null,
+            github_repo: null,
+            build_status: 'not_attempted',
+            video_analysis: {
+              title: analysis.title,
+              summary: analysis.summary,
+              events: analysis.events,
+              actions: analysis.actions,
+              topics: analysis.topics,
+              architectureCode: analysis.architectureCode,
+            },
+            code_generation: null,
+            deployment: null,
+            message: 'Backend pipeline unavailable. Video analysis complete but code generation and deployment require the Python backend.',
+          },
+        });
+      } catch (e) {
+        console.error('Gemini analysis failed:', e);
+      }
+    }
+
+    return NextResponse.json(
+      { error: 'No pipeline available. Configure BACKEND_URL for full pipeline or GEMINI_API_KEY for analysis only.' },
+      { status: 503 },
+    );
+  } catch (error) {
+    console.error('Pipeline error:', error);
+    await publishEvent(EventTypes.PIPELINE_FAILED, { error: String(error) }, videoUrl).catch(() => {});
+    return NextResponse.json(
+      { error: 'Pipeline failed', details: String(error) },
+      { status: 500 },
+    );
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    name: 'EventRelay End-to-End Pipeline',
+    version: '1.0.0',
+    description: 'YouTube URL → Video Analysis → Code Generation → Deployment → Live URL',
+    pipeline_stages: [
+      '1. Ingest: Gemini analyzes video content with Google Search grounding',
+      '2. Translate: Structured output → VideoPack artifact',
+      '3. Transport: CloudEvents published at each stage',
+      '4. Execute: Agents generate code, create repo, deploy to Vercel',
+    ],
+    backend_available: BACKEND_AVAILABLE,
+    gemini_available: hasGeminiKey(),
+    endpoints: {
+      pipeline: 'POST /api/pipeline - Full end-to-end pipeline',
+      video: 'POST /api/video - Video analysis only',
+    },
+  });
+}
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+{"schema":["../dataconnect/.dataconnect/*/.gql","../dataconnect/schema/*/.gql"],"document":["../dataconnect/example/*/.gql"]}`
-Original file line number
+Diff line change
 *.db
 .vercel
 .env*.local
 +.next/
Original file line number	Diff line number	Diff line change
`@@ -81,5 +81,6 @@`
`81`	`81`	`"dart.enableCompletionCommitCharacters": true,`
`82`	`82`	`"geminicodeassist.codeGenerationPaneViewEnabled": true,`
`83`	`83`	`"geminicodeassist.inlineSuggestions.nextEditPredictions": true,`
`84`		`- "geminicodeassist.inlineSuggestions.suggestionSpeed": "Fast"`
	`84`	`+ "geminicodeassist.inlineSuggestions.suggestionSpeed": "Fast",`
	`85`	`+ "geminicodeassist.outlines.automaticOutlineGeneration": true`
`85`	`86`	`}`