@trac3er/oh-my-god 2.0.4 → 2.0.7

package/build/lib/runtime/business_workflow.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+DEFAULT_WORKFLOW_PATH: tuple[str, ...] = (
+    "plan",
+    "implement",
+    "qa",
+    "simulate",
+    "final_test",
+    "production",
+)
+
+_STAGE_ALIASES = {
+    "plan": "plan",
+    "planning": "plan",
+    "implement": "implement",
+    "implementation": "implement",
+    "build": "implement",
+    "qa": "qa",
+    "quality": "qa",
+    "quality_assurance": "qa",
+    "test": "final_test",
+    "testing": "final_test",
+    "final_test": "final_test",
+    "final-testing": "final_test",
+    "simulate": "simulate",
+    "simulation": "simulate",
+    "prod": "production",
+    "production": "production",
+    "deploy": "production",
+}
+
+
+def _as_string_list(value: Any) -> list[str]:
+    if isinstance(value, str):
+        text = value.strip()
+        return [text] if text else []
+    if isinstance(value, Iterable):
+        items: list[str] = []
+        for raw in value:
+            if isinstance(raw, str):
+                text = raw.strip()
+                if text:
+                    items.append(text)
+        return items
+    return []
+
+
+def _resolve_workflow_path(idea: dict[str, Any]) -> list[str]:
+    raw_path = idea.get("workflow") or idea.get("path") or idea.get("delivery_path") or idea.get("workflow_path")
+    requested = _as_string_list(raw_path)
+    resolved: list[str] = []
+    for stage in requested:
+        key = _STAGE_ALIASES.get(stage.strip().lower())
+        if key and key not in resolved:
+            resolved.append(key)
+    if not resolved:
+        return list(DEFAULT_WORKFLOW_PATH)
+    for required in DEFAULT_WORKFLOW_PATH:
+        if required not in resolved:
+            resolved.append(required)
+    return resolved
+
+
+def build_business_task_plan(idea: dict[str, Any]) -> dict[str, Any]:
+    goal = str(idea.get("goal", "")).strip() or "unspecified-goal"
+    constraints = _as_string_list(idea.get("constraints", []))
+    acceptance = _as_string_list(idea.get("acceptance", []))
+    user_instructions = _as_string_list(idea.get("user_instructions", []))
+    workflow_path = _resolve_workflow_path(idea)
+
+    # Plan Council extensions
+    assumptions = _as_string_list(idea.get("assumptions", []))
+    objections = _as_string_list(idea.get("objections", []) or idea.get("dissent", []))
+    rollback_plan = _as_string_list(idea.get("rollback_plan", []))
+    verification_commands = _as_string_list(idea.get("verification_commands", []))
+    evidence_requirements = _as_string_list(idea.get("evidence_requirements", []))
+    falsifiability = _as_string_list(idea.get("falsifiability", []))
+
+    tasks: list[dict[str, Any]] = []
+    task_id = 1
+
+    if user_instructions:
+        for instruction in user_instructions:
+            tasks.append(
+                {
+                    "id": f"T{task_id}",
+                    "stage": "plan",
+                    "title": "Capture user instruction",
+                    "detail": instruction,
+                    "source": "user_instructions",
+                }
+            )
+            task_id += 1
+
+    for item in constraints:
+        tasks.append(
+            {
+                "id": f"T{task_id}",
+                "stage": "plan",
+                "title": "Capture delivery constraint",
+                "detail": item,
+                "source": "constraints",
+            }
+        )
+        task_id += 1
+
+    if "implement" in workflow_path:
+        tasks.append(
+            {
+                "id": f"T{task_id}",
+                "stage": "implement",
+                "title": "Implement scoped changes",
+                "detail": "Apply changes that satisfy user instructions and follow repository patterns.",
+                "source": "workflow",
+            }
+        )
+        task_id += 1
+
+    if "qa" in workflow_path:
+        tasks.append(
+            {
+                "id": f"T{task_id}",
+                "stage": "qa",
+                "title": "Run QA checks",
+                "detail": "Validate behavior against constraints and acceptance criteria.",
+                "source": "workflow",
+            }
+        )
+        task_id += 1
+
+    if "simulate" in workflow_path:
+        tasks.append(
+            {
+                "id": f"T{task_id}",
+                "stage": "simulate",
+                "title": "Simulate delivery scenarios",
+                "detail": "Exercise expected paths and edge cases before final testing.",
+                "source": "workflow",
+            }
+        )
+        task_id += 1
+
+    for item in acceptance:
+        tasks.append(
+            {
+                "id": f"T{task_id}",
+                "stage": "final_test",
+                "title": "Validate acceptance criterion",
+                "detail": item,
+                "source": "acceptance",
+            }
+        )
+        task_id += 1
+
+    if "production" in workflow_path:
+        tasks.append(
+            {
+                "id": f"T{task_id}",
+                "stage": "production",
+                "title": "Prepare production handoff",
+                "detail": "Confirm release readiness, residual risks, and deployment checks.",
+                "source": "workflow",
+            }
+        )
+
+    stage_summaries = []
+    for stage in workflow_path:
+        stage_tasks = [task for task in tasks if task["stage"] == stage]
+        stage_summaries.append(
+            {
+                "stage": stage,
+                "task_count": len(stage_tasks),
+                "tasks": stage_tasks,
+            }
+        )
+
+    return {
+        "goal": goal,
+        "requested_path": _as_string_list(
+            idea.get("workflow") or idea.get("path") or idea.get("delivery_path") or idea.get("workflow_path")
+        ),
+        "resolved_path": workflow_path,
+        "constraints": constraints,
+        "acceptance": acceptance,
+        "user_instructions": user_instructions,
+        "assumptions": assumptions,
+        "objections": objections,
+        "rollback_plan": rollback_plan,
+        "verification_commands": verification_commands,
+        "evidence_requirements": evidence_requirements,
+        "falsifiability": falsifiability,
+        "stages": stage_summaries,
+        "task_count": len(tasks),
+    }
+
+
+def build_business_workflow_result(
+    *,
+    idea: dict[str, Any],
+    plan: dict[str, Any],
+    execution: dict[str, Any],
+    verification: dict[str, Any],
+) -> dict[str, Any]:
+    plan_payload = build_business_task_plan(idea)
+    checks_value = verification.get("checks") if isinstance(verification, dict) else None
+    checks = checks_value if isinstance(checks_value, list) else []
+    checks_ok = bool(checks) and all(isinstance(check, dict) and check.get("passed") is True for check in checks)
+
+    stage_status = {
+        "plan": "completed" if plan.get("status") == "planned" else "failed",
+        "implement": "completed" if execution.get("status") == "executed" else "failed",
+        "qa": "completed" if checks_ok else "failed",
+        "simulate": "completed" if checks_ok else "failed",
+        "final_test": "completed" if checks_ok else "failed",
+        "production": "ready" if checks_ok else "blocked",
+    }
+
+    return {
+        "goal": plan_payload["goal"],
+        "workflow_path": plan_payload["resolved_path"],
+        "requested_workflow_path": plan_payload["requested_path"],
+        "task_plan": plan_payload,
+        "stage_status": [
+            {
+                "stage": stage,
+                "status": stage_status.get(stage, "pending"),
+            }
+            for stage in plan_payload["resolved_path"]
+        ],
+        "ready_for_production": checks_ok,
+    }

