ultra-builder-pro-cli 5.0.0 → 6.0.0

package/hooks/adapters/codex.py

@@ -1,295 +0,0 @@
-#!/usr/bin/env python3
-"""Codex wire adapter for Ultra Builder Pro's five file-first hooks.
-
-Codex and Claude Code share the JSON-on-stdin command-hook shape, but differ
-at three important boundaries:
-
-- Codex emits ``apply_patch`` with the patch text in ``tool_input.command``;
-  the post-edit sensor expects one ``Edit`` event per ``file_path``.
-- Codex rejects ``permissionDecision: ask`` in PreToolUse output. Ultra warning
-  decisions therefore become advisory ``systemMessage`` values.
-- Each event has a strict output schema. This adapter removes foreign fields
-  while preserving real deny/block decisions and additional context.
-
-The adapter executes only allowlisted sibling hook modules. It is both a CLI
-entrypoint used by ``hooks/hooks.json`` and an importable normalization layer
-for tests.
-"""
-
-from __future__ import annotations
-
-import copy
-import json
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-from typing import Any
-
-
-HOOK_ROOT = Path(__file__).resolve().parent.parent
-ALLOWED_FEATURES = {
-    "block_dangerous_commands.py",
-    "compact_context.py",
-    "mid_workflow_recall.py",
-    "post_edit_guard.py",
-    "session_context.py",
-}
-UNIVERSAL_OUTPUT_FIELDS = {"continue", "stopReason", "suppressOutput", "systemMessage"}
-PATCH_FILE_RE = re.compile(r"^\*\*\* (?:Add|Update|Delete) File: (.+?)\s*$", re.MULTILINE)
-PATCH_MOVE_RE = re.compile(r"^\*\*\* Move to: (.+?)\s*$", re.MULTILINE)
-
-
-def _patch_paths(tool_input: Any) -> list[str]:
-    if not isinstance(tool_input, dict):
-        return []
-    patch = tool_input.get("command") or tool_input.get("patch") or ""
-    if not isinstance(patch, str):
-        return []
-    paths: list[str] = []
-    for match in [*PATCH_FILE_RE.findall(patch), *PATCH_MOVE_RE.findall(patch)]:
-        candidate = match.strip()
-        if candidate and candidate not in paths:
-            paths.append(candidate)
-    return paths
-
-
-def normalize_inputs(payload: dict[str, Any]) -> list[dict[str, Any]]:
-    """Return file-first hook input(s) for one Codex hook payload."""
-    normalized = copy.deepcopy(payload)
-    if normalized.get("tool_response") is not None and normalized.get("tool_output") is None:
-        normalized["tool_output"] = normalized["tool_response"]
-
-    if normalized.get("tool_name") != "apply_patch":
-        return [normalized]
-
-    paths = _patch_paths(normalized.get("tool_input"))
-    if not paths:
-        normalized["tool_name"] = "Edit"
-        tool_input = normalized.get("tool_input")
-        normalized["tool_input"] = dict(tool_input) if isinstance(tool_input, dict) else {}
-        normalized["tool_input"].setdefault("file_path", "")
-        return [normalized]
-
-    outputs: list[dict[str, Any]] = []
-    for file_path in paths:
-        item = copy.deepcopy(normalized)
-        item["tool_name"] = "Edit"
-        tool_input = item.get("tool_input")
-        item["tool_input"] = dict(tool_input) if isinstance(tool_input, dict) else {}
-        item["tool_input"]["file_path"] = file_path
-        outputs.append(item)
-    return outputs
-
-
-def _universal(output: dict[str, Any]) -> dict[str, Any]:
-    return {key: output[key] for key in UNIVERSAL_OUTPUT_FIELDS if key in output}
-
-
-def adapt_output(output: dict[str, Any], event: str) -> dict[str, Any]:
-    """Convert a shared hook result to the strict Codex event output schema."""
-    if not isinstance(output, dict):
-        return {}
-    result = _universal(output)
-    hook_specific = output.get("hookSpecificOutput")
-    hook_specific = dict(hook_specific) if isinstance(hook_specific, dict) else None
-
-    if event == "PreToolUse":
-        if hook_specific:
-            decision = hook_specific.get("permissionDecision")
-            reason = hook_specific.get("permissionDecisionReason")
-            if decision == "ask":
-                if reason:
-                    result["systemMessage"] = str(reason)
-                additional = hook_specific.get("additionalContext")
-                if additional:
-                    result["systemMessage"] = "\n".join(
-                        part for part in [result.get("systemMessage"), str(additional)] if part
-                    )
-                return result
-            allowed = {
-                "hookEventName": "PreToolUse",
-                **{key: value for key, value in hook_specific.items() if key in {
-                    "permissionDecision", "permissionDecisionReason", "updatedInput", "additionalContext"
-                }},
-            }
-            result["hookSpecificOutput"] = allowed
-        if output.get("decision") in {"block"}:
-            result["decision"] = "block"
-            if output.get("reason"):
-                result["reason"] = output["reason"]
-        return result
-
-    if event == "PermissionRequest":
-        if hook_specific and hook_specific.get("permissionDecision") in {"allow", "deny"}:
-            result["hookSpecificOutput"] = {
-                "hookEventName": "PermissionRequest",
-                "decision": {
-                    "behavior": hook_specific["permissionDecision"],
-                    "message": hook_specific.get("permissionDecisionReason"),
-                },
-            }
-        return result
-
-    if event == "PostToolUse":
-        if output.get("decision") == "block":
-            result["decision"] = "block"
-            result["reason"] = str(output.get("reason") or "Ultra post-edit gate blocked continuation")
-        if hook_specific and hook_specific.get("additionalContext"):
-            result["hookSpecificOutput"] = {
-                "hookEventName": "PostToolUse",
-                "additionalContext": hook_specific["additionalContext"],
-            }
-        return result
-
-    if event == "SessionStart":
-        if hook_specific and hook_specific.get("additionalContext"):
-            result["hookSpecificOutput"] = {
-                "hookEventName": "SessionStart",
-                "additionalContext": hook_specific["additionalContext"],
-            }
-        return result
-
-    if event == "SubagentStart":
-        if hook_specific and hook_specific.get("additionalContext"):
-            result["hookSpecificOutput"] = {
-                "hookEventName": "SubagentStart",
-                "additionalContext": hook_specific["additionalContext"],
-            }
-        return result
-
-    if event == "UserPromptSubmit":
-        if output.get("decision") == "block":
-            result["decision"] = "block"
-            result["reason"] = str(output.get("reason") or "Ultra prompt gate blocked submission")
-        if hook_specific and hook_specific.get("additionalContext"):
-            result["hookSpecificOutput"] = {
-                "hookEventName": "UserPromptSubmit",
-                "additionalContext": hook_specific["additionalContext"],
-            }
-        return result
-
-    if event == "Stop":
-        if output.get("decision") == "block":
-            result["decision"] = "block"
-            result["reason"] = str(output.get("reason") or "Ultra hook blocked stop")
-        return result
-
-    if event in {"PreCompact", "PostCompact", "SubagentStop"}:
-        extra = output.get("additionalContext")
-        if not extra and hook_specific:
-            extra = hook_specific.get("additionalContext")
-        if extra:
-            result["systemMessage"] = str(extra)
-        return result
-
-    return result
-
-
-def _parse_output(stdout: str) -> dict[str, Any]:
-    text = stdout.strip()
-    if not text:
-        return {}
-    try:
-        value = json.loads(text)
-    except json.JSONDecodeError:
-        return {"systemMessage": f"Ultra hook returned non-JSON output: {text[:500]}"}
-    return value if isinstance(value, dict) else {}
-
-
-def _merge_outputs(outputs: list[dict[str, Any]], event: str) -> dict[str, Any]:
-    if not outputs:
-        return {}
-    if len(outputs) == 1:
-        return outputs[0]
-
-    messages = [str(item.get("systemMessage")) for item in outputs if item.get("systemMessage")]
-    contexts: list[str] = []
-    blocking: dict[str, Any] | None = None
-    for item in outputs:
-        if item.get("decision") == "block":
-            blocking = item
-            break
-        specific = item.get("hookSpecificOutput")
-        if isinstance(specific, dict) and specific.get("permissionDecision") == "deny":
-            blocking = item
-            break
-        if isinstance(specific, dict) and specific.get("additionalContext"):
-            contexts.append(str(specific["additionalContext"]))
-
-    result = dict(blocking or {})
-    if messages:
-        result["systemMessage"] = "\n\n".join(messages)
-    if contexts and not blocking and event in {"PostToolUse", "SessionStart", "SubagentStart", "UserPromptSubmit"}:
-        result["hookSpecificOutput"] = {
-            "hookEventName": event,
-            "additionalContext": "\n\n".join(contexts),
-        }
-    return result
-
-
-def run_feature(feature: str, payload: dict[str, Any], feature_args: list[str]) -> dict[str, Any]:
-    if feature not in ALLOWED_FEATURES or Path(feature).name != feature:
-        return {"systemMessage": f"Ultra hook adapter refused unknown feature: {feature}"}
-    script = HOOK_ROOT / feature
-    if not script.is_file():
-        return {"systemMessage": f"Ultra hook feature is missing: {feature}"}
-
-    event = str(payload.get("hook_event_name") or "")
-    env = os.environ.copy()
-    env["UBP_HOOK_RUNTIME"] = "codex"
-    plugin_data = env.get("PLUGIN_DATA") or env.get("CLAUDE_PLUGIN_DATA")
-    if plugin_data:
-        env["UBP_HOOK_DATA"] = plugin_data
-
-    cwd = payload.get("cwd")
-    run_cwd = str(cwd) if isinstance(cwd, str) and Path(cwd).is_dir() else os.getcwd()
-    outputs: list[dict[str, Any]] = []
-    for normalized in normalize_inputs(payload):
-        proc = subprocess.run(
-            [sys.executable, str(script), *feature_args],
-            input=json.dumps(normalized),
-            text=True,
-            capture_output=True,
-            cwd=run_cwd,
-            env=env,
-            timeout=30,
-            check=False,
-        )
-        if proc.stderr:
-            print(proc.stderr.rstrip(), file=sys.stderr)
-        if proc.returncode != 0:
-            outputs.append({
-                "systemMessage": f"Ultra hook {feature} failed with exit {proc.returncode}: {proc.stderr.strip()[:500]}"
-            })
-            continue
-        outputs.append(adapt_output(_parse_output(proc.stdout), event))
-    return _merge_outputs(outputs, event)
-
-
-def main() -> int:
-    if len(sys.argv) < 2:
-        print(json.dumps({"systemMessage": "Ultra Codex hook adapter requires a feature name"}))
-        return 0
-    feature = sys.argv[1]
-    feature_args = sys.argv[2:]
-    try:
-        payload = json.loads(sys.stdin.read() or "{}")
-        if not isinstance(payload, dict):
-            payload = {}
-    except json.JSONDecodeError as exc:
-        print(json.dumps({"systemMessage": f"Ultra hook input parse error: {exc}"}))
-        return 0
-    try:
-        output = run_feature(feature, payload, feature_args)
-    except subprocess.TimeoutExpired:
-        output = {"systemMessage": f"Ultra hook {feature} timed out"}
-    except Exception as exc:  # adapter boundary must fail open with evidence
-        output = {"systemMessage": f"Ultra hook adapter error in {feature}: {exc}"}
-    print(json.dumps(output, ensure_ascii=False))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/hooks/adapters/grok.py

