Upload engine.py

engine.py

@@ -38,6 +38,25 @@ def load_metadata():
 
 
 def resolve_operator(op, value):
+    # 🔴 Normalize operator input
+    op = op.lower().strip()
+
+    OPERATOR_ALIASES = {
+        "=": "equals",
+        "==": "equals",
+        "eq": "equals",
+        "!=": "not_equals",
+        "<>": "not_equals",
+        ">": "greater_than",
+        "<": "less_than",
+        ">=": "greater_or_equal",
+        "<=": "less_or_equal",
+        "greater than": "greater_than",
+        "less than": "less_than"
+    }
+
+    op = OPERATOR_ALIASES.get(op, op)
+
     mapping = {
         "equals": "=",
         "not_equals": "!=",
@@ -57,18 +76,27 @@ def resolve_operator(op, value):
 
     sql_op = mapping[op]
 
+    # 🔴 Escape string values safely
+    def sql_escape(val):
+        return str(val).replace("'", "''")
+
     if op == "contains":
-        return sql_op, f"'%{value}%'"
+        return sql_op, f"'%{sql_escape(value)}%'"
+
     if op == "starts_with":
-        return sql_op, f"'{value}%'"
+        return sql_op, f"'{sql_escape(value)}%'"
+
     if op == "ends_with":
-        return sql_op, f"'%{value}'"
+        return sql_op, f"'%{sql_escape(value)}'"
+
     if op in ("in", "not_in"):
         if not isinstance(value, list):
             raise ValueError("IN operator requires list")
-        return sql_op, f"({','.join(map(repr, value))})"
+        escaped = [f"'{sql_escape(v)}'" for v in value]
+        return sql_op, f"({','.join(escaped)})"
+
+    return sql_op, f"'{sql_escape(value)}'"
 
-    return sql_op, f"'{value}'"
 
 
 # =========================
@@ -156,10 +184,10 @@ def safe_json_loads(text):
 # INTENT PARSING (LLM)
 # =========================
 
-def parse_intent(question):
+def parse_intent(question, retries=2):
     meta = load_metadata()
 
-    # ✅ Build schema safely (skip empty modules)
+    # ✅ Build schema safely
     schema_description = "\n".join([
         f"{module}: {', '.join(fields)}"
         for module in meta["modules"]
@@ -173,39 +201,61 @@ def parse_intent(question):
 You are a SQL query planner.
 
 You MUST only use fields listed below.
-If a field does not exist, choose the closest valid field.
+If a field does not exist, OMIT it.
 Do NOT invent column names.
 
 Available schema:
 {schema_description}
 
-Extract:
-- module
-- filters (field, operator, value)
-- selected fields
-
-Return ONLY valid JSON.
+Extract EXACTLY this JSON structure:
+{{
+  "module": "string",
+  "select": ["string"],
+  "filters": [
+    {{
+      "field": "string",
+      "operator": "equals|not_equals|greater_than|less_than|contains|in",
+      "value": "string|number|array"
+    }}
+  ]
+}}
+
+Return ONLY valid minified JSON.
+No explanation. No comments.
 
 User question:
 {question}
 """
 
-    res = client.chat.completions.create(
-    model="gpt-4.1-mini",
-    messages=[
-        {"role": "system", "content": "You are a JSON-only API. Return valid JSON only."},
-        {"role": "user", "content": prompt}
-    ],
-    temperature=0
-)
+    for attempt in range(retries):
+        try:
+            res = client.chat.completions.create(
+                model="gpt-4.1-mini",
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "Return ONLY valid minified JSON. No text. No explanation."
+                    },
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0
+            )
 
+            content = res.choices[0].message.content
+            plan = safe_json_loads(content)
 
-    # ✅ Safe JSON parsing
-    try:
-        return json.loads(res.choices[0].message.content)
-    except json.JSONDecodeError:
-        raise ValueError("LLM returned invalid JSON")
+            # ✅ NORMALIZE + STABILIZE INTENT SHAPE
+            if "module" in plan:
+                plan["module"] = plan["module"].lower().strip()
+
+            plan.setdefault("filters", [])
+            plan.setdefault("select", [])
 
+            return plan
+
+        except Exception:
+            if attempt == retries - 1:
+                raise ValueError("LLM failed to return valid JSON")
 
 # =========================
 # SQL GENERATOR
@@ -214,7 +264,9 @@ User question:
 def build_sql(plan):
     meta = load_metadata()
 
-    module = plan["module"]
+    # 🔴 Defensive: normalize module
+    module = plan["module"].lower().strip()
+
     if module not in meta["modules"]:
         raise ValueError(f"Unknown module: {module}")
 
@@ -255,12 +307,15 @@ def build_sql(plan):
             f"{table}.{column} {sql_op} {sql_value}"
         )
 
+    # 🔴 FIX: safe WHERE clause
+    where_sql = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
+
     # ---------- FINAL SQL ----------
     sql = f"""
     SELECT {select_sql}
     FROM {base_table}
     {' '.join(joins)}
-    WHERE {' AND '.join(where_clauses)}
+    {where_sql}
     LIMIT 100
     """
 
@@ -268,6 +323,7 @@ def build_sql(plan):
 
 
 
+
 # =========================
 # VALIDATION
 # =========================
@@ -290,6 +346,18 @@ def validate_sql(sql):
 
 def run(question):
     plan = parse_intent(question)
+
+    # 🔴 REQUIRED: validate minimum intent
+    if not isinstance(plan, dict):
+        raise ValueError("Invalid intent format")
+
+    if "module" not in plan:
+        raise ValueError("Unable to determine module from question")
+
+    # Optional but safe defaults
+    plan.setdefault("filters", [])
+    plan.setdefault("select", [])
+
     sql = build_sql(plan)
     sql = validate_sql(sql)