package/build/lib/runtime/claim_judge.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
+    claim_type = str(claim.get("claim_type", "")).strip()
+    subject = str(claim.get("subject", "")).strip()
+    artifacts = _as_non_empty_str_list(claim.get("artifacts"))
+    trace_ids = _as_non_empty_str_list(claim.get("trace_ids"))
+    security_scans = claim.get("security_scans")
+    browser_evidence = claim.get("browser_evidence")
+
+    reasons: list[dict[str, Any]] = []
+
+    if not artifacts:
+        reasons.append(
+            {
+                "code": "missing_artifacts",
+                "message": "Claim must include at least one evidence artifact reference.",
+                "field": "artifacts",
+            }
+        )
+
+    if not trace_ids:
+        reasons.append(
+            {
+                "code": "missing_trace_ids",
+                "message": "Claim must include at least one trace identifier.",
+                "field": "trace_ids",
+            }
+        )
+
+    if _has_failed_scan(security_scans):
+        reasons.append(
+            {
+                "code": "security_scan_failed",
+                "message": "Security scans report unresolved failures; claim is blocked.",
+                "field": "security_scans",
+            }
+        )
+
+    if _has_failed_scan(browser_evidence):
+        reasons.append(
+            {
+                "code": "browser_evidence_failed",
+                "message": "Browser evidence reports failed checks; claim is blocked.",
+                "field": "browser_evidence",
+            }
+        )
+
+    hard_fail_codes = {"missing_artifacts", "missing_trace_ids"}
+    if any(reason.get("code") in hard_fail_codes for reason in reasons):
+        verdict = "fail"
+    elif reasons:
+        verdict = "block"
+    else:
+        verdict = "pass"
+
+    return {
+        "schema": "ClaimJudgeResult",
+        "verdict": verdict,
+        "reasons": reasons,
+        "claim_type": claim_type,
+        "subject": subject,
+        "evidence": {
+            "artifacts": artifacts,
+            "trace_ids": trace_ids,
+            "lineage": claim.get("lineage") if isinstance(claim.get("lineage"), dict) else {},
+            "security_scans": security_scans if isinstance(security_scans, list) else [],
+            "browser_evidence": browser_evidence if isinstance(browser_evidence, list) else [],
+        },
+    }
+
+
+def _as_non_empty_str_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item).strip() for item in value if str(item).strip()]
+
+
+def _has_failed_scan(value: Any) -> bool:
+    if not isinstance(value, list):
+        return False
+    failure_tokens = {"fail", "failed", "error", "block", "blocked"}
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        status = str(item.get("status", "")).strip().lower()
+        if status in failure_tokens:
+            return True
+        unresolved_risks = item.get("unresolved_risks")
+        if isinstance(unresolved_risks, list) and unresolved_risks:
+            return True
+    return False

