update

backend/app/database.py

@@ -293,44 +293,38 @@ def init_db():
                     conn.commit()
                     
                     # Add new columns to assets table if they don't exist (migration)
+                    # CockroachDB doesn't support ALTER TABLE in DO blocks, so we check first
                     try:
                         cursor = conn.cursor()
-                        # Check and add extracted_content column
+                        
+                        # Check if columns exist and add them if they don't
                         cursor.execute("""
-                            DO $$ 
-                            BEGIN
-                                IF NOT EXISTS (
-                                    SELECT 1 FROM information_schema.columns 
-                                    WHERE table_name='assets' AND column_name='extracted_content'
-                                ) THEN
-                                    ALTER TABLE assets ADD COLUMN extracted_content JSONB;
-                                END IF;
-                            END $$;
+                            SELECT column_name 
+                            FROM information_schema.columns 
+                            WHERE table_name='assets' AND column_name='extracted_content'
                         """)
-                        # Check and add analysis_status column
+                        if not cursor.fetchone():
+                            cursor.execute("ALTER TABLE assets ADD COLUMN extracted_content JSONB")
+                            print("✓ Added extracted_content column")
+                        
                         cursor.execute("""
-                            DO $$ 
-                            BEGIN
-                                IF NOT EXISTS (
-                                    SELECT 1 FROM information_schema.columns 
-                                    WHERE table_name='assets' AND column_name='analysis_status'
-                                ) THEN
-                                    ALTER TABLE assets ADD COLUMN analysis_status VARCHAR DEFAULT 'pending';
-                                END IF;
-                            END $$;
+                            SELECT column_name 
+                            FROM information_schema.columns 
+                            WHERE table_name='assets' AND column_name='analysis_status'
                         """)
-                        # Check and add analyzed_at column
+                        if not cursor.fetchone():
+                            cursor.execute("ALTER TABLE assets ADD COLUMN analysis_status VARCHAR DEFAULT 'pending'")
+                            print("✓ Added analysis_status column")
+                        
                         cursor.execute("""
-                            DO $$ 
-                            BEGIN
-                                IF NOT EXISTS (
-                                    SELECT 1 FROM information_schema.columns 
-                                    WHERE table_name='assets' AND column_name='analyzed_at'
-                                ) THEN
-                                    ALTER TABLE assets ADD COLUMN analyzed_at TIMESTAMP;
-                                END IF;
-                            END $$;
+                            SELECT column_name 
+                            FROM information_schema.columns 
+                            WHERE table_name='assets' AND column_name='analyzed_at'
                         """)
+                        if not cursor.fetchone():
+                            cursor.execute("ALTER TABLE assets ADD COLUMN analyzed_at TIMESTAMP")
+                            print("✓ Added analyzed_at column")
+                        
                         conn.commit()
                         cursor.close()
                         print("✓ Database migration completed (added new asset columns)")

backend/app/main.py

@@ -3,10 +3,11 @@ from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Dict
 import os
 import uuid
 from datetime import datetime
