@trac3r/oh-my-god 2.2.11

package/runtime/router_critics.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import os
+import re
+from typing import Any
+
+
+_CLAIM_PATTERNS: tuple[tuple[str, str], ...] = (
+    (r"\btrust me\b", "contains unsupported confidence phrase 'trust me'"),
+    (r"\bimplemented\b", "claims implementation without evidence pointer"),
+    (r"\bfixed\b", "claims fix without evidence pointer"),
+    (r"\btested\b", "claims testing without evidence pointer"),
+)
+
+_EVIDENCE_PATTERNS: tuple[str, ...] = (
+    r"evidence/[a-zA-Z0-9_.-]+",
+    r"\.omg/state/",
+    r"\bpytest\b",
+    r"\bpython3\s+-m\s+pytest\b",
+    r"\b[a-zA-Z0-9_./-]+\.[a-zA-Z0-9]+(?::\d+)?\b",
+)
+
+_PATH_RE = re.compile(r"\b(?:[a-zA-Z0-9_.-]+/)+[a-zA-Z0-9_.-]+\.[a-zA-Z0-9]+(?:[:#]L?\d+)?\b")
+_FUNC_BACKTICK_RE = re.compile(r"`([a-zA-Z_][a-zA-Z0-9_]*)`")
+_FUNC_TEXT_RE = re.compile(r"\bfunction\s+([a-zA-Z_][a-zA-Z0-9_]*)\b")
+_SYMBOL_TEXT_RE = re.compile(r"\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\(")
+
+
+def _extract_output_text(candidate: dict[str, Any]) -> str:
+    value = candidate.get("output", "")
+    return value if isinstance(value, str) else str(value)
+
+
+def _has_evidence_pointer(text: str, context_packet: dict[str, Any]) -> bool:
+    lowered = text.lower()
+    if any(re.search(pattern, lowered) for pattern in _EVIDENCE_PATTERNS):
+        return True
+    pointers = context_packet.get("artifact_pointers")
+    if isinstance(pointers, list):
+        for pointer in pointers:
+            if isinstance(pointer, str) and pointer and pointer.lower() in lowered:
+                return True
+    return False
+
+
+def _run_skeptic(candidate: dict[str, Any], context_packet: dict[str, Any]) -> dict[str, Any]:
+    output_text = _extract_output_text(candidate)
+    lowered = output_text.lower()
+    findings: list[str] = []
+    has_evidence = _has_evidence_pointer(output_text, context_packet)
+
+    for pattern, message in _CLAIM_PATTERNS:
+        if re.search(pattern, lowered):
+            if "trust me" in pattern or not has_evidence:
+                findings.append(message)
+
+    if findings:
+        verdict = "fail" if any("trust me" in item for item in findings) else "warn"
+        confidence = 0.9 if verdict == "fail" else 0.78
+        return {"verdict": verdict, "findings": findings, "confidence": confidence}
+
+    return {
+        "verdict": "pass",
+        "findings": ["claims include sufficient evidence pointers or are non-assertive"],
+        "confidence": 0.83,
+    }
+
+
+def _extract_context_paths(context_packet: dict[str, Any]) -> set[str]:
+    known: set[str] = set()
+    pointers = context_packet.get("artifact_pointers")
+    if isinstance(pointers, list):
+        known.update(str(p).strip() for p in pointers if isinstance(p, str) and p.strip())
+
+    for key in ("files", "known_paths", "artifacts"):
+        value = context_packet.get(key)
+        if isinstance(value, list):
+            known.update(str(v).strip() for v in value if isinstance(v, str) and v.strip())
+
+    summary = context_packet.get("summary", "")
+    if isinstance(summary, str):
+        known.update(match.group(0).strip() for match in _PATH_RE.finditer(summary))
+
+    return {item.lstrip("./") for item in known}
+
+
+def _extract_context_functions(context_packet: dict[str, Any]) -> set[str]:
+    names: set[str] = set()
+    for key in ("functions", "symbols", "known_functions"):
+        value = context_packet.get(key)
+        if isinstance(value, list):
+            names.update(str(v).strip() for v in value if isinstance(v, str) and v.strip())
+    summary = context_packet.get("summary", "")
+    if isinstance(summary, str):
+        for match in _FUNC_BACKTICK_RE.finditer(summary):
+            names.add(match.group(1))
+        for match in _FUNC_TEXT_RE.finditer(summary):
+            names.add(match.group(1))
+    return names
+
+
+def _extract_output_paths(output_text: str) -> set[str]:
+    return {match.group(0).split(":", 1)[0].lstrip("./") for match in _PATH_RE.finditer(output_text)}
+
+
+def _extract_output_functions(output_text: str) -> set[str]:
+    functions: set[str] = set()
+    for match in _FUNC_BACKTICK_RE.finditer(output_text):
+        functions.add(match.group(1))
+    for match in _FUNC_TEXT_RE.finditer(output_text):
+        functions.add(match.group(1))
+    for match in _SYMBOL_TEXT_RE.finditer(output_text):
+        token = match.group(1)
+        if token not in {"if", "for", "while", "return", "assert"}:
+            functions.add(token)
+    return functions
+
+
+def _is_path_verifiable(path: str, known_paths: set[str], project_dir: str) -> bool:
+    if path in known_paths:
+        return True
+    normalized = path.split("#", 1)[0].strip()
+    return os.path.exists(os.path.join(project_dir, normalized))
+
+
+def _run_hallucination_auditor(
+    candidate: dict[str, Any],
+    context_packet: dict[str, Any],
+    project_dir: str,
+) -> dict[str, Any]:
+    output_text = _extract_output_text(candidate)
+    known_paths = _extract_context_paths(context_packet)
+    known_functions = _extract_context_functions(context_packet)
+
+    referenced_paths = _extract_output_paths(output_text)
+    referenced_functions = _extract_output_functions(output_text)
+
+    findings: list[str] = []
+
+    unknown_paths = [
+        path for path in sorted(referenced_paths) if not _is_path_verifiable(path, known_paths, project_dir)
+    ]
+    unknown_functions = [
+        name for name in sorted(referenced_functions) if known_functions and name not in known_functions
+    ]
+
+    if unknown_paths:
+        findings.append("unverifiable file references: " + ", ".join(unknown_paths[:6]))
+    if unknown_functions:
+        findings.append("unverifiable function references: " + ", ".join(unknown_functions[:6]))
+
+    if findings and (len(unknown_paths) >= max(1, len(referenced_paths))):
+        return {"verdict": "fail", "findings": findings, "confidence": 0.86}
+    if findings:
+        return {"verdict": "warn", "findings": findings, "confidence": 0.72}
+
+    return {
+        "verdict": "pass",
+        "findings": ["output references are verifiable against bounded context packet"],
+        "confidence": 0.8,
+    }
+
+
+def _run_evidence_completeness(
+    candidate: dict[str, Any],
+    context_packet: dict[str, Any],
+    project_dir: str,
+) -> dict[str, Any]:
+    output_text = _extract_output_text(candidate).lower()
+    artifact_pointers = context_packet.get("artifact_pointers")
+    pointers: list[str] = []
+    if isinstance(artifact_pointers, list):
+        pointers = [str(item).strip() for item in artifact_pointers if isinstance(item, str) and str(item).strip()]
+
+    required_claim_tokens = ("implemented", "fixed", "tested", "verified", "release")
+    expects_evidence = any(token in output_text for token in required_claim_tokens)
+
+    existing_pointers: list[str] = []
+    missing_pointers: list[str] = []
+    for pointer in pointers:
+        full_path = os.path.join(project_dir, pointer.lstrip("./"))
+        if os.path.exists(full_path):
+            existing_pointers.append(pointer)
+        else:
+            missing_pointers.append(pointer)
+
+    findings: list[str] = []
+    if missing_pointers:
+        findings.append("missing evidence artifacts: " + ", ".join(missing_pointers[:6]))
+
+    if expects_evidence and not existing_pointers:
+        findings.append("claim-like output requires evidence artifacts but none were present")
+        return {"verdict": "fail", "findings": findings, "confidence": 0.92}
+
+    if findings:
+        return {"verdict": "warn", "findings": findings, "confidence": 0.76}
+
+    if existing_pointers:
+        return {
+            "verdict": "pass",
+            "findings": ["required evidence artifacts are present in bounded context packet"],
+            "confidence": 0.84,
+        }
+
+    return {
+        "verdict": "pass",
+        "findings": ["no evidence artifacts required for non-assertive output"],
+        "confidence": 0.78,
+    }
+
+
+def run_critics(candidate: dict[str, object], context_packet: dict[str, object], project_dir: str) -> dict[str, dict[str, Any]]:
+    bounded_context = {
+        "summary": context_packet.get("summary", ""),
+        "artifact_pointers": context_packet.get("artifact_pointers", []),
+        "files": context_packet.get("files", []),
+        "known_paths": context_packet.get("known_paths", []),
+        "functions": context_packet.get("functions", []),
+        "known_functions": context_packet.get("known_functions", []),
+    }
+
+    skeptic = _run_skeptic(candidate, bounded_context)
+    hallucination_auditor = _run_hallucination_auditor(candidate, bounded_context, project_dir)
+    evidence_completeness = _run_evidence_completeness(candidate, bounded_context, project_dir)
+    return {
+        "skeptic": skeptic,
+        "hallucination_auditor": hallucination_auditor,
+        "evidence_completeness": evidence_completeness,
+    }

