@blxzer/pactile 0.5.0 → 0.6.0-beta.2

package/dist/templates/shared-hooks/inject-shell-session-context.py

@@ -1,183 +0,0 @@
-#!/usr/bin/env python3
-"""Cursor beforeShellExecution hook: bridge conversation identity to task.py.
-
-Cursor's shell command environment does not inherit SessionStart data. This
-hook writes a short-lived runtime ticket before Cursor runs a shell command
-that calls `task.py select/selected/exit`. The task script then consumes the
-ticket only when it has no native session environment.
-"""
-from __future__ import annotations
-
-import hashlib
-import json
-import os
-import shlex
-import sys
-import time
-from pathlib import Path
-from typing import Any
-
-
-DIR_WORKFLOW = ".pactile"
-DIR_RUNTIME = ".runtime"
-DIR_CURSOR_SHELL = "cursor-shell"
-SESSION_SUBCOMMANDS = {"select", "selected", "exit"}
-TICKET_TTL_SECONDS = 30
-CONTEXT_IDENTITY_KEYS = (
-    "session_id",
-    "sessionId",
-    "sessionID",
-    "conversation_id",
-    "conversationId",
-    "conversationID",
-    "transcript_path",
-    "transcriptPath",
-    "transcript",
-)
-
-
-def _string_value(value: Any) -> str | None:
-    if isinstance(value, str):
-        stripped = value.strip()
-        return stripped or None
-    return None
-
-
-def _find_pactile_root(start: Path) -> Path | None:
-    current = start.resolve()
-    while True:
-        if (current / DIR_WORKFLOW).is_dir():
-            return current
-        if current == current.parent:
-            return None
-        current = current.parent
-
-
-def _runtime_ticket_dir(root: Path) -> Path:
-    return root / DIR_WORKFLOW / DIR_RUNTIME / DIR_CURSOR_SHELL
-
-
-def _load_active_task_resolver(root: Path):
-    scripts_dir = root / DIR_WORKFLOW / "scripts"
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-    from common.active_task import resolve_context_key  # type: ignore[import-not-found]
-
-    return resolve_context_key
-
-
-def _extract_task_subcommands(command: str) -> list[dict[str, str]]:
-    try:
-        tokens = shlex.split(command, posix=os.name != "nt")
-    except ValueError:
-        return []
-
-    subcommands: list[dict[str, str]] = []
-    for index, token in enumerate(tokens[:-1]):
-        if Path(token.strip("\"'")).name != "task.py":
-            continue
-        name = tokens[index + 1]
-        if name not in SESSION_SUBCOMMANDS:
-            continue
-        item = {"name": name}
-        if name == "select" and index + 2 < len(tokens):
-            item["task_ref"] = tokens[index + 2]
-        subcommands.append(item)
-    return subcommands
-
-
-def _cleanup_expired_tickets(ticket_dir: Path, now: float) -> None:
-    if not ticket_dir.is_dir():
-        return
-    for ticket_path in ticket_dir.glob("*.json"):
-        try:
-            data = json.loads(ticket_path.read_text(encoding="utf-8"))
-        except (json.JSONDecodeError, OSError):
-            continue
-        expires_at = data.get("expires_at_epoch")
-        if isinstance(expires_at, (int, float)) and expires_at < now:
-            try:
-                ticket_path.unlink()
-            except OSError:
-                pass
-
-
-def _has_context_identity(hook_input: dict[str, Any]) -> bool:
-    return any(_string_value(hook_input.get(key)) for key in CONTEXT_IDENTITY_KEYS)
-
-
-def _write_ticket(
-    root: Path,
-    hook_input: dict[str, Any],
-    context_key: str,
-    subcommands: list[dict[str, str]],
-) -> None:
-    now = time.time()
-    ticket_dir = _runtime_ticket_dir(root)
-    ticket_dir.mkdir(parents=True, exist_ok=True)
-    _cleanup_expired_tickets(ticket_dir, now)
-
-    command = _string_value(hook_input.get("command")) or ""
-    digest = hashlib.sha256(
-        f"{context_key}\0{command}\0{now}".encode("utf-8"),
-    ).hexdigest()[:16]
-    ticket_path = ticket_dir / f"{int(now * 1000)}-{digest}.json"
-
-    payload = {
-        "platform": "cursor",
-        "context_key": context_key,
-        "conversation_id": _string_value(hook_input.get("conversation_id")),
-        "session_id": _string_value(hook_input.get("session_id")),
-        "generation_id": _string_value(hook_input.get("generation_id")),
-        "cwd": _string_value(hook_input.get("cwd")),
-        "command": command,
-        "subcommands": subcommands,
-        "created_at_epoch": now,
-        "expires_at_epoch": now + TICKET_TTL_SECONDS,
-    }
-    ticket_path.write_text(
-        json.dumps(payload, indent=2, ensure_ascii=False) + "\n",
-        encoding="utf-8",
-    )
-
-
-def main() -> int:
-    if os.environ.get("PACTILE_HOOKS") == "0" or os.environ.get("PACTILE_DISABLE_HOOKS") == "1":
-        return 0
-
-    try:
-        hook_input = json.loads(sys.stdin.read())
-    except (json.JSONDecodeError, ValueError):
-        hook_input = {}
-    if not isinstance(hook_input, dict):
-        hook_input = {}
-
-    command = _string_value(hook_input.get("command")) or ""
-    subcommands = _extract_task_subcommands(command)
-    if not subcommands:
-        return 0
-
-    cwd = Path(_string_value(hook_input.get("cwd")) or os.getcwd())
-    root = _find_pactile_root(cwd)
-    if root is None:
-        return 0
-
-    if not _has_context_identity(hook_input):
-        return 0
-
-    resolve_context_key = _load_active_task_resolver(root)
-    context_key = resolve_context_key(hook_input, platform="cursor")
-    if not context_key:
-        return 0
-
-    try:
-        _write_ticket(root, hook_input, context_key, subcommands)
-    except OSError:
-        return 0
-
-    print(json.dumps({"permission": "allow"}, ensure_ascii=False))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/dist/templates/shared-hooks/inject-subagent-context.py