+import asyncio
 
 from app.schemas import (
     IntegrationResponse, AssetResponse, PostResponse, CampaignResponse,
@@ -59,6 +60,9 @@ ai_service = AIService()
 asset_analyzer = AssetAnalyzer()
 agentic_planner = AgenticPlanner()
 
+# Upload status tracking (in-memory, could be moved to Redis in production)
+upload_status: Dict[str, Dict] = {}
+
 # ---- API Endpoints ----
 
 @app.get("/api/health")
@@ -174,6 +178,132 @@ async def generate_ai_content(request: AIContentRequest, db: Session = Depends(g
 
 # ---- Asset Management ----
 
+@app.get("/api/assets/{asset_id}/status")
+async def get_asset_status(asset_id: int, db: Session = Depends(get_db)):
+    """Get the analysis status of an asset"""
+    try:
+        from app.models import Asset
+        conn = get_direct_psycopg2_connection()
+        if conn:
+            try:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    SELECT id, name, analysis_status, analyzed_at 
+                    FROM assets 
+                    WHERE id = %s
+                """, (asset_id,))
+                row = cursor.fetchone()
+                cursor.close()
+                conn.close()
+                if row:
+                    return {
+                        "asset_id": row[0],
+                        "name": row[1],
+                        "status": row[2] or "pending",
+                        "analyzed_at": row[3].isoformat() if row[3] else None
+                    }
+            except Exception as e:
+                if conn:
+                    conn.close()
+                raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=404, detail="Asset not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+async def analyze_asset_background(asset_id: int, file_path: str, file_type: str):
+    """Background task to analyze asset"""
+    try:
+        # Update status to processing
+        conn = get_direct_psycopg2_connection()
+        if conn:
+            try:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    UPDATE assets 
+                    SET analysis_status = 'processing' 
+                    WHERE id = %s
+                """, (asset_id,))
+                conn.commit()
+                cursor.close()
+                conn.close()
+            except Exception as update_error:
+                print(f"Could not update analysis status: {update_error}")
+                if conn:
+                    conn.close()
+        
+        # Analyze asset
+        analysis_result = await asset_analyzer.analyze_document(str(file_path))
+        if analysis_result.get("success") and analysis_result.get("extracted_content"):
+            # Update asset with extracted content
+            conn = get_direct_psycopg2_connection()
+            if conn:
+                try:
+                    cursor = conn.cursor()
+                    import json
+                    extracted_json = json.dumps(analysis_result["extracted_content"])
+                    cursor.execute("""
+                        UPDATE assets 
+                        SET extracted_content = %s::jsonb, 
+                            analysis_status = 'completed',
+                            analyzed_at = NOW()
+                        WHERE id = %s
+                    """, (extracted_json, asset_id))
+                    conn.commit()
+                    cursor.close()
+                    conn.close()
+                    print(f"✓ Asset {asset_id} analyzed successfully")
+                except Exception as update_error:
+                    print(f"Could not save extracted content: {update_error}")
+                    # Try to mark as failed
+                    try:
+                        cursor = conn.cursor()
+                        cursor.execute("""
+                            UPDATE assets 
+                            SET analysis_status = 'failed' 
+                            WHERE id = %s
+                        """, (asset_id,))
+                        conn.commit()
+                        cursor.close()
+                    except:
+                        pass
+                    if conn:
+                        conn.close()
+        else:
+            # Mark as failed if analysis didn't succeed
+            conn = get_direct_psycopg2_connection()
+            if conn:
+                try:
+                    cursor = conn.cursor()
+                    cursor.execute("""
+                        UPDATE assets 
+                        SET analysis_status = 'failed' 
+                        WHERE id = %s
+                    """, (asset_id,))
+                    conn.commit()
+                    cursor.close()
+                    conn.close()
+                except:
+                    if conn:
+                        conn.close()
+    except Exception as analysis_error:
+        print(f"Asset analysis error: {analysis_error}")
+        # Mark as failed
+        conn = get_direct_psycopg2_connection()
+        if conn:
+            try:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    UPDATE assets 
+                    SET analysis_status = 'failed' 
+                    WHERE id = %s
+                """, (asset_id,))
+                conn.commit()
+                cursor.close()
+                conn.close()
+            except:
+                if conn:
+                    conn.close()
+
 @app.post("/api/assets/upload")
 async def upload_asset(
     file: UploadFile = File(...),
@@ -301,97 +431,11 @@ async def upload_asset(
                 else:
                     raise commit_error
             
-            # Analyze asset using OCR API (agentic step)
+            # Start background analysis task
             asset_id = db_asset.id
             if file_type in ["document", "image"]:
-                # Update status to processing
-                try:
-                    conn = get_direct_psycopg2_connection()
-                    if conn:
-                        cursor = conn.cursor()
-                        cursor.execute("""
-                            UPDATE assets 
-                            SET analysis_status = 'processing' 
-                            WHERE id = %s
-                        """, (asset_id,))
-                        conn.commit()
-                        cursor.close()
-                        conn.close()
-                except Exception as update_error:
-                    print(f"Could not update analysis status: {update_error}")
-                
-                # Analyze asset asynchronously (don't block response)
-                try:
-                    analysis_result = await asset_analyzer.analyze_document(str(file_path))
-                    if analysis_result.get("success") and analysis_result.get("extracted_content"):
-                        # Update asset with extracted content
-                        try:
-                            conn = get_direct_psycopg2_connection()
-                            if conn:
-                                cursor = conn.cursor()
-                                import json
-                                extracted_json = json.dumps(analysis_result["extracted_content"])
-                                cursor.execute("""
-                                    UPDATE assets 
-                                    SET extracted_content = %s::jsonb, 
-                                        analysis_status = 'completed',
-                                        analyzed_at = NOW()
-                                    WHERE id = %s
-                                """, (extracted_json, asset_id))
-                                conn.commit()
-                                cursor.close()
-                                conn.close()
-                                print(f"✓ Asset {asset_id} analyzed successfully")
-                        except Exception as update_error:
-                            print(f"Could not save extracted content: {update_error}")
-                            # Try to mark as failed
-                            try:
-                                conn = get_direct_psycopg2_connection()
-                                if conn:
-                                    cursor = conn.cursor()
-                                    cursor.execute("""
-                                        UPDATE assets 
-                                        SET analysis_status = 'failed' 
-                                        WHERE id = %s
-                                    """, (asset_id,))
-                                    conn.commit()
-                                    cursor.close()
-                                    conn.close()
-                            except:
-                                pass
-                    else:
-                        # Mark as failed if analysis didn't succeed
-                        try:
-                            conn = get_direct_psycopg2_connection()
-                            if conn:
-                                cursor = conn.cursor()
-                                cursor.execute("""
-                                    UPDATE assets 
-                                    SET analysis_status = 'failed' 
-                                    WHERE id = %s
-                                """, (asset_id,))
-                                conn.commit()
-                                cursor.close()
-                                conn.close()
-                        except:
-                            pass
-                except Exception as analysis_error:
-                    print(f"Asset analysis error: {analysis_error}")
-                    # Mark as failed
-                    try:
-                        conn = get_direct_psycopg2_connection()
-                        if conn:
-                            cursor = conn.cursor()
-                            cursor.execute("""
-                                UPDATE assets 
-                                SET analysis_status = 'failed' 
-                                WHERE id = %s
-                            """, (asset_id,))
-                            conn.commit()
-                            cursor.close()
-                            conn.close()
-                    except:
-                        pass
+                # Start background task (don't await - return immediately)
+                asyncio.create_task(analyze_asset_background(asset_id, str(file_path), file_type))
             
             return {
                 "id": db_asset.id,
@@ -739,7 +783,7 @@ if FRONTEND_DIST.exists():
         if INDEX_FILE.exists():
             return FileResponse(str(INDEX_FILE))
         return {"detail": "Frontend not found"}
-    
+
     # SPA fallback: any non-/api route should return React index.html
     # This must be last to catch all routes not handled above
     @app.get("/{full_path:path}")

frontend/src/pages/Repository.jsx

@@ -26,6 +26,7 @@ import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Badge } from '@/components/ui/badge';
 import { Label } from '@/components/ui/label';
+import { Progress } from '@/components/ui/progress';
 import {
   Select,
   SelectContent,
@@ -108,6 +109,7 @@ export default function Repository() {
   const [isLoadingAssets, setIsLoadingAssets] = useState(false);
   const [previewAsset, setPreviewAsset] = useState(null);
   const [previewDialogOpen, setPreviewDialogOpen] = useState(false);
+  const [uploadProgress, setUploadProgress] = useState({});
   const fileInputRef = useRef(null);
 
   const toggleProduct = (productId) => {
@@ -212,6 +214,46 @@ export default function Repository() {
     }
   };
 
+  const pollAssetStatus = async (assetId, fileName) => {
+    const maxAttempts = 60; // Poll for up to 60 seconds
+    let attempts = 0;
+    
+    while (attempts < maxAttempts) {
+      try {
+        const response = await fetch(`/api/assets/${assetId}/status`);
+        if (response.ok) {
+          const status = await response.json();
+          setUploadProgress(prev => ({
+            ...prev,
+            [fileName]: {
+              status: status.status,
+              message: getStatusMessage(status.status)
+            }
+          }));
+          
+          if (status.status === 'completed' || status.status === 'failed') {
+            break;
+          }
+        }
+      } catch (error) {
+        console.error('Error polling status:', error);
+      }
+      
+      await new Promise(resolve => setTimeout(resolve, 1000)); // Poll every second
+      attempts++;
+    }
+  };
+
+  const getStatusMessage = (status) => {
+    switch(status) {
+      case 'pending': return 'Uploading file...';
+      case 'processing': return 'Extracting content with OCR...';
+      case 'completed': return 'Content extracted and indexed by AI agent ✓';
+      case 'failed': return 'Analysis failed';
+      default: return 'Processing...';
+    }
+  };
+
   const handleUpload = async () => {
     if (selectedFiles.length === 0) {
       alert('Please select at least one file to upload');
@@ -223,42 +265,103 @@ export default function Repository() {
     }
 
     setIsUploading(true);
+    setUploadProgress({});
+    
     try {
-      const uploadPromises = selectedFiles.map(async (file) => {
-        const formData = new FormData();
-        formData.append('file', file);
-        formData.append('product_category', uploadProductCategory);
-        if (uploadSubCategory && uploadSubCategory !== 'none') {
-          formData.append('sub_category', uploadSubCategory);
-        }
+      // Initialize progress for all files
+      const initialProgress = {};
+      selectedFiles.forEach(file => {
+        initialProgress[file.name] = {
+          status: 'pending',
+          message: 'Uploading file...'
+        };
+      });
+      setUploadProgress(initialProgress);
 
-        const response = await fetch('/api/assets/upload', {
-          method: 'POST',
-          body: formData,
-        });
+      // Upload files sequentially to show progress
+      const results = [];
+      for (const file of selectedFiles) {
+        try {
+          setUploadProgress(prev => ({
+            ...prev,
+            [file.name]: {
+              status: 'pending',
+              message: 'Uploading file...'
+            }
+          }));
 
-        if (!response.ok) {
-          const errorData = await response.json().catch(() => ({ detail: 'Upload failed' }));
-          throw new Error(errorData.detail || `Upload failed for ${file.name}`);
-        }
+          const formData = new FormData();
+          formData.append('file', file);
+          formData.append('product_category', uploadProductCategory);
+          if (uploadSubCategory && uploadSubCategory !== 'none') {
+            formData.append('sub_category', uploadSubCategory);
+          }
 
-        return await response.json();
-      });
+          const response = await fetch('/api/assets/upload', {
+            method: 'POST',
+            body: formData,
+          });
+
+          if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ detail: 'Upload failed' }));
+            throw new Error(errorData.detail || `Upload failed for ${file.name}`);
+          }
+
+          const result = await response.json();
+          results.push(result);
+
+          // Update progress - file uploaded, now analyzing
+          setUploadProgress(prev => ({
+            ...prev,
+            [file.name]: {
+              status: result.analysis_status || 'processing',
+              message: result.analysis_status === 'processing' 
+                ? 'Extracting content with OCR...' 
+                : 'Upload complete, analyzing...'
+            }
+          }));
 
-      const results = await Promise.all(uploadPromises);
+          // Start polling for analysis status if it's a document/image
+          if (result.file_type === 'document' || result.file_type === 'image') {
+            pollAssetStatus(result.id, file.name);
+          } else {
+            setUploadProgress(prev => ({
+              ...prev,
+              [file.name]: {
+                status: 'completed',
+                message: 'Upload complete ✓'
+              }
+            }));
+          }
+        } catch (error) {
+          console.error(`Upload error for ${file.name}:`, error);
+          setUploadProgress(prev => ({
+            ...prev,
+            [file.name]: {
+              status: 'failed',
+              message: `Upload failed: ${error.message}`
+            }
+          }));
+        }
+      }
+      
       console.log('Upload results:', results);
       
-      // Reset form
-      setSelectedFiles([]);
-      setUploadProductCategory('');
-      setUploadSubCategory('');
-      setUploadDialogOpen(false);
+      // Wait a bit for analysis to complete, then refresh
+      setTimeout(async () => {
+        await fetchAssets();
+      }, 2000);
       
-      // Show success message
-      alert(`Successfully uploaded ${selectedFiles.length} file(s)!`);
+      // Don't close dialog immediately - let user see the progress
+      // Reset form after a delay
+      setTimeout(() => {
+        setSelectedFiles([]);
+        setUploadProductCategory('');
+        setUploadSubCategory('');
+        setUploadProgress({});
+        setUploadDialogOpen(false);
+      }, 3000);
       
-      // Refresh assets list to show newly uploaded files
-      await fetchAssets();
     } catch (error) {
       console.error('Upload error:', error);
       alert(`Upload failed: ${error.message}`);
@@ -331,14 +434,61 @@ export default function Repository() {
                       Browse Files
                     </Button>
                     {selectedFiles.length > 0 && (
-                      <div className="mt-4 space-y-2">
+                      <div className="mt-4 space-y-3">
                         <p className="text-xs font-medium text-slate-600">Selected files:</p>
-                        {selectedFiles.map((file, index) => (
-                          <div key={index} className="flex items-center justify-between text-xs bg-slate-50 p-2 rounded">
-                            <span className="text-slate-700">{file.name}</span>
-                            <span className="text-slate-500">{(file.size / 1024 / 1024).toFixed(2)} MB</span>
-                          </div>
-                        ))}
+                        {selectedFiles.map((file, index) => {
+                          const progress = uploadProgress[file.name];
+                          const getProgressValue = () => {
+                            if (!progress) return 0;
+                            switch(progress.status) {
+                              case 'pending': return 25;
+                              case 'processing': return 60;
+                              case 'completed': return 100;
+                              case 'failed': return 0;
+                              default: return 0;
+                            }
+                          };
+                          const getProgressColor = () => {
+                            if (!progress) return 'bg-blue-500';
+                            switch(progress.status) {
+                              case 'pending': return 'bg-blue-500';
+                              case 'processing': return 'bg-yellow-500';
+                              case 'completed': return 'bg-green-500';
+                              case 'failed': return 'bg-red-500';
+                              default: return 'bg-blue-500';
+                            }
+                          };
+                          return (
+                            <div key={index} className="space-y-2">
+                              <div className="flex items-center justify-between text-xs bg-slate-50 p-2 rounded">
+                                <span className="text-slate-700 truncate flex-1 mr-2">{file.name}</span>
+                                <span className="text-slate-500 whitespace-nowrap">{(file.size / 1024 / 1024).toFixed(2)} MB</span>
+                              </div>
+                              {isUploading && (
+                                <div className="space-y-1">
+                                  <div className="flex items-center justify-between text-xs">
+                                    <span className={`font-medium ${
+                                      progress?.status === 'completed' ? 'text-green-600' :
+                                      progress?.status === 'failed' ? 'text-red-600' :
+                                      progress?.status === 'processing' ? 'text-yellow-600' :
+                                      'text-blue-600'
+                                    }`}>
+                                      {progress?.message || 'Uploading...'}
+                                    </span>
+                                    {progress?.status === 'completed' && <Check className="w-3 h-3 text-green-600" />}
+                                    {progress?.status === 'failed' && <X className="w-3 h-3 text-red-600" />}
+                                  </div>
+                                  <div className="relative h-1.5 w-full overflow-hidden rounded-full bg-slate-200">
+                                    <div 
+                                      className={`h-full transition-all ${getProgressColor()}`}
+                                      style={{ width: `${getProgressValue()}%` }}
+                                    />
+                                  </div>
+                                </div>
+                              )}
+                            </div>
+                          );
+                        })}
                       </div>
                     )}
                   </div>