package/runtime/router_executor.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from collections.abc import Mapping
+from typing import Callable, Protocol, TypedDict
+
+from runtime.runtime_profile import resolve_parallel_workers
+
+
+def _resolve_parallel_workers(project_dir: str, requested_workers: int) -> int:
+    return resolve_parallel_workers(project_dir, requested_workers=requested_workers)
+
+
+class WorkerTask(TypedDict, total=False):
+    agent_name: str
+    prompt: str
+    order: int
+
+
+class ResultFuture(Protocol):
+    def result(self, timeout: int | None = None) -> dict[str, object]:
+        ...
+
+
+def _default_as_completed(
+    futures: dict[ResultFuture, tuple[int, int, WorkerTask]],
+) -> list[ResultFuture]:
+    return list(futures.keys())
+
+
+def _status_from_result(result: Mapping[str, object]) -> str:
+    if result.get("fallback") == "claude":
+        return "fallback-claude"
+    if "error" in result:
+        return "error"
+    return "completed" if result.get("exit_code") == 0 else "failed"
+
+
+def _execute_workers_sequential(
+    workers: list[WorkerTask],
+    *,
+    project_dir: str,
+    dispatch_fn: Callable[[str, str, str], dict[str, object]],
+) -> list[dict[str, object]]:
+    sorted_workers = sorted(workers, key=lambda x: x.get("order", 0))
+    results: list[dict[str, object]] = []
+    for worker in sorted_workers:
+        agent_name = str(worker.get("agent_name", "executor"))
+        prompt = str(worker.get("prompt", ""))
+        result = dispatch_fn(agent_name, prompt, project_dir)
+        results.append(
+            {
+                "agent": agent_name,
+                "order": worker.get("order", 0),
+                "status": _status_from_result(result),
+                **result,
+            }
+        )
+    return results
+
+
+def _execute_workers_parallel(
+    workers: list[WorkerTask],
+    *,
+    project_dir: str,
+    dispatch_fn: Callable[[str, str, str], dict[str, object]],
+    timeout_per_worker: int,
+    resolve_workers_fn: Callable[[str, int], int],
+    thread_pool_cls: type[ThreadPoolExecutor],
+    as_completed_fn: Callable[..., list[ResultFuture]],
+) -> list[dict[str, object]]:
+    indexed_workers: list[tuple[int, int, WorkerTask]] = [
+        (idx, int(worker.get("order", 0)), worker) for idx, worker in enumerate(workers)
+    ]
+    sorted_workers = sorted(indexed_workers, key=lambda x: (x[1], x[0]))
+    if not sorted_workers:
+        return []
+
+    max_workers = resolve_workers_fn(project_dir, min(len(sorted_workers), 5))
+    results_by_index: dict[int, dict[str, object]] = {}
+
+    with thread_pool_cls(max_workers=max_workers) as pool:
+        future_map: dict[ResultFuture, tuple[int, int, WorkerTask]] = {
+            pool.submit(
+                dispatch_fn,
+                str(worker_info[2].get("agent_name", "executor")),
+                str(worker_info[2].get("prompt", "")),
+                project_dir,
+            ): worker_info
+            for worker_info in sorted_workers
+        }
+
+        for future in as_completed_fn(future_map):
+            worker_info = future_map[future]
+            worker = worker_info[2]
+            order = worker_info[1]
+            worker_index = worker_info[0]
+            agent_name = str(worker.get("agent_name", "executor"))
+
+            try:
+                result = future.result(timeout=timeout_per_worker)
+            except Exception as exc:
+                result = {"error": str(exc), "fallback": "claude"}
+
+            results_by_index[worker_index] = {
+                "agent": agent_name,
+                "order": order,
+                "status": _status_from_result(result),
+                **result,
+            }
+
+    return [results_by_index[worker_info[0]] for worker_info in sorted_workers]
+
+
+def execute_workers(
+    workers: list[WorkerTask],
+    parallel: bool,
+    *,
+    project_dir: str = ".",
+    dispatch_fn: Callable[[str, str, str], dict[str, object]] | None = None,
+    timeout_per_worker: int = 120,
+    resolve_workers_fn: Callable[[str, int], int] = _resolve_parallel_workers,
+    thread_pool_cls: type[ThreadPoolExecutor] = ThreadPoolExecutor,
+    as_completed_fn: Callable[..., list[ResultFuture]] = _default_as_completed,
+) -> list[dict[str, object]]:
+    if dispatch_fn is None:
+        raise ValueError("dispatch_fn is required")
+    if parallel:
+        return _execute_workers_parallel(
+            workers,
+            project_dir=project_dir,
+            dispatch_fn=dispatch_fn,
+            timeout_per_worker=timeout_per_worker,
+            resolve_workers_fn=resolve_workers_fn,
+            thread_pool_cls=thread_pool_cls,
+            as_completed_fn=as_completed_fn,
+        )
+    return _execute_workers_sequential(
+        workers,
+        project_dir=project_dir,
+        dispatch_fn=dispatch_fn,
+    )

