wicked-garden 12.27.0

package/hooks/scripts/invoke.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+invoke.py — Cross-platform Python script dispatcher for wicked-garden hooks.
+
+On macOS/Linux, `python3` is the standard command. On Windows, Python often
+installs as `python` or `py` instead. This dispatcher is itself a Python
+script invoked via `python3 || python || py` in hooks.json, and then it
+reliably launches the target hook script using the same interpreter that
+successfully ran this file (sys.executable).
+
+Usage (from hooks.json):
+    "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/invoke.py\" bootstrap || python \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/invoke.py\" bootstrap || py \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/invoke.py\" bootstrap"
+
+The target script name is the first argument (without .py extension).
+stdin is forwarded to the target script (hooks receive JSON on stdin).
+"""
+
+import os
+import subprocess
+import sys
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print(
+            '{"ok": false, "reason": "invoke.py: missing script name argument"}',
+            file=sys.stderr,
+        )
+        # Fail open — hooks should not block the user
+        print('{"ok": true}')
+        return
+
+    script_name = sys.argv[1]
+    scripts_dir = os.path.dirname(os.path.abspath(__file__))
+    target = os.path.join(scripts_dir, f"{script_name}.py")
+
+    if not os.path.isfile(target):
+        print(
+            f'{{"ok": false, "reason": "invoke.py: script not found: {script_name}.py"}}',
+            file=sys.stderr,
+        )
+        print('{"ok": true}')
+        return
+
+    # Use the same Python interpreter that is running this script.
+    # This guarantees we use the correct python on any platform.
+    python = sys.executable
+
+    # Read stdin once and pass it to the subprocess (hooks receive JSON on stdin).
+    stdin_data = sys.stdin.buffer.read()
+
+    result = subprocess.run(
+        [python, target] + sys.argv[2:],
+        input=stdin_data,
+        capture_output=False,
+        timeout=120,
+    )
+    sys.exit(result.returncode)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/scripts/notification.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""
+Notification hook — wicked-garden context limit adaptation.
+
+Issue #343: Detect context limit warnings and adjust smaht behavior.
+
+When Claude Code emits notifications about approaching context limits,
+this hook adjusts session state to:
+  - Force smaht to use the HOT path (skip expensive adapters)
+  - Reduce context assembly scope
+  - Encourage delegation over inline execution
+  - Log the context pressure event for observability
+
+Also handles other notification types for general observability.
+
+Always fails open — returns {"continue": true} on any error.
+Runs async so it does not block the user.
+"""
+
+import json
+import os
+import re
+import sys
+import time
+from pathlib import Path
+
+# Add shared scripts directory to path
+_PLUGIN_ROOT = Path(os.environ.get("CLAUDE_PLUGIN_ROOT", Path(__file__).resolve().parents[2]))
+sys.path.insert(0, str(_PLUGIN_ROOT / "scripts"))
+
+
+# ---------------------------------------------------------------------------
+# Ops logger wrapper — fail-silent, never crashes the hook
+# ---------------------------------------------------------------------------
+
+def _log(domain, level, event, ok=True, ms=None, detail=None):
+    """Ops logger — fail-silent, never crashes the hook."""
+    try:
+        from _logger import log
+        log(domain, level, event, ok=ok, ms=ms, detail=detail)
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Context limit detection patterns
+# ---------------------------------------------------------------------------
+
+_CONTEXT_LIMIT_PATTERNS = [
+    re.compile(r"context\s+(?:limit|window|length)", re.IGNORECASE),
+    re.compile(r"(?:approaching|near(?:ing)?|reaching|exceed)\s+(?:the\s+)?(?:context|token)\s+(?:limit|maximum)", re.IGNORECASE),
+    re.compile(r"token\s+(?:limit|budget|count)", re.IGNORECASE),
+    re.compile(r"(?:running\s+)?(?:low|out)\s+(?:of\s+)?(?:context|tokens)", re.IGNORECASE),
+    re.compile(r"compact(?:ion|ing)", re.IGNORECASE),
+    re.compile(r"conversation\s+(?:too\s+)?long", re.IGNORECASE),
+    re.compile(r"context_limit", re.IGNORECASE),
+    re.compile(r"max_tokens", re.IGNORECASE),
+]
+
+
+def _is_context_limit_notification(payload: dict) -> bool:
+    """Check if a notification is about context limits."""
+    message = payload.get("message", "") or payload.get("text", "") or ""
+    notification_type = payload.get("type", "") or ""
+
+    # Direct type match
+    if notification_type in ("context_limit", "compaction", "token_limit"):
+        return True
+
+    # Pattern match on message content
+    for pattern in _CONTEXT_LIMIT_PATTERNS:
+        if pattern.search(message):
+            return True
+
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Handler: context limit adaptation
+# ---------------------------------------------------------------------------
+
+def _handle_context_limit(payload: dict) -> str:
+    """Adapt smaht behavior when context limits are approaching.
+
+    Sets session state flags that smaht's orchestrator checks:
+    - context_pressure: True — forces HOT path (skip expensive adapters)
+    - context_pressure_since: ISO timestamp
+    - force_delegation: True — encourages delegation over inline work
+
+    Returns a systemMessage with guidance for Claude.
+    """
+    _log("notification", "warn", "context.limit_approaching",
+         detail={"payload_type": payload.get("type", ""), "message": (payload.get("message", "") or "")[:100]})
+
+    # Update session state
+    try:
+        from _session import SessionState
+        from datetime import datetime, timezone
+
+        state = SessionState.load()
+        state.update(
+            context_pressure=True,
+            context_pressure_since=datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+            force_delegation=True,
+        )
+    except Exception:
+        pass
+
+    return json.dumps({
+        "systemMessage": (
+            "[Context Pressure] Context limit is approaching. Adapting behavior:\n"
+            "1. Smaht context assembly is now in HOT-path-only mode (minimal context injection)\n"
+            "2. Prefer delegation to subagents via Task() over inline execution\n"
+            "3. Keep responses concise — avoid large code dumps\n"
+            "4. If in a crew project, consider completing the current phase before starting new work\n"
+            "5. Use wicked-brain:memory to save critical context before compaction"
+        ),
+        "continue": True,
+    })
+
+
+# ---------------------------------------------------------------------------
+# Handler: general notification logging
+# ---------------------------------------------------------------------------
+
+def _handle_general_notification(payload: dict) -> str:
+    """Log general notifications for observability."""
+    notification_type = payload.get("type", "unknown")
+    message = (payload.get("message", "") or payload.get("text", "") or "")[:200]
+
+    _log("notification", "debug", f"notification.{notification_type}",
+         detail={"message": message})
+
+    return json.dumps({"continue": True})
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    _t0 = time.monotonic()
+
+    try:
+        raw = sys.stdin.read()
+        payload = json.loads(raw) if raw.strip() else {}
+    except Exception:
+        payload = {}
+
+    try:
+        if _is_context_limit_notification(payload):
+            result = _handle_context_limit(payload)
+        else:
+            result = _handle_general_notification(payload)
+
+        _log("notification", "debug", "hook.end",
+             ms=int((time.monotonic() - _t0) * 1000))
+        print(result)
+
+    except Exception as e:
+        print(f"[wicked-garden] notification error: {e}", file=sys.stderr)
+        print(json.dumps({"continue": True}))
+
+
+if __name__ == "__main__":
+    main()

