ima-claude 2.9.0

package/plugins/ima-claude/hooks/atlassian_prereqs.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: Enforce Atlassian MCP prerequisites before tool calls.
+
+Three checks combined:
+  H3 — cloudId bootstrap: getAccessibleAtlassianResources must be called first
+  H4 — transitions: getTransitionsForJiraIssue must precede transitionJiraIssue
+  M5 — ADF body: Confluence page body must be a JSON string, not a raw object
+
+State is tracked in a JSON file that expires after 1 hour (new session boundary).
+Exit code 0 = allow tool to proceed (soft warnings only).
+"""
+import json
+import os
+import sys
+import time
+
+STATE_FILE = os.path.expanduser("~/.claude/.atlassian_session_state")
+STALENESS_SECONDS = 3600  # 1 hour — new session after this gap
+
+BOOTSTRAP_TOOL = "mcp__claude_ai_Atlassian__getAccessibleAtlassianResources"
+TRANSITIONS_TOOL = "mcp__claude_ai_Atlassian__getTransitionsForJiraIssue"
+TRANSITION_ISSUE_TOOL = "mcp__claude_ai_Atlassian__transitionJiraIssue"
+CONFLUENCE_WRITE_TOOLS = {
+    "mcp__claude_ai_Atlassian__createConfluencePage",
+    "mcp__claude_ai_Atlassian__updateConfluencePage",
+}
+
+BOOTSTRAP_WARNING = """Atlassian bootstrap: Call getAccessibleAtlassianResources first to obtain cloudId.
+  mcp__claude_ai_Atlassian__getAccessibleAtlassianResources
+"""
+
+TRANSITIONS_WARNING = """Transition IDs are issue-specific — call getTransitionsForJiraIssue first.
+  mcp__claude_ai_Atlassian__getTransitionsForJiraIssue issueIdOrKey: "{key}"
+"""
+
+ADF_WARNING = """ADF body must be a JSON string (JSON.stringify'd), not a raw object — #1 cause of Confluence failures.
+"""
+
+
+def load_state():
+    """Load session state, returning defaults if missing or stale."""
+    default = {"bootstrapped": False, "transitions_fetched": False, "timestamp": 0.0}
+    if not os.path.exists(STATE_FILE):
+        return default
+    try:
+        with open(STATE_FILE, "r") as f:
+            state = json.load(f)
+        if (time.time() - state.get("timestamp", 0)) > STALENESS_SECONDS:
+            return default
+        return state
+    except (json.JSONDecodeError, OSError):
+        return default
+
+
+def save_state(state):
+    """Write session state to disk."""
+    state_dir = os.path.dirname(STATE_FILE)
+    os.makedirs(state_dir, exist_ok=True)
+    state["timestamp"] = time.time()
+    with open(STATE_FILE, "w") as f:
+        json.dump(state, f)
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+tool_input = input_data.get("tool_input", {})
+
+# Only act on Atlassian MCP tools
+if not tool_name.startswith("mcp__claude_ai_Atlassian__"):
+    sys.exit(0)
+
+state = load_state()
+
+# H3: If this IS the bootstrap tool, mark and exit silently
+if tool_name == BOOTSTRAP_TOOL:
+    state["bootstrapped"] = True
+    save_state(state)
+    sys.exit(0)
+
+# H4: If this IS the transitions fetch tool, mark and exit silently
+if tool_name == TRANSITIONS_TOOL:
+    state["transitions_fetched"] = True
+    save_state(state)
+    sys.exit(0)
+
+warnings = []
+
+# H3: Any other Atlassian tool requires bootstrap first
+if not state["bootstrapped"]:
+    warnings.append(BOOTSTRAP_WARNING)
+
+# H4: transitionJiraIssue requires getTransitionsForJiraIssue first
+if tool_name == TRANSITION_ISSUE_TOOL and not state["transitions_fetched"]:
+    issue_key = tool_input.get("issueIdOrKey", "<issueIdOrKey>")
+    warnings.append(TRANSITIONS_WARNING.format(key=issue_key))
+
+# M5: ADF body must be a JSON string, not a raw Python dict
+if tool_name in CONFLUENCE_WRITE_TOOLS:
+    content_format = tool_input.get("contentFormat", "")
+    body = tool_input.get("body")
+    if content_format == "adf" and isinstance(body, dict):
+        warnings.append(ADF_WARNING)
+
+for warning in warnings:
+    print(warning, file=sys.stderr)
+
+sys.exit(0)

package/plugins/ima-claude/hooks/block_sed_edits.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: BLOCK sed file editing via Bash.
+
+Hard guard (exit 1 = block execution). sed edits are a symptom of a broken
+workflow — Claude either didn't read the file first, didn't use Serena's
+symbolic editing, or is working with a file that's too large.
+
+Allowed through:
+- Piped sed transforms (no -i, no file redirect)
+- Data pipelines (echo ... | sed ...)
+"""
+import json
+import re
+import sys
+
+BLOCK_MESSAGE = """🚫 BLOCKED: sed file editing is never the right approach.
+
+You're using sed because something went wrong. Stop and fix the root cause:
+
+1. READ the file first — Edit/Write require a prior Read (did you skip this?)
+2. Use Serena symbolic editing — replace_symbol_body, insert_after_symbol, insert_before_symbol
+3. Use Edit tool for targeted string replacements
+4. If the file is too large to read (>500 lines), that's a separate problem — the file needs refactoring
+
+DO NOT retry with sed. Go back to step 1."""
+
+
+def is_sed_file_edit(command: str) -> bool:
+    """Detect sed commands that mutate files (not piped transforms)."""
+    # sed -i (in-place edit) in any flag position
+    if re.search(r"\bsed\b.*\s-[^\s]*i", command):
+        return True
+
+    # sed ... > file or sed ... >> file (redirect output to file)
+    if re.search(r"\bsed\b.+>{1,2}\s*\S+", command):
+        # But not if sed input is piped (e.g., echo x | sed ... > file is borderline,
+        # but still a file mutation via sed — block it)
+        return True
+
+    return False
+
+
+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", {})
+command = tool_input.get("command", "")
+
+if tool_name != "Bash" or not command:
+    sys.exit(0)
+
+if is_sed_file_edit(command):
+    print(BLOCK_MESSAGE, file=sys.stderr)
+    sys.exit(1)

package/plugins/ima-claude/hooks/bootstrap.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# SessionStart hook: Inject ima-claude foundational context into every session.
+# Injects ima-claude foundational context (persona, agents, MCP routing).
+# stdout goes into Claude's context.
+
+cat << 'BOOTSTRAP'
+## ima-claude: Active Plugin
+
+### Default Persona: The Practitioner
+
+A 25-year software development veteran. FP-first, composition-minded, anti-over-engineering.
+Uses "we" not "I" — collaborative, humble, light-hearted. "Slow is smooth, smooth is fast."
+
+### Memory Bootstrap
+
+At session start, check memory before asking questions:
+- Vestige: `mcp__vestige__search` for user preferences and project context
+- Vestige: `mcp__vestige__intention action: "check"` for pending reminders
+- Serena: `mcp__serena__list_memories` if in a Serena-activated project
+
+### Memory Routing
+
+| Store what | Where | Why |
+|---|---|---|
+| Decisions, preferences, patterns, bugs | Vestige `smart_ingest` | Fades naturally if not referenced |
+| Reference material (docs, standards, PRDs) | Qdrant `qdrant-store` | Permanent library |
+| Session state, task progress | Serena `write_memory` | Project-scoped workbench |
+| Future reminders | Vestige `intention` | Surfaces at next session |
+
+Auto-store: "I prefer..." → Vestige preference. "Let's go with X because..." → Vestige decision. "The reason this failed..." → Vestige bug.
+
+After completing work: store outcome in Vestige, reference material in Qdrant, session state in Serena.
+
+### Orchestrator Protocol
+
+You are the Orchestrator. Plan and delegate. Do NOT implement directly.
+- Non-trivial work → `/ima-claude:task-planner` (decompose) → `/ima-claude:task-runner` (delegate)
+- Trivial = single file, < 5 lines, no judgment calls
+- Model selection: opus for orchestration, sonnet for implementation (default), haiku for lookups
+
+### Available Agents
+
+Delegate to named agents — they enforce model, tools, and permissions automatically.
+
+| Agent | Model | Mode | Use For |
+|---|---|---|---|
+| `ima-claude:explorer` | haiku | read-only | File discovery, codebase exploration |
+| `ima-claude:implementer` | sonnet | full | Feature dev, bug fixes, refactoring |
+| `ima-claude:reviewer` | sonnet | read-only | Code review, security audit, FP checks |
+| `ima-claude:wp-developer` | sonnet | full | WordPress plugins, themes, WP-CLI, forms |
+| `ima-claude:memory` | sonnet | full | Memory search, storage, consolidation |
+
+### Code Navigation (Serena — REQUIRED when installed)
+
+**Always prefer Serena over Read/Grep for code investigation.** 40-70% token savings.
+
+| Instead of | Use |
+|---|---|
+| Read file to understand structure | `mcp__serena__jet_brains_get_symbols_overview relative_path: "..."` |
+| Grep for class/function definition | `mcp__serena__jet_brains_find_symbol name_path_pattern: "Name"` |
+| Grep for callers/references | `mcp__serena__jet_brains_find_referencing_symbols name_path: "method"` |
+
+Use Read only when you need the actual implementation body of a known, specific symbol.
+
+### Complex Reasoning (Sequential Thinking — REQUIRED for analysis)
+
+Use `mcp__sequential-thinking__sequentialthinking` before acting on:
+- Debugging / root cause analysis / "why is this failing"
+- Trade-off evaluation / "which approach"
+- Architectural decisions / design choices
+- Multi-step investigations where approach may change
+
+### Other MCP Tools
+
+| Signal | Tool |
+|---|---|
+| "latest", "2025/2026", "what's new" | Tavily |
+| Library/framework API question | Context7 |
+
+Before web tools: check Claude's knowledge → Context7 → then Tavily/WebFetch.
+
+### Search Preference
+
+Always prefer `rg` (ripgrep) over grep/find. Faster, respects .gitignore, recursive by default.
+
+### Session Management
+
+- `/ima-claude:save-session` — save to Serena memory
+- `/ima-claude:resume-session` — load from Serena memory + Vestige context
+BOOTSTRAP

package/plugins/ima-claude/hooks/bootstrap_utility_check.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook: Warn about hardcoded CSS when Bootstrap utilities are available.
+
+Checks (soft warning only, exit 0):
+  M3 — Inline styles in HTML/PHP that have Bootstrap 5 utility equivalents
+  M3 — CSS properties in .scss/.css only when Bootstrap context is detected
+
+Applies to: Edit, Write on .html, .php, .scss, .css files.
+"""
+import json
+import re
+import sys
+
+HTML_PHP_EXTENSIONS = (".html", ".php")
+CSS_EXTENSIONS = (".scss", ".css")
+ALL_EXTENSIONS = HTML_PHP_EXTENSIONS + CSS_EXTENSIONS
+
+# Bootstrap context signals in CSS/SCSS files
+BOOTSTRAP_CONTEXT = re.compile(
+    r"@import\s+['\"].*bootstrap|"
+    r"\$spacer\b|"
+    r"\bbs-"
+)
+
+# Inline style patterns with their Bootstrap equivalents
+INLINE_STYLE_PATTERNS = [
+    (re.compile(r'style=["\'][^"\']*margin', re.IGNORECASE), "margin-*", "m-* / mt-* / mb-* / ms-* / me-*"),
+    (re.compile(r'style=["\'][^"\']*padding', re.IGNORECASE), "padding-*", "p-* / pt-* / pb-* / ps-* / pe-*"),
+    (re.compile(r'style=["\'][^"\']*display\s*:\s*flex', re.IGNORECASE), "display: flex", "d-flex"),
+    (re.compile(r'style=["\'][^"\']*display\s*:\s*none', re.IGNORECASE), "display: none", "d-none"),
+    (re.compile(r'style=["\'][^"\']*text-align\s*:\s*center', re.IGNORECASE), "text-align: center", "text-center"),
+    (re.compile(r'style=["\'][^"\']*font-weight\s*:\s*bold', re.IGNORECASE), "font-weight: bold", "fw-bold"),
+]
+
+WARNING_HEADER = "⚠️  Hardcoded CSS detected — Bootstrap 5 utilities available:"
+WARNING_EXAMPLES = (
+    '  style="margin-top: 16px"   →  class="mt-3"\n'
+    '  style="display: flex"      →  class="d-flex"\n'
+    '  style="text-align: center" →  class="text-center"\n'
+    "  See /ima-bootstrap skill for utility-first patterns."
+)
+
+
+def is_bootstrap_context(content: str) -> bool:
+    return bool(BOOTSTRAP_CONTEXT.search(content))
+
+
+def find_inline_style_issues(content: str) -> list[str]:
+    return [
+        f"  {css_prop}  →  {utility}"
+        for pattern, css_prop, utility in INLINE_STYLE_PATTERNS
+        if pattern.search(content)
+    ]
+
+
+def get_content(tool_name: str, tool_input: dict) -> str:
+    if tool_name == "Write":
+        return tool_input.get("content", "")
+    # Edit: scan only new_string — what's being written now
+    return tool_input.get("new_string", "")
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+tool_input = input_data.get("tool_input", {})
+file_path = tool_input.get("file_path", "")
+
+if tool_name not in ("Edit", "Write"):
+    sys.exit(0)
+
+if not file_path.endswith(ALL_EXTENSIONS):
+    sys.exit(0)
+
+content = get_content(tool_name, tool_input)
+if not content:
+    sys.exit(0)
+
+is_css_file = file_path.endswith(CSS_EXTENSIONS)
+
+# CSS/SCSS files only warn when Bootstrap is confirmed in context
+if is_css_file and not is_bootstrap_context(content):
+    sys.exit(0)
+
+issues = find_inline_style_issues(content)
+if issues:
+    print(WARNING_HEADER, file=sys.stderr)
+    print(WARNING_EXAMPLES, file=sys.stderr)
+
+sys.exit(0)

package/plugins/ima-claude/hooks/composer_autoload_check.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook: Warn about Composer autoload "files" entries that break PHPUnit.
+
+M9 — Composer autoload files bug detection (from phpunit-wp skill).
+
+After writing or editing a composer.json, checks whether autoload.files is populated.
+Autoload files run BEFORE the test bootstrap defines ABSPATH/WPINC, causing WordPress
+plugin files to fatal error during `composer install` in test environments.
+Exit code 0 = soft warning via stderr.
+"""
+import json
+import sys
+
+WARNING = (
+    '⚠️  Composer autoload "files" detected — this can break PHPUnit tests.\n'
+    "  Autoload files run BEFORE test bootstrap defines ABSPATH/WPINC.\n"
+    "  WordPress plugin files will fatal error during `composer install`.\n"
+    "  Fix: Move plugin files to autoload.classmap or load via bootstrap.\n"
+    "  See /phpunit-wp skill for the full fix pattern."
+)
+
+
+def get_content(tool_name: str, tool_input: dict) -> str:
+    if tool_name == "Write":
+        return tool_input.get("content", "")
+
+    # Edit: file already written to disk — read it for the current state
+    file_path = tool_input.get("file_path", "")
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            return f.read()
+    except OSError:
+        return ""
+
+
+def has_autoload_files(content: str) -> bool:
+    try:
+        data = json.loads(content)
+    except (json.JSONDecodeError, ValueError):
+        return False
+
+    files = data.get("autoload", {}).get("files", [])
+    return isinstance(files, list) and len(files) > 0
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+tool_input = input_data.get("tool_input", {})
+file_path = tool_input.get("file_path", "")
+
+if tool_name not in ("Edit", "Write"):
+    sys.exit(0)
+
+if not file_path.endswith("composer.json"):
+    sys.exit(0)
+
+content = get_content(tool_name, tool_input)
+
+if not content:
+    sys.exit(0)
+
+if has_autoload_files(content):
+    print(WARNING, file=sys.stderr)
+
+sys.exit(0)

package/plugins/ima-claude/hooks/docs_organization.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook: Warn when a Markdown file is written to the project root.
+
+M10 — Markdown files scattered in project root.
+
+After a Write to a .md file, checks whether the file lands at the root level of the
+project rather than in a designated docs subdirectory. Exempt files (README.md, etc.)
+and files in docs/, .claude/, skills/, or hooks/ subdirectories are silently allowed.
+Exit code 0 = soft warning via stderr.
+"""
+import json
+import os
+import subprocess
+import sys
+
+EXEMPT_FILENAMES = {
+    "README.md",
+    "CLAUDE.md",
+    "CHANGELOG.md",
+    "LICENSE.md",
+    "CONTRIBUTING.md",
+    "CODE_OF_CONDUCT.md",
+}
+
+EXEMPT_DIRS = {"docs", ".claude", "skills", "hooks"}
+
+WARNING = (
+    "⚠️  Markdown file written to project root — consider docs-organize structure:\n"
+    "  docs/active/    — permanent documentation\n"
+    "  docs/archive/   — historical records\n"
+    "  docs/transient/ — ephemeral notes (git-ignored)"
+)
+
+
+def get_git_root(path: str) -> str:
+    """Return the git repository root, or the file's directory as fallback.
+
+    Walks up from the file's directory to find the first existing ancestor,
+    so this works even when Claude is writing a file into a not-yet-created dir.
+    """
+    search_dir = os.path.dirname(os.path.abspath(path))
+    while search_dir and not os.path.isdir(search_dir):
+        parent = os.path.dirname(search_dir)
+        if parent == search_dir:
+            break
+        search_dir = parent
+
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            cwd=search_dir,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except OSError:
+        pass
+    return search_dir
+
+
+def is_exempt(file_path: str, git_root: str) -> bool:
+    filename = os.path.basename(file_path)
+    if filename in EXEMPT_FILENAMES:
+        return True
+
+    rel = os.path.relpath(file_path, git_root)
+    parts = rel.split(os.sep)
+
+    # File is inside an exempt subdirectory
+    if len(parts) > 1 and parts[0] in EXEMPT_DIRS:
+        return True
+
+    return False
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+tool_input = input_data.get("tool_input", {})
+file_path = tool_input.get("file_path", "")
+
+if tool_name != "Write":
+    sys.exit(0)
+
+if not file_path.endswith(".md"):
+    sys.exit(0)
+
+git_root = get_git_root(file_path)
+rel = os.path.relpath(file_path, git_root)
+
+# Only warn when the file is at the root level (no subdirectory component)
+if os.path.dirname(rel) != "":
+    sys.exit(0)
+
+if is_exempt(file_path, git_root):
+    sys.exit(0)
+
+print(WARNING, file=sys.stderr)
+sys.exit(0)

package/plugins/ima-claude/hooks/enforce_rg_over_grep.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: Warn about using grep/find instead of ripgrep.
+
+Warns (allows command to proceed):
+- grep → suggests rg
+- find -name → suggests rg --files -g pattern
+
+The warning is shown to Claude, encouraging it to use rg for subsequent operations.
+"""
+import json
+import re
+import sys
+
+VALIDATION_RULES = [
+    (
+        r"\bgrep\b(?!.*\|)",
+        "⚠️  PREFER ripgrep: Use 'rg' instead of 'grep' - faster, better defaults, respects .gitignore. "
+        "Please use 'rg' for the rest of this session. See /rg skill for usage.",
+    ),
+    (
+        r"\bfind\s+\S+\s+-name\b",
+        "⚠️  PREFER ripgrep: Use 'rg --files -g \"pattern\"' instead of 'find -name' - faster, respects .gitignore. "
+        "Please use 'rg' for the rest of this session. See /rg skill for usage.",
+    ),
+]
+
+
+def validate_command(command: str) -> list[str]:
+    issues = []
+    for pattern, message in VALIDATION_RULES:
+        if re.search(pattern, command):
+            issues.append(message)
+    return issues
+
+
+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", {})
+command = tool_input.get("command", "")
+
+if tool_name != "Bash" or not command:
+    sys.exit(0)
+
+issues = validate_command(command)
+
+if issues:
+    for message in issues:
+        print(f"{message}", file=sys.stderr)
+    # Exit code 0 allows command to proceed but stderr is shown to Claude as a warning
+    sys.exit(0)

package/plugins/ima-claude/hooks/fp_utility_check.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook: Warn about custom FP utility definitions.
+
+Checks (soft warning only, exit 0):
+  M1 — Custom pipe/compose using reduce/reduceRight
+  M1 — Custom curry with rest/spread params
+  M1 — Custom monads (Maybe, Either, Result, Option classes)
+  M1 — Custom pattern matching function named 'match'
+
+Applies to: Edit, Write on .js, .ts, .mjs, .mts, .php files.
+"""
+import json
+import re
+import sys
+
+JS_PHP_EXTENSIONS = (".js", ".ts", ".mjs", ".mts", ".php")
+
+# Import lines — these are safe, skip them
+IMPORT_LINE = re.compile(r"^\s*(import|require|use)\b", re.MULTILINE)
+
+FP_UTILITY_PATTERNS = [
+    # pipe/compose backed by reduce
+    re.compile(r"(function|const|let|var)\s+pipe\s*[=(].*reduce", re.DOTALL),
+    re.compile(r"(function|const|let|var)\s+compose\s*[=(].*reduce", re.DOTALL),
+    # PHP pipe/compose
+    re.compile(r"function\s+pipe\s*\("),
+    re.compile(r"function\s+compose\s*\("),
+    # curry definitions
+    re.compile(r"(function|const|let|var)\s+curry\s*[=(]"),
+    # monad classes
+    re.compile(r"class\s+(Maybe|Either|Result|Option)\b"),
+    # custom match pattern matching
+    re.compile(r"(function|const|let|var)\s+match\s*[=(][^;]*patterns", re.DOTALL),
+]
+
+WARNING = (
+    "⚠️  Custom FP utility detected — js-fp/php-fp skills say: use native patterns instead.\n"
+    "  No pipe/compose — use chained methods or intermediate variables\n"
+    "  No curry — use closures and partial application naturally\n"
+    "  No custom monads — use early returns, null coalescing, optional chaining"
+)
+
+
+def is_import_line(line: str) -> bool:
+    return bool(IMPORT_LINE.match(line))
+
+
+def strip_import_lines(content: str) -> str:
+    return "\n".join(
+        line for line in content.splitlines()
+        if not is_import_line(line)
+    )
+
+
+def has_fp_utility(content: str) -> bool:
+    cleaned = strip_import_lines(content)
+    return any(pattern.search(cleaned) for pattern in FP_UTILITY_PATTERNS)
+
+
+def get_content(tool_name: str, tool_input: dict) -> str:
+    if tool_name == "Write":
+        return tool_input.get("content", "")
+    # Edit: scan only new_string — we care about what's being added
+    return tool_input.get("new_string", "")
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+tool_input = input_data.get("tool_input", {})
+file_path = tool_input.get("file_path", "")
+
+if tool_name not in ("Edit", "Write"):
+    sys.exit(0)
+
+if not file_path.endswith(JS_PHP_EXTENSIONS):
+    sys.exit(0)
+
+content = get_content(tool_name, tool_input)
+if not content:
+    sys.exit(0)
+
+if has_fp_utility(content):
+    print(WARNING, file=sys.stderr)
+
+sys.exit(0)