mapify-cli 3.3.0__tar.gz → 3.4.0__tar.gz

{mapify_cli-3.3.0 → mapify_cli-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapify-cli
-Version: 3.3.0
+Version: 3.4.0
 Summary: MAP Framework installer - Modular Agentic Planner for Claude Code
 Project-URL: Homepage, https://github.com/azalio/map-framework
 Project-URL: Repository, https://github.com/azalio/map-framework.git

{mapify_cli-3.3.0 → mapify_cli-3.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mapify-cli"
-version = "3.3.0"
+version = "3.4.0"
 description = "MAP Framework installer - Modular Agentic Planner for Claude Code"
 authors = [{ name = "MAP Framework Contributors" }]
 readme = "README.md"

{mapify_cli-3.3.0 → mapify_cli-3.4.0}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.3.0"
+__version__ = "3.4.0"
 
 import copy
 import os

mapify_cli-3.4.0/src/mapify_cli/templates/hooks/post-compact-context.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Post-Compact Context Injector - SessionStart Hook (matcher: compact).
+
+After context compaction, injects a pointer to the saved transcript
+so Claude knows where to find the full pre-compaction conversation.
+
+Also reads restore_point.json if available (from ralph-context-pruner).
+
+Exit codes:
+  0 - Always
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+PROJECT_DIR = Path(os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd()))
+MAP_DIR = PROJECT_DIR / ".map"
+
+
+def sanitize_branch_name(branch: str) -> str:
+    """Sanitize branch name for safe filesystem paths."""
+    sanitized = branch.replace("/", "-")
+    sanitized = re.sub(r"[^a-zA-Z0-9_.-]", "-", sanitized)
+    sanitized = re.sub(r"-+", "-", sanitized).strip("-")
+    if ".." in sanitized or sanitized.startswith("."):
+        return "default"
+    return sanitized or "default"
+
+
+def get_branch_name() -> str:
+    """Get current git branch name."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            cwd=PROJECT_DIR,
+            timeout=2,
+        )
+        if result.returncode == 0:
+            return sanitize_branch_name(result.stdout.strip())
+    except Exception:
+        pass
+    return "default"
+
+
+def main() -> None:
+    try:
+        json.load(sys.stdin)
+    except json.JSONDecodeError:
+        pass
+
+    branch = get_branch_name()
+    branch_dir = MAP_DIR / branch
+
+    parts = []
+
+    # Check for saved transcript pointer
+    pointer = branch_dir / "last-transcript.txt"
+    if pointer.exists():
+        try:
+            transcript_path = pointer.read_text(encoding="utf-8").strip()
+            if transcript_path:
+                parts.append(
+                    f"The full transcript of the previous conversation "
+                    f"(before compaction) was saved to {transcript_path}. "
+                    f"Read that file if you need details from before compaction."
+                )
+        except (IOError, OSError):
+            pass
+
+    # Check for workflow restore point
+    restore = branch_dir / "restore_point.json"
+    if restore.exists():
+        try:
+            data = json.loads(restore.read_text(encoding="utf-8"))
+            state = data.get("workflow_state", {})
+            workflow = state.get("workflow", "")
+            phase = state.get("current_step", {}).get("phase", "") or state.get(
+                "current_state", ""
+            )
+            if workflow or phase:
+                parts.append(
+                    f"MAP workflow state before compaction: "
+                    f"workflow={workflow}, phase={phase}. "
+                    f"Full state: .map/{branch}/workflow_state.json"
+                )
+        except (json.JSONDecodeError, IOError, OSError):
+            pass
+
+    if not parts:
+        print("{}")
+        sys.exit(0)
+
+    result = {
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": "\n".join(parts),
+        }
+    }
+    print(json.dumps(result))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

mapify_cli-3.4.0/src/mapify_cli/templates/hooks/pre-compact-save-transcript.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+Pre-Compact Transcript Saver - PreCompact Hook.
+
+Before context compaction, saves the full conversation transcript
+to .map/<branch>/transcript-YYYY-MM-DD-HH-MM-SS.md as readable markdown.
+
+This preserves the full context for later review.
+
+Exit codes:
+  0 - Always (PreCompact hooks don't block)
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+PROJECT_DIR = Path(os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd()))
+MAP_DIR = PROJECT_DIR / ".map"
+
+
+def sanitize_branch_name(branch: str) -> str:
+    """Sanitize branch name for safe filesystem paths."""
+    sanitized = branch.replace("/", "-")
+    sanitized = re.sub(r"[^a-zA-Z0-9_.-]", "-", sanitized)
+    sanitized = re.sub(r"-+", "-", sanitized).strip("-")
+    if ".." in sanitized or sanitized.startswith("."):
+        return "default"
+    return sanitized or "default"
+
+
+def get_branch_name() -> str:
+    """Get current git branch name."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            cwd=PROJECT_DIR,
+            timeout=2,
+        )
+        if result.returncode == 0:
+            return sanitize_branch_name(result.stdout.strip())
+    except Exception:
+        pass
+    return "default"
+
+
+def extract_text_from_content(content):
+    """Extract readable text from message content (string or list)."""
+    if isinstance(content, str):
+        return content
+    if not isinstance(content, list):
+        return ""
+
+    parts = []
+    for item in content:
+        if isinstance(item, str):
+            parts.append(item)
+        elif isinstance(item, dict):
+            item_type = item.get("type", "")
+            if item_type == "text":
+                parts.append(item.get("text", ""))
+            elif item_type == "tool_use":
+                name = item.get("name", "unknown")
+                tool_input = item.get("input", {})
+                input_str = json.dumps(tool_input, ensure_ascii=False)
+                # Truncate long tool inputs
+                if len(input_str) > 500:
+                    input_str = input_str[:500] + "..."
+                parts.append(f"**Tool:** `{name}`\n```json\n{input_str}\n```")
+            elif item_type == "tool_result":
+                result_content = item.get("content", "")
+                if isinstance(result_content, list):
+                    for rc in result_content:
+                        if isinstance(rc, dict) and rc.get("type") == "text":
+                            text = rc.get("text", "")
+                            if len(text) > 1000:
+                                text = text[:1000] + "...[truncated]"
+                            parts.append(text)
+                elif isinstance(result_content, str):
+                    if len(result_content) > 1000:
+                        result_content = result_content[:1000] + "...[truncated]"
+                    parts.append(result_content)
+    return "\n".join(parts)
+
+
+def parse_transcript(transcript_path: Path) -> str:
+    """Parse JSONL transcript into readable markdown."""
+    lines = []
+    try:
+        with open(transcript_path, encoding="utf-8") as f:
+            for raw_line in f:
+                raw_line = raw_line.strip()
+                if not raw_line:
+                    continue
+                try:
+                    entry = json.loads(raw_line)
+                except json.JSONDecodeError:
+                    continue
+
+                entry_type = entry.get("type", "")
+                message = entry.get("message", {})
+                role = message.get("role", "")
+                content = message.get("content", "")
+
+                if entry_type == "human" or role == "user":
+                    text = extract_text_from_content(content)
+                    if text.strip():
+                        lines.append(f"## User\n\n{text}\n")
+                elif entry_type == "assistant" or role == "assistant":
+                    text = extract_text_from_content(content)
+                    if text.strip():
+                        lines.append(f"## Assistant\n\n{text}\n")
+                elif entry_type == "tool_result":
+                    text = extract_text_from_content(content)
+                    if text.strip():
+                        lines.append(
+                            f"<details><summary>Tool result</summary>\n\n"
+                            f"```\n{text}\n```\n</details>\n"
+                        )
+    except (IOError, OSError) as e:
+        lines.append(f"Error reading transcript: {e}\n")
+
+    return "\n".join(lines)
+
+
+def main() -> None:
+    try:
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        input_data = {}
+
+    transcript_path = input_data.get("transcript_path", "")
+    session_id = input_data.get("session_id", "unknown")
+
+    if not transcript_path or not Path(transcript_path).is_file():
+        print("{}")
+        sys.exit(0)
+
+    branch = get_branch_name()
+    timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+
+    branch_dir = MAP_DIR / branch
+    branch_dir.mkdir(parents=True, exist_ok=True)
+    outfile = branch_dir / f"transcript-{timestamp}.md"
+
+    header = (
+        f"# Conversation snapshot before compact\n\n"
+        f"- **Branch:** {branch}\n"
+        f"- **Date:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+        f"- **Session:** {session_id}\n\n"
+        f"---\n\n"
+    )
+
+    body = parse_transcript(Path(transcript_path))
+
+    try:
+        outfile.write_text(header + body, encoding="utf-8")
+        print(f"[pre-compact-save] Saved transcript to {outfile}", file=sys.stderr)
+    except (IOError, OSError) as e:
+        print(f"[pre-compact-save] Failed to save: {e}", file=sys.stderr)
+        print("{}")
+        sys.exit(0)
+
+    # Write a pointer file so the context-pruner (or compact summary) can reference it
+    pointer = branch_dir / "last-transcript.txt"
+    try:
+        pointer.write_text(str(outfile.relative_to(PROJECT_DIR)), encoding="utf-8")
+    except (IOError, OSError):
+        pass
+
+    print("{}")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

