@webjsdev/cli 0.10.0 → 0.10.1

package/lib/create.js

@@ -373,6 +373,7 @@ export async function scaffoldApp(name, cwd, opts = {}) {
     '.claude/hooks/block-prose-punctuation.sh',
     '.claude/hooks/guard-branch-context.sh',
     '.claude/hooks/nudge-uncommitted.sh',
+    '.claude/hooks/require-tests-with-src.sh',
     // Gemini CLI config + hooks
     '.gemini/settings.json',
     '.gemini/hooks/nudge-uncommitted.sh',
@@ -405,7 +406,7 @@ export async function scaffoldApp(name, cwd, opts = {}) {
 
   // Make hook scripts executable
   const { chmod } = await import('node:fs/promises');
-  for (const hook of ['block-prose-punctuation.sh', 'guard-branch-context.sh', 'nudge-uncommitted.sh']) {
+  for (const hook of ['block-prose-punctuation.sh', 'guard-branch-context.sh', 'nudge-uncommitted.sh', 'require-tests-with-src.sh']) {
     const hookPath = join(appDir, '.claude', 'hooks', hook);
     if (existsSync(hookPath)) await chmod(hookPath, 0o755);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/cli",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "type": "module",
   "description": "webjs CLI - dev, start, create, db",
   "bin": {

package/templates/.claude/hooks/require-tests-with-src.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+#
+# PreToolUse hook (scaffolded by `webjs create`): block a `git commit`
+# that adds or changes application code without any accompanying test.
+#
+# webjs is AI-first: most apps are built with an AI agent, and the
+# easiest corner to cut is shipping a feature with no test. This gate
+# makes "every change ships with a test" a hard floor, not a suggestion.
+#
+# What a hook CANNOT do: judge WHICH test layer a change needs (a unit
+# test vs a browser/e2e test is a judgement call). So it enforces the
+# floor (some real test must accompany app code) and reminds you to add
+# browser/e2e coverage for interactive surfaces. `webjs test` runs the
+# actual suite in the commit hook.
+#
+# Scope: fires only on `git commit`. Inspects the STAGED diff.
+#
+# Blocks (exit 2) when the staged diff changes app code (app/, modules/,
+# components/, lib/) but stages no test (test/** or *.test.* / *.spec.*).
+# Allowed: commits with no app-code change, commits that stage a test
+# alongside, and WEBJS_NO_TEST_GATE=1 for a genuine non-code commit.
+#
+# Bypass (humans, emergencies): git commit --no-verify.
+
+set -euo pipefail
+
+if [ "${WEBJS_NO_TEST_GATE:-}" = "1" ]; then
+  exit 0
+fi
+
+payload=$(cat)
+cmd=$(printf '%s' "$payload" | jq -r '.tool_input.command // empty' 2>/dev/null || true)
+if [ -z "$cmd" ]; then exit 0; fi
+# Match `git commit` as a whole word so sibling subcommands
+# (git commit-graph, git commit-tree) and string mentions do not trip it.
+if ! printf '%s' "$cmd" | grep -Eq '(^|[^[:alnum:]-])git commit([^[:alnum:]-]|$)'; then
+  exit 0
+fi
+
+if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then exit 0; fi
+
+staged=$(git diff --cached --name-only 2>/dev/null || true)
+if [ -z "$staged" ]; then exit 0; fi
+
+# App code lives under app/, modules/, components/, lib/. A `.server.*`
+# file is still app code. Match source extensions only (skip .css, .md).
+app_code=$(printf '%s\n' "$staged" \
+  | grep -E '^(app|modules|components|lib)/.*\.([mc]?[jt]sx?)$' || true)
+if [ -z "$app_code" ]; then exit 0; fi
+
+test_staged=$(printf '%s\n' "$staged" \
+  | grep -E '(^|/)test/|\.test\.[mc]?[jt]sx?$|\.spec\.[mc]?[jt]sx?$' || true)
+
+if [ -z "$test_staged" ]; then
+  cat >&2 <<'EOF'
+BLOCKED: this commit changes app code but stages no test.
+
+You staged application code (app/, modules/, components/, lib/) with no
+accompanying test. Every change ships with a test. Add or update the test
+that proves the new behaviour, then `git add` it.
+
+Pick the layer the change needs (a unit test is not always enough):
+  - logic / actions / queries / utils  -> a unit test
+  - a component, hydration, a server action called from the client, the
+    router, anything interactive -> a browser or e2e test that asserts the
+    real behaviour in a browser, not just the function in isolation.
+
+See `webjs test` and the testing guide. Genuine non-code commit (docs,
+config) that needs no test? Re-run with WEBJS_NO_TEST_GATE=1.
+
+Hook: .claude/hooks/require-tests-with-src.sh
+EOF
+  exit 2
+fi
+
+# Reminder for interactive surfaces: a unit test alone rarely covers them.
+interactive=$(printf '%s\n' "$app_code" | grep -E '^components/|/components/' || true)
+if [ -n "$interactive" ]; then
+  jq -n --arg ctx "Reminder: this commit changes component code. A unit test alone usually is not enough for an interactive component; add a browser test (webjs test --browser) that asserts the rendered/hydrated behaviour." '{
+    hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext: $ctx }
+  }'
+fi
+exit 0

package/templates/.claude/settings.json

@@ -18,6 +18,15 @@
             "command": ".claude/hooks/guard-branch-context.sh"
           }
         ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": ".claude/hooks/require-tests-with-src.sh"
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/templates/.hooks/pre-commit

@@ -21,6 +21,31 @@ if [ "$BRANCH" = "main" ] || [ "$BRANCH" = "master" ]; then
   exit 1
 fi
 
+# Require a test to accompany app-code changes. Tool-agnostic floor: a
+# commit that stages app code (app/, modules/, components/, lib/) with no
+# test (test/** or *.test.* / *.spec.*) is blocked. The full suite below
+# proves tests PASS; this proves a test was WRITTEN. Bypass for a genuine
+# non-code commit with WEBJS_NO_TEST_GATE=1, or --no-verify in emergencies.
+if [ "${WEBJS_NO_TEST_GATE:-}" != "1" ]; then
+  STAGED=$(git diff --cached --name-only 2>/dev/null)
+  APP_CODE=$(printf '%s\n' "$STAGED" | grep -E '^(app|modules|components|lib)/.*\.([mc]?[jt]sx?)$' || true)
+  if [ -n "$APP_CODE" ]; then
+    TESTS=$(printf '%s\n' "$STAGED" | grep -E '(^|/)test/|\.test\.[mc]?[jt]sx?$|\.spec\.[mc]?[jt]sx?$' || true)
+    if [ -z "$TESTS" ]; then
+      echo ""
+      echo "ERROR: app code changed but no test is staged."
+      echo "Every change ships with a test. Add or update the test that"
+      echo "proves the new behaviour (a browser/e2e test for interactive"
+      echo "or component code), then git add it."
+      echo ""
+      echo "Genuine non-code commit? WEBJS_NO_TEST_GATE=1 git commit ..."
+      echo "Emergency bypass: git commit --no-verify"
+      echo ""
+      exit 1
+    fi
+  fi
+fi
+
 # webjs test + webjs check on every commit. Tool-agnostic enforcement:
 # fires regardless of which agent (Claude, Cursor, Antigravity, Copilot,
 # human) is making the commit. Skipped if the CLI is not yet installed

package/templates/AGENTS.md

@@ -883,8 +883,15 @@ composition, so a nested shell ends up dropped by the HTML parser.
 ## Workflow expectations for AI agents
 
 1. Branch before editing. Never push to `main` directly.
-2. Every code change comes with: unit test(s), AGENTS.md / docs updates if
-   the feature surface changed, `webjs check` passing.
+2. Every code change comes with a test, AGENTS.md / docs updates if the
+   feature surface changed, `webjs check` passing. A unit test is not
+   always enough: a component, hydration, the client router, or a server
+   action called from the client needs a browser test
+   (`webjs test --browser`) asserting the behaviour in a real browser. A
+   commit that stages app code (`app/`, `modules/`, `components/`, `lib/`)
+   with no test is blocked by `.claude/hooks/require-tests-with-src.sh`
+   and the `.hooks/pre-commit` floor (bypass a genuine non-code commit
+   with `WEBJS_NO_TEST_GATE=1`).
 3. Commit and push **per logical unit**, not at the end. A logical unit is one
    feature, one fix, one rename, one doc rewrite. If you have 5+ unstaged files
    spanning different concerns, commit the current group before continuing.

package/templates/CONVENTIONS.md

@@ -451,6 +451,15 @@ test/
 - `webjs test --browser` (or `npx wtr`) runs the browser tests.
 - `WEBJS_E2E=1 webjs test` adds the e2e tests.
 
+**Every change ships with a test, enforced at commit time.** A commit
+that stages app code (`app/`, `modules/`, `components/`, `lib/`) without
+staging a test is blocked by `.claude/hooks/require-tests-with-src.sh`
+(Claude Code) and the universal `.hooks/pre-commit` (any agent or human).
+A unit test alone is not enough for interactive or component code: add
+the browser test that asserts the rendered/hydrated behaviour. Bypass a
+genuine non-code commit with `WEBJS_NO_TEST_GATE=1`, or `--no-verify` in
+an emergency.
+
 ### Choosing a feature folder
 
 Use the same name as the matching module folder when one exists: