Update main.py

main.py

@@ -88,14 +88,44 @@ OPENALEX_MAILTO = os.environ.get("OPENALEX_MAILTO", "rairo@sozofix.tech")
 # 2. HELPER FUNCTIONS & AUTHENTICATION
 # -----------------------------------------------------------------------------
 
+# -----------------------------------------------------------------------------
+# ODYSSEUS V10 CONSTANTS & LINTING
+# -----------------------------------------------------------------------------
+FORBIDDEN_CODE_PATTERNS = [
+    r"\bfetch\s*\(", r"\bXMLHttpRequest\b", r"\bWebSocket\b", r"\blocalStorage\b",
+    r"\bsessionStorage\b", r"\bdocument\.cookie\b", r"\bwindow\.location\b",
+    r"\beval\s*\(", r"\bnew\s+Function\s*\(", r"\bimport\s*\(", r"\brequire\s*\("
+]
+
+REQUIRED_CODE_PATTERNS = [r"\bexport\s+default\s+Instrument\b"]
+ALLOWED_INTERACTIONS = {"drag", "dial", "toggle", "tap", "hold", "keys"}
+ALLOWED_WIN_TYPES = {"zone_dwell", "threshold", "sequence", "match"}
+
 def _strip_json_fences(s: str) -> str:
-    """Removes markdown code fences and cleans up AI string responses."""
     s = (s or "").strip()
     if "```" in s:
         m = re.search(r"```(?:json)?\s*(.*?)\s*```", s, re.DOTALL)
         if m: return m.group(1).strip()
     return s
 
+def validate_manifest(m: dict) -> (bool, str):
+    if not isinstance(m, dict): return False, "Manifest is not an object"
+    for k in ("engine", "interaction", "win_rule"):
+        if k not in m: return False, f"Manifest missing '{k}'"
+    return True, "ok"
+
+def lint_component_code(code: str) -> (bool, list):
+    errors = []
+    if not isinstance(code, str) or len(code.strip()) < 50:
+        return False, ["component_code missing/too short"]
+    for pat in FORBIDDEN_CODE_PATTERNS:
+        if re.search(pat, code): errors.append(f"forbidden_pattern")
+    for pat in REQUIRED_CODE_PATTERNS:
+        if not re.search(pat, code): errors.append(f"missing_export_default_Instrument")
+    if "onAction" not in code: errors.append("missing_call:onAction")
+    if "onWin" not in code: errors.append("missing_call:onWin")
+    return len(errors) == 0, errors
+
 def verify_token(auth_header):
     """Verifies Firebase ID token from the Authorization header."""
     if not auth_header or not auth_header.startswith('Bearer '):
@@ -453,84 +483,108 @@ def validate_odysseus_v6(t: dict) -> (bool, str):
 @app.route('/api/trial/generate', methods=['POST'])
 def generate_trial():
     """
-    Odysseus v10: The Socratic Instrument.
-    Architects a bespoke, interactive React Component based on the 'Essential Verb'.
+    Odysseus v10: The Self-Repairing Instrumentalist.
+    Generates bespoke Vanilla React components with a 3-pass repair loop.
     Cost: 1 Spark.
     """
-    logger.info(">>> ODYSSEUS V10: ARCHITECTING SOCRATIC INSTRUMENT")
+    logger.info(">>> ODYSSEUS V10: GENERATING TRIAL")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({"error": "Unauthorized"}), 401
-    
-    payload = request.get_json()
+
+    payload = request.get_json(silent=True) or {}
     ep_id, layer_key, subject = payload.get("epiphanyId"), payload.get("layerKey"), payload.get("subject")
 
+    if not all([ep_id, layer_key, subject]):
+        return jsonify({"error": "Missing context parameters."}), 400
+
+    # 1. Cache Check
     trial_path = f"epiphanies/{ep_id}/trials/{layer_key}"
     existing = db_ref.child(trial_path).get()
     if existing: return jsonify(existing), 200
 
+    # 2. Concurrency Lock
     lock_ref = db_ref.child(f"epiphanies/{ep_id}/trialLocks/{layer_key}")
-    if lock_ref.get(): return jsonify({"error": "Forging Instrument..."}), 409
+    if lock_ref.get(): return jsonify({"status": "locked"}), 409
     lock_ref.set({"uid": uid, "at": datetime.utcnow().isoformat()})
 
