@blxzer/pactile 0.5.0 → 0.6.0-beta.4

package/dist/templates/shared-hooks/session-start.py

@@ -1,355 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Session Start Hook - Inject the context-progressive Session pack only.
-
-Event Bridge remains a separate earlier `sessionStart` command in hooks.json.
-This hook must not crash: compiler failure is a successful no-op (exit 0).
-"""
-from __future__ import annotations
-
-# IMPORTANT: Suppress all warnings FIRST
-import warnings
-warnings.filterwarnings("ignore")
-
-import importlib.util
-import json
-import os
-import re
-import shlex
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-
-def _normalize_windows_shell_path(path_str: str) -> str:
-    """Normalize Unix-style shell paths to real Windows paths.
-
-    On Windows, shells like Git Bash / MSYS2 / Cygwin may report paths like
-    `/d/Users/...` or `/cygdrive/d/Users/...`. `Path.resolve()` will misinterpret
-    these as `D:/d/Users...` on drive D: (or similar), breaking repo root
-    detection.
-
-    This function is intentionally conservative: it only rewrites patterns that
-    unambiguously represent a drive letter mount.
-    """
-    if not isinstance(path_str, str) or not path_str:
-        return path_str
-
-    # Only relevant on Windows; keep other platforms untouched.
-    if not sys.platform.startswith("win"):
-        return path_str
-
-    p = path_str.strip()
-
-    # Already a Windows drive path (C:\... or C:/...)
-    if re.match(r"^[A-Za-z]:[\/]", p):
-        return p
-
-    # MSYS/Git-Bash style: /c/Users/... or /d/Work/...
-    m = re.match(r"^/([A-Za-z])/(.*)", p)
-    if m:
-        drive, rest = m.group(1).upper(), m.group(2)
-        rest = rest.replace('/', '\\')
-        return f"{drive}:\\{rest}"
-
-    # Cygwin style: /cygdrive/c/Users/...
-    m = re.match(r"^/cygdrive/([A-Za-z])/(.*)", p)
-    if m:
-        drive, rest = m.group(1).upper(), m.group(2)
-        rest = rest.replace('/', '\\')
-        return f"{drive}:\\{rest}"
-
-    # WSL mounted drive (sometimes leaked into env): /mnt/c/Users/...
-    m = re.match(r"^/mnt/([A-Za-z])/(.*)", p)
-    if m:
-        drive, rest = m.group(1).upper(), m.group(2)
-        rest = rest.replace('/', '\\')
-        return f"{drive}:\\{rest}"
-
-    return path_str
-
-
-FIRST_REPLY_NOTICE = """<first-reply-notice>
-First visible reply: say once in Chinese that Pactile SessionStart context is loaded, then answer directly.
-This notice is one-shot: do not repeat it after the first assistant reply in the same session.
-</first-reply-notice>"""
-
-# 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 should_skip_injection() -> bool:
-    """Check if any platform's non-interactive flag is set, or if Pactile
-    hooks are explicitly disabled via PACTILE_HOOKS=0 / PACTILE_DISABLE_HOOKS=1.
-    """
-    if os.environ.get("PACTILE_HOOKS") == "0":
-        return True
-    if os.environ.get("PACTILE_DISABLE_HOOKS") == "1":
-        return True
-    non_interactive_vars = [
-        "CLAUDE_NON_INTERACTIVE",
-        "QODER_NON_INTERACTIVE",
-        "CODEBUDDY_NON_INTERACTIVE",
-        "FACTORY_NON_INTERACTIVE",
-        "CURSOR_NON_INTERACTIVE",
-        "GEMINI_NON_INTERACTIVE",
-        "KIRO_NON_INTERACTIVE",
-        "COPILOT_NON_INTERACTIVE",
-    ]
-    return any(os.environ.get(var) == "1" for var in non_interactive_vars)
-
-
-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 _append_hook_log(pactile_dir: Path, record: dict) -> None:
-    """Side-channel: prove this process ran even if additional_context is dropped."""
-    try:
-        log_dir = pactile_dir / ".runtime" / "hooks"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        payload = {
-            "ts": datetime.now(timezone.utc)
-            .replace(microsecond=0)
-            .isoformat()
-            .replace("+00:00", "Z"),
-            **record,
-        }
-        with (log_dir / "session-start.log").open("a", encoding="utf-8") as handle:
-            handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
-    except Exception:
-        pass
-
-
-def _resolve_pactile_dir(project_dir: Path) -> Path:
-    """Resolve the pactile instance directory for this project.
-
-    Mirrors common/paths.py get_repo_root(): finds the nearest .pactile upward
-    from project_dir. Harness sub-repos without a local .pactile resolve to the
-    harness root instance (thin-connect, 2026-08-16 instance-boundary decision).
-    """
-    current = project_dir
-    while True:
-        if (current / ".pactile").is_dir():
-            return current / ".pactile"
-        if current.parent == current:
-            break
-        current = current.parent
-    return project_dir / ".pactile"
-
-
-def _resolve_context_key(pactile_dir: Path, input_data: dict) -> str | None:
-    scripts_dir = pactile_dir / "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(input_data, platform=_detect_platform(input_data))
-
-
-def _persist_context_key_for_bash(context_key: str | None) -> None:
-    """Expose Pactile session identity to later Claude Code Bash commands.
-
-    Claude Code SessionStart hooks can append exports to CLAUDE_ENV_FILE; those
-    variables are then available to Bash tools in the same conversation. Without
-    this bridge, `task.py select` has hook stdin during SessionStart but no
-    session identity when the AI later runs it as a normal shell command.
-    """
-    if not context_key:
-        return
-    env_file = os.environ.get("CLAUDE_ENV_FILE")
-    if not env_file:
-        return
-    try:
-        with open(env_file, "a", encoding="utf-8") as handle:
-            handle.write(f"export PACTILE_CONTEXT_ID={shlex.quote(context_key)}\n")
-    except OSError:
-        pass
-
-
-def _resolve_selected_task(pactile_dir: Path, input_data: dict):
-    scripts_dir = pactile_dir / "scripts"
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-    from common.active_task import resolve_selected_task  # type: ignore[import-not-found]
-
-    return resolve_selected_task(
-        pactile_dir.parent,
-        input_data,
-        platform=_detect_platform(input_data),
-    )
-
-
-def _load_session_pack_module(pactile_dir: Path):
-    """Load session_pack.py without executing common/__init__.py."""
-    pack_path = pactile_dir / "scripts" / "common" / "session_pack.py"
-    if not pack_path.is_file():
-        return None
-    spec = importlib.util.spec_from_file_location("pactile_session_pack", pack_path)
-    if spec is None or spec.loader is None:
-        return None
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-def _compile_session_pack_text(pactile_dir: Path, input_data: dict) -> str:
-    """Return compiled Session pack XML, or empty string on any failure."""
-    try:
-        module = _load_session_pack_module(pactile_dir)
-        if module is None:
-            return ""
-        selected_path = None
-        selected_stale = False
-        try:
-            active = _resolve_selected_task(pactile_dir, input_data)
-            selected_path = active.task_path
-            selected_stale = bool(active.stale)
-        except Exception:
-            selected_path = None
-            selected_stale = False
-        fact_gap = os.environ.get("PACTILE_SESSION_FACT_GAP") == "1"
-        pack = module.compile_session_pack_from_pactile(
-            pactile_dir,
-            selected_task_path=selected_path,
-            selected_stale=selected_stale,
-            fact_gap=fact_gap,
-        )
-        rendered = module.render_session_pack(pack)
-        return rendered if isinstance(rendered, str) else ""
-    except Exception:
-        return ""
-
-
-def _emit(context_text: str) -> None:
-    result = {
-        # Claude Code / Qoder / CodeBuddy / Droid / Gemini / Copilot format
-        "hookSpecificOutput": {
-            "hookEventName": "SessionStart",
-            "additionalContext": context_text,
-        },
-        # Cursor sessionStart format (top-level snake_case per Cursor docs)
-        "additional_context": context_text,
-    }
-    print(json.dumps(result, ensure_ascii=False), flush=True)
-
-
-def main():
-    enter_root = Path(_normalize_windows_shell_path(os.getcwd())).resolve()
-    _append_hook_log(_resolve_pactile_dir(enter_root), {"phase": "enter"})
-    if should_skip_injection():
-        _append_hook_log(_resolve_pactile_dir(enter_root), {"phase": "skip"})
-        sys.exit(0)
-
-    try:
-        hook_input = json.loads(sys.stdin.read())
-        if not isinstance(hook_input, dict):
-            hook_input = {}
-    except (json.JSONDecodeError, ValueError):
-        hook_input = {}
-
-    # Try platform-specific env vars, hook cwd, fallback to cwd
-    project_dir_env_vars = [
-        "CLAUDE_PROJECT_DIR",
-        "QODER_PROJECT_DIR",
-        "CODEBUDDY_PROJECT_DIR",
-        "FACTORY_PROJECT_DIR",
-        "CURSOR_PROJECT_DIR",
-        "GEMINI_PROJECT_DIR",
-        "KIRO_PROJECT_DIR",
-        "COPILOT_PROJECT_DIR",
-    ]
-    project_dir = None
-    for var in project_dir_env_vars:
-        val = os.environ.get(var)
-        if val:
-            project_dir = Path(_normalize_windows_shell_path(val)).resolve()
-            break
-    if project_dir is None:
-        project_dir = Path(_normalize_windows_shell_path(hook_input.get("cwd", "."))).resolve()
-
-    pactile_dir = _resolve_pactile_dir(project_dir)
-    try:
-        context_key = _resolve_context_key(pactile_dir, hook_input)
-        _persist_context_key_for_bash(context_key)
-    except Exception:
-        pass
-
-    compiled = _compile_session_pack_text(pactile_dir, hook_input)
-    parts = [FIRST_REPLY_NOTICE]
-    if compiled.strip():
-        parts.append(compiled)
-    text = "\n\n".join(parts)
-    _append_hook_log(
-        pactile_dir,
-        {
-            "phase": "emit",
-            "chars": len(text),
-            "has_session_pack": "<session-pack" in text,
-        },
-    )
-    _emit(text)
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception:
-        # Hook must never crash the host session.
-        try:
-            _emit(FIRST_REPLY_NOTICE)
-        except Exception:
-            pass
-        sys.exit(0)

package/dist/templates/shared-hooks/spec-write-audit.py

@@ -1,173 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Spec Write Audit Hook — machine record of writes to long-term spec knowledge.
-
-Part of the "record mandatory / flow free / verdict by human" trichotomy
-(P41 memory-s3-spec-gate). This hook ONLY records that a write to
-`.pactile/spec/`, `docs/adr/`, or Policy files was initiated. It NEVER blocks
-the write:
-
-- Always prints a preToolUse ``allow`` permission decision.
-- Every failure path is a silent no-op (exit 0) — a recording failure must
-  not block any write.
-
-The preToolUse event fires before the tool executes, so the record describes
-the *initiated* write (actor / when / target file / verification state),
-not the write result. ``verified`` is conservative: with no confirmation
-signal in the hook input it records ``false`` (unverified write, recorded
-not rejected).
-"""
-from __future__ import annotations
-
-import getpass
-import json
-import os
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-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"
-DIR_RUNTIME = ".runtime"
-DIR_HOOKS = "hooks"
-AUDIT_FILE = "spec-write.log"
-
-# Authoritative protected roots, matching `spec-learning` contract wording:
-# ".pactile/spec/", ADR (docs/adr/), Policy. Policy files live under .pactile/spec/
-# (e.g. .pactile/spec/Pactile/...); platform rule files (.cursor/rules/*.mdc) are
-# outside this machine-record scope.
-PROTECTED_REL_PREFIXES = (
-    ".pactile/spec/",
-    "pactile/spec/",
-    "docs/adr/",
-    ".pactile/spec",
-    "docs/adr",
-)
-
-WRITE_TOOLS = frozenset({"write", "edit", "notebookedit", "applydiff", "multiplediff"})
-
-
-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 _safe_payload() -> dict:
-    raw = sys.stdin.read() if not sys.stdin.isatty() else ""
-    if not raw.strip():
-        return {}
-    try:
-        parsed = json.loads(raw)
-    except json.JSONDecodeError:
-        return {}
-    return parsed if isinstance(parsed, dict) else {}
-
-
-def _string_value(value, default: str = "") -> str:
-    if isinstance(value, str):
-        return value.strip()
-    return default
-
-
-def _extract_target_path(hook_input: dict) -> str | None:
-    tool_input = hook_input.get("tool_input")
-    if not isinstance(tool_input, dict):
-        tool_input = {}
-    for key in ("file_path", "filePath", "path", "target_path", "targetPath", "doc_path", "docPath"):
-        value = _string_value(tool_input.get(key))
-        if value:
-            return value
-    return None
-
-
-def _is_protected_target(repo_root: str, raw_path: str) -> bool:
-    target = Path(raw_path)
-    if target.is_absolute():
-        try:
-            relative = target.resolve().relative_to(Path(repo_root).resolve())
-        except ValueError:
-            return False
-        target_rel = str(relative).replace("\\", "/")
-    else:
-        target_rel = raw_path.replace("\\", "/").lstrip("./")
-    return any(target_rel == prefix or target_rel.startswith(prefix.rstrip("/") + "/") for prefix in PROTECTED_REL_PREFIXES)
-
-
-def _actor_for(hook_input: dict) -> str:
-    """Best-effort actor label. OS user is always available; enrich with the
-    session/interaction id when the hook payload carries one."""
-    user = ""
-    try:
-        user = getpass.getuser()
-    except Exception:
-        user = "unknown"
-    for key in ("session_id", "sessionId", "conversation_id", "conversationId", "interaction_id", "interactionId"):
-        if _string_value(hook_input.get(key)):
-            return f"{user}:{_string_value(hook_input.get(key))}"
-    return user
-
-
-def _record(repo_root: str, hook_input: dict, target_path: str) -> None:
-    log_dir = Path(repo_root) / DIR_WORKFLOW / DIR_RUNTIME / DIR_HOOKS
-    log_dir.mkdir(parents=True, exist_ok=True)
-    record = {
-        "event": "spec-write-initiated",
-        "ts": datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z"),
-        "actor": _actor_for(hook_input),
-        "tool": _string_value(hook_input.get("tool_name", hook_input.get("toolName"))).lower() or "unknown",
-        "file": target_path.replace("\\", "/"),
-        # No confirmation signal exists in the preToolUse payload: an
-        # unverified write is *recorded*, never blocked.
-        "verified": False,
-    }
-    with (log_dir / AUDIT_FILE).open("a", encoding="utf-8") as handle:
-        handle.write(json.dumps(record, ensure_ascii=False) + "\n")
-
-
-def main() -> int:
-    try:
-        hook_input = _safe_payload()
-        tool_name = _string_value(
-            hook_input.get("tool_name", hook_input.get("toolName"))
-        ).lower()
-        if tool_name not in WRITE_TOOLS:
-            print(json.dumps({"permission": "allow"}), flush=True)
-            return 0
-
-        target_path = _extract_target_path(hook_input)
-        if not target_path:
-            print(json.dumps({"permission": "allow"}), flush=True)
-            return 0
-
-        repo_root = find_repo_root(_string_value(hook_input.get("cwd"), os.getcwd()))
-        if not repo_root or not _is_protected_target(repo_root, target_path):
-            print(json.dumps({"permission": "allow"}), flush=True)
-            return 0
-
-        # Recording failure must never block the write: swallow and allow.
-        try:
-            _record(repo_root, hook_input, target_path)
-        except Exception:
-            pass
-    except Exception:
-        pass
-    print(json.dumps({"permission": "allow"}), flush=True)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/dist/utils/cursor-retrieval-env.d.ts

