@pmaddire/gcie 0.1.13 → 0.1.15

package/cli/commands/context.py

@@ -422,7 +422,16 @@ def _mentioned_file_paths(file_text: dict[str, str], query: str) -> list[tuple[f
     matches.sort(key=lambda item: (-item[0], item[1]))
     return matches
 
-
+def _target_matched(target: str, files: list[str]) -> bool:
+    target_norm = target.replace("\\", "/").lower()
+    target_name = Path(target_norm).name
+    return any(
+        file_path.lower() == target_norm
+        or Path(file_path.lower()).name == target_name
+        for file_path in files
+    )
+
+
 def _layer_bucket(path: str | None) -> str:
     if not path:
         return "unknown"
@@ -2032,6 +2041,129 @@ def _context_fallback_reason(
     return None
 
 
+
+def _context_retrieval_diagnostics(
+    payload,
+    query: str,
+    intent: str | None,
+    file_text: dict[str, str],
+    attached: dict[str, dict[str, object]],
+    *,
+    budget: int | None = None,
+) -> dict[str, object]:
+    """Summarize retrieval coverage and confidence for fallback gating."""
+    selected_paths = _selected_file_paths(payload.snippets)
+    code_paths = [path for path in selected_paths if _classify_path(path) == "code"]
+    families = {_candidate_family(path) for path in code_paths}
+    selected_scores = sorted((float(snippet.score) for snippet in payload.snippets), reverse=True)
+    score_top = selected_scores[0] if selected_scores else 0.0
+    score_second = selected_scores[1] if len(selected_scores) > 1 else 0.0
+    score_gap = max(0.0, score_top - score_second)
+    score_ratio = score_top / max(score_second, 0.15) if selected_scores else 0.0
+
+    explicit_targets = [path for _, path in _mentioned_file_paths(file_text, query)]
+    explicit_hits = sum(1 for target in explicit_targets if _target_matched(target, selected_paths))
+    explicit_missing = max(0, len(explicit_targets) - explicit_hits)
+    referenced_missing = _referenced_companion_paths(code_paths, file_text, set(selected_paths))
+
+    strong_files = 0
+    for snippet in payload.snippets:
+        meta = attached.get(snippet.node_id, {})
+        channels = meta.get("channels", []) if isinstance(meta, dict) else []
+        if len(channels) >= 2 and (_node_file_path(snippet.node_id) or "") in code_paths:
+            strong_files += 1
+
+    selected_count = len(selected_paths)
+    code_count = len(code_paths)
+    coverage_ratio = (code_count / selected_count) if selected_count else 0.0
+    explicit_coverage_ratio = (explicit_hits / len(explicit_targets)) if explicit_targets else 1.0
+    family_diversity = len(families)
+
+    confidence = 0.0
+    if selected_count:
+        confidence += 0.18
+    confidence += min(0.22, coverage_ratio * 0.22)
+    confidence += min(0.18, explicit_coverage_ratio * 0.18)
+    confidence += min(0.12, 0.04 * min(code_count, 3))
+    confidence += min(0.08, 0.04 * min(strong_files, 2))
+    confidence += min(0.08, 0.04 * min(family_diversity, 2))
+    confidence += min(0.10, score_top * 0.10)
+    confidence += min(0.06, score_gap * 0.35)
+
+    reason = _context_fallback_reason(payload, query, intent, file_text, attached)
+    if reason == "support_family_missing":
+        confidence -= 0.28
+    elif reason == "insufficient_context_coverage":
+        confidence -= 0.22
+    elif reason == "low_context_confidence":
+        confidence -= 0.16
+    if explicit_missing:
+        confidence -= min(0.18, 0.09 * explicit_missing)
+    if referenced_missing:
+        confidence -= min(0.18, 0.08 * len(referenced_missing))
+    if _is_system_query(query) and (code_count < 2 or family_diversity < 2):
+        confidence -= 0.12
+    if _support_promotion_enabled(query, intent) and strong_files < 2:
+        confidence -= 0.10
+    if budget is not None and int(payload.total_tokens_estimate) > budget:
+        confidence -= 0.05
+
+    confidence = max(0.0, min(1.0, confidence))
+    if confidence >= 0.75:
+        confidence_band = "high"
+    elif confidence >= 0.55:
+        confidence_band = "guarded"
+    else:
+        confidence_band = "low"
+
+    return {
+        "confidence": round(confidence, 3),
+        "confidence_band": confidence_band,
+        "selected_count": selected_count,
+        "code_count": code_count,
+        "family_count": family_diversity,
+        "strong_file_count": strong_files,
+        "coverage_ratio": round(coverage_ratio, 3),
+        "explicit_target_count": len(explicit_targets),
+        "explicit_target_hits": explicit_hits,
+        "explicit_target_misses": explicit_missing,
+        "explicit_coverage_ratio": round(explicit_coverage_ratio, 3),
+        "referenced_missing_count": len(referenced_missing),
+        "score_top": round(score_top, 3),
+        "score_second": round(score_second, 3),
+        "score_gap": round(score_gap, 3),
+        "score_ratio": round(score_ratio, 3),
+        "fallback_reason": reason,
+    }
+
+
+def _confidence_gate_threshold(strict_accuracy: bool) -> float:
+    return 0.72 if strict_accuracy else 0.58
+
+
+def _confidence_gate_triggers(diagnostics: dict[str, object], *, strict_accuracy: bool) -> bool:
+    confidence = float(diagnostics.get("confidence", 0.0) or 0.0)
+    if diagnostics.get("fallback_reason"):
+        return True
+    if confidence < 0.35:
+        return True
+    return confidence < _confidence_gate_threshold(strict_accuracy)
+
+
+def _accuracy_fallback_stage(
+    diagnostics: dict[str, object],
+    *,
+    search_used: bool,
+    strict_accuracy: bool,
+) -> str:
+    if not search_used:
+        return "none"
+    if strict_accuracy and float(diagnostics.get("confidence", 0.0) or 0.0) < 0.72:
+        return "search_fallback_strict"
+    if diagnostics.get("fallback_reason"):
+        return "search_fallback"
+    return "confidence_gate"
+
 def _normal_search_fallback_snippets(
     file_text: dict[str, str],
     query: str,
@@ -2085,13 +2217,22 @@ def _apply_normal_search_fallback(
     intent: str | None,
     payload,
     attached: dict[str, dict[str, object]],
+    *,
+    limit: int = 4,
 ) -> tuple[list[RankedSnippet], dict[str, dict[str, object]], set[str], str | None, bool]:
     reason = _context_fallback_reason(payload, query, intent, file_text, attached)
     if not reason:
         return ranked, attached, set(), None, False
 
     existing_ids = {item.node_id for item in ranked}
-    fallback_candidates = _normal_search_fallback_snippets(file_text, query, intent, payload.snippets, existing_ids)
+    fallback_candidates = _normal_search_fallback_snippets(
+        file_text,
+        query,
+        intent,
+        payload.snippets,
+        existing_ids,
+        limit=limit,
+    )
     if not fallback_candidates:
         return ranked, attached, set(), reason, True
 
@@ -2540,7 +2681,7 @@ def run_context_basic(path: str, query: str, budget: int | None, intent: str | N
     }
 
 
-def run_context(path: str, query: str, budget: int | None, intent: str | None, top_k: int = 40) -> dict:
+def run_context(path: str, query: str, budget: int | None, intent: str | None, top_k: int = 40, *, strict_accuracy: bool = False) -> dict:
     target = Path(path)
 
     if target.is_dir():
@@ -2699,148 +2840,208 @@ def run_context(path: str, query: str, budget: int | None, intent: str | None, t
         mandatory_node_ids=mandatory_node_ids,
     )
 
-    payload = build_context(
-        query,
-        packed_ranked,
-        token_budget=budget,
-        intent=intent,
-        mandatory_node_ids=mandatory_node_ids,
-    )
-
-    ranked, attached, fallback_priority_ids, fallback_reason, fallback_search_used = _apply_normal_search_fallback(
-        ranked,
-        file_text,
-        query,
-        intent,
-        payload,
-        attached,
-    )
-    if fallback_priority_ids:
-        combined_priority_ids = support_priority_ids | fallback_priority_ids | linked_priority_ids | chain_priority_ids
-        ranked, support_priority_ids = _collapse_support_query_snippets(ranked, query, intent, file_text)
-        combined_priority_ids |= support_priority_ids
-        ranked = _promote_priority_first(
-            ranked,
-            explicit_priority_ids,
-            linked_priority_ids,
-            chain_priority_ids,
-            explicit_target_paths,
-        )
-        mandatory_node_ids = _mandatory_node_ids(
-            ranked,
-            query,
-            intent,
-            support_priority_ids=combined_priority_ids,
-            explicit_priority_ids=explicit_priority_ids | linked_priority_ids | chain_priority_ids,
-        )
-        mandatory_node_ids = _trim_mandatory_node_ids_for_dense_queries(
-            mandatory_node_ids,
-            ranked,
-            query,
-            intent,
-            explicit_priority_ids=explicit_priority_ids | linked_priority_ids | chain_priority_ids,
-        )
-        ranked = _mmr_diversify_ranked(
-            ranked,
-            attached,
-            query_shape=query_shape,
-            mandatory_node_ids=mandatory_node_ids,
-            explicit_priority_ids=explicit_priority_ids,
-            linked_priority_ids=linked_priority_ids,
-            chain_priority_ids=chain_priority_ids,
-        )
-        ranked = _prune_non_musthave_candidates(
-            ranked,
-            attached,
-            query=query,
-            intent=intent,
-            query_shape=query_shape,
-            mandatory_node_ids=mandatory_node_ids,
-            explicit_priority_ids=explicit_priority_ids,
-            linked_priority_ids=linked_priority_ids,
-            chain_priority_ids=chain_priority_ids,
-        )
-        ranked = _enforce_family_file_cap(
-            ranked,
-            query=query,
-            intent=intent,
-            query_shape=query_shape,
-            mandatory_node_ids=mandatory_node_ids,
-            explicit_priority_ids=explicit_priority_ids,
-            linked_priority_ids=linked_priority_ids,
-            chain_priority_ids=chain_priority_ids,
-        )
-        ranked = _order_for_packing(
-            ranked,
-            mandatory_node_ids=mandatory_node_ids,
-            explicit_priority_ids=explicit_priority_ids,
-            linked_priority_ids=linked_priority_ids,
-            chain_priority_ids=chain_priority_ids,
-        )
-        pivot_node_ids, skeleton_node_ids, compact_node_ids = _packaging_sets(
-            ranked,
-            attached,
-            explicit_priority_ids=explicit_priority_ids,
-            linked_priority_ids=linked_priority_ids,
-            chain_priority_ids=chain_priority_ids,
-            mandatory_node_ids=mandatory_node_ids,
-        )
-        packed_ranked = _apply_packaging(
-            ranked,
-            pivot_node_ids,
-            skeleton_node_ids,
-            compact_node_ids,
-            query=query,
-            intent=intent,
-            query_shape=query_shape,
-            mandatory_node_ids=mandatory_node_ids,
-        )
-        payload = build_context(
-            query,
-            packed_ranked,
-            token_budget=budget,
-            intent=intent,
-            mandatory_node_ids=mandatory_node_ids,
-        )
-    snippets_out: list[dict[str, object]] = []
-    for snippet in payload.snippets:
-        base_meta = attached.get(
-            snippet.node_id,
-            {
-                "channels": [],
-                "family": _candidate_family(_node_file_path(snippet.node_id)),
-                "file_role": _file_role(_node_file_path(snippet.node_id)),
-                "candidate_role": "ranked",
-                "query_shape": query_shape,
-                "file_class": _classify_path(_node_file_path(snippet.node_id) or ""),
-                "why_included": "selected",
-            },
-        )
-        meta = dict(base_meta)
-        if snippet.node_id in pivot_node_ids:
-            meta["packaging_role"] = "pivot"
-        elif snippet.node_id in skeleton_node_ids:
-            meta["packaging_role"] = "adjacent_support"
-        else:
-            meta["packaging_role"] = "full"
-
-        snippets_out.append(
-            {
-                "node_id": snippet.node_id,
-                "score": snippet.score,
-                "content": snippet.content,
-                "attached_context": meta,
-            }
-        )
-
-    return {
-        "query": payload.query,
-        "tokens": payload.total_tokens_estimate,
-        "snippets": snippets_out,
-        "fallback_search_used": fallback_search_used,
-        "fallback_reason": fallback_reason,
-    }
-
+    payload = build_context(
+        query,
+        packed_ranked,
+        token_budget=budget,
+        intent=intent,
+        mandatory_node_ids=mandatory_node_ids,
+    )
+    pre_fallback_diagnostics = _context_retrieval_diagnostics(
+        payload,
+        query,
+        intent,
+        file_text,
+        attached,
+        budget=budget,
+    )
+    fallback_triggered = _confidence_gate_triggers(pre_fallback_diagnostics, strict_accuracy=strict_accuracy)
+    fallback_stage = "none"
+    fallback_reason = pre_fallback_diagnostics.get("fallback_reason")
+    fallback_search_used = False
+
+    if fallback_triggered:
+        fallback_limit = 6 if strict_accuracy else 4
+        ranked, attached, fallback_priority_ids, fallback_reason, fallback_search_used = _apply_normal_search_fallback(
+            ranked,
+            file_text,
+            query,
+            intent,
+            payload,
+            attached,
+            limit=fallback_limit,
+        )
+        if fallback_priority_ids:
+            combined_priority_ids = support_priority_ids | fallback_priority_ids | linked_priority_ids | chain_priority_ids
+            ranked, support_priority_ids = _collapse_support_query_snippets(ranked, query, intent, file_text)
+            combined_priority_ids |= support_priority_ids
+            ranked = _promote_priority_first(
+                ranked,
+                explicit_priority_ids,
+                linked_priority_ids,
+                chain_priority_ids,
+                explicit_target_paths,
+            )
+            mandatory_node_ids = _mandatory_node_ids(
+                ranked,
+                query,
+                intent,
+                support_priority_ids=combined_priority_ids,
+                explicit_priority_ids=explicit_priority_ids | linked_priority_ids | chain_priority_ids,
+            )
+            mandatory_node_ids = _trim_mandatory_node_ids_for_dense_queries(
+                mandatory_node_ids,
+                ranked,
+                query,
+                intent,
+                explicit_priority_ids=explicit_priority_ids | linked_priority_ids | chain_priority_ids,
+            )
+            ranked = _mmr_diversify_ranked(
+                ranked,
+                attached,
+                query_shape=query_shape,
+                mandatory_node_ids=mandatory_node_ids,
+                explicit_priority_ids=explicit_priority_ids,
+                linked_priority_ids=linked_priority_ids,
+                chain_priority_ids=chain_priority_ids,
+            )
+            ranked = _prune_non_musthave_candidates(
+                ranked,
+                attached,
+                query=query,
+                intent=intent,
+                query_shape=query_shape,
+                mandatory_node_ids=mandatory_node_ids,
+                explicit_priority_ids=explicit_priority_ids,
+                linked_priority_ids=linked_priority_ids,
+                chain_priority_ids=chain_priority_ids,
+            )
+            ranked = _enforce_family_file_cap(
+                ranked,
+                query=query,
+                intent=intent,
+                query_shape=query_shape,
+                mandatory_node_ids=mandatory_node_ids,
+                explicit_priority_ids=explicit_priority_ids,
+                linked_priority_ids=linked_priority_ids,
+                chain_priority_ids=chain_priority_ids,
+            )
+            ranked = _order_for_packing(
+                ranked,
+                mandatory_node_ids=mandatory_node_ids,
+                explicit_priority_ids=explicit_priority_ids,
+                linked_priority_ids=linked_priority_ids,
+                chain_priority_ids=chain_priority_ids,
+            )
+            pivot_node_ids, skeleton_node_ids, compact_node_ids = _packaging_sets(
+                ranked,
+                attached,
+                explicit_priority_ids=explicit_priority_ids,
+                linked_priority_ids=linked_priority_ids,
+                chain_priority_ids=chain_priority_ids,
+                mandatory_node_ids=mandatory_node_ids,
+            )
+            packed_ranked = _apply_packaging(
+                ranked,
+                pivot_node_ids,
+                skeleton_node_ids,
+                compact_node_ids,
+                query=query,
+                intent=intent,
+                query_shape=query_shape,
+                mandatory_node_ids=mandatory_node_ids,
+            )
+            payload = build_context(
+                query,
+                packed_ranked,
+                token_budget=budget,
+                intent=intent,
+                mandatory_node_ids=mandatory_node_ids,
+            )
+        fallback_stage = _accuracy_fallback_stage(
+            pre_fallback_diagnostics,
+            search_used=bool(fallback_search_used),
+            strict_accuracy=strict_accuracy,
+        )
+        if not fallback_reason:
+            fallback_reason = pre_fallback_diagnostics.get("fallback_reason")
+        if not fallback_reason and fallback_triggered:
+            fallback_reason = "confidence_gate"
+
+    diagnostics = _context_retrieval_diagnostics(
+        payload,
+        query,
+        intent,
+        file_text,
+        attached,
+        budget=budget,
+    )
+    if fallback_stage == "none" and fallback_triggered:
+        fallback_stage = "confidence_gate"
+
+    snippets_out: list[dict[str, object]] = []
+    for snippet in payload.snippets:
+        base_meta = attached.get(
+            snippet.node_id,
+            {
+                "channels": [],
+                "family": _candidate_family(_node_file_path(snippet.node_id)),
+                "file_role": _file_role(_node_file_path(snippet.node_id)),
+                "candidate_role": "ranked",
+                "query_shape": query_shape,
+                "file_class": _classify_path(_node_file_path(snippet.node_id) or ""),
+                "why_included": "selected",
+            },
+        )
+        meta = dict(base_meta)
+        if snippet.node_id in pivot_node_ids:
+            meta["packaging_role"] = "pivot"
+        elif snippet.node_id in skeleton_node_ids:
+            meta["packaging_role"] = "adjacent_support"
+        else:
+            meta["packaging_role"] = "full"
+
+        snippets_out.append(
+            {
+                "node_id": snippet.node_id,
+                "score": snippet.score,
+                "content": snippet.content,
+                "attached_context": meta,
+            }
+        )
+
+    return {
+        "query": payload.query,
+        "tokens": payload.total_tokens_estimate,
+        "snippets": snippets_out,
+        "fallback_search_used": fallback_search_used,
+        "fallback_reason": fallback_reason,
+        "retrieval_fallback_stage": fallback_stage,
+        "retrieval_accuracy_gate_triggered": fallback_triggered,
+        "retrieval_confidence": diagnostics.get("confidence", 0.0),
+        "retrieval_confidence_pre_fallback": pre_fallback_diagnostics.get("confidence", 0.0),
+        "retrieval_confidence_band": diagnostics.get("confidence_band", "low"),
+        "retrieval_coverage": {
+            "selected_count": diagnostics.get("selected_count", 0),
+            "code_count": diagnostics.get("code_count", 0),
+            "family_count": diagnostics.get("family_count", 0),
+            "strong_file_count": diagnostics.get("strong_file_count", 0),
+            "coverage_ratio": diagnostics.get("coverage_ratio", 0.0),
+            "explicit_target_count": diagnostics.get("explicit_target_count", 0),
+            "explicit_target_hits": diagnostics.get("explicit_target_hits", 0),
+            "explicit_target_misses": diagnostics.get("explicit_target_misses", 0),
+            "explicit_coverage_ratio": diagnostics.get("explicit_coverage_ratio", 0.0),
+            "referenced_missing_count": diagnostics.get("referenced_missing_count", 0),
+        },
+        "retrieval_score_stats": {
+            "score_top": diagnostics.get("score_top", 0.0),
+            "score_second": diagnostics.get("score_second", 0.0),
+            "score_gap": diagnostics.get("score_gap", 0.0),
+            "score_ratio": diagnostics.get("score_ratio", 0.0),
+        },
+        "retrieval_diagnostics": diagnostics,
+    }
+
 def _adaptive_companion_candidates(
     payload: dict,
     file_text: dict[str, str],
@@ -3066,6 +3267,11 @@ def run_context_adaptive(
 
 
 
+
+
+
+
+