+    # 3. Context Retrieval
+    layer_obj = db_ref.child(f"epiphanies/{ep_id}/layers/{layer_key}").get() or {}
+    ctx_text = layer_obj.get("text", "General scientific principles.")
+
+    # 4. Forge & Repair Loop
+    attempts, forged, last_raw = 0, None, ""
+    
+    base_prompt = f"""
+    You are Athena's Master Instrumentalist. Forge a tactile scientific Instrument for {subject}.
+    Layer Context: {ctx_text}
+
+    TASK: Write a React component named 'Instrument'. 
+    REQUIREMENTS:
+    1. Vanilla React ONLY. No external libraries (No Matter.js). Use SVG/Canvas for visuals.
+    2. Tactile: The system must fail/decay if user does nothing.
+    3. Handshake: Must accept and call `props.onAction()` (on touch) and `props.onWin()` (on success).
+    4. Design: Midnight Navy #0B1120, Gold #D4AF37. 
+
+    JSON SCHEMA:
+    {{
+      "engine": "odysseus_v10",
+      "instrument_name": "Title",
+      "mission_brief": "Goal",
+      "instrument_manifest": {{ "engine": "odysseus_v10", "interaction": "drag|tap|hold", "win_rule": {{ "type": "zone_dwell" }} }},
+      "component_code": "const Instrument = (props) => {{ ... }}; export default Instrument;",
+      "feynman_truth": "The law proven."
+    }}
+    """
+
     try:
-        layer_data = db_ref.child(f"epiphanies/{ep_id}/layers/{layer_key}").get() or {}
-        context = layer_data.get('text', '')
-
-        trial_prompt = f"""
-You are 'Athena's Master Instrumentalist'. 
-Subject: {subject}. Layer: {layer_key}. Context: {context}
-
-TASK: Forge a bespoke, interactive React component named 'Instrument'.
-This is a TACTILE EXPERIMENT that communicates with the Odysseus Workbench.
-
-MANDATORY PROPS INTERFACE:
-- The component receives: `{{ onAction, onWin }}`.
-- `onAction()`: You MUST call this the instant the user interacts (clicks/drags/keys).
-- `onWin()`: You MUST call this when the seeker achieves the scientific goal.
-
-RULES FOR THE CODE:
-1. DESIGN: Create a high-contrast lab environment (Dark #0B1120, Gold #D4AF37).
-2. PHYSICS: Use Matter.js for weight and tension. 
-3. INTERACTION: Design a specific interaction (e.g. 'Stitching the DNA', 'Managing the Fuel flow').
-4. ENTROPY: The system must have a decay factor. If the user doesn't call `onAction()`, show visual failure.
-5. NO WRAPPERS: Return only the component code. Use React hooks.
-
-JSON SCHEMA:
-{{
-    "engine": "odysseus_v10",
-    "instrument_name": "Unique Title",
-    "mission_brief": "Feynman-style objective.",
-    "component_code": "const Instrument = ({{ onAction, onWin }}) => {{ ... }}; export default Instrument;",
-    "feynman_truth": "The law proven by this instrument."
-}}
-"""
+        while attempts < 3 and not forged:
+            attempts += 1
+            current_prompt = base_prompt if attempts == 1 else f"REPAIR THIS CODE: {last_raw}\nERRORS: {last_errs}"
+            
+            res = client.models.generate_content(
+                model=ATHENA_FLASH,
+                contents=current_prompt,
+                config=types.GenerateContentConfig(response_mime_type="application/json")
+            )
+            
+            last_raw = _strip_json_fences(res.text)
+            candidate = json.loads(last_raw)
+            
+            # Validation logic
+            ok_m, _ = validate_manifest(candidate.get("instrument_manifest"))
+            ok_c, last_errs = lint_component_code(candidate.get("component_code"))
+            
+            if ok_m and ok_c:
+                forged = candidate
+                break
 
-        res = client.models.generate_content(
-            model=ATHENA_FLASH,
-            contents=trial_prompt,
-            config=types.GenerateContentConfig(response_mime_type="application/json")
-        )
-        
-        trial_data = json.loads(_strip_json_fences(res.text))
-        
+        if not forged:
+            lock_ref.delete()
+            return jsonify({"status": "failed", "reason": "Compilation failure"}), 422
+
+        # 5. Atomic Credit Deduction (1 Spark)
         user_ref = db_ref.child(f'users/{uid}')
-        credits = (user_ref.get() or {}).get('credits', 0)
-        if credits < 1:
+        def credits_txn(cur):
+            cur = cur or 0
+            return cur - 1 if cur >= 1 else cur
+        
+        result = user_ref.child('credits').transaction(credits_txn)
+        if result < 0:
             lock_ref.delete()
             return jsonify({"error": "Insufficient Sparks"}), 402
-        
-        trial_data["createdAt"] = datetime.utcnow().isoformat()
-        db_ref.child(trial_path).set(trial_data)
-        user_ref.update({'credits': credits - 1})
-        
+
+        # 6. Finalize
+        forged["createdAt"] = datetime.utcnow().isoformat()
+        db_ref.child(trial_path).set(forged)
         lock_ref.delete()
-        logger.info(f"Odysseus v10: Instrument forged for {subject}")
-        return jsonify(trial_data), 201
+        
+        logger.info(f"Odysseus v10 forged for {subject} in {attempts} attempts.")
+        return jsonify(forged), 201
 
     except Exception as e:
         lock_ref.delete()
-        logger.error(f"v10 Forging Error: {e}")
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Forging Global Error: {e}")
+        return jsonify({"error": "The laws of physics failed to compile."}), 500
 
 # -----------------------------------------------------------------------------
 # 5. THE CHIRON MENTOR & SYSTEM UTILS