@@ -1,17 +0,0 @@
-/**
- * Legacy import-path shim.
- *
- * Retrieval planning no longer reads user-global route state or process
- * environment to select an implementation. Host capability probing and
- * concrete Provider binding belong to Adapter/Middleware integration.
- */
-export declare const ENV_UNKNOWN: "unknown";
-export type CursorRetrievalEnv = typeof ENV_UNKNOWN;
-export interface CursorRetrievalEnvInfo {
-    readonly env: CursorRetrievalEnv;
-    readonly source: "neutral-compat";
-    readonly detail: null;
-}
-export declare function detectCursorRetrievalEnvInfo(): CursorRetrievalEnvInfo;
-export declare function detectCursorRetrievalEnv(): CursorRetrievalEnv;
-//# sourceMappingURL=cursor-retrieval-env.d.ts.map

package/dist/utils/cursor-retrieval-env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cursor-retrieval-env.d.ts","sourceRoot":"","sources":["../../src/utils/cursor-retrieval-env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,WAAW,EAAG,SAAkB,CAAC;AAC9C,MAAM,MAAM,kBAAkB,GAAG,OAAO,WAAW,CAAC;AAEpD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,GAAG,EAAE,kBAAkB,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;CACvB;AAED,wBAAgB,4BAA4B,IAAI,sBAAsB,CAMrE;AAED,wBAAgB,wBAAwB,IAAI,kBAAkB,CAE7D"}

