Update main.py

main.py

@@ -3,6 +3,8 @@ from flask_cors import CORS
 import json
 from datetime import datetime
 from typing import Optional, Dict, Any
+import re
+from typing import List
 
 from firestore_client import get_firestore_client
 from gemini_client import ask_gpt
@@ -74,6 +76,265 @@ def normalize_plan(plan: dict, token_map: Optional[Dict[str, Any]] = None) -> di
 
     return {"collections": collections_out}
 
+def _norm(v):
+    return str(v or "").strip().lower()
+
+
+def _safe_number(v, default=0):
+    try:
+        n = float(v)
+        return n
+    except Exception:
+        return default
+
+
+def _clamp_pct(n):
+    try:
+        return max(0, min(100, round(float(n))))
+    except Exception:
+        return 0
+
+
+def _normalize_metric(metric: Optional[str]) -> Optional[str]:
+    m = _norm(metric)
+    if not m:
+        return None
+    if "hour" in m:
+        return "hours"
+    if "session" in m:
+        return "sessions"
+    if "document" in m:
+        return "documents"
+    if "deliverable" in m:
+        return "deliverables"
+    if "report" in m:
+        return "reports"
+    if "submission" in m:
+        return "submissions"
+    return None
+
+
+def _proof_rules_for_metric(metric_key: Optional[str]) -> List[Dict[str, Any]]:
+    if metric_key == "sessions":
+        return [
+            {
+                "type": "attendance",
+                "label": "Attendance register / session proof",
+                "reason": "Sessions usually require attendance or meeting evidence.",
+                "required": True,
+            },
+            {
+                "type": "minutes",
+                "label": "Session notes / minutes",
+                "reason": "Session outcomes should be supported by notes or minutes.",
+                "required": False,
+            },
+        ]
+    if metric_key in ["reports", "documents", "deliverables", "submissions"]:
+        return [
+            {
+                "type": "document",
+                "label": "Output file / submitted document",
+                "reason": "This metric usually requires the actual file or submission proof.",
+                "required": True,
+            }
+        ]
+    if metric_key == "hours":
+        return [
+            {
+                "type": "supporting_evidence",
+                "label": "Supporting evidence",
+                "reason": "Hours-only updates should still have some supporting evidence where possible.",
+                "required": False,
+            }
+        ]
+    return []
+
+
+def _build_intervention_analysis_prompt(payload: Dict[str, Any]) -> str:
+    return f"""
+You are analysing a consultant intervention progress update.
+
+Return STRICT JSON only with this shape:
+{{
+  "summary": "short summary",
+  "polishedNotes": "professional progress notes",
+  "activities": ["..."],
+  "outputs": ["..."],
+  "blockers": ["..."],
+  "nextSteps": ["..."],
+  "suggestedHours": 0,
+  "suggestedUnitsCompleted": 0,
+  "confidence": 0,
+  "completionSignal": "none|partial|strong",
+  "warnings": ["..."],
+  "proofHints": [
+    {{
+      "type": "attendance|minutes|document|photo|supporting_evidence|submission_receipt|other",
+      "label": "short label",
+      "reason": "why this is needed"
+    }}
+  ]
+}}
+
+Rules:
+- Use the user's notes/transcript/message as the primary source.
+- Do not invent facts not grounded in the input.
+- suggestedHours should be conservative.
+- suggestedUnitsCompleted should only be given if the described work clearly maps to a measurable unit.
+- completionSignal means:
+  - "none" = no sign of completion
+  - "partial" = meaningful progress but not clearly complete
+  - "strong" = strong signal that deliverable/work may be complete
+- warnings should mention ambiguity, weak evidence, or missing detail.
+- polishedNotes should be concise and professional.
+
+Intervention context:
+{json.dumps(payload, ensure_ascii=False)}
+""".strip()
+
+
+def _extract_json_block(text: str) -> Dict[str, Any]:
+    text = (text or "").strip()
+
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+
+    match = re.search(r"\{.*\}", text, flags=re.DOTALL)
+    if match:
+        try:
+            return json.loads(match.group(0))
+        except Exception:
+            pass
+
+    return {
+        "summary": "",
+        "polishedNotes": text,
+        "activities": [],
+        "outputs": [],
+        "blockers": [],
+        "nextSteps": [],
+        "suggestedHours": None,
+        "suggestedUnitsCompleted": None,
+        "confidence": 40,
+        "completionSignal": "none",
+        "warnings": ["AI response was not clean JSON. Parsed fallback response."],
+        "proofHints": [],
+    }
+
+
+def _merge_proof_hints(metric_rules: List[Dict[str, Any]], ai_hints: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    merged = []
+    seen = set()
+
+    for item in metric_rules + (ai_hints or []):
+        t = _norm(item.get("type"))
+        label = str(item.get("label") or "").strip()
+        key = f"{t}|{label.lower()}"
+        if not t and not label:
+            continue
+        if key in seen:
+            continue
+        seen.add(key)
+        merged.append({
+            "type": t or "other",
+            "label": label or "Supporting evidence",
+            "reason": str(item.get("reason") or "").strip(),
+            "required": bool(item.get("required", False)),
+        })
+
+    return merged
+
+
+def _calculate_progress_suggestion(intervention: Dict[str, Any], ai_result: Dict[str, Any]) -> Dict[str, Any]:
+    target_type = _norm(intervention.get("targetType"))
+    target_value = _safe_number(intervention.get("targetValue"), 0)
+    current_progress = _clamp_pct(_safe_number(intervention.get("progress"), 0))
+    current_actual = _safe_number(intervention.get("targetActual"), 0)
+    metric_key = _normalize_metric(intervention.get("targetMetric"))
+
+    suggested_hours = ai_result.get("suggestedHours")
+    try:
+        suggested_hours = float(suggested_hours) if suggested_hours is not None else None
+    except Exception:
+        suggested_hours = None
+
+    suggested_units = ai_result.get("suggestedUnitsCompleted")
+    try:
+        suggested_units = float(suggested_units) if suggested_units is not None else None
+    except Exception:
+        suggested_units = None
+
+    if target_type == "percentage":
+        # For percentage interventions, AI can only suggest a conservative bump.
+        base_bump = 0
+        signal = _norm(ai_result.get("completionSignal"))
+        if signal == "strong":
+            base_bump = 20
+        elif signal == "partial":
+            base_bump = 10
+        elif suggested_hours and suggested_hours > 0:
+            base_bump = 5
+
+        suggested_progress = _clamp_pct(current_progress + base_bump)
+
+        return {
+            "targetMode": "percentage",
+            "metricKey": metric_key,
+            "suggestedHours": suggested_hours,
+            "suggestedUnitsCompleted": None,
+            "currentActual": None,
+            "suggestedActualAfter": None,
+            "suggestedProgressPct": suggested_progress,
+            "overTargetBy": 0,
+        }
+
+    if target_type == "number" and target_value > 0:
+        units = suggested_units
+
+        if metric_key == "hours" and (units is None or units <= 0):
+            units = suggested_hours
+
+        if units is None or units <= 0:
+            return {
+                "targetMode": "number",
+                "metricKey": metric_key,
+                "suggestedHours": suggested_hours,
+                "suggestedUnitsCompleted": None,
+                "currentActual": current_actual,
+                "suggestedActualAfter": current_actual,
+                "suggestedProgressPct": current_progress,
+                "overTargetBy": 0,
+            }
+
+        actual_after = current_actual + units
+        progress_after = _clamp_pct((actual_after / target_value) * 100)
+        over_target_by = max(0, actual_after - target_value)
+
+        return {
+            "targetMode": "number",
+            "metricKey": metric_key,
+            "suggestedHours": suggested_hours,
+            "suggestedUnitsCompleted": units,
+            "currentActual": current_actual,
+            "suggestedActualAfter": actual_after,
+            "suggestedProgressPct": progress_after,
+            "overTargetBy": over_target_by,
+        }
+
+    return {
+        "targetMode": "none",
+        "metricKey": metric_key,
+        "suggestedHours": suggested_hours,
+        "suggestedUnitsCompleted": suggested_units,
+        "currentActual": None,
+        "suggestedActualAfter": None,
+        "suggestedProgressPct": current_progress,
+        "overTargetBy": 0,
+    }
+
 # -- route ---------------------------------------------------------------
 
 @app.route('/chat', methods=['POST'])
@@ -277,6 +538,142 @@ def assist():
             }
         })
 
