@trac3er/oh-my-god 2.0.0 → 2.0.2

package/runtime/tmux_session_manager.py

@@ -0,0 +1,169 @@
+"""tmux session lifecycle manager for persistent model invocations."""
+
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+import subprocess
+import time
+import uuid
+
+
+_logger = logging.getLogger(__name__)
+
+
+class TmuxSessionManager:
+    """Manage lightweight tmux sessions used for provider command execution."""
+
+    def __init__(self, session_prefix: str = "omg") -> None:
+        """Initialize manager with a session name prefix."""
+        self.session_prefix: str = session_prefix
+
+    def is_tmux_available(self) -> bool:
+        """Return True when tmux is available on PATH."""
+        return shutil.which("tmux") is not None
+
+    def session_exists(self, name: str) -> bool:
+        """Return True if a tmux session exists."""
+        if not self.is_tmux_available():
+            return False
+        try:
+            result = subprocess.run(
+                ["tmux", "has-session", "-t", name],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=5,
+            )
+            return result.returncode == 0
+        except Exception as exc:
+            _logger.warning("Failed to check tmux session %r: %s", name, exc)
+            return False
+
+    def create_session(self, name: str) -> bool:
+        """Create a detached tmux session and return success state."""
+        if not self.is_tmux_available():
+            return False
+        try:
+            result = subprocess.run(
+                ["tmux", "new-session", "-d", "-s", name],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            return result.returncode == 0
+        except Exception as exc:
+            _logger.warning("Failed to create tmux session %r: %s", name, exc)
+            return False
+
+    def kill_session(self, name: str) -> bool:
+        """Kill a tmux session and return success state."""
+        if not self.is_tmux_available():
+            return False
+        try:
+            result = subprocess.run(
+                ["tmux", "kill-session", "-t", name],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            return result.returncode == 0
+        except Exception as exc:
+            _logger.warning("Failed to kill tmux session %r: %s", name, exc)
+            return False
+
+    def send_command(self, name: str, command: str, timeout: int = 120) -> str:
+        """Send a command to a tmux session and return captured pane output."""
+        if not self.is_tmux_available():
+            return ""
+
+        sentinel = f"__OMG_DONE_{uuid.uuid4().hex}__"
+        deadline = time.monotonic() + timeout
+
+        try:
+            send_main = subprocess.run(
+                ["tmux", "send-keys", "-t", name, command, "Enter"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            if send_main.returncode != 0:
+                return ""
+
+            send_marker = subprocess.run(
+                ["tmux", "send-keys", "-t", name, f"echo {sentinel}", "Enter"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            if send_marker.returncode != 0:
+                return ""
+
+            last_output = ""
+            while time.monotonic() < deadline:
+                captured = subprocess.run(
+                    ["tmux", "capture-pane", "-t", name, "-p"],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                    timeout=10,
+                )
+                if captured.returncode == 0:
+                    last_output = captured.stdout
+                    if sentinel in last_output:
+                        return last_output.split(sentinel, 1)[0].rstrip()
+                time.sleep(0.25)
+
+            return last_output.rstrip()
+        except Exception as exc:
+            _logger.warning("Failed to send tmux command to %r: %s", name, exc)
+            return ""
+
+    def get_or_create_session(self, name: str) -> str:
+        """Return a fresh tmux session name, recreating stale sessions if needed."""
+        if self.session_exists(name):
+            _ = self.kill_session(name)
+        if not self.create_session(name):
+            raise RuntimeError(f"Unable to create tmux session: {name}")
+        return name
+
+    def make_session_name(self, provider: str, unique_id: str | None = None) -> str:
+        """Build a normalized tmux session name using provider and optional id."""
+        provider_clean = re.sub(r"[^a-zA-Z0-9_-]", "-", provider).strip("-").lower() or "session"
+        base_name = f"{self.session_prefix}-{provider_clean}"
+        if unique_id:
+            unique_clean = re.sub(r"[^a-zA-Z0-9_-]", "-", unique_id).strip("-").lower()
+            if unique_clean:
+                return f"{base_name}-{unique_clean}"
+        return base_name
+
+    def cleanup_stale_sessions(self) -> int:
+        """Kill all tmux sessions matching this manager prefix and return count."""
+        if not self.is_tmux_available():
+            return 0
+
+        try:
+            listed = subprocess.run(
+                ["tmux", "list-sessions", "-F", "#{session_name}"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            if listed.returncode != 0:
+                return 0
+
+            killed = 0
+            prefix = f"{self.session_prefix}-"
+            for session_name in listed.stdout.splitlines():
+                if session_name.startswith(prefix) and self.kill_session(session_name):
+                    killed += 1
+            return killed
+        except Exception as exc:
+            _logger.warning("Failed to cleanup tmux sessions for prefix %r: %s", self.session_prefix, exc)
+            return 0

package/scripts/check-omg-compat-contract-snapshot.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Validate committed OMG compatibility snapshot against runtime contracts."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from runtime.compat import (  # noqa: E402
+    CONTRACT_SNAPSHOT_SCHEMA,
+    CONTRACT_SNAPSHOT_VERSION,
+    DEFAULT_CONTRACT_SNAPSHOT_PATH,
+    LEGACY_CONTRACT_SNAPSHOT_PATH,
+    build_contract_snapshot_payload,
+    migrate_contract_snapshot_payload,
+)
+
+
+def _load_snapshot(path: Path) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        payload = json.load(f)
+    if not isinstance(payload, dict):
+        raise ValueError("snapshot must be a JSON object")
+    return payload
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Check OMG compatibility contract snapshot drift")
+    parser.add_argument("--snapshot", default="")
+    parser.add_argument("--strict-version", action="store_true")
+    args = parser.parse_args()
+
+    if args.snapshot:
+        snapshot_path = Path(args.snapshot)
+    else:
+        primary = ROOT / DEFAULT_CONTRACT_SNAPSHOT_PATH
+        legacy = ROOT / LEGACY_CONTRACT_SNAPSHOT_PATH
+        snapshot_path = primary if primary.exists() else legacy
+
+    if not snapshot_path.exists():
+        print(
+            json.dumps(
+                {"status": "error", "message": f"snapshot not found: {snapshot_path}"},
+                indent=2,
+            )
+        )
+        return 2
+
+    try:
+        current = _load_snapshot(snapshot_path)
+    except Exception as exc:
+        print(json.dumps({"status": "error", "message": f"invalid snapshot json: {exc}"}, indent=2))
+        return 2
+
+    migrated, migrations = migrate_contract_snapshot_payload(current)
+    expected = build_contract_snapshot_payload(include_generated_at=False)
+
+    if migrated.get("schema") != CONTRACT_SNAPSHOT_SCHEMA:
+        print(
+            json.dumps(
+                {
+                    "status": "error",
+                    "message": "snapshot schema mismatch",
+                    "expected_schema": CONTRACT_SNAPSHOT_SCHEMA,
+                    "actual_schema": migrated.get("schema"),
+                },
+                indent=2,
+            )
+        )
+        return 3
+
+    if args.strict_version and current.get("contract_version") != CONTRACT_SNAPSHOT_VERSION:
+        print(
+            json.dumps(
+                {
+                    "status": "error",
+                    "message": "snapshot contract_version mismatch (strict)",
+                    "expected_version": CONTRACT_SNAPSHOT_VERSION,
+                    "actual_version": current.get("contract_version"),
+                },
+                indent=2,
+            )
+        )
+        return 3
+
+    if migrated.get("contract_version") != CONTRACT_SNAPSHOT_VERSION:
+        print(
+            json.dumps(
+                {
+                    "status": "error",
+                    "message": "snapshot contract_version unsupported",
+                    "expected_version": CONTRACT_SNAPSHOT_VERSION,
+                    "actual_version": migrated.get("contract_version"),
+                },
+                indent=2,
+            )
+        )
+        return 3
+
+    if migrated.get("count") != expected.get("count") or migrated.get("contracts") != expected.get("contracts"):
+        print(
+            json.dumps(
+                {
+                    "status": "error",
+                    "message": "snapshot drift detected",
+                    "expected_count": expected.get("count"),
+                    "actual_count": migrated.get("count"),
+                    "migrations_applied": migrations,
+                },
+                indent=2,
+            )
+        )
+        return 3
+
+    print(
+        json.dumps(
+            {
+                "status": "ok",
+                "message": "snapshot matches runtime contracts",
+                "contract_version": CONTRACT_SNAPSHOT_VERSION,
+                "migrations_applied": migrations,
+                "snapshot": str(snapshot_path),
+            },
+            indent=2,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

package/scripts/check-omg-contract-snapshot.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Legacy wrapper for OMG compatibility snapshot checker."""
+from __future__ import annotations
+
+import runpy
+from pathlib import Path
+
+
+if __name__ == "__main__":
+    target = Path(__file__).resolve().with_name("check-omg-compat-contract-snapshot.py")
+    runpy.run_path(str(target), run_name="__main__")
+

package/scripts/check-omg-public-ready.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Check that the repo is safe and polished enough for a public launch."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import re
+
+ROOT = Path(__file__).resolve().parents[1]
+
+REQUIRED_PUBLIC_DOCS = [
+    "README.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "CODE_OF_CONDUCT.md",
+    "CHANGELOG.md",
+]
+
+REQUIRED_COMMUNITY_TEMPLATES = [
+    ".github/ISSUE_TEMPLATE/bug_report.yml",
+    ".github/ISSUE_TEMPLATE/feature_request.yml",
+    ".github/pull_request_template.md",
+]
+
+PUBLIC_DOC_GLOBS = [
+    "README.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "CODE_OF_CONDUCT.md",
+    "CHANGELOG.md",
+    "docs/**/*.md",
+    "plugins/README.md",
+    ".github/**/*.md",
+]
+
+TEXT_GLOBS = [
+    "README.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "CODE_OF_CONDUCT.md",
+    "CHANGELOG.md",
+    "docs/**/*.md",
+    "commands/**/*.md",
+    "plugins/**/*.md",
+    "agents/**/*.md",
+    "rules/**/*.md",
+    "runtime/**/*.py",
+    "hooks/**/*.py",
+    "scripts/**/*.py",
+    ".github/workflows/**/*.yml",
+    ".github/workflows/**/*.yaml",
+    "OMG-setup.sh",
+    "install.sh",
+    "package.json",
+    "settings.json",
+    ".claude-plugin/**/*.json",
+    "plugins/**/*.json",
+]
+
+MARKDOWN_LINK_RE = re.compile(r"!\[[^\]]*\]\(([^)]+)\)|\[[^\]]+\]\(([^)]+)\)")
+ALLOW_PATTERN_REFERENCES = {
+    ROOT / "scripts" / "check-omg-public-ready.py",
+}
+ALLOW_DEPRECATED_MARKETPLACE = {
+    ROOT / "OMG-setup.sh",
+    ROOT / "scripts" / "check-omg-public-ready.py",
+}
+
+
+def _iter_files(root: Path, globs: list[str]) -> list[Path]:
+    files: list[Path] = []
+    for pattern in globs:
+        files.extend(path for path in root.glob(pattern) if path.is_file())
+    return sorted(set(files))
+
+
+def _read(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def _find_text_violations(root: Path) -> list[str]:
+    violations: list[str] = []
+    for path in _iter_files(root, TEXT_GLOBS):
+        rel = path.relative_to(root)
+        content = _read(path)
+        if "/Users/" in content:
+            if path not in ALLOW_PATTERN_REFERENCES:
+                violations.append(f"{rel}: absolute local path found in public repo content")
+        if ".sisyphus/" in content:
+            if path not in ALLOW_PATTERN_REFERENCES:
+                violations.append(f"{rel}: stale internal path reference found (.sisyphus/)")
+        if "trac3er00/OAL" in content:
+            if path not in ALLOW_PATTERN_REFERENCES:
+                violations.append(f"{rel}: old repo identifier found (trac3er00/OAL)")
+        if "oh-advanced-layer" in content:
+            if path not in ALLOW_DEPRECATED_MARKETPLACE:
+                violations.append(f"{rel}: deprecated marketplace identifier found (oh-advanced-layer)")
+    return violations
+
+
+def _find_missing_docs(root: Path) -> list[str]:
+    violations: list[str] = []
+    for rel in REQUIRED_PUBLIC_DOCS:
+        if not (root / rel).exists():
+            violations.append(f"{rel}: missing required public doc")
+    return violations
+
+
+def _find_missing_templates(root: Path) -> list[str]:
+    violations: list[str] = []
+    for rel in REQUIRED_COMMUNITY_TEMPLATES:
+        if not (root / rel).exists():
+            violations.append(f"{rel}: missing required community template")
+    return violations
+
+
+def _find_internal_docs(root: Path) -> list[str]:
+    plans_dir = root / "docs" / "plans"
+    if plans_dir.exists():
+        return [f"{plans_dir.relative_to(root)}: internal planning docs must not ship in public branch"]
+    return []
+
+
+def _normalize_link_target(raw: str) -> str:
+    target = raw.strip()
+    if target.startswith("<") and target.endswith(">"):
+        target = target[1:-1].strip()
+    return target
+
+
+def _is_relative_markdown_link(target: str) -> bool:
+    if not target:
+        return False
+    if target.startswith("#"):
+        return False
+    lowered = target.lower()
+    return not (
+        lowered.startswith("http://")
+        or lowered.startswith("https://")
+        or lowered.startswith("mailto:")
+        or lowered.startswith("data:")
+        or lowered.startswith("file:")
+        or target.startswith("/")
+    )
+
+
+def _link_target_exists(doc_path: Path, target: str) -> bool:
+    file_part = target.split("#", 1)[0].split("?", 1)[0]
+    if not file_part:
+        return True
+    resolved = (doc_path.parent / file_part).resolve()
+    return resolved.exists()
+
+
+def _find_broken_markdown_links(root: Path) -> list[str]:
+    violations: list[str] = []
+    for path in _iter_files(root, PUBLIC_DOC_GLOBS):
+        rel = path.relative_to(root)
+        content = _read(path)
+        for match in MARKDOWN_LINK_RE.finditer(content):
+            target = _normalize_link_target(match.group(1) or match.group(2) or "")
+            if not _is_relative_markdown_link(target):
+                continue
+            if not _link_target_exists(path, target):
+                violations.append(f"{rel}: broken markdown link -> {target}")
+    return violations
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Check OMG public-readiness hygiene")
+    parser.add_argument("--root", default=str(ROOT))
+    args = parser.parse_args()
+    root = Path(args.root).resolve()
+
+    violations = []
+    violations.extend(_find_missing_docs(root))
+    violations.extend(_find_missing_templates(root))
+    violations.extend(_find_internal_docs(root))
+    violations.extend(_find_text_violations(root))
+    violations.extend(_find_broken_markdown_links(root))
+    violations = sorted(set(violations))
+
+    if violations:
+        print(json.dumps({"status": "error", "violations": violations}, indent=2))
+        return 1
+
+    print(json.dumps({"status": "ok", "message": "public readiness check passed"}, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/check-omg-standalone-clean.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Check that standalone/OMG-first naming rules are preserved."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+
+# Paths where legacy aliases are explicitly allowed.
+ALLOW_COMPAT_CLI = {
+    ROOT / "commands" / "OMG:compat.md",
+    ROOT / "tests" / "scripts" / "test_omg_cli.py",
+    ROOT / "tests" / "scripts" / "test_standalone_clean_check.py",
+    ROOT / "scripts" / "check-omg-standalone-clean.py",
+    ROOT / ".github" / "workflows" / "omg-compat-gate.yml",
+}
+
+ALLOW_LEGACY_MIGRATOR = {
+    ROOT / "scripts" / "migrate-legacy.py",
+    ROOT / "tests" / "e2e" / "test_standalone_ga.py",
+    ROOT / "scripts" / "check-omg-standalone-clean.py",
+}
+
+ALLOW_LEGACY_SNAPSHOT_CHECKER = {
+    ROOT / "scripts" / "check-omg-contract-snapshot.py",
+    ROOT / "tests" / "scripts" / "test_compat_snapshot_check.py",
+    ROOT / "scripts" / "check-omg-standalone-clean.py",
+}
+
+ALLOW_LEGACY_RUNTIME_IMPORT = {
+    ROOT / "tests" / "scripts" / "test_standalone_clean_check.py",
+    ROOT / "scripts" / "check-omg-standalone-clean.py",
+}
+
+SCAN_GLOBS = [
+    "README.md",
+    "OMG-setup.sh",
+    "install.sh",
+    "runtime/**/*.py",
+    "hooks/**/*.py",
+    "scripts/**/*.py",
+    "commands/**/*.md",
+    ".github/workflows/**/*.yml",
+    "tests/**/*.py",
+]
+
+
+def _iter_files(root: Path) -> list[Path]:
+    files: list[Path] = []
+    for pattern in SCAN_GLOBS:
+        files.extend(p for p in root.glob(pattern) if p.is_file())
+    # deterministic order
+    return sorted(set(files))
+
+
+def _contains(path: Path, token: str) -> bool:
+    return token in path.read_text(encoding="utf-8")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Check OMG standalone naming hygiene")
+    parser.add_argument("--root", default=str(ROOT))
+    args = parser.parse_args()
+    root = Path(args.root).resolve()
+
+    violations: list[str] = []
+
+    deprecated_workflow = root / ".github" / "workflows" / "compat-gate.yml"
+    if deprecated_workflow.exists():
+        violations.append(f"deprecated workflow exists: {deprecated_workflow.relative_to(root)}")
+
+    for path in _iter_files(root):
+        rel = path.relative_to(root)
+
+        if _contains(path, "python3 scripts/omg.py compat ") or _contains(path, "python3 scripts/omg.py omc "):
+            if path not in ALLOW_COMPAT_CLI:
+                violations.append(f"{rel}: legacy CLI namespace used outside allowlist")
+
+        if _contains(path, "migrate-legacy.py"):
+            if path not in ALLOW_LEGACY_MIGRATOR:
+                violations.append(f"{rel}: legacy migrator path reference outside allowlist")
+
+        if _contains(path, "check-omg-contract-snapshot.py"):
+            if path not in ALLOW_LEGACY_SNAPSHOT_CHECKER:
+                violations.append(f"{rel}: legacy snapshot checker reference outside allowlist")
+
+        if _contains(path, "runtime.legacy_compat"):
+            if path not in ALLOW_LEGACY_RUNTIME_IMPORT:
+                violations.append(f"{rel}: legacy runtime import outside allowlist")
+
+    if violations:
+        print(json.dumps({"status": "error", "violations": violations}, indent=2))
+        return 1
+
+    print(json.dumps({"status": "ok", "message": "standalone naming check passed"}, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/legacy_to_omg_migrate.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""CLI utility: migrate legacy state into canonical `.omg` layout."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from hooks.state_migration import migrate_legacy_to_omg  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Migrate legacy state to .omg")
+    parser.add_argument("--project-dir", default=os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd()))
+    args = parser.parse_args()
+
+    report = migrate_legacy_to_omg(args.project_dir)
+    print(json.dumps(report, indent=2))
+    return 0 if report.get("result") in {"ok", "no_legacy"} else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())