package/dist/utils/cursor-retrieval-env.js

@@ -1,19 +0,0 @@
-/**
- * Legacy import-path shim.
- *
- * Retrieval planning no longer reads user-global route state or process
- * environment to select an implementation. Host capability probing and
- * concrete Provider binding belong to Adapter/Middleware integration.
- */
-export const ENV_UNKNOWN = "unknown";
-export function detectCursorRetrievalEnvInfo() {
-    return {
-        env: ENV_UNKNOWN,
-        source: "neutral-compat",
-        detail: null,
-    };
-}
-export function detectCursorRetrievalEnv() {
-    return ENV_UNKNOWN;
-}
-//# sourceMappingURL=cursor-retrieval-env.js.map

package/dist/utils/cursor-retrieval-env.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cursor-retrieval-env.js","sourceRoot":"","sources":["../../src/utils/cursor-retrieval-env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG,SAAkB,CAAC;AAS9C,MAAM,UAAU,4BAA4B;IAC1C,OAAO;QACL,GAAG,EAAE,WAAW;QAChB,MAAM,EAAE,gBAAgB;QACxB,MAAM,EAAE,IAAI;KACb,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,wBAAwB;IACtC,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/dist/utils/mirror-check.d.ts

@@ -1,22 +0,0 @@
-export interface MirrorDiffEntry {
-    relativePath: string;
-    kind: "missing-dogfood" | "missing-template" | "content";
-}
-export interface MirrorCheckOptions {
-    /** Project root containing .cursor/ and AGENTS.md (dogfood instance) */
-    dogfoodRoot: string;
-    /** Path to packages/cli/src/templates/cursor */
-    templateCursorDir: string;
-    /** Path to packages/cli/src/templates/markdown/agents.md */
-    templateAgentsPath: string;
-}
-export interface MirrorCheckResult {
-    ok: boolean;
-    diffs: MirrorDiffEntry[];
-}
-/** Extract the canonical managed block for AGENTS.md mirror comparison. */
-export declare function extractPactileManagedBlock(content: string): string;
-/** Compare dogfood .cursor/{rules,agents} + AGENTS.md against CLI templates. */
-export declare function runMirrorCheck(options: MirrorCheckOptions): MirrorCheckResult;
-export declare function formatMirrorDiffs(diffs: MirrorDiffEntry[]): string;
-//# sourceMappingURL=mirror-check.d.ts.map