package/build/lib/runtime/cli_provider.py

@@ -0,0 +1,85 @@
+"""CLI provider abstractions and provider registry."""
+
+from __future__ import annotations
+
+import subprocess
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+def _run_tool(cmd: list[str], *, timeout: int = 30) -> subprocess.CompletedProcess[str]:
+    """Run an external tool with a mandatory timeout."""
+    return subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=timeout,
+    )
+
+
+class CLIProvider(ABC):
+    """Abstract contract for external CLI providers."""
+
+    @abstractmethod
+    def get_name(self) -> str:
+        """Return the provider name (for example: codex or gemini)."""
+
+    @abstractmethod
+    def detect(self) -> bool:
+        """Return True when the provider CLI binary is available on PATH."""
+
+    @abstractmethod
+    def check_auth(self) -> tuple[bool | None, str]:
+        """Return provider authentication state and a human-readable message."""
+
+    @abstractmethod
+    def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke provider directly using subprocess mode."""
+
+    @abstractmethod
+    def invoke_tmux(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke provider through tmux-managed execution mode."""
+
+    @abstractmethod
+    def get_non_interactive_cmd(self, prompt: str) -> list[str]:
+        """Return non-interactive command arguments for the provider CLI."""
+
+    @abstractmethod
+    def get_config_path(self) -> str:
+        """Return provider configuration file path."""
+
+    @abstractmethod
+    def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:
+        """Write or update MCP server configuration for this provider."""
+
+    def run_tool(self, cmd: list[str], *, timeout: int = 30) -> subprocess.CompletedProcess[str]:
+        """Execute subprocess commands via mandatory timeout helper."""
+        return _run_tool(cmd, timeout=timeout)
+
+
+_PROVIDER_REGISTRY: dict[str, CLIProvider] = {}
+
+
+def register_provider(provider: CLIProvider) -> None:
+    """Register a CLI provider by its canonical name."""
+    _PROVIDER_REGISTRY[provider.get_name()] = provider
+
+
+def get_provider(name: str) -> CLIProvider | None:
+    """Return a registered CLI provider by name."""
+    return _PROVIDER_REGISTRY.get(name)
+
+
+def list_available_providers() -> list[str]:
+    """Return registered provider names in insertion order."""
+    return list(_PROVIDER_REGISTRY)
+
+
+__all__ = [
+    "CLIProvider",
+    "_PROVIDER_REGISTRY",
+    "get_provider",
+    "list_available_providers",
+    "register_provider",
+]