@punks/cli 0.1.16 → 1.0.1

package/dist/data/hooks/format-edited-file.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+SUPPORTED_SUFFIXES = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json")
+IGNORED_PARTS = {".git", "node_modules", ".next", "dist"}
+
+
+def read_input() -> dict[str, object]:
+    try:
+        return json.load(sys.stdin)
+    except json.JSONDecodeError:
+        return {}
+
+
+def run_git(args: list[str], cwd: str) -> str:
+    result = subprocess.run(
+        ["git", "-C", cwd, *args],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout
+
+
+def repo_root(cwd: str) -> str:
+    try:
+        return run_git(["rev-parse", "--show-toplevel"], cwd).strip()
+    except subprocess.CalledProcessError:
+        return ""
+
+
+def dirty_files(root: str) -> list[str]:
+    try:
+        output = run_git(["ls-files", "-m", "-o", "--exclude-standard"], root)
+    except subprocess.CalledProcessError:
+        return []
+
+    files: list[str] = []
+    for raw_path in output.splitlines():
+        path = raw_path.strip()
+        if not path:
+            continue
+        if not path.endswith(SUPPORTED_SUFFIXES):
+            continue
+        if any(part in IGNORED_PARTS for part in Path(path).parts):
+            continue
+        files.append(path)
+
+    return sorted(set(files))
+
+
+def file_hash(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(65536), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def snapshot_path(root: str, session_id: str, tool_use_id: str) -> Path:
+    repo_name = Path(root).name or "repo"
+    safe_session_id = session_id.replace("/", "_")
+    safe_tool_use_id = tool_use_id.replace("/", "_")
+    state_dir = Path(os.environ.get("TMPDIR", "/tmp")) / "codex-hooks" / repo_name / safe_session_id
+    state_dir.mkdir(parents=True, exist_ok=True)
+    return state_dir / f"{safe_tool_use_id}.json"
+
+
+def load_snapshot(path: Path) -> dict[str, str]:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def fingerprints(root: str) -> dict[str, str]:
+    snapshot: dict[str, str] = {}
+    for relative_path in dirty_files(root):
+        absolute_path = Path(root) / relative_path
+        if absolute_path.exists():
+            snapshot[relative_path] = file_hash(absolute_path)
+    return snapshot
+
+
+def format_files(root: str, files: list[str]) -> list[str]:
+    failed: list[str] = []
+    for relative_path in files:
+        absolute_path = Path(root) / relative_path
+        result = subprocess.run(
+            ["npx", "oxfmt", "--write", str(absolute_path)],
+            cwd=root,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        if result.returncode != 0:
+            failed.append(relative_path)
+    return failed
+
+
+def emit_failure(files: list[str]) -> None:
+    message = "Auto-format failed for " + ", ".join(files) + ". Review the file and format it manually if needed."
+    print(json.dumps({"systemMessage": message}))
+
+
+def main() -> int:
+    mode = sys.argv[1] if len(sys.argv) > 1 else ""
+    payload = read_input()
+
+    cwd = str(payload.get("cwd") or os.getcwd())
+    session_id = str(payload.get("session_id") or "")
+    tool_use_id = str(payload.get("tool_use_id") or "")
+    root = repo_root(cwd)
+
+    if not root or not session_id or not tool_use_id:
+        return 0
+
+    state_file = snapshot_path(root, session_id, tool_use_id)
+
+    if mode == "pre":
+        state_file.write_text(json.dumps(fingerprints(root), sort_keys=True), encoding="utf-8")
+        return 0
+
+    if mode != "post":
+        return 0
+
+    previous = load_snapshot(state_file)
+    current = fingerprints(root)
+
+    try:
+        state_file.unlink()
+    except OSError:
+        pass
+
+    touched = [path for path, digest in current.items() if previous.get(path) != digest]
+    if not touched:
+        return 0
+
+    failed = format_files(root, touched)
+    if failed:
+        emit_failure(failed)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/data/hooks/format-edited-file.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+set -euo pipefail
+
+INPUT="$(cat)"
+FILE_PATH="$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_response.filePath // empty')"
+
+if [[ -z "$FILE_PATH" ]]; then
+  exit 0
+fi
+
+if [[ "${CLAUDE_PROJECT_DIR:-}" != "" && "$FILE_PATH" != "$CLAUDE_PROJECT_DIR"/* ]]; then
+  exit 0
+fi
+
+case "$FILE_PATH" in
+  *"/.git/"*|*"/node_modules/"*|*"/.next/"*|*"/dist/"*)
+    exit 0
+    ;;
+esac
+
+case "$FILE_PATH" in
+  *.ts|*.tsx|*.js|*.jsx|*.mjs|*.cjs|*.json)
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+
+if ! npx oxfmt --write "$FILE_PATH" >/dev/null 2>&1; then
+  jq -n --arg file_path "$FILE_PATH" '{
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      additionalContext: ("Auto-format failed for " + $file_path + ". Review the file and format it manually if needed.")
+    }
+  }'
+fi

package/dist/data/hooks/require-tests-for-pr.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const denyMessage = "Tests are failing. Fix all test failures before creating a PR.";
+const prCommandPattern = /\bgh\s+pr\s+create\b/i;
+const prToolPattern = /(^|[._-])create[_-]?pull[_-]?request([._-]|$)/i;
+
+function readStdinJson() {
+  try {
+    return JSON.parse(readFileSync(0, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function runGit(args, cwd) {
+  const result = spawnSync("git", ["-C", cwd, ...args], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+
+  return result.status === 0 ? result.stdout : null;
+}
+
+function repoRoot(cwd) {
+  return runGit(["rev-parse", "--show-toplevel"], cwd)?.trim() ?? "";
+}
+
+function collectStrings(value, values = []) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed) {
+      values.push(trimmed);
+    }
+    return values;
+  }
+
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectStrings(entry, values);
+    }
+    return values;
+  }
+
+  if (!value || typeof value !== "object") {
+    return values;
+  }
+
+  for (const entry of Object.values(value)) {
+    collectStrings(entry, values);
+  }
+
+  return values;
+}
+
+function matchesPrAction(...values) {
+  const strings = [...new Set(values.flatMap((value) => collectStrings(value)))];
+
+  return strings.some((value) => prCommandPattern.test(value) || prToolPattern.test(value));
+}
+
+function runTests(root) {
+  const result = spawnSync("pnpm", ["--silent", "test"], {
+    cwd: root,
+    stdio: "ignore",
+  });
+
+  return result.status === 0;
+}
+
+function emitCodexOrClaudeBlock(message) {
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: message,
+      },
+      systemMessage: message,
+    }),
+  );
+}
+
+function emitCursorBlock(message) {
+  process.stdout.write(
+    JSON.stringify({
+      continue: false,
+      permission: "deny",
+      agent_message: message,
+      user_message: message,
+    }),
+  );
+}
+
+function runCommandHook(style) {
+  const payload = readStdinJson();
+  const root = repoRoot(String(payload.cwd ?? process.cwd()));
+
+  if (!root || !matchesPrAction(payload) || runTests(root)) {
+    return;
+  }
+
+  if (style === "cursor") {
+    emitCursorBlock(denyMessage);
+    return;
+  }
+
+  emitCodexOrClaudeBlock(denyMessage);
+}
+
+export const RequireTestsForPrPlugin = async ({ worktree }) => {
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (!matchesPrAction(input?.tool, output?.args?.command)) {
+        return;
+      }
+
+      if (runTests(worktree)) {
+        return;
+      }
+
+      throw new Error(denyMessage);
+    },
+  };
+};
+
+function main() {
+  const mode = process.argv[2] ?? "";
+
+  if (mode === "claude" || mode === "codex" || mode === "cursor") {
+    runCommandHook(mode);
+  }
+}
+
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : "";
+const modulePath = fileURLToPath(import.meta.url);
+
+if (invokedPath && path.basename(invokedPath) === path.basename(modulePath)) {
+  main();
+}