{mapify_cli-3.3.0 → mapify_cli-3.4.0}/src/mapify_cli/templates/hooks/ralph-context-pruner.py

@@ -13,7 +13,7 @@ Exit codes:
   0 - Always (PreCompact hooks don't block)
 
 Output:
-  hookSpecificOutput.additionalContext - Recovery message injected into context
+  Side effects only (PreCompact has no decision control per docs)
 """
 import json
 import os
@@ -239,12 +239,9 @@ def main() -> None:
                 file=sys.stderr,
             )
 
-        # Inject recovery message into context
-        recovery_msg = format_recovery_message(state, branch)
-        output["hookSpecificOutput"] = {
-            "hookEventName": "PreCompact",
-            "additionalContext": recovery_msg,
-        }
+        # Note: PreCompact has no decision control per docs — additionalContext
+        # is not supported. Recovery context is injected via SessionStart(compact)
+        # hook (post-compact-context.py) which reads restore_point.json.
 
     # Prune log files in ALL branch directories
     actions = []

{mapify_cli-3.3.0 → mapify_cli-3.4.0}/src/mapify_cli/templates/settings.json

@@ -35,6 +35,20 @@
     ]
   },
   "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "compact",
+        "description": "Post-Compact Context - inject transcript path and workflow state after compaction",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/post-compact-context.py",
+            "timeout": 5,
+            "description": "Tells Claude where to find the pre-compaction transcript and workflow state"
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "Edit|Write|Read|MultiEdit|Bash",
@@ -75,14 +89,14 @@
     ],
     "PostToolUse": [
       {
-        "matcher": "Edit|Write|MultiEdit",
-        "description": "Post-Edit Reminder - lightweight test reminder after code changes",
+        "matcher": "Edit|Write|MultiEdit|Bash",
+        "description": "Iteration Logger - logs tool calls, detects thrashing patterns",
         "hooks": [
           {
             "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/post-edit-reminder.py",
-            "timeout": 3,
-            "description": "Reminds to run tests after Edit/Write (only when MAP workflow active)"
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/ralph-iteration-logger.py",
+            "timeout": 5,
+            "description": "Logs iterations to .map/<branch>/iteration_log.jsonl, alerts on file thrashing"
           }
         ]
       }
@@ -99,6 +113,18 @@
             "description": "Saves workflow restore point and prunes old logs"
           }
         ]
+      },
+      {
+        "matcher": "*",
+        "description": "Transcript Saver - save full conversation to .map/ before compaction",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pre-compact-save-transcript.py",
+            "timeout": 30,
+            "description": "Saves full transcript as readable markdown to .map/<branch>/transcript-YYYY-MM-DD-HH-MM.md"
+          }
+        ]
       }
     ],
     "Stop": [

mapify_cli-3.3.0/src/mapify_cli/templates/hooks/block-dangerous.sh

@@ -1,173 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# Claude Code PreToolUse Hook: Block Dangerous Commands
-# =============================================================================
-#
-# Intercepts Bash tool calls and blocks destructive commands like:
-# - rm -rf (recursive force delete)
-# - git push --force to main/master branches
-# - git reset --hard
-#
-# USAGE:
-#   This hook runs automatically before Bash tool calls.
-#   Claude Code passes JSON via stdin with tool_name and tool_input.
-#
-# EXIT CODES:
-#   0 - Allow command execution
-#   0 + permissionDecision=deny - Block command execution (preferred)
-#
-# TESTING:
-#   echo '{"tool_name": "Bash", "tool_input": {"command": "rm -rf /"}}' | bash block-dangerous.sh
-#   # Expected: Exit code 0 with permissionDecision=deny in JSON output
-#
-# =============================================================================
-
-set -euo pipefail
-
-# Read JSON from stdin
-INPUT=$(cat)
-
-deny() {
-    local reason="$1"
-
-    if command -v jq >/dev/null 2>&1; then
-        jq -n --arg reason "$reason" '{
-          hookSpecificOutput: {
-            hookEventName: "PreToolUse",
-            permissionDecision: "deny",
-            permissionDecisionReason: $reason
-          }
-        }'
-        return 0
-    fi
-
-    if command -v python3 >/dev/null 2>&1; then
-        python3 - "$reason" <<'PY'
-import json
-import sys
-
-reason = sys.argv[1]
-print(
-    json.dumps(
-        {
-            "hookSpecificOutput": {
-                "hookEventName": "PreToolUse",
-                "permissionDecision": "deny",
-                "permissionDecisionReason": reason,
-            }
-        }
-    )
-)
-PY
-        return 0
-    fi
-
-    local escaped=${reason//\\/\\\\}
-    escaped=${escaped//\"/\\\"}
-    printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"%s"}}\n' "$escaped"
-}
-
-if command -v jq >/dev/null 2>&1; then
-    TOOL_NAME=$(jq -r '.tool_name // empty' <<<"$INPUT" 2>/dev/null || true)
-    COMMAND=$(jq -r '.tool_input.command // empty' <<<"$INPUT" 2>/dev/null || true)
-elif command -v python3 >/dev/null 2>&1; then
-    TOOL_NAME=$(
-        python3 -c 'import json,sys; d=json.loads(sys.stdin.read() or "{}"); print(d.get("tool_name",""))' <<<"$INPUT" 2>/dev/null || true
-    )
-    COMMAND=$(
-        python3 -c 'import json,sys; d=json.loads(sys.stdin.read() or "{}"); ti=d.get("tool_input") or {}; print(ti.get("command",""))' <<<"$INPUT" 2>/dev/null || true
-    )
-else
-    TOOL_NAME=""
-    COMMAND=""
-fi
-
-# Only intercept Bash tool
-if [[ "$TOOL_NAME" != "Bash" ]]; then
-    echo '{}'
-    exit 0
-fi
-
-# If no command, allow
-if [[ -z "$COMMAND" ]]; then
-    echo '{}'
-    exit 0
-fi
-
-# Normalize command for pattern matching (lowercase for case-insensitive)
-COMMAND_LOWER=$(echo "$COMMAND" | tr '[:upper:]' '[:lower:]')
-
-# =============================================================================
-# Dangerous Pattern Checks
-# =============================================================================
-
-# Check for rm -rf (recursive force delete)
-# Matches: rm -rf, rm -fr, rm -r -f, rm -f -r, rm --recursive --force, and edge
-# cases where flags touch the path (e.g., rm -rf0dir).
-if echo "$COMMAND_LOWER" | grep -qE '(^|[[:space:];|&()])rm[[:space:]]'; then
-    # Long flags: --recursive and --force
-    if echo "$COMMAND_LOWER" | grep -qE -- '--recursive' && echo "$COMMAND_LOWER" | grep -qE -- '--force'; then
-        deny "Blocked: rm -rf is prohibited (recursive force delete can cause irreversible data loss)"
-        exit 0
-    fi
-
-    # Combined short flags: -rf / -fr (including edge cases where the path touches flags)
-    if echo "$COMMAND_LOWER" | grep -qE '(^|[[:space:];|&()])rm[[:space:]].*-[^[:space:]]*r[^[:space:]]*f'; then
-        deny "Blocked: rm -rf is prohibited (recursive force delete can cause irreversible data loss)"
-        exit 0
-    fi
-    if echo "$COMMAND_LOWER" | grep -qE '(^|[[:space:];|&()])rm[[:space:]].*-[^[:space:]]*f[^[:space:]]*r'; then
-        deny "Blocked: rm -rf is prohibited (recursive force delete can cause irreversible data loss)"
-        exit 0
-    fi
-
-    # Separate short flags: -r -f / -f -r
-    if echo "$COMMAND_LOWER" | grep -qE '(^|[[:space:]])-r([[:space:]]|$)' && echo "$COMMAND_LOWER" | grep -qE '(^|[[:space:]])-f([[:space:]]|$)'; then
-        deny "Blocked: rm -rf is prohibited (recursive force delete can cause irreversible data loss)"
-        exit 0
-    fi
-fi
-
-# Check for git push --force to main/master
-# Matches: git push --force origin main, git push -f origin master
-if echo "$COMMAND" | grep -qE 'git\s+push\s+.*(-f|--force).*\s+(origin|upstream)\s+(main|master)(\s|$)'; then
-    deny "Blocked: Force push to main/master is prohibited (can overwrite team work)"
-    exit 0
-fi
-
-# Also check reverse order: git push origin main --force
-if echo "$COMMAND" | grep -qE 'git\s+push\s+(origin|upstream)\s+(main|master)\s+(-f|--force)'; then
-    deny "Blocked: Force push to main/master is prohibited (can overwrite team work)"
-    exit 0
-fi
-
-# Check for git reset --hard (without specific commit, or dangerous patterns)
-# Block: git reset --hard, git reset --hard HEAD~, git reset --hard origin/
-if echo "$COMMAND" | grep -qE 'git\s+reset\s+--hard(\s|$)'; then
-    deny "Blocked: git reset --hard is prohibited (can cause irreversible loss of uncommitted changes)"
-    exit 0
-fi
-
-# Check for dangerous chmod/chown on system directories
-if echo "$COMMAND" | grep -qE '(chmod|chown)\s+(-R|--recursive)\s+.*\s+/($|\s)'; then
-    deny "Blocked: Recursive chmod/chown on / is prohibited (can break system permissions)"
-    exit 0
-fi
-
-# Check for dd with of=/dev/
-if echo "$COMMAND" | grep -qE 'dd\s+.*of=/dev/'; then
-    deny "Blocked: dd with of=/dev/* is prohibited (writing to raw devices can destroy data)"
-    exit 0
-fi
-
-# Check for mkfs (format filesystem)
-if echo "$COMMAND" | grep -qE 'mkfs'; then
-    deny "Blocked: mkfs is prohibited (formatting filesystems can destroy data)"
-    exit 0
-fi
-
-# =============================================================================
-# All checks passed - allow command
-# =============================================================================
-echo '{}'
-exit 0

mapify_cli-3.3.0/src/mapify_cli/templates/hooks/block-secrets.py

@@ -1,158 +0,0 @@
-#!/usr/bin/env python3
-"""
-Claude Code PreToolUse Hook: Block Sensitive File Access
-Intercepts Read/Edit/Write tool calls and prevents access to sensitive files
-like .env files, credentials, private keys, and secrets.
-
-USAGE:
-  This hook runs automatically before Read/Edit/Write tool calls.
-  No manual invocation needed - Claude Code handles hook execution.
-
-BLOCKED FILE PATTERNS:
-  - .env, .env.local, .env.production (environment variables)
-  - *credentials*, *secret* (credential/secret files)
-  - *.pem, *_(private|secret|rsa|dsa|ecdsa).key (private keys)
-  - *_rsa, *_dsa, *_ecdsa, *_ed25519 (SSH keys without extension)
-  - *.p12, *.pfx, *.keystore, *.jks (certificates/keystores)
-  - *.ppk (PuTTY keys)
-
-ALLOWED FILE PATTERNS:
-  - *.pub (public keys - safe to read)
-  - license.key, api.key (generic .key files without private key indicators)
-
-HOOK BEHAVIOR:
-  - Exit code 0: Allow tool execution (non-sensitive file)
-  - Exit code 0 + permissionDecision=deny: Block tool execution (sensitive file detected)
-
-TESTING:
-  echo '{"tool_name": "Read", "tool_input": {"file_path": ".env"}}' | python3 block-secrets.py
-  # Expected: Exit code 0, JSON on stdout with permissionDecision=deny
-
-PERFORMANCE:
-  Target: <100ms per invocation
-  Actual: ~27ms average (measured with 100 iterations)
-"""
-import json
-import sys
-import re
-from pathlib import Path
-
-# Sensitive file patterns (PRE-COMPILED for performance)
-SENSITIVE_PATTERNS = [
-    re.compile(r"\.env.*", re.IGNORECASE),  # .env, .env.local, .env.production, etc.
-    re.compile(
-        r".*credentials.*", re.IGNORECASE
-    ),  # credentials.json, aws-credentials, etc.
-    re.compile(r".*secret.*", re.IGNORECASE),  # secrets.yaml, secret-key.txt, etc.
-    re.compile(r".*\.pem$", re.IGNORECASE),  # Private key files
-    re.compile(
-        r".*_(private|secret|rsa|dsa|ecdsa)\.key$", re.IGNORECASE
-    ),  # Specific private key files only
-    re.compile(r".*_rsa$", re.IGNORECASE),  # SSH keys without extension
-    re.compile(r".*_dsa$", re.IGNORECASE),  # DSA keys
-    re.compile(r".*_ecdsa$", re.IGNORECASE),  # ECDSA keys
-    re.compile(r".*_ed25519$", re.IGNORECASE),  # Ed25519 keys
-    re.compile(r".*\.p12$", re.IGNORECASE),  # PKCS#12 certificate files
-    re.compile(r".*\.pfx$", re.IGNORECASE),  # PKCS#12 certificate files (Windows)
-    re.compile(r".*\.keystore$", re.IGNORECASE),  # Java keystores
-    re.compile(r".*\.jks$", re.IGNORECASE),  # Java keystores
-    re.compile(r".*\.ppk$", re.IGNORECASE),  # PuTTY private keys
-]
-
-
-SAFE_PATH_PREFIXES = [
-    ".claude/hooks/",
-    ".claude/agents/",
-    ".claude/commands/",
-    ".claude/references/",
-    ".claude/skills/",
-    "src/",
-    "tests/",
-    "docs/",
-    "scripts/",
-]
-
-
-def is_sensitive_file(file_path: str) -> bool:
-    """Check if file path matches any sensitive file pattern.
-
-    Checks ALL path components (not just filename) to catch patterns
-    in directory names or parent paths. Skips files in known safe
-    directories (hooks, agents, source code, tests, etc.)
-    """
-    path_obj = Path(file_path)
-
-    # Normalize to relative path for prefix matching
-    try:
-        rel = str(path_obj.relative_to(Path.cwd()))
-    except ValueError:
-        rel = str(path_obj)
-
-    # Allow known safe directories
-    for prefix in SAFE_PATH_PREFIXES:
-        if rel.startswith(prefix):
-            return False
-
-    # Check each path component against all patterns
-    for part in path_obj.parts:
-        for pattern in SENSITIVE_PATTERNS:
-            if pattern.match(part):
-                return True
-    return False
-
-
-def block_access(file_path: str, tool_name: str):
-    """Block tool execution and output error message."""
-    print(
-        json.dumps(
-            {
-                "hookSpecificOutput": {
-                    "hookEventName": "PreToolUse",
-                    "permissionDecision": "deny",
-                    "permissionDecisionReason": (
-                        f"Blocked: Access to sensitive file '{file_path}' is prohibited "
-                        f"(tool={tool_name})."
-                    ),
-                }
-            }
-        )
-    )
-    sys.exit(0)
-
-
-def main():
-    """Main hook execution logic."""
-    # Load input from stdin
-    try:
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError as e:
-        print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    tool_name = input_data.get("tool_name", "")
-    tool_input = input_data.get("tool_input", {})
-
-    # Only intercept Read, Edit, Write tools
-    if tool_name not in ["Read", "Edit", "Write"]:
-        print("{}")
-        sys.exit(0)  # Allow other tools
-
-    # Extract file_path from tool_input
-    file_path = tool_input.get("file_path", "")
-
-    # If no file_path, allow (shouldn't happen for Read/Edit/Write, but be safe)
-    if not file_path:
-        print("{}")
-        sys.exit(0)
-
-    # Check if file is sensitive
-    if is_sensitive_file(file_path):
-        block_access(file_path, tool_name)
-
-    # Allow non-sensitive files
-    print("{}")
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

mapify_cli-3.3.0/src/mapify_cli/templates/hooks/improve-prompt.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-"""
-Claude Code Prompt Improver Hook
-Intercepts user prompts and evaluates if they need enrichment before execution.
-Uses main session context for intelligent, non-pedantic evaluation.
-"""
-import json
-import sys
-
-# Load input from stdin
-try:
-    input_data = json.load(sys.stdin)
-except json.JSONDecodeError as e:
-    print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
-    sys.exit(1)
-
-prompt = input_data.get("prompt", "")
-
-# Escape quotes in prompt for safe embedding in wrapped instructions
-escaped_prompt = prompt.replace("\\", "\\\\").replace('"', '\\"')
-
-
-def output_json(text):
-    """Output text in UserPromptSubmit JSON format"""
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "UserPromptSubmit",
-            "additionalContext": text,
-        }
-    }
-    print(json.dumps(output))
-
-
-# Check for bypass conditions
-# 1. Explicit bypass with * prefix
-# 2. Slash commands (built-in or custom)
-# 3. Memorize feature (# prefix)
-if prompt.startswith("*") or prompt.startswith("/") or prompt.startswith("#"):
-    # User bypassed improvement - don't add evaluation wrapper
-    # Output empty JSON to signal success without modification
-    print("{}")
-    sys.exit(0)
-
-# Build the improvement wrapper
-wrapped_prompt = f"""PROMPT EVALUATION
-
-Original user request: "{escaped_prompt}"
-
-EVALUATE: Is this prompt clear enough to execute, or does it need enrichment?
-
-PROCEED IMMEDIATELY if:
-- Detailed/specific OR you have sufficient context OR can infer intent
-
-ONLY ASK if genuinely vague (e.g., "fix the bug" with no context):
-- CRITICAL (NON-NEGOTIABLE) RULES:
-  - Trust user intent by default. Check conversation history before doing research.
-  - Do not rely on base knowledge.
-  - Never skip Phase 1. Research before asking.
-  - Don't announce evaluation - just proceed or ask.
-
-- PHASE 1 - RESEARCH (DO NOT SKIP):
-  1. Preface with brief note: "Prompt Improver Hook is seeking clarification because [specific reason: ambiguous scope/missing context/unclear requirements/etc]"
-  2. Create research plan with TodoWrite: Ask yourself "What do I need to research to clarify this vague request?" Research WHAT NEEDS CLARIFICATION, not just the project. Use available tools: Task/Explore for codebase, WebSearch for online research (current info, common approaches, best practices, typical architectures), Read/Grep as needed
-  3. Execute research
-  4. Use research findings (not your training) to formulate grounded questions with specific options
-  5. Mark completed
-
-- PHASE 2 - ASK (ONLY AFTER PHASE 1):
-  1. Use AskUserQuestion tool with max 1-6 questions offering specific options from your research
-  2. Use the answers to execute the original user request
-"""
-
-output_json(wrapped_prompt)
-sys.exit(0)

mapify_cli-3.3.0/src/mapify_cli/templates/hooks/post-edit-reminder.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-"""
-Post-Edit Reminder - PostToolUse Hook
-
-Lightweight reminder after Edit/Write operations to run tests.
-Only triggers when there's an active MAP workflow.
-
-Trigger: Edit|Write
-Exit codes: Always 0 (non-blocking)
-Output: ~80 char reminder via hookSpecificOutput.additionalContext
-"""
-
-import json
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-
-def sanitize_branch_name(branch: str) -> str:
-    """Sanitize branch name for safe filesystem paths."""
-    sanitized = branch.replace("/", "-")
-    sanitized = re.sub(r"[^a-zA-Z0-9_.-]", "-", sanitized)
-    sanitized = re.sub(r"-+", "-", sanitized).strip("-")
-    if ".." in sanitized or sanitized.startswith("."):
-        return "default"
-    return sanitized or "default"
-
-
-def get_branch_name() -> str:
-    """Get current git branch name."""
-    try:
-        result = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-            capture_output=True,
-            text=True,
-            timeout=1,
-        )
-        if result.returncode == 0:
-            return sanitize_branch_name(result.stdout.strip())
-    except Exception:
-        pass
-    return "default"
-
-
-def has_active_workflow(branch: str) -> bool:
-    """Check if there's an active MAP workflow."""
-    project_dir = Path(os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd()))
-    state_file = project_dir / ".map" / branch / "workflow_state.json"
-    return state_file.exists()
-
-
-def main() -> None:
-    try:
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        print("{}")
-        sys.exit(0)
-
-    tool_name = input_data.get("tool_name", "")
-
-    # Only for Edit/Write
-    if tool_name not in ("Edit", "Write", "MultiEdit"):
-        print("{}")
-        sys.exit(0)
-
-    # Only when MAP workflow is active
-    branch = get_branch_name()
-    if not has_active_workflow(branch):
-        print("{}")
-        sys.exit(0)
-
-    # Inject lightweight reminder
-    reminder = "[MAP] Code changed. Run tests before committing!"
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "PostToolUse",
-            "additionalContext": reminder,
-        }
-    }
-    print(json.dumps(output))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()