@trac3er/oh-my-god 2.0.0 → 2.0.2

package/runtime/adapters/local.py

@@ -0,0 +1,53 @@
+"""Local model runtime adapter (v1 stub)."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+
+class LocalAdapter:
+    runtime = "local"
+
+    def plan(self, idea: dict[str, Any]) -> dict[str, Any]:
+        goal = str(idea.get("goal", "")).strip() or "unspecified-goal"
+        return {
+            "runtime": self.runtime,
+            "phase": "plan",
+            "status": "planned",
+            "goal": goal,
+            "steps": ["analyze-goal", "generate-plan", "emit-checklist"],
+        }
+
+    def execute(self, plan: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "execute",
+            "status": "executed",
+            "operations": ["apply-plan", "collect-diff"],
+            "errors": [],
+        }
+
+    def verify(self, execution_result: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "verify",
+            "status": "verified",
+            "ok": True,
+            "checks": [
+                {"name": "tests", "passed": True},
+                {"name": "security", "passed": True},
+            ],
+        }
+
+    def collect_evidence(self, verify_result: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "evidence",
+            "status": "collected",
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "tests": verify_result.get("checks", []),
+            "security_scans": [],
+            "diff_summary": {},
+            "reproducibility": {"seed": "deterministic"},
+            "unresolved_risks": [],
+        }

package/runtime/adoption.py

@@ -0,0 +1,212 @@
+"""Native OMG adoption helpers for setup and trust-release surfaces."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+CANONICAL_BRAND = "OMG"
+CANONICAL_REPO_URL = "https://github.com/trac3er00/OMG"
+CANONICAL_PACKAGE_NAME = "@trac3er/oh-my-god"
+CANONICAL_PLUGIN_ID = "omg"
+CANONICAL_MARKETPLACE_ID = "omg"
+CANONICAL_VERSION = "2.0.2"
+
+VALID_ADOPTION_MODES = ("omg-only", "coexist")
+VALID_PRESETS = ("safe", "balanced", "interop", "labs")
+
+MANAGED_PRESET_FLAGS = (
+    "SETUP",
+    "SETUP_WIZARD",
+    "MEMORY_AUTOSTART",
+    "SESSION_ANALYTICS",
+    "CONTEXT_MANAGER",
+    "COST_TRACKING",
+    "MEMORY_SERVER",
+    "GIT_WORKFLOW",
+    "TEST_GENERATION",
+    "DEP_HEALTH",
+    "CODEBASE_VIZ",
+)
+
+PRESET_FEATURES: dict[str, dict[str, bool]] = {
+    "safe": {flag: False for flag in MANAGED_PRESET_FLAGS},
+    "balanced": {
+        "SETUP": True,
+        "SETUP_WIZARD": True,
+        "MEMORY_AUTOSTART": True,
+        "SESSION_ANALYTICS": True,
+        "CONTEXT_MANAGER": True,
+        "COST_TRACKING": True,
+        "MEMORY_SERVER": False,
+        "GIT_WORKFLOW": False,
+        "TEST_GENERATION": False,
+        "DEP_HEALTH": False,
+        "CODEBASE_VIZ": False,
+    },
+    "interop": {
+        "SETUP": True,
+        "SETUP_WIZARD": True,
+        "MEMORY_AUTOSTART": True,
+        "SESSION_ANALYTICS": True,
+        "CONTEXT_MANAGER": True,
+        "COST_TRACKING": True,
+        "MEMORY_SERVER": True,
+        "GIT_WORKFLOW": False,
+        "TEST_GENERATION": False,
+        "DEP_HEALTH": False,
+        "CODEBASE_VIZ": False,
+    },
+    "labs": {
+        "SETUP": True,
+        "SETUP_WIZARD": True,
+        "MEMORY_AUTOSTART": True,
+        "SESSION_ANALYTICS": True,
+        "CONTEXT_MANAGER": True,
+        "COST_TRACKING": True,
+        "MEMORY_SERVER": True,
+        "GIT_WORKFLOW": True,
+        "TEST_GENERATION": True,
+        "DEP_HEALTH": True,
+        "CODEBASE_VIZ": True,
+    },
+}
+
+_SUPERPOWERS_SENTINELS = (
+    ("skills", "brainstorming"),
+    ("commands", "superpowers.md"),
+    ("commands", "superpower.md"),
+)
+
+
+def resolve_preset(preset: str | None) -> str:
+    if preset in VALID_PRESETS:
+        return preset
+    return "safe"
+
+
+def get_preset_features(preset: str | None) -> dict[str, bool]:
+    resolved = resolve_preset(preset)
+    return dict(PRESET_FEATURES[resolved])
+
+
+def _resolve_claude_dir(base_dir: Path) -> Path:
+    nested = base_dir / ".claude"
+    if nested.exists():
+        return nested
+    return base_dir
+
+
+def detect_ecosystems(project_dir: str | Path) -> list[str]:
+    root = Path(project_dir)
+    claude_dir = _resolve_claude_dir(root)
+    detected: list[str] = []
+
+    if (root / ".omc").exists():
+        detected.append("omc")
+    if (root / ".omx").exists():
+        detected.append("omx")
+
+    if any((claude_dir / Path(*parts)).exists() for parts in _SUPERPOWERS_SENTINELS):
+        detected.append("superpowers")
+
+    return detected
+
+
+def recommend_mode(detected_ecosystems: list[str]) -> str:
+    if detected_ecosystems:
+        return "omg-only"
+    return "omg-only"
+
+
+def _build_actions(mode: str, detected_ecosystems: list[str]) -> list[str]:
+    if mode == "coexist":
+        actions = [
+            "Keep OMG in a non-destructive coexistence mode.",
+            "Avoid claiming ownership of third-party command namespaces or HUD surfaces.",
+            "Install OMG hooks, MCP, and runtime where they do not overwrite existing ecosystems.",
+        ]
+        if detected_ecosystems:
+            actions.append(
+                "Record overlapping ecosystems and route around conflicts instead of disabling them."
+            )
+        return actions
+
+    actions = [
+        "Promote OMG to the primary orchestration, HUD, and MCP layer.",
+        "Back up existing OMG-adjacent surfaces before disabling overlaps.",
+        "Keep compat available for legacy skill routing without using it as onboarding."
+    ]
+    if detected_ecosystems:
+        actions.append(
+            "Adopt portable state where safe and disable overlapping third-party surfaces."
+        )
+    return actions
+
+
+def _build_skipped_overlaps(mode: str, detected_ecosystems: list[str]) -> list[str]:
+    if not detected_ecosystems:
+        return []
+    if mode == "coexist":
+        return [
+            "Third-party slash-command namespaces remain untouched.",
+            "Existing HUD and hook ownership is preserved unless explicitly replaced later.",
+        ]
+    return [
+        "Destructive cross-ecosystem migration is skipped unless OMG can back up the prior state first.",
+    ]
+
+
+def _build_follow_up(mode: str, preset: str, detected_ecosystems: list[str]) -> list[str]:
+    follow_up = [
+        "Run /OMG:setup again whenever providers or auth state change.",
+        f"Current preset: {preset}.",
+    ]
+    if mode == "coexist":
+        follow_up.append("Review overlaps before enabling additional OMG labs surfaces.")
+    else:
+        follow_up.append("Run /OMG:crazy <goal> after setup to use the recommended front door.")
+    if detected_ecosystems:
+        follow_up.append(
+            "Review the adoption report before deleting any previous OMC, OMX, or Superpowers files."
+        )
+    return follow_up
+
+
+def build_adoption_report(
+    project_dir: str | Path,
+    *,
+    requested_mode: str | None = None,
+    preset: str | None = None,
+    adopt: str = "auto",
+) -> dict[str, Any]:
+    detected_ecosystems = detect_ecosystems(project_dir) if adopt == "auto" else []
+    recommended_mode = recommend_mode(detected_ecosystems)
+    selected_mode = requested_mode if requested_mode in VALID_ADOPTION_MODES else recommended_mode
+    resolved_preset = resolve_preset(preset)
+
+    return {
+        "schema": "OmgAdoptionReport",
+        "brand": CANONICAL_BRAND,
+        "version": CANONICAL_VERSION,
+        "repo": CANONICAL_REPO_URL,
+        "package": CANONICAL_PACKAGE_NAME,
+        "plugin_id": CANONICAL_PLUGIN_ID,
+        "marketplace_id": CANONICAL_MARKETPLACE_ID,
+        "detected_ecosystems": detected_ecosystems,
+        "recommended_mode": recommended_mode,
+        "selected_mode": selected_mode,
+        "preset": resolved_preset,
+        "actions": _build_actions(selected_mode, detected_ecosystems),
+        "skipped_overlaps": _build_skipped_overlaps(selected_mode, detected_ecosystems),
+        "follow_up": _build_follow_up(selected_mode, resolved_preset, detected_ecosystems),
+    }
+
+
+def write_adoption_report(project_dir: str | Path, report: dict[str, Any]) -> str:
+    state_dir = Path(project_dir) / ".omg" / "state"
+    state_dir.mkdir(parents=True, exist_ok=True)
+    report_path = state_dir / "adoption-report.json"
+    report_path.write_text(json.dumps(report, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+    return str(report_path)

package/runtime/business_workflow.py

@@ -0,0 +1,220 @@
+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)
+
+    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,
+        "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/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",
+]