Upload 15 files

server/environment.py

@@ -623,6 +623,9 @@ def analyze_uploaded_database(conn: sqlite3.Connection, schema_info: dict[str, d
                 ratio = profile["date_ratio"]
             if not family:
                 continue
+            if family == "date" and ratio >= 0.98:
+                # Fully parseable date-like text does not need repair unless another anomaly exists.
+                continue
             score = ratio
             if family in {"numeric", "score_scale"}:
                 score += 0.15

server/graders.py

@@ -246,13 +246,20 @@ def _evaluate_fix_outcome(
             original_rows = ground_truth.get("original_row_count", total_after)
             preservation = min(1.0, total_after / max(1, original_rows))
             improvement = max(0.0, parse_ratio - baseline_ratio)
+            baseline_gap = max(0.0, 1.0 - baseline_ratio)
             desired_types = {
                 "boolean": {"BOOLEAN", "INTEGER", "NUMERIC"},
                 "date": {"DATE", "DATETIME", "TIMESTAMP", "TEXT"},
                 "numeric": {"REAL", "INTEGER", "NUMERIC", "FLOAT", "DOUBLE"},
             }
             type_fixed = current_declared in desired_types.get(issue_type, {"TEXT"}) and current_declared != original_declared
-            issue_resolved = (parse_ratio >= 0.95 and type_fixed) or improvement >= 0.20
+            near_clean = parse_ratio >= 0.98
+            meaningful_gain = improvement >= max(0.02, baseline_gap * 0.5)
+            issue_resolved = (
+                (parse_ratio >= 0.95 and type_fixed)
+                or meaningful_gain
+                or (near_clean and improvement > 0.005)
+            )
             final_preservation = min(1.0, (preservation * 0.55) + (min(1.0, parse_ratio) * 0.45))
             return issue_resolved, round(final_preservation, 4), True
         try:

server/main.py

@@ -739,6 +739,13 @@ def is_aggregate_like_column_name(column_name: str) -> bool:
     return bool(tokens and any(token in aggregate_tokens for token in tokens))
 
 
+def is_key_like_column_name(column_name: str) -> bool:
+    """Heuristic for key-like result columns where duplicate values are suspicious."""
+    tokens = [token for token in re.split(r"[^a-z0-9]+", (column_name or "").lower()) if token]
+    key_tokens = {"id", "email", "phone", "ssn", "uuid", "employee", "patient"}
+    return bool(tokens and any(token in key_tokens for token in tokens))
+
+
 def get_db_schema(conn: sqlite3.Connection) -> list[dict]:
     """Extract schema information from a SQLite connection."""
     schema = []
@@ -1700,7 +1707,7 @@ def _generate_local_insights(sql: str, rows: list, columns: list, row_count: int
     
     # Duplicate detection
     for col in columns:
-        if is_aggregate_like_column_name(col):
+        if is_aggregate_like_column_name(col) or not is_key_like_column_name(col):
             continue
         values = [str(r.get(col, '')) for r in rows if r.get(col) is not None]
         unique = set(values)

static/index.html

@@ -680,6 +680,11 @@
       const aggregateTokens = new Set(['avg', 'sum', 'count', 'total', 'min', 'max', 'rank', 'highest', 'lowest']);
       return tokens.some(token => aggregateTokens.has(token));
     }
+    function isKeyLikeColumn(col) {
+      const tokens = String(col || '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+      const keyTokens = new Set(['id', 'email', 'phone', 'ssn', 'uuid', 'employee', 'patient']);
+      return tokens.some(token => keyTokens.has(token));
+    }
 
     // ── Toast notification system ──
     let toastTimer = null;
@@ -1084,7 +1089,7 @@
 
       // Duplicate detection
       for (const col of columns) {
-        if (isAggregateLikeColumn(col)) continue;
+        if (isAggregateLikeColumn(col) || !isKeyLikeColumn(col)) continue;
         const values = rows.map(r => r[col]).filter(v => v !== null);
         const unique = new Set(values.map(String));
         if (unique.size < values.length * 0.8 && values.length > 5) {
@@ -1133,7 +1138,7 @@
       }
 
       // Check for duplicates
-      const suggestionCols = columns.filter(col => !isAggregateLikeColumn(col));
+      const suggestionCols = columns.filter(col => !isAggregateLikeColumn(col) && isKeyLikeColumn(col));
       const allValues = rows.flatMap(r => suggestionCols.map(col => r[col])).filter(v => v !== null);
       const duplicates = allValues.filter((v, i, a) => a.indexOf(v) !== i);
       if (suggestionCols.length > 0 && duplicates.length > rows.length * 0.1) {