codebuff-agent 2.1.74__py3-none-any.whl

jupyter_ext/agent/codex_hooks.py

@@ -0,0 +1,320 @@
+"""codex hook 을 pod 가 대신 돌린다 (이슈 #145).
+
+**codex 네이티브 hook 은 쓸 수 없다.** hook 명령은 codex 프로세스가 도는 기계에서
+세션 cwd 로 실행되는데, codex 는 centri 에서 돌고 사용자 파일은 pod 에 있다. 그래서
+pod 가 codex 와 같은 규격으로 hook 을 찾고 돌린다 — 물리 위치만 다르고 메커니즘은
+같다. `custom_skills` (#134) 가 스킬에 대해 한 것과 같은 방식이다.
+규격: https://learn.chatgpt.com/docs/hooks
+
+| 층 | 위치 | 모드 |
+|---|---|---|
+| `builtin` | 이 모듈의 `BUILTIN_HOOKS` — ruff/biome autofix | 두 모드 다 |
+| `repo` | 워크스페이스부터 git 루트까지 `.codex/hooks.json` | `bypass` 에서만 |
+| `user` | `$CODEX_HOME/hooks.json` (없으면 `~/.codex/hooks.json`) | 두 모드 다 |
+
+- codex 의 hook 별 trust 검토는 대행하지 않고 모드로 대신한다 — pod 에는 검토 화면이
+  없다. repo 층을 `ask` 에서 안 돌리는 이유는, 클론한 저장소의 hooks.json 이 승인받은
+  편집 한 번에 임의 명령을 승인 없이 돌리면 `ask` 의 승인 계약이 무너져서다.
+- 이벤트는 `PostToolUse` 하나다. config.toml 의 `[hooks]`·requirements·플러그인 층과
+  `async` 는 대행하지 않는다 (`async` hook 은 동기로 돈다).
+- 도구 이름은 codex 이름으로 바꿔 matcher 에 댄다 — 파일 편집은 `apply_patch`
+  (별칭 `Edit`·`Write`), 셸은 `Bash`. 그래야 CLI 용으로 쓴 hooks.json 이 그대로 돈다.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .custom_skills import _repo_dirs
+
+logger = logging.getLogger(__name__)
+
+EVENT = "PostToolUse"
+#: codex 의 기본값이다 (SessionEnd·Interrupt 만 1초)
+DEFAULT_TIMEOUT = 600
+#: 내장 autofix 전체 한도 — ruff check·format 두 단계(`codex_autofix.STEP_TIMEOUT`)가 들어간다
+BUILTIN_TIMEOUT = 60
+
+_CODEX_TOOL_NAMES = {
+    "write_file": "apply_patch",
+    "edit_file": "apply_patch",
+    "execute_command": "Bash",
+}
+_ALIASES = {"apply_patch": ("Edit", "Write")}
+_PERMISSION_MODES = {"bypass": "bypassPermissions", "ask": "default"}
+
+
+@dataclass(frozen=True)
+class Hook:
+    matcher: Optional[str]
+    command: str
+    timeout: float
+    status_message: str
+    scope: str
+    source: str
+
+
+BUILTIN_HOOKS = (
+    Hook(
+        matcher="apply_patch",
+        # `-I`: hook 은 워크스페이스를 cwd 로 돈다. `-m` 은 cwd 를 sys.path 앞에 두므로
+        # 워크스페이스의 `json.py`·`jupyter_ext/` 가 표준 라이브러리·패키지를 가린다
+        command=f'"{sys.executable}" -I -m jupyter_ext.agent.codex_autofix',
+        timeout=BUILTIN_TIMEOUT,
+        status_message="",
+        scope="builtin",
+        source="ruff/biome autofix",
+    ),
+)
+
+
+@dataclass
+class Outcome:
+    """hook 들의 결과를 모은 것. 브리지가 도구 결과와 패널에 반영한다."""
+
+    context: List[str] = field(default_factory=list)
+    block_reason: Optional[str] = None
+    #: 실패·시간 초과 — 매번 띄운다. 첫 번째만 보이면 두 번째 멈춤이 무음이 된다
+    messages: List[str] = field(default_factory=list)
+    #: `systemMessage` — 같은 문장은 세션당 한 번만 띄운다 (도구 없음 알림 등)
+    notices: List[str] = field(default_factory=list)
+
+
+def codex_tool_name(tool: str) -> str:
+    return _CODEX_TOOL_NAMES.get(tool, tool)
+
+
+def matches(matcher: Optional[str], tool_name: str) -> bool:
+    """codex 처럼 matcher 를 정규식으로 본다. `*`·빈 값·생략은 전체다."""
+    if not matcher or matcher == "*":
+        return True
+    names = (tool_name, *_ALIASES.get(tool_name, ()))
+    try:
+        return any(re.fullmatch(matcher, n) for n in names)
+    except re.error:
+        return False
+
+
+def _user_hooks_file() -> Path:
+    home = Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex")
+    return home / "hooks.json"
+
+
+def hook_files(workspace_root: str) -> List[tuple]:
+    """(경로, 층) — 실제로 있는 hooks.json 만.
+
+    워크스페이스가 홈이면 `~/.codex/hooks.json` 이 repo 층에도 잡힌다. 같은 파일은
+    한 번만 싣고 user 층으로 본다 — 두 번 돌거나 ask 모드에서 거짓 "건너뜀" 이 뜨면 안 된다.
+    """
+    user = _user_hooks_file()
+    found = [(d / ".codex" / "hooks.json", "repo") for d in _repo_dirs(workspace_root)]
+    found.append((user, "user"))
+    out: List[tuple] = []
+    seen = set()
+    for path, scope in found:
+        # 권한 없는 상위 디렉터리는 `is_file()` 도 예외를 던진다 (custom_skills 와 같다)
+        try:
+            if not path.is_file():
+                continue
+            key = path.resolve()
+            if scope == "repo" and user.is_file() and key == user.resolve():
+                continue
+        except OSError as e:
+            logger.warning("hooks.json 을 확인하지 못함 (%s): %s", path, e)
+            continue
+        if key not in seen:
+            seen.add(key)
+            out.append((path, scope))
+    return out
+
+
+def _parse(path: Path, scope: str, errors: List[str]) -> List[Hook]:
+    """hook 하나가 규격 밖이면 그 hook 만 빼고 알린다 — 파일째 버리지 않는다."""
+    data = json.loads(path.read_text(encoding="utf-8"))
+    hooks: List[Hook] = []
+    for group in (data.get("hooks") or {}).get(EVENT) or []:
+        matcher = group.get("matcher")
+        for h in group.get("hooks") or []:
+            if h.get("type", "command") != "command" or not h.get("command"):
+                continue
+            try:
+                if matcher is not None and not isinstance(matcher, str):
+                    raise ValueError(f"matcher 는 정규식 문자열이다: {matcher!r}")
+                timeout = float(h.get("timeout") or DEFAULT_TIMEOUT)
+            except (TypeError, ValueError) as e:
+                errors.append(f"hooks.json 의 hook 하나를 뺐습니다: {path} ({e})")
+                continue
+            hooks.append(
+                Hook(
+                    matcher=matcher,
+                    command=str(h["command"]),
+                    timeout=timeout,
+                    status_message=str(h.get("statusMessage") or ""),
+                    scope=scope,
+                    source=str(path),
+                )
+            )
+    return hooks
+
+
+def discover(workspace_root: str, errors: Optional[List[str]] = None) -> List[Hook]:
+    """내장 → repo → user 순. 여러 층을 모두 싣는다 (codex 도 덮어쓰지 않는다)."""
+    if errors is None:
+        errors = []
+    hooks: List[Hook] = list(BUILTIN_HOOKS)
+    for path, scope in hook_files(workspace_root):
+        try:
+            hooks.extend(_parse(path, scope, errors))
+        except (OSError, ValueError, AttributeError, TypeError) as e:
+            logger.warning("hooks.json 을 읽지 못함 (%s): %s", path, e)
+            errors.append(f"hooks.json 을 읽지 못했습니다: {path} ({e})")
+    return hooks
+
+
+def patch_envelope(path: str, is_new: bool) -> str:
+    """codex `apply_patch` 의 `tool_input.command` 꼴. CLI 용 hook 이 경로를 여기서 읽는다."""
+    head = "Add File" if is_new else "Update File"
+    return f"*** Begin Patch\n*** {head}: {path}\n*** End Patch\n"
+
+
+def build_payload(
+    *,
+    tool: str,
+    args: Dict[str, Any],
+    is_new_file: bool,
+    tool_response: str,
+    tool_use_id: str,
+    cwd: str,
+    session_id: str,
+    turn_id: str,
+    model: str,
+    permission_mode: str,
+) -> Dict[str, Any]:
+    name = codex_tool_name(tool)
+    if name == "apply_patch":
+        path = str(args.get("path") or "")
+        tool_input: Dict[str, Any] = {
+            "command": patch_envelope(path, is_new_file),
+            "path": path,
+            "codebuff_tool": tool,
+        }
+    else:
+        tool_input = dict(args)
+    return {
+        "session_id": session_id,
+        "turn_id": turn_id,
+        "transcript_path": None,
+        "cwd": cwd,
+        "hook_event_name": EVENT,
+        "model": model,
+        "permission_mode": _PERMISSION_MODES.get(permission_mode, "default"),
+        "tool_name": name,
+        "tool_input": tool_input,
+        "tool_response": tool_response,
+        "tool_use_id": tool_use_id,
+    }
+
+
+@dataclass
+class Run:
+    returncode: Optional[int]
+    stdout: str
+    stderr: str
+    timed_out: bool = False
+
+
+async def run_hook(
+    hook: Hook, payload: Dict[str, Any], cwd: str, env: Dict[str, str]
+) -> Run:
+    """hook 명령을 셸로 돌린다. 시간이 넘거나 취소되면 프로세스 그룹째 끝낸다."""
+    proc = await asyncio.create_subprocess_shell(
+        hook.command,
+        cwd=cwd,
+        env=env,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        start_new_session=True,
+    )
+    data = json.dumps(payload, ensure_ascii=False).encode()
+    try:
+        out, err = await asyncio.wait_for(proc.communicate(data), hook.timeout)
+    except asyncio.TimeoutError:
+        _kill_group(proc)
+        await proc.wait()
+        return Run(None, "", "", timed_out=True)
+    except BaseException:
+        _kill_group(proc)
+        raise
+    return Run(
+        proc.returncode,
+        out.decode("utf-8", errors="replace"),
+        err.decode("utf-8", errors="replace"),
+    )
+
+
+def _kill_group(proc: Any) -> None:
+    try:
+        os.killpg(proc.pid, 9)
+    except (ProcessLookupError, PermissionError):
+        try:
+            proc.kill()
+        except ProcessLookupError:
+            pass
+
+
+def _label(hook: Hook) -> str:
+    """패널에 띄우는 hook 이름. 명령줄은 싣지 않는다 — 토큰이 박혀 있을 수 있다."""
+    return hook.source
+
+
+def interpret(hook: Hook, run: Run, outcome: Outcome) -> None:
+    """codex `PostToolUse` 출력 규칙대로 결과를 모은다.
+
+    - exit 0: stdout 이 JSON 이면 해석한다. 평문은 PostToolUse 에서 무시한다.
+    - exit 2: 차단 — stderr 가 이유다. JSON 의 `decision: "block"`·`continue: false` 도 같다.
+      실행은 되돌리지 않고 결과를 이유로 바꾼다. 여럿이면 마지막 것이 남는다.
+    - 그 밖·시간 초과: hook 실패로 알리고 계속 간다.
+    """
+    if run.timed_out:
+        outcome.messages.append(f"hook 시간 초과 ({hook.timeout:g}초): {_label(hook)}")
+        return
+    if run.returncode == 2:
+        outcome.block_reason = (
+            run.stderr.strip() or f"hook 이 막았습니다: {_label(hook)}"
+        )
+        return
+    if run.returncode != 0:
+        outcome.messages.append(
+            f"hook 실패 (종료 코드 {run.returncode}): {_label(hook)}"
+        )
+        return
+    try:
+        out = json.loads(run.stdout) if run.stdout.strip() else {}
+    except ValueError:
+        return
+    if not isinstance(out, dict):
+        return
+    if out.get("systemMessage"):
+        outcome.notices.append(str(out["systemMessage"]))
+    specific = out.get("hookSpecificOutput") or {}
+    if isinstance(specific, dict) and specific.get("additionalContext"):
+        outcome.context.append(str(specific["additionalContext"]))
+    if out.get("decision") == "block":
+        outcome.block_reason = str(
+            out.get("reason") or f"hook 이 막았습니다: {_label(hook)}"
+        )
+    if out.get("continue") is False:
+        outcome.block_reason = str(
+            out.get("stopReason")
+            or out.get("reason")
+            or f"hook 이 멈췄습니다: {_label(hook)}"
+        )