@blxzer/pactile 0.5.0 → 0.6.0-beta.4

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

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

package/dist/templates/shared-hooks/research-end-retrieval-pack.py

@@ -1,345 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Research-end / stop hook: quality-layer retrieval-pack for collected evidence.
-
-Three-layer retrieval ABI (frozen; do not merge back into workflow.md):
-
-| Layer    | Owner                 | This hook                                         |
-| -------- | --------------------- | ------------------------------------------------- |
-| Intent   | context-progressive   | does not own intents                              |
-| Provider | Middleware            | does not take smart-search as a Kernel dependency |
-| Quality  | retrieval-extended    | owner: pack only when collected-evidence exists   |
-
-Runs after an agent turn (Cursor ``stop``, Claude ``Stop``). No research
-artifacts → no-op exit 0 (do not fail, do not write a pack, do not inject
-教战). Collected evidence present → pack via ``build_retrieval_pack.py``
-(input role ``collected-evidence``). The written JSON is not AC Evidence.
-
-Does not change default ``get_context --json`` behavior.
-"""
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-import sys
-import warnings
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-warnings.filterwarnings("ignore")
-
-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(  # type: ignore[union-attr]
-            sys.stdout.detach(), encoding="utf-8", errors="replace"
-        )
-
-DIR_WORKFLOW = ".pactile"
-OUTPUT_BASENAME = "retrieval-pack-latest.json"
-MARKER = "<!-- pactile-research-end-pack -->"
-
-ABI_INTENT_OWNER = "context-progressive"
-ABI_PROVIDER_OWNER = "middleware"
-ABI_QUALITY_OWNER = "retrieval-extended"
-ABI_LAYER = "quality"
-INPUT_ROLE = "collected-evidence"
-
-
-def _repo_root(cwd: str) -> Path | None:
-    current = Path(cwd).resolve()
-    for _ in range(32):
-        if (current / DIR_WORKFLOW / "scripts").is_dir():
-            return current
-        if current.parent == current:
-            break
-        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",
-    }
-    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 _selected_task(repo_root: Path, input_data: dict) -> str | None:
-    scripts_dir = 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(
-        repo_root,
-        input_data,
-        platform=_detect_platform(input_data),
-    )
-    return selected.task_path if selected else None
-
-
-def _retrieval_extended_active(repo_root: Path, task_dir: Path) -> bool:
-    """Unactivated retrieval-extended → no pack write, no delivery claim."""
-    scripts_dir = 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
-    return bool(is_ondemand_module_active(task_dir, "retrieval-extended"))
-
-
-def _relpath(path: Path, repo_root: Path) -> str:
-    try:
-        return path.resolve().relative_to(repo_root.resolve()).as_posix()
-    except ValueError:
-        return str(path)
-
-
-def _freshness(path: Path) -> str | None:
-    try:
-        return datetime.fromtimestamp(path.stat().st_mtime, timezone.utc).isoformat()
-    except OSError:
-        return None
-
-
-def collect_evidence_items(task_dir: Path, repo_root: Path) -> list[dict[str, Any]]:
-    """Build collected-evidence items (path + provider + optional freshness)."""
-    items: list[dict[str, Any]] = []
-    research = task_dir / "research"
-    if not research.is_dir():
-        return items
-
-    for child in sorted(research.iterdir(), key=lambda path: path.name):
-        if child.name == OUTPUT_BASENAME:
-            continue
-        if child.is_file() and child.suffix.lower() in {".md", ".json"}:
-            record: dict[str, Any] = {
-                "path": _relpath(child, repo_root),
-                "provider": "task-research",
-            }
-            stamp = _freshness(child)
-            if stamp:
-                record["freshness"] = stamp
-            items.append(record)
-            continue
-        if child.is_dir() and child.name == "smart-search":
-            for run_dir in sorted(child.iterdir(), key=lambda path: path.name):
-                manifest = run_dir / "manifest.json"
-                if not manifest.is_file():
-                    continue
-                record = {
-                    "path": _relpath(manifest, repo_root),
-                    "provider": "smart-search",
-                }
-                stamp = _freshness(manifest)
-                if stamp:
-                    record["freshness"] = stamp
-                items.append(record)
-    return items
-
-
-def _stamp_pack(pack: dict[str, Any], collection_status: str, reason: str) -> dict[str, Any]:
-    stamped = dict(pack)
-    stamped["inputRole"] = INPUT_ROLE
-    stamped["outputRole"] = "retrieval-pack"
-    stamped["abiLayer"] = ABI_LAYER
-    stamped["abiOwner"] = ABI_QUALITY_OWNER
-    stamped["abiIntentOwner"] = ABI_INTENT_OWNER
-    stamped["abiProviderOwner"] = ABI_PROVIDER_OWNER
-    stamped["collectionStatus"] = collection_status
-    stamped["closeEvidenceEligible"] = False
-    stamped["notAcEvidence"] = True
-    stamped["reason"] = reason
-    return stamped
-
-
-def _pack_via_quality_cli(
-    repo_root: Path, items: list[dict[str, Any]]
-) -> dict[str, Any] | None:
-    scripts_dir = repo_root / DIR_WORKFLOW / "scripts"
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-    try:
-        from build_retrieval_pack import pack_from_collected_evidence
-    except Exception:
-        return None
-    try:
-        return pack_from_collected_evidence(
-            items,
-            payload={"inputRole": INPUT_ROLE, "items": items},
-            repo_root=repo_root,
-        )
-    except Exception:
-        return None
-
-
-def _pack_via_get_context(repo_root: Path) -> dict[str, Any] | None:
-    script = repo_root / DIR_WORKFLOW / "scripts" / "get_context.py"
-    if not script.is_file():
-        return None
-    env = os.environ.copy()
-    env["PYTHONIOENCODING"] = "utf-8"
-    cmd = [
-        sys.executable,
-        "-W",
-        "ignore",
-        str(script),
-        "--mode",
-        "retrieval-pack",
-        "--json",
-    ]
-    proc = subprocess.run(
-        cmd,
-        cwd=str(repo_root),
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        timeout=45,
-        env=env,
-    )
-    if proc.returncode != 0:
-        print(
-            f"[research-end-retrieval-pack] WARN: get_context exit {proc.returncode}: "
-            f"{proc.stderr[:500]}",
-            file=sys.stderr,
-        )
-        return None
-    try:
-        parsed = json.loads(proc.stdout)
-    except json.JSONDecodeError:
-        return None
-    if not isinstance(parsed, dict):
-        return None
-    collection = parsed.get("collection") if isinstance(parsed.get("collection"), dict) else {}
-    total = 0
-    for value in collection.values():
-        if isinstance(value, int):
-            total += value
-    status = "collected" if total > 0 else "empty"
-    reason = (
-        "quality-layer retrieval-pack of collected-evidence; "
-        "not AC Evidence and not Close Evidence"
-        if status == "collected"
-        else (
-            "collected-evidence items were present but pack collection is empty; "
-            "not AC Evidence"
-        )
-    )
-    return _stamp_pack(parsed, status, reason)
-
-
-def _is_collected_pack(pack: dict[str, Any]) -> bool:
-    if pack.get("collectionStatus") == "collected":
-        return True
-    collection = pack.get("collection")
-    if not isinstance(collection, dict):
-        return False
-    return any(isinstance(value, int) and value > 0 for value in collection.values())
-
-
-def _emit(platform: str | None, message: str) -> None:
-    payload: dict[str, Any]
-    if platform == "cursor":
-        payload = {"followup_message": message}
-    else:
-        payload = {
-            "hookSpecificOutput": {
-                "hookEventName": "Stop",
-                "additionalContext": message,
-            },
-        }
-    print(json.dumps(payload, ensure_ascii=False), flush=True)
-
-
-def main() -> int:
-    try:
-        raw = sys.stdin.read()
-        input_data = json.loads(raw) if raw.strip() else {}
-    except json.JSONDecodeError:
-        return 0
-
-    cwd = (
-        input_data.get("cwd")
-        or input_data.get("workspace_roots", [None])[0]
-        or os.getcwd()
-    )
-    if not isinstance(cwd, str):
-        return 0
-
-    repo_root = _repo_root(cwd)
-    if repo_root is None:
-        return 0
-
-    task_ref = _selected_task(repo_root, input_data)
-    if not task_ref:
-        return 0
-
-    task_dir = (repo_root / task_ref).resolve()
-    if not task_dir.is_dir():
-        return 0
-
-    try:
-        if not _retrieval_extended_active(repo_root, task_dir):
-            return 0
-    except Exception:
-        return 0
-
-    items = collect_evidence_items(task_dir, repo_root)
-    if not items:
-        return 0
-
-    pack = _pack_via_quality_cli(repo_root, items)
-    if not pack:
-        pack = _pack_via_get_context(repo_root)
-    if not pack or not _is_collected_pack(pack):
-        return 0
-
-    research_dir = task_dir / "research"
-    research_dir.mkdir(parents=True, exist_ok=True)
-    out_path = research_dir / OUTPUT_BASENAME
-    out_path.write_text(
-        json.dumps(pack, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
-    )
-
-    selected_n = 0
-    context_pack = pack.get("contextPack")
-    if isinstance(context_pack, dict):
-        selected = context_pack.get("selected")
-        if isinstance(selected, list):
-            selected_n = len(selected)
-
-    rel = out_path.relative_to(repo_root).as_posix()
-    message = (
-        f"{MARKER}\n"
-        f"retrieval-extended quality layer wrote `{rel}` from collected-evidence "
-        f"(contextPack.selected={selected_n}). "
-        f"This retrieval-pack is not AC Evidence and must not be used as Close Evidence."
-    )
-    _emit(_detect_platform(input_data), message)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())