Update main.py

main.py

@@ -457,18 +457,28 @@ class WhatsAppZipProcessor:
 # WHATSAPP EXTRACTION PROMPT
 # ══════════════════════════════════════════════════════════════════════════════
 
-WHATSAPP_EXTRACTION_PROMPT = """You are a support knowledge base curator for the Iris field staff management app used in Zimbabwe.
+WHATSAPP_EXTRACTION_PROMPT = """You are a support knowledge base curator for the Iris platform, deployed across Zimbabwe.
 
 Your task: analyse this WhatsApp support group chat segment and extract ONLY clear problem→solution pairs.
 
-CONTEXT ABOUT THIS APP:
-- "Iris" is a POS system and it also includes fiscalisation, mobile attendance/location tracking at retail stores.
-- Common issues: GPS location not detected, clock-in failures, app killed by Android battery optimiser,
-  teller passkey problems, hours not recording correctly, store radius too small, wrong teller name shown.
-- Messages mix English, Shona, and Ndebele. Understand regional vernacular (e.g. "irikudzima" = switching off,
-  "ndakashanda" = I worked, "short yemahours" = hours shortage, "gadzirisayi" = fix it through).
-- If screenshots show Android error dialogs (e.g. "Service killed by system", "App stopped"), reason through
-  what that means for Android background restriction and include it in the solution.
+CONTEXT ABOUT THIS PLATFORM:
+- "Iris" is an integrated POS (Point of Sale) and fiscalisation system with a mobile attendance and
+  location-tracking module used by field sales reps and in-store tellers at retail stores.
+- The POS and fiscalisation layer handles sales transactions, receipt generation, and ZIMRA fiscal
+  compliance. The mobile module handles teller clock-in/out, GPS location verification, and hours tracking.
+- Common POS/fiscal issues: fiscalisation failures, receipt errors, device not syncing to ZIMRA servers,
+  Elixir (fiscal device software) login/password problems.
+- Common mobile attendance issues: GPS location not detected, clock-in failures, app killed by Android
+  battery optimiser, teller passkey problems, hours recording incorrectly, store radius too small,
+  wrong teller name shown after login, app not running in the background.
+- Messages mix English, Shona, and Ndebele. Understand regional vernacular (e.g. "irikudzima" = switching
+  off, "ndakashanda" = I worked, "short yemahours" = hours shortage, "gadzirisayi" = fix it, "hupfu" = flour,
+  "yakuda kulogwa patsva" = needs to be logged in fresh).
+- If screenshots show Android error dialogs (e.g. "Service killed by system", "App stopped", "Abrupt stop"),
+  reason through what that means for Android background restriction and background service killing, and include
+  that diagnosis and fix in the solution content.
+- If screenshots show fiscal device or POS screens, extract the error code or state shown and reason through
+  the likely cause from the Elixir/ZIMRA integration context.
 
 STRICT RULES:
 1. Extract ONLY exchanges where a user described a problem AND a named support person (Tendayi, Tony, Violet,
@@ -822,57 +832,208 @@ def submit_ticket_voice():
 # FEATURE 4 — System Tutorial Ingestion
 # ══════════════════════════════════════════════════════════════════════════════
 
-TUTORIAL_EXTRACTION_PROMPT = """You are a knowledge base curator for a software support system.
+TUTORIAL_VIDEO_PROMPT = """You are a knowledge base curator watching a tutorial video about the Iris platform.
 
-You have a timestamped transcript from a tutorial video about the Iris Support Portal.
-Extract one KB article per distinct feature or task demonstrated.
+CONTEXT ABOUT IRIS:
+- Iris is an integrated POS (Point of Sale) and fiscalisation system with a mobile attendance and
+  location-tracking module used by tellers and field reps at retail stores in Zimbabwe.
+- The POS/fiscal layer handles sales, receipts, and ZIMRA fiscal compliance (Elixir device).
+- The mobile module handles teller clock-in/out, GPS location, store radius, and hours tracking.
+- The Iris Support Portal is a customer support desk used by admin staff, agents, and support tiers
+  to manage tickets, agents, customers, and the knowledge base.
 
-Return ONLY a valid JSON array — no preamble, no markdown fences.
-All strings must be properly JSON-escaped.
+YOUR TASK:
+Watch this tutorial video in full. For every distinct feature, workflow, or task you observe being
+demonstrated, extract one self-contained KB article. Identify the exact timestamp range in the video
+where each demonstration occurs so users can jump directly to the relevant moment.
 
-Schema per item:
-{"title": "string", "content": "string (step-by-step instructions)", "category": "one of: Account|Tickets|Agents|Reports|Admin|Other", "tags": ["string"], "timestamp_start": <integer seconds>, "timestamp_end": <integer seconds>}
+Be precise about timestamps — state the second at which the demonstration starts and ends.
+Write step-by-step instructions based on what you see happening on screen, not generic descriptions.
+If the presenter speaks, incorporate their narration into the steps.
+
+Return ONLY a valid JSON array. No preamble, no markdown fences. All strings properly JSON-escaped.
+Use \n for line breaks within content strings.
 
-Transcript:
+Schema per item:
+{
+  "title": "string — concise how-to title, max 80 chars",
+  "content": "string — numbered step-by-step instructions based on what is shown",
+  "category": "one of: Account|Tickets|Agents|Reports|Admin|POS|Attendance|Other",
+  "tags": ["string"],
+  "timestamp_start": <integer — seconds from video start where this demo begins>,
+  "timestamp_end": <integer — seconds from video start where this demo ends>
+}
+
+If the video contains no discernible how-to demonstrations, return an empty array: []
 """
 
-def _parse_timestamp_to_seconds(ts: str) -> int:
-    parts = str(ts).strip("[]").split(":")
+
+def _upload_video_to_gemini(video_bytes: bytes, mime_type: str, display_name: str) -> Optional[Any]:
+    """
+    Upload a video to the Gemini Files API and poll until processing is ACTIVE.
+    Returns the uploaded file object (with .uri and .name) or None on failure.
+
+    Gemini Files API processes video at 1 FPS, adding timestamps every second.
+    Files are retained for 48 hours. We delete after use to be tidy.
+    """
+    if not _gemini_client:
+        return None
+
     try:
-        if len(parts) == 2:
-            return int(parts[0]) * 60 + int(parts[1])
-        elif len(parts) == 3:
-            return int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2])
-    except Exception:
-        pass
-    return 0
+        # Write bytes to a named temp file — Files API needs a file path or IO object
+        with tempfile.NamedTemporaryFile(suffix=f".{mime_type.split('/')[-1]}", delete=False) as tmp:
+            tmp.write(video_bytes)
+            tmp_path = tmp.name
+
+        logger.info("Uploading video to Gemini Files API: %s (%d bytes)", display_name, len(video_bytes))
+        uploaded = _gemini_client.files.upload(
+            file=tmp_path,
+            config={"mime_type": mime_type, "display_name": display_name}
+        )
+        os.unlink(tmp_path)
+        logger.info("Upload complete. File name: %s — polling for ACTIVE state...", uploaded.name)
+
+    except Exception as e:
+        logger.error("Gemini Files API upload error: %s", e)
+        return None
+
+    # Poll until state is ACTIVE (video processing complete) — max ~3 minutes
+    for attempt in range(36):
+        time.sleep(5)
+        try:
+            file_info = _gemini_client.files.get(name=uploaded.name)
+            state = getattr(file_info, "state", None)
+            state_str = str(state).upper() if state else ""
+            logger.info("Poll %d: file state = %s", attempt + 1, state_str)
+            if "ACTIVE" in state_str:
+                logger.info("Video ACTIVE after %d polls (~%ds)", attempt + 1, (attempt + 1) * 5)
+                return file_info
+            elif "FAILED" in state_str:
+                logger.error("Gemini Files API processing failed for %s", uploaded.name)
+                return None
+        except Exception as e:
+            logger.warning("Poll error: %s", e)
+
+    logger.error("Video did not reach ACTIVE state within timeout")
+    return None
+
+
+def _delete_gemini_file(file_obj: Any) -> None:
+    """Best-effort cleanup of a file from the Gemini Files API."""
+    try:
+        _gemini_client.files.delete(name=file_obj.name)
+        logger.info("Deleted Gemini file: %s", file_obj.name)
+    except Exception as e:
+        logger.warning("Could not delete Gemini file %s: %s", file_obj.name, e)
+
+
+# Supported video MIME types for tutorial upload
+SUPPORTED_VIDEO_MIMES = {
+    ".mp4":  "video/mp4",
+    ".mov":  "video/quicktime",
+    ".avi":  "video/x-msvideo",
+    ".webm": "video/webm",
+    ".mkv":  "video/x-matroska",
+    ".3gp":  "video/3gpp",
+    ".flv":  "video/x-flv",
+}
+
 
 @app.post("/api/kb/tutorial-ingest")
 def tutorial_ingest():
-    body        = request.get_json(silent=True) or {}
-    transcript  = body.get("transcript", "").strip()
-    video_url   = body.get("video_url", "")
-    video_title = body.get("video_title", "Tutorial")
-    if not transcript:
-        return jsonify({"ok": False, "error": "transcript is required"}), 400
-    raw      = _gemini_text(TUTORIAL_EXTRACTION_PROMPT + transcript[:50000], json_mode=True)
+    """
+    Accepts a tutorial video file upload (multipart, field name "file").
+    Gemini watches the full video, self-generates timestamps, and extracts
+    one KB article per distinct feature or task demonstrated.
+
+    No transcript required — Gemini reasons directly from video + audio.
+
+    Supported: mp4, mov, avi, webm, mkv, 3gp, flv
+    Max practical size: ~500MB (Files API limit is 2GB, but HF Space upload limit applies)
+
+    Returns articles with timestamp_start/end in seconds so the frontend
+    can generate deep-links into the video.
+    """
+    if "file" not in request.files:
+        return jsonify({"ok": False, "error": "No file uploaded. Use multipart field name 'file'."}), 400
+
+    f           = request.files["file"]
+    filename    = f.filename or "tutorial"
+    ext         = os.path.splitext(filename.lower())[1]
+    video_title = request.form.get("video_title", filename)
+    video_url   = request.form.get("video_url", "")
+
+    mime_type = SUPPORTED_VIDEO_MIMES.get(ext)
+    if not mime_type:
+        return jsonify({
+            "ok": False,
+            "error": f"Unsupported video format '{ext}'. Supported: {', '.join(SUPPORTED_VIDEO_MIMES)}"
+        }), 400
+
+    if not _gemini_client:
+        return jsonify({"ok": False, "error": "Gemini client not initialised — check GOOGLE_API_KEY"}), 500
+
+    video_bytes = f.read()
+    logger.info("Tutorial ingest: '%s', %d bytes, mime=%s", video_title, len(video_bytes), mime_type)
+
+    # Upload to Gemini Files API and wait for processing
+    gemini_file = _upload_video_to_gemini(video_bytes, mime_type, display_name=video_title)
+    if not gemini_file:
+        return jsonify({"ok": False, "error": "Video upload or processing by Gemini failed. Try a smaller file or check the format."}), 500
+
+    # Ask Gemini to watch and extract articles with self-generated timestamps
+    try:
+        logger.info("Sending video to Gemini for tutorial extraction...")
+        resp = _gemini_client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=[gemini_file, TUTORIAL_VIDEO_PROMPT],
+            config=genai_types.GenerateContentConfig(
+                response_mime_type="application/json"
+            )
+        )
+        raw = resp.text or ""
+    except Exception as e:
+        logger.error("Gemini video analysis error: %s", e)
+        _delete_gemini_file(gemini_file)
+        return jsonify({"ok": False, "error": f"Gemini analysis failed: {e}"}), 500
+    finally:
+        # Always attempt cleanup — files expire in 48h anyway but clean up early
+        _delete_gemini_file(gemini_file)
+
     parsed   = _safe_json(raw, [])
     articles = _validate_articles(parsed) if isinstance(parsed, list) else []
+
     if not articles:
-        return jsonify({"ok": False, "error": "Gemini returned no valid articles from transcript"}), 500
+        return jsonify({
+            "ok":    False,
+            "error": "Gemini could not extract any how-to articles from this video. "
+                     "Ensure the video contains on-screen demonstrations of Iris features."
+        }), 500
+
+    # Attach video metadata and normalise timestamp types
     for a in articles:
         a["video_url"]   = video_url
         a["video_title"] = video_title
         for ts_key in ("timestamp_start", "timestamp_end"):
             val = a.get(ts_key)
-            if isinstance(val, str):
-                a[ts_key] = _parse_timestamp_to_seconds(val)
-            elif not isinstance(val, int):
-                a[ts_key] = 0
+            if not isinstance(val, int):
+                try:
+                    a[ts_key] = int(val) if val is not None else 0
+                except (TypeError, ValueError):
+                    a[ts_key] = 0
+
     stats = _save_kb_articles(articles, source_label=f"tutorial:{video_title}")
-    return jsonify({"ok": True, "video_title": video_title, "articles_found": len(articles),
-                    "articles": articles,  # full list — frontend INSERTs to Supabase kb_articles
-                    "saved": stats["saved"], "skipped_dupes": stats["skipped"]})
+    logger.info("Tutorial ingest complete: %d articles, saved=%d, skipped=%d",
+                len(articles), stats["saved"], stats["skipped"])
+
+    return jsonify({
+        "ok":             True,
+        "video_title":    video_title,
+        "articles_found": len(articles),
+        "articles":       articles,   # full list — frontend INSERTs to Supabase kb_articles
+        "saved":          stats["saved"],
+        "skipped_dupes":  stats["skipped"],
+    })
 
 
 # ══════════════════════════════════════════════════════════════════════════════