@@ -1,134 +0,0 @@
-#!/usr/bin/env python3
-"""Grok Build wire adapter for Ultra observational lifecycle hooks."""
-
-from __future__ import annotations
-
-import copy
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-from typing import Any
-
-
-HOOK_ROOT = Path(__file__).resolve().parent.parent
-ALLOWED_FEATURES = {
-    "block_dangerous_commands.py",
-    "compact_context.py",
-    "mid_workflow_recall.py",
-    "post_edit_guard.py",
-    "session_context.py",
-}
-
-
-def normalize_input(payload: dict[str, Any]) -> dict[str, Any]:
-    """Translate Grok's camelCase wire names into the shared hook contract."""
-    normalized = copy.deepcopy(payload)
-    aliases = {
-        "hookEventName": "hook_event_name",
-        "sessionId": "session_id",
-        "toolName": "tool_name",
-        "toolInput": "tool_input",
-        "toolResult": "tool_output",
-        "stopHookActive": "stop_hook_active",
-        "agentId": "agent_id",
-        "agentType": "agent_type",
-        "workspaceRoot": "workspace_root",
-    }
-    for source, target in aliases.items():
-        if source in normalized and target not in normalized:
-            normalized[target] = normalized[source]
-    return normalized
-
-
-def _parse_output(stdout: str) -> dict[str, Any]:
-    text = stdout.strip()
-    if not text:
-        return {}
-    try:
-        value = json.loads(text)
-    except json.JSONDecodeError:
-        return {}
-    return value if isinstance(value, dict) else {}
-
-
-def adapt_output(output: dict[str, Any], event: str, reason: str | None) -> dict[str, Any]:
-    """Return only output fields Grok actually consumes for this event."""
-    if event == "PreToolUse":
-        specific = output.get("hookSpecificOutput")
-        specific = specific if isinstance(specific, dict) else {}
-        if specific.get("permissionDecision") == "deny":
-            return {
-                "decision": "deny",
-                "reason": str(
-                    specific.get("permissionDecisionReason")
-                    or "Ultra refused a direct write to a managed authority file"
-                ),
-            }
-        return {"decision": "allow"}
-    # Ultra Stop is advisory. Grok's session-end Stop is observe-only and must
-    # never be confused with a genuine end_turn gate.
-    if event == "Stop" and reason != "end_turn":
-        return {}
-    return {}
-
-
-def run_feature(feature: str, payload: dict[str, Any], feature_args: list[str]) -> dict[str, Any]:
-    if feature not in ALLOWED_FEATURES or Path(feature).name != feature:
-        return {}
-    script = HOOK_ROOT / feature
-    if not script.is_file():
-        return {}
-    normalized = normalize_input(payload)
-    env = os.environ.copy()
-    env["UBP_HOOK_RUNTIME"] = "grok"
-    plugin_data = env.get("GROK_PLUGIN_DATA") or env.get("CLAUDE_PLUGIN_DATA")
-    if plugin_data:
-        env["UBP_HOOK_DATA"] = plugin_data
-    cwd = normalized.get("cwd")
-    run_cwd = str(cwd) if isinstance(cwd, str) and Path(cwd).is_dir() else os.getcwd()
-    proc = subprocess.run(
-        [sys.executable, str(script), *feature_args],
-        input=json.dumps(normalized),
-        text=True,
-        capture_output=True,
-        cwd=run_cwd,
-        env=env,
-        timeout=30,
-        check=False,
-    )
-    if proc.stderr:
-        print(proc.stderr.rstrip(), file=sys.stderr)
-    if proc.returncode != 0:
-        return {}
-    return adapt_output(
-        _parse_output(proc.stdout),
-        str(payload.get("hookEventName") or ""),
-        str(payload.get("reason") or "") or None,
-    )
-
-
-def main() -> int:
-    if len(sys.argv) < 2:
-        print(json.dumps({}))
-        return 0
-    feature = sys.argv[1]
-    try:
-        payload = json.loads(sys.stdin.read() or "{}")
-        if not isinstance(payload, dict):
-            payload = {}
-    except json.JSONDecodeError as exc:
-        print(f"[grok hook] invalid input: {exc}", file=sys.stderr)
-        payload = {}
-    try:
-        output = run_feature(feature, payload, sys.argv[2:])
-    except Exception as exc:
-        print(f"[grok hook] {feature} failed open: {exc}", file=sys.stderr)
-        output = {}
-    print(json.dumps(output, ensure_ascii=False))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/hooks/adapters/kimi.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-"""Kimi Code wire adapter for Ultra Builder Pro's five file-first hooks.
-
-Kimi uses snake_case JSON input compatible with the shared hooks, but
-its output contract accepts only ``message`` plus an optional structured deny.
-This adapter preserves explicit projection denials and optional Stop decisions, converts foreign context
-fields into Kimi messages, and fails open with diagnostic evidence.
-"""
-
-from __future__ import annotations
-
-import copy
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-from typing import Any
-
-
-HOOK_ROOT = Path(__file__).resolve().parent.parent
-ALLOWED_FEATURES = {
-    "block_dangerous_commands.py",
-    "compact_context.py",
-    "mid_workflow_recall.py",
-    "post_edit_guard.py",
-    "session_context.py",
-}
-
-
-def normalize_input(payload: dict[str, Any]) -> dict[str, Any]:
-    """Add only aliases required by the shared file-first hooks."""
-    normalized = copy.deepcopy(payload)
-    agent_name = normalized.get("agent_name")
-    if isinstance(agent_name, str) and agent_name:
-        normalized.setdefault("agent_id", agent_name)
-        normalized.setdefault("agent_type", agent_name)
-    if normalized.get("tool_response") is not None and normalized.get("tool_output") is None:
-        normalized["tool_output"] = normalized["tool_response"]
-    return normalized
-
-
-def _text(value: Any) -> str:
-    return str(value).strip() if value is not None else ""
-
-
-def adapt_output(output: dict[str, Any], event: str) -> dict[str, Any]:
-    """Convert one legacy hook result to Kimi's exact structured schema."""
-    if not isinstance(output, dict):
-        return {}
-    specific = output.get("hookSpecificOutput")
-    specific = specific if isinstance(specific, dict) else {}
-
-    decision = specific.get("permissionDecision")
-    blocked = output.get("decision") == "block" or decision == "deny"
-    reason = (
-        _text(specific.get("permissionDecisionReason"))
-        or _text(output.get("reason"))
-        or f"Ultra {event} gate blocked continuation"
-    )
-    if blocked:
-        return {
-            "hookSpecificOutput": {
-                "message": reason,
-                "permissionDecision": "deny",
-                "permissionDecisionReason": reason,
-            }
-        }
-
-    context = (
-        _text(specific.get("additionalContext"))
-        or _text(output.get("additionalContext"))
-        or _text(output.get("systemMessage"))
-        or _text(specific.get("message"))
-        or _text(output.get("message"))
-    )
-    advisory = _text(specific.get("permissionDecisionReason")) if decision == "ask" else ""
-    message = "\n\n".join(part for part in [advisory, context] if part)
-    return {"message": message} if message else {}
-
-
-def _parse_output(stdout: str) -> dict[str, Any]:
-    text = stdout.strip()
-    if not text:
-        return {}
-    try:
-        value = json.loads(text)
-    except json.JSONDecodeError:
-        return {"message": f"Ultra hook returned non-JSON output: {text[:500]}"}
-    return value if isinstance(value, dict) else {}
-
-
-def run_feature(feature: str, payload: dict[str, Any], feature_args: list[str]) -> dict[str, Any]:
-    if feature not in ALLOWED_FEATURES or Path(feature).name != feature:
-        return {"message": f"Ultra hook adapter refused unknown feature: {feature}"}
-    script = HOOK_ROOT / feature
-    if not script.is_file():
-        return {"message": f"Ultra hook feature is missing: {feature}"}
-
-    event = str(payload.get("hook_event_name") or "")
-    normalized = normalize_input(payload)
-    env = os.environ.copy()
-    env["UBP_HOOK_RUNTIME"] = "kimi"
-    plugin_data = env.get("PLUGIN_DATA") or env.get("KIMI_PLUGIN_ROOT")
-    if plugin_data:
-        env["UBP_HOOK_DATA"] = plugin_data
-
-    cwd = normalized.get("cwd")
-    run_cwd = str(cwd) if isinstance(cwd, str) and Path(cwd).is_dir() else os.getcwd()
-    proc = subprocess.run(
-        [sys.executable, str(script), *feature_args],
-        input=json.dumps(normalized),
-        text=True,
-        capture_output=True,
-        cwd=run_cwd,
-        env=env,
-        timeout=30,
-        check=False,
-    )
-    if proc.stderr:
-        print(proc.stderr.rstrip(), file=sys.stderr)
-    if proc.returncode != 0:
-        return {
-            "message": (
-                f"Ultra hook {feature} failed with exit {proc.returncode}: "
-                f"{proc.stderr.strip()[:500]}"
-            )
-        }
-    return adapt_output(_parse_output(proc.stdout), event)
-
-
-def main() -> int:
-    if len(sys.argv) < 2:
-        print(json.dumps({"message": "Ultra Kimi hook adapter requires a feature name"}))
-        return 0
-    feature = sys.argv[1]
-    feature_args = sys.argv[2:]
-    try:
-        payload = json.loads(sys.stdin.read() or "{}")
-        if not isinstance(payload, dict):
-            payload = {}
-    except json.JSONDecodeError as exc:
-        print(json.dumps({"message": f"Ultra hook input parse error: {exc}"}))
-        return 0
-    try:
-        output = run_feature(feature, payload, feature_args)
-    except subprocess.TimeoutExpired:
-        output = {"message": f"Ultra hook {feature} timed out"}
-    except Exception as exc:  # Kimi hooks are fail-open at this adapter boundary.
-        output = {"message": f"Ultra hook adapter error in {feature}: {exc}"}
-    print(json.dumps(output, ensure_ascii=False))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())