+@app.route('/analyze-intervention-update', methods=['POST'])
+def analyze_intervention_update():
+    """
+    AI-assisted intervention update analysis.
+
+    Request JSON:
+    {
+      "role": "consultant",
+      "companyCode": "ABC",
+      "userId": "uid123",
+      "captureMode": "message|notes|audio",
+      "rawInput": "what the user typed or transcript",
+      "intervention": {
+        "id": "...",
+        "interventionTitle": "...",
+        "subtitle": "...",
+        "beneficiaryName": "...",
+        "status": "assigned|in-progress|completed",
+        "targetType": "percentage|number",
+        "targetMetric": "sessions|hours|reports|...",
+        "targetValue": 10,
+        "targetActual": 2,
+        "progress": 20,
+        "dueDate": "...",
+        "notes": "..."
+      },
+      "history": [
+        {
+          "notes": "...",
+          "progressAfter": 20,
+          "targetActualAfter": 2,
+          "createdAt": "..."
+        }
+      ]
+    }
+    """
+    data = request.json or {}
+
+    role = data.get('role')
+    company_code = data.get('companyCode')
+    user_id = data.get('userId')
+    capture_mode = data.get('captureMode')
+    raw_input = (data.get('rawInput') or '').strip()
+    intervention = data.get('intervention') or {}
+    history = data.get('history') or []
+
+    if not role or not company_code or not user_id or not capture_mode or not raw_input:
+        return jsonify({
+            "error": "Missing role, companyCode, userId, captureMode, or rawInput"
+        }), 400
+
+    if capture_mode not in ['message', 'notes', 'audio']:
+        return jsonify({"error": "Invalid captureMode"}), 400
+
+    metric_key = _normalize_metric(intervention.get("targetMetric"))
+    metric_rules = _proof_rules_for_metric(metric_key)
+
+    prompt_payload = {
+        "captureMode": capture_mode,
+        "rawInput": raw_input,
+        "role": role,
+        "intervention": {
+            "id": intervention.get("id"),
+            "interventionTitle": intervention.get("interventionTitle"),
+            "subtitle": intervention.get("subtitle"),
+            "beneficiaryName": intervention.get("beneficiaryName"),
+            "status": intervention.get("status"),
+            "targetType": intervention.get("targetType"),
+            "targetMetric": intervention.get("targetMetric"),
+            "targetValue": intervention.get("targetValue"),
+            "targetActual": intervention.get("targetActual"),
+            "progress": intervention.get("progress"),
+            "dueDate": to_jsonable(intervention.get("dueDate")),
+            "notes": intervention.get("notes"),
+        },
+        "history": history[:10],
+        "rules": {
+            "metricKey": metric_key,
+            "proofRules": metric_rules,
+            "instruction": (
+                "Infer what work was likely done from the raw input, "
+                "but do not freely calculate final progress. "
+                "Only suggest hours and measurable units if grounded in the text."
+            )
+        }
+    }
+
+    try:
+        system_msg = {
+            "role": "system",
+            "content": (
+                "You are an assistant that analyses intervention update notes for a business workflow. "
+                "You must return strict JSON only."
+            )
+        }
+        user_msg = {
+            "role": "user",
+            "content": _build_intervention_analysis_prompt(prompt_payload)
+        }
+
+        ai_raw = ask_gpt([system_msg, user_msg])
+        ai_result = _extract_json_block(ai_raw)
+
+        progress_calc = _calculate_progress_suggestion(intervention, ai_result)
+        merged_proof = _merge_proof_hints(metric_rules, ai_result.get("proofHints", []))
+
+        completion_signal = _norm(ai_result.get("completionSignal"))
+        readiness = "not_ready"
+        if completion_signal == "strong":
+            readiness = "close"
+        elif progress_calc.get("suggestedProgressPct", 0) >= 100:
+            readiness = "ready"
+
+        response = {
+            "summary": ai_result.get("summary", ""),
+            "polishedNotes": ai_result.get("polishedNotes", ""),
+            "activities": ai_result.get("activities", []),
+            "outputs": ai_result.get("outputs", []),
+            "blockers": ai_result.get("blockers", []),
+            "nextSteps": ai_result.get("nextSteps", []),
+            "warnings": ai_result.get("warnings", []),
+            "confidence": ai_result.get("confidence", 0),
+            "completionSignal": completion_signal or "none",
+            "completionReadiness": readiness,
+            "proofSuggestions": merged_proof,
+            "calculation": progress_calc,
+            "rawInput": raw_input,
+        }
+
+        return jsonify(to_jsonable(response))
+    except Exception as e:
+        print("analyze_intervention_update_failed:", e)
+        return jsonify({
+            "error": "Failed to analyse intervention update"
+        }), 500
+
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)