@blxzer/pactile 0.5.0

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

@@ -0,0 +1,267 @@
+#!/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

@@ -0,0 +1,106 @@
+#!/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())

package/dist/templates/shared-hooks/rename-session-for-task.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""Cursor afterShellExecution hook: prompt session rename after task bind/start.
+
+When the agent successfully runs `task.py select` or
+`task.py start-execution <task> --approved`, emit an agent_message (best-effort)
+so the main session calls cursor-app-control `rename_chat` with the task
+directory name. MCP unavailable → agent skips silently per pactile-session-rename rule.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import shlex
+import sys
+from pathlib import Path
+from typing import Any
+
+DIR_WORKFLOW = ".pactile"
+DIR_RUNTIME = ".runtime"
+DIR_SESSION_RENAME = "session-rename"
+ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*m")
+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 _strip_ansi(text: str) -> str:
+    return ANSI_ESCAPE.sub("", text)
+
+
+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 _task_py_token_index(tokens: list[str]) -> int | None:
+    for index, token in enumerate(tokens):
+        if Path(token.strip("\"'")).name == "task.py":
+            return index
+    return None
+
+
+def parse_rename_intent(command: str) -> dict[str, str] | None:
+    """Return subcommand + task_ref when command should trigger rename."""
+    try:
+        tokens = shlex.split(command, posix=os.name != "nt")
+    except ValueError:
+        return None
+
+    task_index = _task_py_token_index(tokens)
+    if task_index is None or task_index + 1 >= len(tokens):
+        return None
+
+    subcommand = tokens[task_index + 1]
+    if subcommand == "select":
+        if task_index + 2 >= len(tokens):
+            return None
+        return {"subcommand": subcommand, "task_ref": tokens[task_index + 2]}
+    if subcommand == "start-execution":
+        if "--approved" not in tokens:
+            return None
+        if task_index + 2 >= len(tokens):
+            return None
+        task_ref = tokens[task_index + 2]
+        if task_ref.startswith("-"):
+            return None
+        return {"subcommand": subcommand, "task_ref": task_ref}
+    return None
+
+
+def task_directory_name(task_ref: str) -> str:
+    """Use task folder basename as the chat title."""
+    cleaned = task_ref.strip().strip("\"'")
+    return Path(cleaned.replace("\\", "/")).name
+
+
+def shell_output_succeeded(subcommand: str, output: str) -> bool:
+    text = _strip_ansi(output or "")
+    if "Error:" in text or "error:" in text.lower():
+        return False
+    if subcommand == "select":
+        return "Selected task:" in text or "✓ Selected task" in text
+    if subcommand == "start-execution":
+        return "Execution approved" in text or "✓ Execution approved" in text
+    return False
+
+
+def _safe_context_filename(context_key: str) -> str:
+    digest = hashlib.sha256(context_key.encode("utf-8")).hexdigest()[:24]
+    return f"{digest}.json"
+
+
+def _rename_state_dir(root: Path) -> Path:
+    return root / DIR_WORKFLOW / DIR_RUNTIME / DIR_SESSION_RENAME
+
+
+def _load_rename_state(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _should_emit_rename(state: dict[str, Any], title: str) -> bool:
+    return state.get("last_title") != title
+
+
+def _write_rename_state(path: Path, context_key: str, title: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "context_key": context_key,
+        "last_title": title,
+    }
+    path.write_text(
+        json.dumps(payload, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _agent_rename_message(title: str) -> str:
+    return (
+        "Pactile session rename: call cursor-app-control MCP `rename_chat` once "
+        f'with title "{title}" (task directory name). '
+        "If rename_chat is not in your tool list, skip silently — do not ask the user "
+        "to rename manually."
+    )
+
+
+def _load_context_key(root: Path, hook_input: dict[str, Any]) -> str | None:
+    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]
+
+    if not any(_string_value(hook_input.get(key)) for key in CONTEXT_IDENTITY_KEYS):
+        return None
+    return resolve_context_key(hook_input, platform="cursor")
+
+
+def main() -> int:
+    if os.environ.get("PACTILE_HOOKS") == "0" or os.environ.get("PACTILE_DISABLE_HOOKS") == "1":
+        print("{}")
+        return 0
+
+    try:
+        hook_input = json.loads(sys.stdin.read())
+    except (json.JSONDecodeError, ValueError):
+        hook_input = {}
+    if not isinstance(hook_input, dict):
+        hook_input = {}
+
+    event = _string_value(hook_input.get("hook_event_name")) or "afterShellExecution"
+    if event != "afterShellExecution":
+        print("{}")
+        return 0
+
+    command = _string_value(hook_input.get("command")) or ""
+    intent = parse_rename_intent(command)
+    if intent is None:
+        print("{}")
+        return 0
+
+    output = _string_value(hook_input.get("output")) or ""
+    if not shell_output_succeeded(intent["subcommand"], output):
+        print("{}")
+        return 0
+
+    title = task_directory_name(intent["task_ref"])
+    if not title:
+        print("{}")
+        return 0
+
+    cwd = Path(_string_value(hook_input.get("cwd")) or os.getcwd())
+    root = _find_pactile_root(cwd)
+    if root is None:
+        print("{}")
+        return 0
+
+    context_key = _load_context_key(root, hook_input)
+    if not context_key:
+        print("{}")
+        return 0
+
+    state_path = _rename_state_dir(root) / _safe_context_filename(context_key)
+    state = _load_rename_state(state_path)
+    if not _should_emit_rename(state, title):
+        print("{}")
+        return 0
+
+    try:
+        _write_rename_state(state_path, context_key, title)
+    except OSError:
+        print("{}")
+        return 0
+
+    print(
+        json.dumps(
+            {"agent_message": _agent_rename_message(title)},
+            ensure_ascii=False,
+        ),
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())