package/hooks/scripts/permission_request.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+PermissionRequest hook — wicked-garden intelligent auto-approval for known-safe operations.
+
+Issue #336: Auto-approve known-safe operations to reduce permission prompt fatigue
+during crew workflows and normal development.
+
+Auto-approved operations (when in an active crew project or onboarded session):
+  - Read: reading any file in the project directory
+  - Grep/Glob: searching for files and patterns
+  - Bash: running test commands (pytest, npm test, vitest, jest, cargo test, go test)
+  - Bash: running lint/format commands (eslint, prettier, ruff, black, mypy)
+  - Bash: running build commands (npm run build, cargo build, go build, make)
+  - Bash: git status, git log, git diff (read-only git operations)
+
+Never auto-approved (always require user confirmation):
+  - Write/Edit to files outside the project
+  - Bash commands that modify git state (push, reset, checkout, rebase)
+  - Bash commands that install packages (npm install, pip install)
+  - Any destructive operations (rm, delete, drop)
+
+Always fails open — any unhandled exception returns {"decision": "ask"} (default behavior).
+"""
+
+import json
+import os
+import re
+import sys
+import time
+from pathlib import Path
+
+# Add shared scripts directory to path
+_PLUGIN_ROOT = Path(os.environ.get("CLAUDE_PLUGIN_ROOT", Path(__file__).resolve().parents[2]))
+sys.path.insert(0, str(_PLUGIN_ROOT / "scripts"))
+
+
+# ---------------------------------------------------------------------------
+# Ops logger wrapper — fail-silent, never crashes the hook
+# ---------------------------------------------------------------------------
+
+def _log(domain, level, event, ok=True, ms=None, detail=None):
+    """Ops logger — fail-silent, never crashes the hook."""
+    try:
+        from _logger import log
+        log(domain, level, event, ok=ok, ms=ms, detail=detail)
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Safe operation patterns
+# ---------------------------------------------------------------------------
+
+# Read-only git commands that are always safe
+_SAFE_GIT_PATTERNS = [
+    r"^git\s+status\b",
+    r"^git\s+log\b",
+    r"^git\s+diff\b",
+    r"^git\s+show\b",
+    r"^git\s+branch\b(?!.*-[dD])",  # branch without -d/-D
+    r"^git\s+remote\s+-v\b",
+    r"^git\s+tag\b(?!.*-d)",  # tag without -d
+    r"^git\s+stash\s+list\b",
+]
+
+# Test runner commands
+_SAFE_TEST_PATTERNS = [
+    r"^(?:npx\s+)?(?:jest|vitest|mocha|playwright)\b",
+    r"^(?:npm|yarn|pnpm)\s+(?:run\s+)?test\b",
+    r"^pytest\b",
+    r"^python3?\s+-m\s+pytest\b",
+    r"^cargo\s+test\b",
+    r"^go\s+test\b",
+    r"^dotnet\s+test\b",
+    r"^ruby\s+-Itest\b",
+    r"^rspec\b",
+    r"^make\s+test\b",
+]
+
+# Lint/format commands
+_SAFE_LINT_PATTERNS = [
+    r"^(?:npx\s+)?(?:eslint|prettier|biome)\b",
+    r"^(?:npm|yarn|pnpm)\s+run\s+(?:lint|format|check)\b",
+    r"^(?:ruff|black|isort|mypy|flake8|pylint)\b",
+    r"^(?:python3?\s+-m\s+)?(?:ruff|black|isort|mypy|flake8|pylint)\b",
+    r"^cargo\s+(?:clippy|fmt)\b",
+    r"^go\s+vet\b",
+    r"^golangci-lint\b",
+    r"^rubocop\b",
+    r"^make\s+(?:lint|check|format)\b",
+]
+
+# Build commands
+_SAFE_BUILD_PATTERNS = [
+    r"^(?:npm|yarn|pnpm)\s+run\s+build\b",
+    r"^cargo\s+build\b",
+    r"^go\s+build\b",
+    r"^make(?:\s+(?!clean|install|deploy))?$",
+    r"^dotnet\s+build\b",
+    r"^tsc\b",
+]
+
+# Dangerous patterns that should NEVER be auto-approved
+_DANGEROUS_PATTERNS = [
+    r"\brm\s+-rf?\b",
+    r"\bgit\s+(?:push|reset|checkout|rebase|merge|cherry-pick)\b",
+    r"\bgit\s+branch\s+-[dD]\b",
+    r"\b(?:npm|yarn|pnpm|pip|pip3)\s+install\b",
+    r"\bcurl\b.*\|\s*(?:sh|bash)\b",
+    r"\bsudo\b",
+    r"\bdrop\s+(?:table|database)\b",
+    r"\bdelete\s+from\b",
+    r"\bchmod\b",
+    r"\bchown\b",
+    r"\bmkfs\b",
+    r"\bformat\b",
+]
+
+# Compile all patterns
+_SAFE_GIT_RE = [re.compile(p, re.IGNORECASE) for p in _SAFE_GIT_PATTERNS]
+_SAFE_TEST_RE = [re.compile(p, re.IGNORECASE) for p in _SAFE_TEST_PATTERNS]
+_SAFE_LINT_RE = [re.compile(p, re.IGNORECASE) for p in _SAFE_LINT_PATTERNS]
+_SAFE_BUILD_RE = [re.compile(p, re.IGNORECASE) for p in _SAFE_BUILD_PATTERNS]
+_DANGEROUS_RE = [re.compile(p, re.IGNORECASE) for p in _DANGEROUS_PATTERNS]
+
+
+def _is_safe_bash_command(command: str) -> bool:
+    """Check if a bash command is known-safe for auto-approval."""
+    cmd = command.strip()
+
+    # First check: dangerous commands are never safe
+    for pattern in _DANGEROUS_RE:
+        if pattern.search(cmd):
+            return False
+
+    # Check safe patterns
+    all_safe = _SAFE_GIT_RE + _SAFE_TEST_RE + _SAFE_LINT_RE + _SAFE_BUILD_RE
+    for pattern in all_safe:
+        if pattern.search(cmd):
+            return True
+
+    return False
+
+
+def _is_project_file(file_path: str) -> bool:
+    """Check if a file path is within the current project directory."""
+    try:
+        cwd = str(Path.cwd().resolve())
+        resolved = str(Path(file_path).resolve())
+        return resolved.startswith(cwd)
+    except Exception:
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Main handler
+# ---------------------------------------------------------------------------
+
+def _evaluate_permission(payload: dict) -> str:
+    """Evaluate a permission request and return 'allow', 'deny', or 'ask'.
+
+    Returns 'ask' (defer to user) for anything uncertain.
+    Returns 'allow' only for known-safe operations.
+    Never returns 'deny' — that is too aggressive for auto-approval.
+    """
+    tool_name = payload.get("tool_name", "")
+    tool_input = payload.get("tool_input", {}) or {}
+
+    # Read, Grep, Glob within the project are always safe
+    if tool_name in ("Read", "Grep", "Glob"):
+        # Check that target is within project
+        target = tool_input.get("file_path", "") or tool_input.get("path", "")
+        if not target or _is_project_file(target):
+            return "allow"
+
+    # Bash commands: check against safe patterns
+    if tool_name == "Bash":
+        command = tool_input.get("command", "")
+        if command and _is_safe_bash_command(command):
+            return "allow"
+
+    # All other tools: defer to user
+    return "ask"
+
+
+def main():
+    _t0 = time.monotonic()
+
+    try:
+        raw = sys.stdin.read()
+        payload = json.loads(raw) if raw.strip() else {}
+    except Exception:
+        payload = {}
+
+    try:
+        tool_name = payload.get("tool_name", "")
+        decision = _evaluate_permission(payload)
+
+        _log("permission", "debug", "permission.evaluate",
+             detail={"tool": tool_name, "decision": decision})
+
+        if decision == "allow":
+            print(json.dumps({
+                "hookSpecificOutput": {
+                    "hookEventName": "PermissionRequest",
+                    "autoApprove": True,
+                }
+            }))
+        else:
+            # Return empty/default to defer to normal permission flow
+            print(json.dumps({}))
+
+    except Exception as e:
+        print(f"[wicked-garden] permission_request error: {e}", file=sys.stderr)
+        # Always fail open — defer to user on any error
+        print(json.dumps({}))
+
+    _log("permission", "debug", "hook.end",
+         ms=int((time.monotonic() - _t0) * 1000))
+
+
+if __name__ == "__main__":
+    main()