package/dist/utils/mirror-check.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mirror-check.d.ts","sourceRoot":"","sources":["../../src/utils/mirror-check.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,SAAS,CAAC;CAC1D;AAED,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,eAAe,EAAE,CAAC;CAC1B;AAOD,2EAA2E;AAC3E,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CASlE;AAoDD,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,OAAO,EAAE,kBAAkB,GAAG,iBAAiB,CA+B7E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,MAAM,CAalE"}

package/dist/utils/mirror-check.js

@@ -1,90 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { FILE_NAMES } from "../constants/paths.js";
-import { normalizeText } from "./normalize-text.js";
-const MIRROR_SUBDIRS = ["rules", "agents"];
-const PACTILE_BLOCK_START = "<!-- PACTILE:START -->";
-const PACTILE_BLOCK_END = "<!-- PACTILE:END -->";
-/** Extract the canonical managed block for AGENTS.md mirror comparison. */
-export function extractPactileManagedBlock(content) {
-    const startIdx = content.indexOf(PACTILE_BLOCK_START);
-    const endIdx = content.indexOf(PACTILE_BLOCK_END);
-    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
-        return normalizeText(content.slice(startIdx, endIdx + PACTILE_BLOCK_END.length));
-    }
-    return normalizeText(content);
-}
-function listRelativeFiles(root, subdir) {
-    const dir = path.join(root, subdir);
-    if (!fs.existsSync(dir)) {
-        return [];
-    }
-    return fs
-        .readdirSync(dir)
-        .filter((name) => !name.startsWith("."))
-        .sort()
-        .map((name) => path.posix.join(subdir, name));
-}
-function compareFilePair(relativePath, dogfoodPath, templatePath) {
-    const dogfoodExists = fs.existsSync(dogfoodPath);
-    const templateExists = fs.existsSync(templatePath);
-    if (!dogfoodExists && templateExists) {
-        return { relativePath, kind: "missing-dogfood" };
-    }
-    if (dogfoodExists && !templateExists) {
-        return { relativePath, kind: "missing-template" };
-    }
-    if (!dogfoodExists && !templateExists) {
-        return null;
-    }
-    let dogfood;
-    let template;
-    if (relativePath === FILE_NAMES.AGENTS) {
-        dogfood = extractPactileManagedBlock(fs.readFileSync(dogfoodPath, "utf-8"));
-        template = extractPactileManagedBlock(fs.readFileSync(templatePath, "utf-8"));
-    }
-    else {
-        dogfood = normalizeText(fs.readFileSync(dogfoodPath, "utf-8"));
-        template = normalizeText(fs.readFileSync(templatePath, "utf-8"));
-    }
-    if (dogfood !== template) {
-        return { relativePath, kind: "content" };
-    }
-    return null;
-}
-/** Compare dogfood .cursor/{rules,agents} + AGENTS.md against CLI templates. */
-export function runMirrorCheck(options) {
-    const dogfoodCursor = path.join(options.dogfoodRoot, ".cursor");
-    const diffs = [];
-    for (const subdir of MIRROR_SUBDIRS) {
-        const dogfoodFiles = listRelativeFiles(dogfoodCursor, subdir);
-        const templateFiles = listRelativeFiles(options.templateCursorDir, subdir);
-        const allFiles = [...new Set([...dogfoodFiles, ...templateFiles])].sort();
-        for (const relativePath of allFiles) {
-            const diff = compareFilePair(relativePath, path.join(dogfoodCursor, relativePath), path.join(options.templateCursorDir, relativePath));
-            if (diff) {
-                diffs.push(diff);
-            }
-        }
-    }
-    const agentsDiff = compareFilePair(FILE_NAMES.AGENTS, path.join(options.dogfoodRoot, FILE_NAMES.AGENTS), options.templateAgentsPath);
-    if (agentsDiff) {
-        diffs.push(agentsDiff);
-    }
-    return { ok: diffs.length === 0, diffs };
-}
-export function formatMirrorDiffs(diffs) {
-    return diffs
-        .map((entry) => {
-        switch (entry.kind) {
-            case "missing-dogfood":
-                return `- ${entry.relativePath}: present in template, missing in dogfood`;
-            case "missing-template":
-                return `- ${entry.relativePath}: present in dogfood, missing in template`;
-            case "content":
-                return `- ${entry.relativePath}: content differs (normalized)`;
-        }
-    })
-        .join("\n");
-}
-//# sourceMappingURL=mirror-check.js.map