claude-dev-env 8.4.1 → 8.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.4.1",
+    "version": "8.4.3",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/scripts/windows/pstack/pstack-command-shim.ps1

@@ -32,8 +32,15 @@ $scriptsRoot = Split-Path -Parent (Split-Path -Parent $entrypoint)
 $exitCode = 1
 Push-Location $scriptsRoot
 try {
-  & bun $entrypoint @commandArguments
-  $exitCode = $LASTEXITCODE
+  & bun -e 'import { ensureDependenciesInstalled } from "./bootstrap.ts"; ensureDependenciesInstalled();'
+  $bootstrapExitCode = $LASTEXITCODE
+  if ($bootstrapExitCode -ne 0) {
+    Write-Error "The pstack dependencies could not be installed"
+    $exitCode = $bootstrapExitCode
+  } else {
+    & bun $entrypoint @commandArguments
+    $exitCode = $LASTEXITCODE
+  }
 }
 finally {
   Pop-Location

package/hooks/blocking/stop_dispatcher.py

@@ -1,81 +0,0 @@
-#!/usr/bin/env python3
-"""Stop-hook dispatcher that hosts the Stop-chain blockers in one process.
-
-Reads the Stop payload from stdin once, runs each hosted hook in registration
-order via the shared hosted-hook runner, and emits the first block decision the
-chain produced. Later hooks still run after an earlier block so every hosted
-hook gets a chance to run. A single hosted hook crash fails open and does not
-suppress the remaining hooks.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-
-import _path_setup  # noqa: F401
-
-from hooks_constants.hosted_hook_runner import (
-    run_hook_capturing_output,
-    HostedHookRun,
-    resolved_hook_script_path,
-)
-from hooks_constants.stop_dispatcher_constants import (
-    ALL_STOP_HOSTED_HOOK_PATHS,
-    BLOCK_DECISION,
-    DECISION_KEY,
-)
-
-
-def _is_block_decision(stdout_text: str) -> bool:
-    """Return True when stdout carries a Stop decision of block."""
-    stripped_text = stdout_text.strip()
-    if not stripped_text:
-        return False
-    try:
-        parsed_output = json.loads(stripped_text)
-    except json.JSONDecodeError:
-        return False
-    if not isinstance(parsed_output, dict):
-        return False
-    return parsed_output.get(DECISION_KEY) == BLOCK_DECISION
-
-
-def select_first_block_stdout(all_runs: list[HostedHookRun]) -> str:
-    """Return the first non-crashed block stdout, or empty when none blocked."""
-    for each_run in all_runs:
-        if each_run.did_crash:
-            continue
-        if _is_block_decision(each_run.captured_stdout):
-            return each_run.captured_stdout.strip()
-    return ""
-
-
-def dispatch(payload_text: str) -> None:
-    """Run every Stop hosted hook and emit the first block decision if any."""
-    all_runs: list[HostedHookRun] = []
-    for each_relative_path in ALL_STOP_HOSTED_HOOK_PATHS:
-        script_path = resolved_hook_script_path(each_relative_path)
-        hook_run = run_hook_capturing_output(script_path, payload_text)
-        all_runs.append(hook_run)
-    block_stdout = select_first_block_stdout(all_runs)
-    if block_stdout:
-        sys.stdout.write(block_stdout + "\n")
-        sys.stdout.flush()
-
-
-def main() -> None:
-    """Read stdin once and dispatch the Stop hosted-hook chain."""
-    payload_text = sys.stdin.read()
-    if not payload_text.strip():
-        sys.exit(0)
-    try:
-        json.loads(payload_text)
-    except json.JSONDecodeError:
-        sys.exit(0)
-    dispatch(payload_text)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/test_stop_dispatcher.py

@@ -1,165 +0,0 @@
-"""Behavior tests for the Stop-hook dispatcher."""
-
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-_HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
-_BLOCKING_DIR = Path(__file__).resolve().parent
-if _HOOKS_DIR not in sys.path:
-    sys.path.insert(0, _HOOKS_DIR)
-_blocking_dir_text = str(_BLOCKING_DIR)
-if _blocking_dir_text not in sys.path:
-    sys.path.insert(0, _blocking_dir_text)
-
-from hooks_constants.hosted_hook_runner import HostedHookRun  # noqa: E402
-from stop_dispatcher import dispatch, select_first_block_stdout  # noqa: E402
-
-_DISPATCHER_SCRIPT = str(_BLOCKING_DIR / "stop_dispatcher.py")
-
-
-def _block_json(
-    reason: str, *, system_message: str = "", suppress_output: bool = False
-) -> str:
-    """Build a Stop block stdout string with optional supplementary fields."""
-    payload: dict[str, object] = {"decision": "block", "reason": reason}
-    if system_message:
-        payload["systemMessage"] = system_message
-    if suppress_output:
-        payload["suppressOutput"] = True
-    return json.dumps(payload)
-
-
-def test_first_block_wins_among_non_crashed_runs() -> None:
-    """The first non-crashed block decision is the one the dispatcher emits."""
-    all_runs = [
-        HostedHookRun(captured_stdout="", did_crash=False),
-        HostedHookRun(captured_stdout=_block_json("first"), did_crash=False),
-        HostedHookRun(captured_stdout=_block_json("second"), did_crash=False),
-    ]
-    selected = select_first_block_stdout(all_runs)
-    assert json.loads(selected)["reason"] == "first"
-
-
-def test_crashed_hook_before_block_is_skipped() -> None:
-    """A crash before a block fails open so a later block still surfaces."""
-    all_runs = [
-        HostedHookRun(captured_stdout="", did_crash=True),
-        HostedHookRun(captured_stdout=_block_json("later"), did_crash=False),
-    ]
-    selected = select_first_block_stdout(all_runs)
-    assert json.loads(selected)["reason"] == "later"
-
-
-def test_no_block_when_every_hook_is_silent() -> None:
-    """A silent chain produces no block stdout."""
-    assert select_first_block_stdout([HostedHookRun("", False), HostedHookRun("", False)]) == ""
-
-
-def test_select_preserves_system_message_and_suppress_output() -> None:
-    """select_first_block_stdout keeps supplementary fields on the winning block."""
-    all_runs = [
-        HostedHookRun(captured_stdout="", did_crash=True),
-        HostedHookRun(
-            captured_stdout=_block_json(
-                "keep fields",
-                system_message="rewrite the ending",
-                suppress_output=True,
-            ),
-            did_crash=False,
-        ),
-    ]
-    selected = json.loads(select_first_block_stdout(all_runs))
-    assert selected["reason"] == "keep fields"
-    assert selected["systemMessage"] == "rewrite the ending"
-    assert selected["suppressOutput"] is True
-
-
-def test_dispatch_re_emits_first_block_with_system_message_and_suppress(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """dispatch re-emits the first block's full JSON including supplementary fields."""
-    all_responses = [
-        HostedHookRun(captured_stdout="", did_crash=False),
-        HostedHookRun(
-            captured_stdout=_block_json(
-                "keep fields",
-                system_message="rewrite the ending",
-                suppress_output=True,
-            ),
-            did_crash=False,
-        ),
-        HostedHookRun(captured_stdout=_block_json("later block"), did_crash=False),
-    ]
-    response_iterator = iter(all_responses)
-
-    def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:
-        del script_path, payload_text
-        return next(response_iterator)
-
-    monkeypatch.setattr("stop_dispatcher.run_hook_capturing_output", _fake_run_hook)
-    monkeypatch.setattr(
-        "stop_dispatcher.ALL_STOP_HOSTED_HOOK_PATHS",
-        (
-            "blocking/first_stub_hook.py",
-            "blocking/question_to_user_enforcer.py",
-            "blocking/second_stub_hook.py",
-        ),
-    )
-    dispatch('{"session_id": "test"}')
-    emitted_payload = json.loads(capsys.readouterr().out.strip())
-    assert emitted_payload["decision"] == "block"
-    assert emitted_payload["reason"] == "keep fields"
-    assert emitted_payload["systemMessage"] == "rewrite the ending"
-    assert emitted_payload["suppressOutput"] is True
-
-
-def test_dispatch_writes_nothing_when_no_hook_blocks(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """dispatch leaves stdout empty when every hosted hook is silent or allows."""
-    monkeypatch.setattr(
-        "stop_dispatcher.run_hook_capturing_output",
-        lambda script_path, payload_text: HostedHookRun(captured_stdout="", did_crash=False),
-    )
-    monkeypatch.setattr(
-        "stop_dispatcher.ALL_STOP_HOSTED_HOOK_PATHS",
-        ("blocking/first_stub_hook.py",),
-    )
-    dispatch('{"session_id": "test"}')
-    assert capsys.readouterr().out == ""
-
-
-def test_dispatcher_exits_zero_on_empty_payload() -> None:
-    """The dispatcher exits zero when stdin is empty."""
-    completed = subprocess.run(
-        [sys.executable, _DISPATCHER_SCRIPT],
-        check=False,
-        input="",
-        capture_output=True,
-        text=True,
-    )
-    assert completed.returncode == 0
-    assert completed.stdout.strip() == ""
-
-
-def test_dispatcher_imports_standalone_with_only_blocking_on_the_path() -> None:
-    """The dispatcher's bootstrap resolves hooks_constants without hooks/ on PYTHONPATH."""
-    subprocess_environment = {**os.environ, "PYTHONPATH": str(_BLOCKING_DIR)}
-    completed = subprocess.run(
-        [sys.executable, "-c", "import stop_dispatcher; print('ok')"],
-        check=False,
-        capture_output=True,
-        text=True,
-        env=subprocess_environment,
-    )
-    assert completed.returncode == 0, completed.stderr
-    assert completed.stdout.strip() == "ok"

package/hooks/hooks_constants/stop_dispatcher_constants.py

@@ -1,20 +0,0 @@
-"""Constants for the Stop-hook dispatcher.
-
-Holds the ordered hosted-hook roster for the Stop chain. The dispatcher imports
-this roster to run every Stop hook in registration order inside one process.
-"""
-
-from __future__ import annotations
-
-__all__ = [
-    "ALL_STOP_HOSTED_HOOK_PATHS",
-    "BLOCK_DECISION",
-    "DECISION_KEY",
-    "REASON_KEY",
-]
-
-BLOCK_DECISION = "block"
-DECISION_KEY = "decision"
-REASON_KEY = "reason"
-
-ALL_STOP_HOSTED_HOOK_PATHS: tuple[str, ...] = ()

package/hooks/hooks_constants/test_stop_dispatcher_constants.py

@@ -1,7 +0,0 @@
-"""Tests for the Stop-hook dispatcher hosted-hook roster."""
-
-from hooks_constants.stop_dispatcher_constants import ALL_STOP_HOSTED_HOOK_PATHS
-
-
-def test_roster_has_no_blocking_hooks() -> None:
-    assert ALL_STOP_HOSTED_HOOK_PATHS == ()

package/scripts/audit-hooks-cli.mjs

@@ -1,59 +0,0 @@
-import { writeFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { auditHooks } from "./audit-hooks.mjs";
-
-function parseArguments(argv) {
-  const options = {
-    catalogPath: null,
-    format: "text",
-    homeDirectory: null,
-    includeInstalled: false,
-    outputPath: null,
-    requireNonblocking: false,
-    repositoryRoot: path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../.."),
-  };
-  for (let offset = 0; offset < argv.length; offset += 1) {
-    const argument = argv[offset];
-    if (argument === "--installed") options.includeInstalled = true;
-    else if (argument === "--catalog") options.catalogPath = argv[++offset];
-    else if (argument === "--format") options.format = argv[++offset];
-    else if (argument === "--home") options.homeDirectory = argv[++offset];
-    else if (argument === "--output") options.outputPath = argv[++offset];
-    else if (argument === "--require-nonblocking") options.requireNonblocking = true;
-    else if (argument === "--repository-root") options.repositoryRoot = argv[++offset];
-    else throw new Error(`unknown argument ${argument}`);
-  }
-  return options;
-}
-
-function renderText(report) {
-  const summary = report.summary;
-  return [
-    `canonical direct: ${summary.directCount}`,
-    `dispatchers: ${summary.dispatcherCount}`,
-    `hosted entries: ${summary.effectiveCount}`,
-    `logical associations: ${summary.logicalAssociationCount}`,
-    `unclassified targets: ${summary.unclassifiedCount}`,
-    `installed Claude direct: ${summary.claudeDirectCount}`,
-    `installed Codex direct: ${summary.codexDirectCount}`,
-    `active native Git hooks: ${summary.gitHookCount}`,
-    `known native Git hooks: ${summary.knownGitHookCount}`,
-    `registration eligibility: ${report.registrationEligibility.status}`,
-    "runtime proof: separate verification required",
-    `findings: ${summary.findingCount}`,
-  ].join("\n");
-}
-
-function main() {
-  const options = parseArguments(process.argv.slice(2));
-  const report = auditHooks(options);
-  const rendered =
-    options.format === "json" ? `${JSON.stringify(report, null, 2)}\n` : `${renderText(report)}\n`;
-  if (options.outputPath) writeFileSync(options.outputPath, rendered, "utf8");
-  else process.stdout.write(rendered);
-  process.exitCode = report.findings.some(({ severity }) => severity === "error") ? 1 : 0;
-}
-
-main();