@@ -1,267 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Multi-Platform Sub-Agent Context Injection Hook (thin wrapper).
-
-CLI Layer 2 (`generate-dispatch-prompt`) is the primary Cursor path; this hook is
-best-effort and skips when the prompt already contains the injection marker.
-"""
-from __future__ import annotations
-
-import warnings
-
-warnings.filterwarnings("ignore")
-
-import json
-import os
-import sys
-from pathlib import Path
-from typing import Any
-
-if sys.platform.startswith("win"):
-    import io as _io
-
-    if hasattr(sys.stdout, "reconfigure"):
-        sys.stdout.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
-    elif hasattr(sys.stdout, "detach"):
-        sys.stdout = _io.TextIOWrapper(sys.stdout.detach(), encoding="utf-8", errors="replace")  # type: ignore[union-attr]
-
-DIR_WORKFLOW = ".pactile"
-
-AGENT_IMPLEMENT = "pactile-implement"
-AGENT_CHECK = "pactile-check"
-AGENT_RESEARCH = "pactile-research"
-AGENTS_ALL = (AGENT_IMPLEMENT, AGENT_CHECK, AGENT_RESEARCH)
-AGENTS_REQUIRE_TASK = (AGENT_IMPLEMENT, AGENT_CHECK)
-
-
-def find_repo_root(start_path: str) -> str | None:
-    current = Path(start_path).resolve()
-    while current != current.parent:
-        if (current / DIR_WORKFLOW).is_dir():
-            return str(current)
-        if (current / ".git").exists():
-            return str(current)
-        current = current.parent
-    return None
-
-
-def _detect_platform(input_data: dict) -> str | None:
-    if isinstance(input_data.get("cursor_version"), str):
-        return "cursor"
-    env_map = {
-        "CLAUDE_PROJECT_DIR": "claude",
-        "CURSOR_PROJECT_DIR": "cursor",
-        "CODEBUDDY_PROJECT_DIR": "codebuddy",
-        "FACTORY_PROJECT_DIR": "droid",
-        "GEMINI_PROJECT_DIR": "gemini",
-        "QODER_PROJECT_DIR": "qoder",
-        "KIRO_PROJECT_DIR": "kiro",
-        "COPILOT_PROJECT_DIR": "copilot",
-    }
-    for env_name, platform in env_map.items():
-        if os.environ.get(env_name):
-            return platform
-    script_parts = set(Path(sys.argv[0]).parts)
-    if ".cursor" in script_parts:
-        return "cursor"
-    if ".claude" in script_parts:
-        return "claude"
-    return None
-
-
-def get_selected_task(repo_root: str, input_data: dict) -> str | None:
-    scripts_dir = Path(repo_root) / DIR_WORKFLOW / "scripts"
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-    try:
-        from common.active_task import resolve_selected_task  # type: ignore[import-not-found]
-    except Exception:
-        return None
-
-    selected = resolve_selected_task(
-        Path(repo_root),
-        input_data,
-        platform=_detect_platform(input_data),
-    )
-    return selected.task_path
-
-
-def _worker_orchestration_active(repo_root: str, task_dir: str | None) -> bool:
-    """Unactivated worker-orchestration → no prompt mutation."""
-    scripts_dir = Path(repo_root) / DIR_WORKFLOW / "scripts"
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-    try:
-        from common.ondemand_topology import is_ondemand_module_active  # type: ignore[import-not-found]
-    except Exception:
-        return False
-    path: Path | None = None
-    if task_dir:
-        candidate = Path(task_dir)
-        path = candidate if candidate.is_absolute() else Path(repo_root) / task_dir
-    return bool(is_ondemand_module_active(path, "worker-orchestration"))
-
-
-def _string_value(value: Any) -> str:
-    if isinstance(value, str):
-        return value.strip()
-    return ""
-
-
-def _extract_subagent_name(value: Any) -> str:
-    direct = _string_value(value)
-    if direct:
-        return direct
-    if not isinstance(value, dict):
-        return ""
-    for key in ("name", "subagent_type_name", "subagentTypeName"):
-        direct = _string_value(value.get(key))
-        if direct:
-            return direct
-    custom = value.get("custom")
-    if isinstance(custom, dict):
-        custom_name = _string_value(custom.get("name"))
-        if custom_name:
-            return custom_name
-    oneof = value.get("type")
-    if isinstance(oneof, dict):
-        case_name = _string_value(oneof.get("case"))
-        if case_name == "custom":
-            nested_value = oneof.get("value")
-            if isinstance(nested_value, dict):
-                custom_name = _string_value(nested_value.get("name"))
-                if custom_name:
-                    return custom_name
-        if case_name:
-            return case_name
-    for agent_name in AGENTS_ALL:
-        if agent_name in value:
-            return agent_name
-    return ""
-
-
-def _extract_subagent_type(tool_input: dict) -> str:
-    for key in (
-        "subagent_type",
-        "subagentType",
-        "subagent_type_name",
-        "subagentTypeName",
-        "agent_type",
-        "agentType",
-        "name",
-    ):
-        agent_name = _extract_subagent_name(tool_input.get(key))
-        if agent_name:
-            return agent_name
-    return ""
-
-
-def _parse_hook_input(input_data: dict) -> tuple[str, str, dict]:
-    tool_input = input_data.get("tool_input", {})
-    tool_name = input_data.get("tool_name", "") or input_data.get("toolName", "")
-    if tool_name.lower() in ("task", "agent", "subagent"):
-        return (
-            _extract_subagent_type(tool_input),
-            tool_input.get("prompt", ""),
-            tool_input,
-        )
-    agent_name = input_data.get("agent_name", "")
-    if agent_name:
-        return agent_name, tool_input.get("prompt", input_data.get("prompt", "")), tool_input
-    if tool_name in AGENTS_ALL:
-        return tool_name, tool_input.get("prompt", ""), tool_input
-    tool_name_camel = input_data.get("toolName", "")
-    if tool_name_camel in AGENTS_ALL:
-        return tool_name_camel, input_data.get("toolArgs", ""), tool_input
-    return "", "", tool_input
-
-
-def main() -> None:
-    if os.environ.get("PACTILE_HOOKS") == "0" or os.environ.get("PACTILE_DISABLE_HOOKS") == "1":
-        sys.exit(0)
-
-    try:
-        input_text = sys.stdin.read()
-        # Remove UTF-8 BOM if present
-        if input_text.startswith('\ufeff'):
-            input_text = input_text[1:]
-        input_data = json.loads(input_text)
-    except (json.JSONDecodeError, ValueError):
-        sys.exit(0)
-
-    subagent_type, original_prompt, tool_input = _parse_hook_input(input_data)
-    if subagent_type not in AGENTS_ALL:
-        sys.exit(0)
-
-    repo_root = find_repo_root(input_data.get("cwd", os.getcwd()))
-    if not repo_root:
-        sys.exit(0)
-
-    scripts_dir = Path(repo_root) / DIR_WORKFLOW / "scripts"
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-
-    try:
-        from common.subagent_dispatch import (  # type: ignore[import-not-found]
-            build_dispatch_prompt_for_agent,
-            prompt_has_injection_marker,
-        )
-    except Exception:
-        sys.exit(0)
-
-    if prompt_has_injection_marker(original_prompt):
-        sys.exit(0)
-
-    task_dir = get_selected_task(repo_root, input_data)
-    if not task_dir and original_prompt:
-        for line in original_prompt.split("\n"):
-            line = line.strip()
-            if line.startswith("Selected task:"):
-                candidate = line.split("Selected task:", 1)[1].strip()
-                if candidate and os.path.isdir(os.path.join(repo_root, candidate)):
-                    task_dir = candidate
-                    print(
-                        f"[inject-subagent-context] Resolved task from prompt: {task_dir}",
-                        file=sys.stderr,
-                    )
-                break
-
-    try:
-        if not _worker_orchestration_active(repo_root, task_dir):
-            sys.exit(0)
-    except Exception:
-        sys.exit(0)
-
-    if subagent_type in AGENTS_REQUIRE_TASK:
-        if not task_dir:
-            sys.exit(0)
-        if not os.path.exists(os.path.join(repo_root, task_dir)):
-            sys.exit(0)
-
-    new_prompt = build_dispatch_prompt_for_agent(
-        repo_root,
-        task_dir or "",
-        subagent_type,
-        original_prompt,
-    )
-    if not new_prompt:
-        sys.exit(0)
-
-    updated = {**tool_input, "prompt": new_prompt}
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "allow",
-            "updatedInput": updated,
-        },
-        "permission": "allow",
-        "updated_input": updated,
-        "updatedInput": updated,
-    }
-    print(json.dumps(output, ensure_ascii=False))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/dist/templates/shared-hooks/inject-workflow-state.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""Per-turn hook that used to inject workflow.md methodology breadcrumbs.
-
-Methodology injection is retired. This script is a permanent successful no-op:
-it never writes workflow-state methodology to stdout, and it must not fail
-when no module is subscribed. The five-layer compiler will own session
-packets later; this file stays so platform install routing still has a hook.
-"""
-from __future__ import annotations
-
-import json
-import os
-import sys
-from pathlib import Path
-
-# Force UTF-8 on stdin/stdout/stderr on Windows. Default codepage there is
-# cp936 / cp1252 / etc. — non-ASCII content (Chinese task names, prd snippets)
-# both in stdin (hook payload from host CLI) and stdout (our emitted blocks)
-# raises UnicodeDecodeError / UnicodeEncodeError. Equivalent to `python -X utf8`
-# but applied per-stream so we don't depend on host CLI's command wiring.
-if sys.platform.startswith("win"):
-    import io as _io
-    for _stream_name in ("stdin", "stdout", "stderr"):
-        _stream = getattr(sys, _stream_name, None)
-        if _stream is None:
-            continue
-        if hasattr(_stream, "reconfigure"):
-            try:
-                _stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
-            except Exception:
-                pass
-        elif hasattr(_stream, "detach"):
-            try:
-                setattr(sys, _stream_name, _io.TextIOWrapper(_stream.detach(), encoding="utf-8", errors="replace"))
-            except Exception:
-                pass
-
-
-def _detect_platform(input_data: dict) -> str | None:
-    if isinstance(input_data.get("cursor_version"), str):
-        return "cursor"
-    env_map = {
-        "CLAUDE_PROJECT_DIR": "claude",
-        "CURSOR_PROJECT_DIR": "cursor",
-        "CODEBUDDY_PROJECT_DIR": "codebuddy",
-        "FACTORY_PROJECT_DIR": "droid",
-        "GEMINI_PROJECT_DIR": "gemini",
-        "QODER_PROJECT_DIR": "qoder",
-        "KIRO_PROJECT_DIR": "kiro",
-        "COPILOT_PROJECT_DIR": "copilot",
-    }
-    for env_name, platform in env_map.items():
-        if os.environ.get(env_name):
-            return platform
-    script_parts = set(Path(sys.argv[0]).parts)
-    if ".claude" in script_parts:
-        return "claude"
-    if ".cursor" in script_parts:
-        return "cursor"
-    if ".codex" in script_parts:
-        return "codex"
-    if ".gemini" in script_parts:
-        return "gemini"
-    if ".qoder" in script_parts:
-        return "qoder"
-    if ".codebuddy" in script_parts:
-        return "codebuddy"
-    if ".factory" in script_parts:
-        return "droid"
-    if ".kiro" in script_parts:
-        return "kiro"
-    return None
-
-
-def main() -> int:
-    if os.environ.get("PACTILE_HOOKS") == "0" or os.environ.get("PACTILE_DISABLE_HOOKS") == "1":
-        return 0
-
-    try:
-        data = json.load(sys.stdin)
-    except (json.JSONDecodeError, ValueError):
-        data = {}
-    if not isinstance(data, dict):
-        data = {}
-
-    # Gemini CLI 0.40.x rejects "UserPromptSubmit" — its per-turn event is
-    # named "BeforeAgent". Other platforms accept the original Claude-style name.
-    platform = _detect_platform(data)
-    hook_event_name = (
-        "BeforeAgent" if platform == "gemini" else "UserPromptSubmit"
-    )
-    print(
-        json.dumps(
-            {
-                "hookSpecificOutput": {
-                    "hookEventName": hook_event_name,
-                    "additionalContext": "",
-                }
-            }
-        )
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())