@trac3er/oh-my-god 2.0.4 → 2.0.7

package/build/lib/runtime/custom_agent_loader.py

@@ -0,0 +1,366 @@
+"""Custom Agent Loader — scans user/project agent dirs, hot-reloads on change.
+
+Scans ~/.omg/agents/ (user-level) and <project>/.omg/agents/ (project-level)
+for custom agent markdown files. Project-level agents override user-level.
+
+Feature flag: OMG_CUSTOM_AGENTS_ENABLED (default: False)
+"""
+from __future__ import annotations
+
+import os
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+# --- Lazy import helpers ---
+_OMG_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def _get_feature_flag() -> Any:
+    """Lazy-import get_feature_flag from hooks/_common.py."""
+    hooks_dir = os.path.join(_OMG_ROOT, "hooks")
+    if hooks_dir not in sys.path:
+        sys.path.insert(0, hooks_dir)
+    try:
+        from _common import get_feature_flag  # pyright: ignore[reportMissingImports]
+        return get_feature_flag
+    except ImportError:
+        return None
+
+
+def _is_enabled() -> bool:
+    """Check if custom agents feature is enabled.
+
+    Resolution: env var OMG_CUSTOM_AGENTS_ENABLED → settings.json → default False.
+    """
+    # Fast path: check env var directly
+    env_val = os.environ.get("OMG_CUSTOM_AGENTS_ENABLED", "").lower()
+    if env_val in ("0", "false", "no"):
+        return False
+    if env_val in ("1", "true", "yes"):
+        return True
+
+    # Slow path: check via get_feature_flag
+    get_flag = _get_feature_flag()
+    if get_flag is not None:
+        return get_flag("CUSTOM_AGENTS", default=False)
+    return False
+
+
+# --- Schema validation ---
+
+# Required sections
+_AGENT_HEADER_RE = re.compile(r"^#\s+Agent:\s*.+", re.MULTILINE)
+_ROLE_SECTION_RE = re.compile(r"^##\s+Role\b", re.MULTILINE)
+
+# Optional sections (validated if present)
+_OPTIONAL_SECTIONS = {
+    "Model": re.compile(r"^##\s+Model\b", re.MULTILINE),
+    "Capabilities": re.compile(r"^##\s+Capabilities\b", re.MULTILINE),
+    "Instructions": re.compile(r"^##\s+Instructions\b", re.MULTILINE),
+}
+
+
+def _validate_agent_schema(content: str) -> tuple[bool, list[str]]:
+    """Validate custom agent markdown schema.
+
+    Args:
+        content: Markdown content of the agent file.
+
+    Returns:
+        (is_valid, issues) where issues is a list of validation error strings.
+        Required: ``# Agent:`` header AND ``## Role`` section.
+        Optional but validated if present: ``## Model``, ``## Capabilities``, ``## Instructions``.
+    """
+    issues: list[str] = []
+
+    if not content or not content.strip():
+        return False, ["Agent file is empty"]
+
+    # Required: # Agent: header
+    if not _AGENT_HEADER_RE.search(content):
+        issues.append("Missing required '# Agent: <name>' header")
+
+    # Required: ## Role section
+    if not _ROLE_SECTION_RE.search(content):
+        issues.append("Missing required '## Role' section")
+
+    # Optional sections: validate format if present (check for typos)
+    # We don't flag missing optional sections, but if they're present with wrong format,
+    # we note it as informational (not blocking).
+
+    is_valid = len(issues) == 0
+    return is_valid, issues
+
+
+def _extract_agent_name(content: str, filename: str) -> str:
+    """Extract agent name from # Agent: header or fall back to filename."""
+    match = _AGENT_HEADER_RE.search(content)
+    if match:
+        # Extract the name part after "# Agent:"
+        line = match.group(0)
+        name = line.split(":", 1)[1].strip() if ":" in line else ""
+        if name:
+            return name.lower().replace(" ", "_")
+    # Fallback: use filename without extension
+    return Path(filename).stem.lower().replace("-", "_")
+
+
+def _extract_description(content: str) -> str:
+    """Extract description from ## Role section content."""
+    match = _ROLE_SECTION_RE.search(content)
+    if not match:
+        return ""
+    # Get text after ## Role until next ## or end
+    rest = content[match.end():]
+    next_section = re.search(r"^##\s+", rest, re.MULTILINE)
+    if next_section:
+        rest = rest[:next_section.start()]
+    # Take first non-empty line as description
+    for line in rest.strip().splitlines():
+        line = line.strip()
+        if line:
+            return line[:200]  # Cap at 200 chars
+    return ""
+
+
+def _extract_model_role(content: str) -> str | None:
+    """Extract model role from ## Model section if present."""
+    model_match = _OPTIONAL_SECTIONS["Model"].search(content)
+    if not model_match:
+        return None
+    rest = content[model_match.end():]
+    next_section = re.search(r"^##\s+", rest, re.MULTILINE)
+    if next_section:
+        rest = rest[:next_section.start()]
+    text = rest.strip().lower()
+    # Look for known role keywords
+    for role in ("smol", "slow", "default", "fast"):
+        if role in text:
+            return role
+    return None
+
+
+# --- Agent scanning ---
+
+def _get_user_agents_dir() -> str:
+    """Get user-level agents directory: ~/.omg/agents/"""
+    return os.path.join(os.path.expanduser("~"), ".omg", "agents")
+
+
+def _get_project_agents_dir(project_dir: str) -> str:
+    """Get project-level agents directory: <project>/.omg/agents/"""
+    return os.path.join(project_dir, ".omg", "agents")
+
+
+def _scan_agents_dir(agents_dir: str, level: str) -> list[dict[str, Any]]:
+    """Scan a directory for agent .md files.
+
+    Args:
+        agents_dir: Path to scan for .md files.
+        level: 'user' or 'project'.
+
+    Returns:
+        List of agent info dicts.
+    """
+    agents: list[dict[str, Any]] = []
+
+    if not os.path.isdir(agents_dir):
+        return agents
+
+    for filename in sorted(os.listdir(agents_dir)):
+        if not filename.endswith(".md"):
+            continue
+
+        filepath = os.path.join(agents_dir, filename)
+        if not os.path.isfile(filepath):
+            continue
+
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read(256 * 1024)  # 256KB limit
+        except OSError:
+            continue
+
+        is_valid, issues = _validate_agent_schema(content)
+        name = _extract_agent_name(content, filename)
+        description = _extract_description(content)
+        model_role = _extract_model_role(content)
+
+        agents.append({
+            "name": name,
+            "file": filepath,
+            "level": level,
+            "model_role": model_role,
+            "description": description,
+            "validated": is_valid,
+            "issues": issues,
+        })
+
+    return agents
+
+
+def load_custom_agents(project_dir: str = ".") -> list[dict[str, Any]]:
+    """Load custom agents from user and project directories.
+
+    If OMG_CUSTOM_AGENTS_ENABLED is False, returns empty list.
+    Scans ~/.omg/agents/*.md (user-level) and <project_dir>/.omg/agents/*.md (project-level).
+    Project-level agents override user-level agents with the same name.
+
+    Args:
+        project_dir: Project directory (default: current directory).
+
+    Returns:
+        List of agent info dicts with keys:
+        name, file, level, model_role, description, validated, issues
+    """
+    if not _is_enabled():
+        return []
+
+    project_dir = os.path.abspath(project_dir)
+
+    # Scan user-level first
+    user_dir = _get_user_agents_dir()
+    user_agents = _scan_agents_dir(user_dir, "user")
+
+    # Scan project-level
+    project_agents_dir = _get_project_agents_dir(project_dir)
+    project_agents = _scan_agents_dir(project_agents_dir, "project")
+
+    # Merge: project overrides user with same name
+    agents_by_name: dict[str, dict[str, Any]] = {}
+    for agent in user_agents:
+        agents_by_name[agent["name"]] = agent
+    for agent in project_agents:
+        agents_by_name[agent["name"]] = agent  # Override user-level
+
+    return list(agents_by_name.values())
+
+
+# --- Hot-reload watcher ---
+
+def _get_dir_state(agents_dir: str) -> dict[str, float]:
+    """Get mtime state of all .md files in a directory.
+
+    Returns:
+        Dict mapping filename → mtime.
+    """
+    state: dict[str, float] = {}
+    if not os.path.isdir(agents_dir):
+        return state
+    try:
+        for filename in os.listdir(agents_dir):
+            if not filename.endswith(".md"):
+                continue
+            filepath = os.path.join(agents_dir, filename)
+            try:
+                state[filepath] = os.stat(filepath).st_mtime
+            except OSError:
+                continue
+    except OSError:
+        pass
+    return state
+
+
+def watch_for_changes(
+    project_dir: str,
+    callback: Callable[[list[dict[str, Any]]], None],
+    poll_interval: float = 5.0,
+    max_iterations: int | None = None,
+) -> None:
+    """Poll agent dirs for changes and call callback when detected.
+
+    Uses stdlib-only mtime polling (no watchdog dependency).
+    Polls every ``poll_interval`` seconds.
+
+    Args:
+        project_dir: Project directory.
+        callback: Called with updated agent list when changes detected.
+        poll_interval: Seconds between polls (default: 5.0).
+        max_iterations: If set, stop after this many iterations (for testing).
+    """
+    project_dir = os.path.abspath(project_dir)
+    user_dir = _get_user_agents_dir()
+    project_agents_dir = _get_project_agents_dir(project_dir)
+
+    # Initial state
+    prev_user_state = _get_dir_state(user_dir)
+    prev_project_state = _get_dir_state(project_agents_dir)
+
+    iterations = 0
+    while True:
+        if max_iterations is not None and iterations >= max_iterations:
+            break
+
+        time.sleep(poll_interval)
+        iterations += 1
+
+        # Check for changes
+        curr_user_state = _get_dir_state(user_dir)
+        curr_project_state = _get_dir_state(project_agents_dir)
+
+        if curr_user_state != prev_user_state or curr_project_state != prev_project_state:
+            # Reload agents
+            agents = load_custom_agents(project_dir)
+            callback(agents)
+            prev_user_state = curr_user_state
+            prev_project_state = curr_project_state
+
+
+# --- Merged agent registry ---
+
+def get_all_agents(project_dir: str = ".") -> dict[str, dict[str, Any]]:
+    """Return merged dict of built-in + custom agents.
+
+    Custom agents extend/override built-in registry entries.
+    Returns dict mapping agent name → agent config.
+
+    Args:
+        project_dir: Project directory (default: current directory).
+
+    Returns:
+        Dict of agent configs. Built-in agents have standard keys.
+        Custom agents have: name, file, level, model_role, description,
+        validated, preferred_model, task_category, trigger_keywords, etc.
+    """
+    # Get built-in agents via lazy import
+    hooks_dir = os.path.join(_OMG_ROOT, "hooks")
+    if hooks_dir not in sys.path:
+        sys.path.insert(0, hooks_dir)
+
+    merged: dict[str, dict[str, Any]] = {}
+
+    try:
+        from _agent_registry import AGENT_REGISTRY  # pyright: ignore[reportMissingImports]
+        # Copy built-in agents
+        for name, config in AGENT_REGISTRY.items():
+            merged[name] = dict(config)
+            merged[name]["source"] = "builtin"
+    except ImportError:
+        pass
+
+    # Overlay custom agents
+    custom_agents = load_custom_agents(project_dir)
+    for agent in custom_agents:
+        if not agent.get("validated", False):
+            continue  # Skip invalid custom agents
+
+        name = agent["name"]
+        merged[name] = {
+            "preferred_model": "claude",
+            "task_category": "unspecified-high",
+            "skills": [],
+            "trigger_keywords": set(),
+            "mcp_tools": [],
+            "description": agent.get("description", ""),
+            "agent_file": agent.get("file", ""),
+            "model_version": "claude-sonnet-4-5",
+            "model_role": agent.get("model_role"),
+            "source": "custom",
+            "level": agent.get("level", "unknown"),
+            "validated": True,
+        }
+
+    return merged