package/runtime/router_selector.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import re
+from typing import Callable
+
+
+_COST_TIER: dict[str, int] = {
+    "gemini": 1,
+    "codex": 2,
+    "ccg": 3,
+}
+
+
+def rank_targets_by_cost(targets: list[str]) -> list[str]:
+    return sorted(targets, key=lambda name: _COST_TIER.get(name, 999))
+
+
+def infer_target(problem: str) -> str:
+    p = problem.lower()
+    ccg_kw = bool(re.search(r"\bccg\b", p)) or "tri-track" in p or "tri track" in p
+    gemini_kw = bool(re.search(r"\bgemini\b", p))
+    codex_kw = bool(re.search(r"\bcodex\b", p))
+
+    if ccg_kw or (gemini_kw and codex_kw):
+        return "ccg"
+    if gemini_kw:
+        return "gemini"
+    if codex_kw:
+        return "codex"
+
+    ui_signals = ["ui", "ux", "layout", "css", "visual", "responsive", "frontend"]
+    code_signals = ["auth", "security", "backend", "debug", "performance", "algorithm"]
+    ccg_signals = [
+        "full-stack",
+        "full stack",
+        "front-end and back-end",
+        "frontend and backend",
+        "backend and frontend",
+        "cross-functional",
+        "review everything",
+        "architecture",
+        "system design",
+        "e2e",
+        "end-to-end",
+    ]
+
+    ui_hit = any(k in p for k in ui_signals)
+    code_hit = any(k in p for k in code_signals)
+    ccg_hit = any(k in p for k in ccg_signals)
+
+    if ccg_hit or (ui_hit and code_hit):
+        return "ccg"
+    if ui_hit:
+        return "gemini"
+    if code_hit:
+        return "codex"
+    return "codex"
+
+
+def select_target(problem: str, context: str) -> dict[str, str]:
+    target = infer_target(problem)
+    reason = "problem intent matched routing heuristic"
+    if context and target == "ccg":
+        reason = "cross-functional intent favored dual-track routing"
+    elif context:
+        reason = "problem intent favored single-track routing"
+    return {"target": target, "reason": reason}
+
+
+def collect_cli_health(
+    target: str,
+    *,
+    check_tool_available: Callable[[str], bool],
+    check_tool_auth: Callable[[str], tuple[bool | None, str]],
+    install_hints: dict[str, str],
+) -> dict[str, dict[str, bool | None | str]]:
+    if target == "ccg":
+        providers = ("codex", "gemini")
+    elif target in ("codex", "gemini"):
+        providers = (target,)
+    else:
+        providers = tuple()
+
+    health: dict[str, dict[str, bool | None | str]] = {}
+    for provider in providers:
+        available = check_tool_available(provider)
+        auth_ok: bool | None = None
+        auth_message = "CLI is not installed"
+        if available:
+            auth_ok, auth_message = check_tool_auth(provider)
+        live_connection = bool(available and auth_ok is True)
+        health[provider] = {
+            "available": available,
+            "auth_ok": auth_ok,
+            "live_connection": live_connection,
+            "status_message": auth_message,
+            "install_hint": install_hints.get(provider, ""),
+        }
+    return health