@trac3er/oh-my-god 2.2.2 → 2.2.4

package/build/lib/runtime/router_critics.py

@@ -1,229 +0,0 @@
-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/build/lib/runtime/router_executor.py

@@ -1,142 +0,0 @@
-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/build/lib/runtime/router_selector.py

@@ -1,99 +0,0 @@
-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