package/build/lib/runtime/data_lineage.py

@@ -0,0 +1,73 @@
+"""Lineage manifests for generated OMG artifacts."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def build_lineage_manifest(
+    project_dir: str,
+    *,
+    artifact_type: str,
+    sources: list[dict[str, Any]],
+    privacy: str,
+    license: str,
+    derivation: dict[str, Any],
+    trace_id: str | None = None,
+) -> dict[str, Any]:
+    lineage_id = f"lineage-{uuid4().hex}"
+    payload = {
+        "schema": "DataLineageManifest",
+        "lineage_id": lineage_id,
+        "generated_at": _now(),
+        "artifact_type": artifact_type,
+        "sources": sources,
+        "privacy": privacy,
+        "license": license,
+        "derivation": derivation,
+        "trace_id": trace_id or "",
+    }
+    validation = validate_lineage_manifest(payload)
+    payload["status"] = validation["status"]
+    payload["errors"] = validation["errors"]
+
+    rel_path = Path(".omg") / "lineage" / f"{lineage_id}.json"
+    path = Path(project_dir) / rel_path
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+    payload["path"] = rel_path.as_posix()
+    return payload
+
+
+def validate_lineage_manifest(payload: dict[str, Any]) -> dict[str, Any]:
+    errors: list[str] = []
+    if not payload.get("artifact_type"):
+        errors.append("artifact_type is required")
+    if not payload.get("privacy"):
+        errors.append("privacy is required")
+    if not payload.get("license"):
+        errors.append("license is required")
+    sources = payload.get("sources", [])
+    if not isinstance(sources, list) or not sources:
+        errors.append("sources are required")
+    else:
+        for idx, source in enumerate(sources):
+            if not isinstance(source, dict):
+                errors.append(f"source {idx} must be an object")
+                continue
+            if not source.get("license"):
+                errors.append(f"source {idx} missing license")
+            if not source.get("path"):
+                errors.append(f"source {idx} missing path")
+    return {
+        "schema": "DataLineageValidationResult",
+        "status": "ok" if not errors else "error",
+        "errors": errors,
+    }

package/build/lib/runtime/delta_classifier.py

@@ -0,0 +1,81 @@
+"""Repo-aware change classification for routing and policy attachment."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import subprocess
+from typing import Any
+
+
+_CATEGORY_RULES: dict[str, tuple[str, ...]] = {
+    "auth": ("auth", "token", "secret", "login", "credential"),
+    "payment": ("payment", "billing", "invoice", "stripe", "checkout"),
+    "db": ("migration", "schema", "database", "sql", "postgres", "mysql"),
+    "infra": ("terraform", ".tf", "deploy", "helm", "k8s", "docker"),
+    "api": ("openapi", "swagger", "postman", "endpoint", "api"),
+    "data": ("dataset", "lineage", "privacy", "warehouse", "etl"),
+    "compliance": ("gdpr", "hipaa", "pci", "soc2", "privacy"),
+    "robotics": ("robot", "actuator", "sensor", "simulator"),
+    "vision": ("vision", "image", "camera", "cv"),
+    "health": ("health", "patient", "clinical", "medical"),
+    "algorithms": ("algorithm", "benchmark", "determinism", "complexity"),
+}
+
+
+def classify_project_changes(
+    project_dir: str,
+    *,
+    touched_files: list[str] | None = None,
+    goal: str = "",
+) -> dict[str, Any]:
+    files = touched_files if touched_files is not None else _discover_files(project_dir)
+    manifest_names = sorted(path.name for path in Path(project_dir).glob("*") if path.is_file())
+    haystacks = [goal.lower(), *[file.lower() for file in files], *[name.lower() for name in manifest_names]]
+
+    categories = {
+        category
+        for category, tokens in _CATEGORY_RULES.items()
+        if any(token in haystack for token in tokens for haystack in haystacks)
+    }
+    if not categories:
+        categories.add("implementation")
+
+    result = {
+        "schema": "DeltaClassification",
+        "project_dir": project_dir,
+        "goal": goal,
+        "categories": sorted(categories),
+        "touched_files": files,
+        "manifests": manifest_names,
+    }
+    return result
+
+
+def _discover_files(project_dir: str) -> list[str]:
+    root = Path(project_dir)
+    git_dir = root / ".git"
+    if git_dir.exists():
+        proc = subprocess.run(
+            ["git", "diff", "--name-only", "HEAD"],
+            cwd=str(root),
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=10,
+        )
+        if proc.returncode == 0:
+            files = [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+            if files:
+                return files
+
+    discovered: list[str] = []
+    for path in sorted(root.rglob("*")):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(root).as_posix()
+        if rel.startswith(".omg/"):
+            continue
+        discovered.append(rel)
+        if len(discovered) >= 32:
+            break
+    return discovered

package/build/lib/runtime/dispatcher.py

@@ -0,0 +1,47 @@
+"""Runtime dispatch orchestration for OMG v1 adapters."""
+from __future__ import annotations
+
+from typing import Any
+
+from runtime.adapters import get_adapters
+from runtime.business_workflow import build_business_workflow_result
+
+
+def dispatch_runtime(runtime: str, idea: dict[str, Any]) -> dict[str, Any]:
+    adapters = get_adapters()
+    adapter = adapters.get(runtime)
+    if adapter is None:
+        return {
+            "status": "error",
+            "error_code": "RUNTIME_NOT_FOUND",
+            "runtime": runtime,
+            "message": f"Unknown runtime: {runtime}",
+        }
+
+    try:
+        plan = adapter.plan(idea)
+        execution = adapter.execute(plan)
+        verification = adapter.verify(execution)
+        evidence = adapter.collect_evidence(verification)
+        business_workflow = build_business_workflow_result(
+            idea=idea,
+            plan=plan,
+            execution=execution,
+            verification=verification,
+        )
+        return {
+            "status": "ok",
+            "runtime": runtime,
+            "plan": plan,
+            "execution": execution,
+            "verification": verification,
+            "evidence": evidence,
+            "business_workflow": business_workflow,
+        }
+    except Exception as exc:  # pragma: no cover - defensive guard
+        return {
+            "status": "error",
+            "error_code": "RUNTIME_EXECUTION_FAILED",
+            "runtime": runtime,
+            "message": str(exc),
+        }

package/build/lib/runtime/domain_packs.py

@@ -0,0 +1,46 @@
+"""Optional domain pack contracts for high-risk verticals."""
+from __future__ import annotations
+
+from typing import Any
+
+
+DOMAIN_PACKS: dict[str, dict[str, Any]] = {
+    "robotics": {
+        "name": "robotics",
+        "required_approvals": ["actuation-approval"],
+        "required_evidence": ["simulator-replay", "kill-switch-check"],
+        "policy_modules": ["safe-actuation", "simulator-gate"],
+        "eval_hooks": ["robotics-sim"],
+        "replay_hooks": ["incident-replay"],
+    },
+    "vision": {
+        "name": "vision",
+        "required_approvals": [],
+        "required_evidence": ["dataset-provenance", "drift-check"],
+        "policy_modules": ["dataset-lineage", "drift-gate"],
+        "eval_hooks": ["vision-regression"],
+        "replay_hooks": ["incident-replay"],
+    },
+    "algorithms": {
+        "name": "algorithms",
+        "required_approvals": [],
+        "required_evidence": ["benchmark-harness", "determinism-check"],
+        "policy_modules": ["benchmark-gate", "determinism-gate"],
+        "eval_hooks": ["algorithm-benchmarks"],
+        "replay_hooks": ["incident-replay"],
+    },
+    "health": {
+        "name": "health",
+        "required_approvals": ["human-review"],
+        "required_evidence": ["audit-trail", "restricted-tools", "provenance"],
+        "policy_modules": ["human-review", "privacy-gate"],
+        "eval_hooks": ["health-safety"],
+        "replay_hooks": ["incident-replay"],
+    },
+}
+
+
+def get_domain_pack_contract(name: str) -> dict[str, Any]:
+    if name not in DOMAIN_PACKS:
+        raise KeyError(name)
+    return dict(DOMAIN_PACKS[name])