@trac3er/oh-my-god 1.0.2

package/omg_natives/html.py

@@ -0,0 +1,157 @@
+"""OMG Natives — html: HTML→Markdown and HTML→text conversion.
+
+Pure-Python fallback for HTML processing.
+Uses ``re`` only — avoids importing stdlib ``html`` to prevent circular
+import issues (this file is named ``html.py`` which shadows the stdlib).
+
+Feature flag: ``OMG_RUST_ENGINE_ENABLED`` (default: False)
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, List, Optional
+
+from omg_natives._bindings import bind_function
+
+# ---------------------------------------------------------------------------
+# Minimal HTML entity unescaping (avoids importing stdlib html module)
+# ---------------------------------------------------------------------------
+
+_ENTITIES: Dict[str, str] = {
+    "&": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " ",
+}
+
+_NUMERIC_ENTITY_RE = re.compile(r"&#x([0-9a-fA-F]+);|&#(\d+);")
+
+
+def _unescape(text: str) -> str:
+    """Minimal HTML entity unescaping."""
+    for entity, char in _ENTITIES.items():
+        text = text.replace(entity, char)
+
+    def _replace_numeric(m: re.Match) -> str:
+        hex_val, dec_val = m.group(1), m.group(2)
+        try:
+            if hex_val:
+                return chr(int(hex_val, 16))
+            if dec_val:
+                return chr(int(dec_val))
+        except (ValueError, OverflowError):
+            pass
+        return m.group(0)
+
+    return _NUMERIC_ENTITY_RE.sub(_replace_numeric, text)
+
+
+# ---------------------------------------------------------------------------
+# Regex-based HTML→Markdown converter (avoids stdlib html.parser)
+# ---------------------------------------------------------------------------
+
+_TAG_RE = re.compile(r"<(/?)(\w+)([^>]*)(/?)>", re.DOTALL)
+_ATTR_RE = re.compile(r'(\w+)\s*=\s*["\']([^"\']*)["\']')
+
+
+def _html_to_markdown(content: str) -> str:
+    """Convert basic HTML to Markdown using regex."""
+    parts: List[str] = []
+    last_end = 0
+    pending_href: Optional[str] = None
+
+    for m in _TAG_RE.finditer(content):
+        text_before = content[last_end:m.start()]
+        if text_before:
+            parts.append(text_before)
+        last_end = m.end()
+
+        is_closing = m.group(1) == "/"
+        tag = m.group(2).lower()
+        attrs_str = m.group(3)
+
+        if not is_closing:
+            if tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
+                level = int(tag[1])
+                parts.append("\n" + "#" * level + " ")
+            elif tag == "p":
+                parts.append("\n\n")
+            elif tag == "br":
+                parts.append("\n")
+            elif tag in ("strong", "b"):
+                parts.append("**")
+            elif tag in ("em", "i"):
+                parts.append("*")
+            elif tag == "a":
+                attrs = dict(_ATTR_RE.findall(attrs_str))
+                pending_href = attrs.get("href", "")
+                parts.append("[")
+            elif tag == "li":
+                parts.append("\n- ")
+            elif tag in ("ul", "ol"):
+                parts.append("\n")
+            elif tag == "code":
+                parts.append("`")
+            elif tag == "pre":
+                parts.append("\n```\n")
+            elif tag == "blockquote":
+                parts.append("\n> ")
+            elif tag == "hr":
+                parts.append("\n---\n")
+        else:
+            if tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
+                parts.append("\n")
+            elif tag == "p":
+                parts.append("\n")
+            elif tag in ("strong", "b"):
+                parts.append("**")
+            elif tag in ("em", "i"):
+                parts.append("*")
+            elif tag == "a":
+                parts.append(f"]({pending_href or ''})")
+                pending_href = None
+            elif tag == "code":
+                parts.append("`")
+            elif tag == "pre":
+                parts.append("\n```\n")
+
+    if last_end < len(content):
+        parts.append(content[last_end:])
+
+    return "".join(parts).strip()
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def html(content: str, operation: str = "to_text") -> str:
+    """Process HTML content.
+
+    Operations:
+
+    - ``"to_text"``: strip all HTML tags, return plain text.
+    - ``"to_markdown"``: convert basic HTML to Markdown
+      (h1→#, h2→##, p→newline, a→[text](href), strong→**, em→*).
+    """
+    if operation == "to_text":
+        text = re.sub(r"<[^>]+>", "", content)
+        return _unescape(text).strip()
+    elif operation == "to_markdown":
+        return _html_to_markdown(content)
+    else:
+        return content
+
+
+# Self-register with the global binding registry
+bind_function(
+    name="html",
+    rust_symbol="omg_natives::html::html",
+    python_fallback=html,
+    type_hints={"content": "str", "operation": "str"},
+)

package/omg_natives/image.py

@@ -0,0 +1,51 @@
+"""OMG Natives — image: image file info via stdlib.
+
+Pure-Python fallback for image file metadata retrieval.
+Uses ``os.path`` and ``pathlib`` — no PIL/Pillow dependency.
+
+Feature flag: ``OMG_RUST_ENGINE_ENABLED`` (default: False)
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from omg_natives._bindings import bind_function
+
+
+def image(path: str, operation: str = "info") -> dict:
+    """Get image file information.
+
+    Operations:
+
+    - ``"info"``: returns ``{"path": str, "size_bytes": int, "exists": bool, "extension": str}``
+
+    No PIL/Pillow dependency — stdlib only.
+    """
+    if operation == "info":
+        p = Path(path)
+        exists = p.exists()
+        size_bytes = 0
+        if exists:
+            try:
+                size_bytes = os.path.getsize(path)
+            except OSError:
+                pass
+        return {
+            "path": str(p),
+            "size_bytes": size_bytes,
+            "exists": exists,
+            "extension": p.suffix,
+        }
+    else:
+        return {"path": path, "size_bytes": 0, "exists": False, "extension": ""}
+
+
+# Self-register with the global binding registry
+bind_function(
+    name="image",
+    rust_symbol="omg_natives::image::image",
+    python_fallback=image,
+    type_hints={"path": "str", "operation": "str"},
+)

package/omg_natives/keys.py

@@ -0,0 +1,46 @@
+"""OMG Natives — keys: keyboard protocol stubs.
+
+Pure-Python stub for keyboard key listing and encoding.
+No actual keyboard interaction — returns static data.
+
+Feature flag: ``OMG_RUST_ENGINE_ENABLED`` (default: False)
+"""
+
+from __future__ import annotations
+
+from typing import List
+
+from omg_natives._bindings import bind_function
+
+# Common key names for the stub
+_COMMON_KEYS: List[str] = [
+    "Enter", "Escape", "Tab", "Backspace", "Delete",
+    "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight",
+    "Home", "End", "PageUp", "PageDown",
+    "F1", "F2", "F3", "F4", "F5", "F6",
+    "F7", "F8", "F9", "F10", "F11", "F12",
+    "Space", "Insert", "PrintScreen", "ScrollLock", "Pause",
+]
+
+
+def keys(operation: str = "list") -> list[str]:
+    """Keyboard protocol stubs.
+
+    - ``"list"``: returns a list of common key names.
+    - ``"encode"``: returns an empty list (stub).
+    """
+    if operation == "list":
+        return list(_COMMON_KEYS)
+    elif operation == "encode":
+        return []
+    else:
+        return []
+
+
+# Self-register with the global binding registry
+bind_function(
+    name="keys",
+    rust_symbol="omg_natives::keys::keys",
+    python_fallback=keys,
+    type_hints={"operation": "str"},
+)

package/omg_natives/prof.py

@@ -0,0 +1,39 @@
+"""OMG Natives — prof: profiling wrapper.
+
+Pure-Python fallback for simple function profiling.
+Uses ``time.perf_counter`` for high-resolution timing.
+
+Feature flag: ``OMG_RUST_ENGINE_ENABLED`` (default: False)
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Callable
+
+from omg_natives._bindings import bind_function
+
+
+def prof(fn: Callable[..., Any], *args: Any, **kwargs: Any) -> dict:
+    """Profile the execution of *fn(*args, **kwargs)*.
+
+    Returns ``{"result": value, "elapsed_ms": float, "error": None}`` on success,
+    or ``{"result": None, "elapsed_ms": float, "error": str}`` on failure.
+    """
+    start = time.perf_counter()
+    try:
+        result = fn(*args, **kwargs)
+        elapsed = (time.perf_counter() - start) * 1000.0
+        return {"result": result, "elapsed_ms": elapsed, "error": None}
+    except Exception as exc:
+        elapsed = (time.perf_counter() - start) * 1000.0
+        return {"result": None, "elapsed_ms": elapsed, "error": str(exc)}
+
+
+# Self-register with the global binding registry
+bind_function(
+    name="prof",
+    rust_symbol="omg_natives::prof::prof",
+    python_fallback=prof,
+    type_hints={"fn": "callable"},
+)

package/omg_natives/ps.py

@@ -0,0 +1,93 @@
+"""OMG Natives — ps: process listing.
+
+Pure-Python fallback for process listing.
+Uses ``os`` module — reads ``/proc`` on Linux, falls back to
+``os.getpid()`` / ``os.getppid()`` on other platforms.
+
+Feature flag: ``OMG_RUST_ENGINE_ENABLED`` (default: False)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import List
+
+from omg_natives._bindings import bind_function
+
+
+def ps() -> list[dict]:
+    """Return a list of process info dicts.
+
+    Each dict contains ``{"pid": int, "name": str, "status": str}``.
+
+    On Linux, reads ``/proc`` for process data. On other platforms,
+    returns at minimum the current process and parent process.
+    """
+    processes: List[dict] = []
+
+    if sys.platform == "linux" and os.path.isdir("/proc"):
+        try:
+            for entry in os.listdir("/proc"):
+                if not entry.isdigit():
+                    continue
+                pid = int(entry)
+                name = _read_proc_name(pid)
+                status = _read_proc_status(pid)
+                processes.append({"pid": pid, "name": name, "status": status})
+        except OSError:
+            pass
+
+    # Always include at least the current and parent process
+    if not processes:
+        processes.append({
+            "pid": os.getpid(),
+            "name": _get_current_process_name(),
+            "status": "running",
+        })
+        ppid = os.getppid()
+        if ppid > 0:
+            processes.append({
+                "pid": ppid,
+                "name": "parent",
+                "status": "running",
+            })
+
+    return processes
+
+
+def _read_proc_name(pid: int) -> str:
+    """Read the process name from /proc/<pid>/comm."""
+    try:
+        with open(f"/proc/{pid}/comm", "r") as f:
+            return f.read().strip()
+    except OSError:
+        return "unknown"
+
+
+def _read_proc_status(pid: int) -> str:
+    """Read the process status from /proc/<pid>/status."""
+    try:
+        with open(f"/proc/{pid}/status", "r") as f:
+            for line in f:
+                if line.startswith("State:"):
+                    return line.split(":", 1)[1].strip().split()[0]
+    except OSError:
+        pass
+    return "unknown"
+
+
+def _get_current_process_name() -> str:
+    """Get the current process name."""
+    try:
+        return os.path.basename(sys.executable)
+    except Exception:
+        return "python"
+
+
+# Self-register with the global binding registry
+bind_function(
+    name="ps",
+    rust_symbol="omg_natives::ps::ps",
+    python_fallback=ps,
+)

package/omg_natives/shell.py

@@ -0,0 +1,58 @@
+"""OMG Natives — shell: subprocess execution.
+
+Pure-Python fallback for subprocess execution.
+Uses ``subprocess.run`` with capture and timeout support.
+
+Feature flag: ``OMG_RUST_ENGINE_ENABLED`` (default: False)
+"""
+
+from __future__ import annotations
+
+import subprocess
+
+from omg_natives._bindings import bind_function
+
+
+def shell(cmd: str, timeout: int = 30) -> dict:
+    """Execute *cmd* in a subprocess shell.
+
+    Returns ``{"stdout": str, "stderr": str, "returncode": int, "success": bool}``.
+    On timeout or other errors, ``returncode`` is ``-1`` and ``success`` is ``False``.
+    """
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        return {
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "returncode": result.returncode,
+            "success": result.returncode == 0,
+        }
+    except subprocess.TimeoutExpired:
+        return {
+            "stdout": "",
+            "stderr": f"Command timed out after {timeout}s",
+            "returncode": -1,
+            "success": False,
+        }
+    except OSError as exc:
+        return {
+            "stdout": "",
+            "stderr": str(exc),
+            "returncode": -1,
+            "success": False,
+        }
+
+
+# Self-register with the global binding registry
+bind_function(
+    name="shell",
+    rust_symbol="omg_natives::shell::shell",
+    python_fallback=shell,
+    type_hints={"cmd": "str", "timeout": "int"},
+)

package/omg_natives/task.py

@@ -0,0 +1,41 @@
+"""OMG Natives — task: concurrent.futures thread pool execution.
+
+Pure-Python fallback using ``concurrent.futures.ThreadPoolExecutor``
+for running callables in a background thread with timeout support.
+
+Feature flag: ``OMG_RUST_ENGINE_ENABLED`` (default: False)
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
+from typing import Any, Callable
+
+from omg_natives._bindings import bind_function
+
+
+def task_run(fn: Callable[..., Any], *args: Any, timeout: float = 30.0) -> dict:
+    """Run *fn(*args)* in a ``ThreadPoolExecutor``.
+
+    Returns ``{"result": value, "error": None}`` on success,
+    or ``{"result": None, "error": str}`` on failure.
+    """
+    try:
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(fn, *args)
+            result = future.result(timeout=timeout)
+            return {"result": result, "error": None}
+    except FuturesTimeoutError:
+        return {"result": None, "error": f"Task timed out after {timeout}s"}
+    except Exception as exc:
+        return {"result": None, "error": str(exc)}
+
+
+# Self-register with the global binding registry
+# Note: function is 'task_run' to avoid shadowing Python's 'task' concept
+bind_function(
+    name="task_run",
+    rust_symbol="omg_natives::task::task_run",
+    python_fallback=task_run,
+    type_hints={"fn": "callable", "timeout": "float"},
+)

package/omg_natives/text.py

@@ -0,0 +1,50 @@
+"""OMG Natives — text: ANSI-aware text operations.
+
+Pure-Python fallback for text normalization, ANSI stripping, and counting.
+Uses ``re`` for ANSI escape code removal.
+
+Feature flag: ``OMG_RUST_ENGINE_ENABLED`` (default: False)
+"""
+
+from __future__ import annotations
+
+import re
+
+from omg_natives._bindings import bind_function
+
+# ANSI escape code pattern (covers CSI sequences, OSC, etc.)
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?\x07|\x1b[^[\]()]")
+
+
+def text(content: str, operation: str = "normalize") -> str:
+    """Perform text operations on *content*.
+
+    Supported operations:
+
+    - ``"normalize"``: strip ANSI codes and normalize whitespace
+    - ``"strip_ansi"``: remove ANSI escape codes only
+    - ``"word_count"``: return word count as a string
+    - ``"line_count"``: return line count as a string
+    """
+    if operation == "strip_ansi":
+        return _ANSI_RE.sub("", content)
+    elif operation == "normalize":
+        stripped = _ANSI_RE.sub("", content)
+        # Normalize whitespace: collapse runs, strip leading/trailing
+        return " ".join(stripped.split())
+    elif operation == "word_count":
+        clean = _ANSI_RE.sub("", content)
+        return str(len(clean.split()))
+    elif operation == "line_count":
+        return str(content.count("\n") + (1 if content and not content.endswith("\n") else 0))
+    else:
+        return content
+
+
+# Self-register with the global binding registry
+bind_function(
+    name="text",
+    rust_symbol="omg_natives::text::text",
+    python_fallback=text,
+    type_hints={"content": "str", "operation": "str"},
+)

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@trac3er/oh-my-god",
+  "version": "1.0.2",
+  "description": "OAL (Orchestration Abstraction Layer) — Multi-agent orchestration, intelligent model routing, and durable session state for Claude Code",
+  "main": "OMG-setup.sh",
+  "scripts": {
+    "install": "./OMG-setup.sh install",
+    "update": "./OMG-setup.sh update",
+    "uninstall": "./OMG-setup.sh uninstall",
+    "test": "python3 -m pytest tests/ -x -q"
+  },
+  "keywords": ["claude", "claude-code", "orchestration", "multi-agent", "ai", "llm", "codex", "gemini"],
+  "author": "trac3er00",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/trac3er00/OAL.git"
+  },
+  "bugs": {
+    "url": "https://github.com/trac3er00/OAL/issues"
+  },
+  "homepage": "https://github.com/trac3er00/OAL#readme",
+  "engines": {
+    "node": ">=14"
+  }
+}

package/plugins/README.md

@@ -0,0 +1,82 @@
+# OMG Commands
+
+OMG (Oh My OpenCode Alternative) provides two tiers of commands:
+
+## Core Commands (`commands/`)
+
+Essential functionality available in all OMG installations:
+
+| Command | Description |
+|---------|-------------|
+| `/OMG:init` | Initialize project or domain |
+| `/OMG:escalate` | Route to Codex/Gemini/CCG |
+| `/OMG:teams` | Team routing (standalone) |
+| `/OMG:ccg` | Tri-track synthesis (Claude+Codex+Gemini) |
+| `/OMG:crazy` | Parallel multi-agent orchestration |
+| `/OMG:compat` | Legacy compatibility dispatcher |
+| `/OMG:health-check` | Verify setup and tools |
+| `/OMG:mode` | Set cognitive mode |
+
+## Advanced Commands (`plugins/advanced/`)
+
+Extended functionality for specialized workflows:
+
+| Command | Category | Description |
+|---------|----------|-------------|
+| `/OMG:deep-plan` | Planning | Strategic planning with domain awareness |
+| `/OMG:learn` | Knowledge | Create skills from patterns |
+| `/OMG:code-review` | Quality | Deep code review |
+| `/OMG:security-review` | Security | Security vulnerability scanning |
+| `/OMG:ship` | Delivery | Ship pipeline (idea → PR) |
+| `/OMG:handoff` | Collaboration | Session transfer |
+| `/OMG:maintainer` | OSS | Open-source maintainer tools |
+| `/OMG:sequential-thinking` | Thinking | Structured reasoning |
+| `/OMG:ralph-start` | Automation | Start Ralph loop |
+| `/OMG:ralph-stop` | Automation | Stop Ralph loop |
+
+## Plugin Architecture
+
+Commands are organized as plugins:
+
+```
+plugins/
+├── core/           # Essential commands
+│   ├── commands/   # Command definitions
+│   └── plugin.json # Plugin manifest
+└── advanced/       # Extended commands
+    ├── commands/
+    └── plugin.json
+```
+
+### Using Advanced Commands
+
+Advanced commands work the same as core commands:
+
+```
+/OMG:deep-plan implement OAuth2 flow
+/OMG:learn from this session
+/OMG:code-review src/auth.ts
+```
+
+### Creating Custom Plugins
+
+1. Create `plugins/my-plugin/plugin.json`
+2. Add commands to `plugins/my-plugin/commands/`
+3. OMG auto-discovers plugins on startup
+
+See `plugins/advanced/` for examples.
+
+## Migration from Superpowers
+
+Advanced commands are OMG-native equivalents of superpowers capabilities:
+
+| Superpowers | OMG Advanced |
+|-------------|--------------|
+| `writing-plans` | `/OMG:deep-plan` |
+| `learner` | `/OMG:learn` |
+| `requesting-code-review` | `/OMG:code-review` |
+| `security-review` | `/OMG:security-review` |
+| `finishing-a-development-branch` | `/OMG:ship` |
+| `handoff` | `/OMG:handoff` |
+
+OMG advanced commands are designed for OMG standalone mode without requiring external plugins.