@jjchill/probity-rules 0.4.11 → 0.4.12

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.4.12
+
+`probity-claude` now runs Probity in the worktree a session is working
+in, so rules judge that tree's specs and files (#66).
+
+- **What went wrong.** The documented hook is
+  `cd "$CLAUDE_PROJECT_DIR" && ./node_modules/.bin/probity-claude`.
+  After a session moves into a worktree (`EnterWorktree`, or an
+  `isolation: "worktree"` sub-agent), `CLAUDE_PROJECT_DIR` still names
+  the main checkout. Probity finds `probity.config.ts` by searching
+  upward from its working directory, so it loaded the main checkout's
+  config, and `ROOT`, `specsDir` and `glossaryPath` all pointed there.
+  In #66 the spec-first rule blocked an acceptance test whose
+  `Covers:` scenario existed only in the worktree's `specs/`
+  submodule, and named the main checkout's `specs/features`.
+- **Now:** the wrapper finds the git worktree the action targets: the
+  edited file's location, or for a command its `git -C <dir>` or
+  leading `cd <dir> &&`, else the session's `cwd`. When that worktree
+  is nested inside the project and has its own `probity.config.*`, the
+  wrapper starts Probity there. Its config's imports resolve from the
+  project's `node_modules` (one level up the folder tree), so the
+  worktree needs no install. Work in the main checkout, worktrees
+  without a Probity config, and paths outside the project run as before.
+- A relative `--debug <path>` is anchored to the project directory, so
+  the debug log stays in one place.
+- Only hooks that run `probity-claude` get this. A worktree outside the
+  project folder still runs against the project.
+- Consumers: no config change. The worktree's own `probity.config.ts`
+  (from its branch) is the one that runs.
+
 ## 0.4.11
 
 The commit-on-green gate now catches every form of `git commit`, and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jjchill/probity-rules",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "description": "Versioned Probity rule presets and CLI tooling for the agent-skills catalog (test-driven-development, ports-and-adapters, acceptance-testing, spec-test parity, ubiquitous-language) — see hooks/PROBITY.md.",
   "license": "MIT",
   "repository": {

package/scripts/probity-claude.mjs

@@ -24,6 +24,17 @@
  * deletes the copy when Probity exits. The gates only need recent
  * events: the last test run, the red before a green.
  *
+ * And it runs Probity in the right tree (issue #66). The hook `cd`s to
+ * $CLAUDE_PROJECT_DIR, which still names the main checkout after a
+ * session moves into a worktree (EnterWorktree, or an `isolation:
+ * "worktree"` sub-agent). Probity finds its config by searching upward
+ * from its working directory, so every rule judged the main checkout's
+ * specs and files. When the edited file (or, for a command, the
+ * session's cwd) is inside a git worktree nested in the project that
+ * has its own probity.config.*, the wrapper starts Probity there. That
+ * config's imports still resolve from the project's node_modules, one
+ * directory level up the tree.
+ *
  * Use it in place of the probity bin in `.claude/settings.json`:
  *
  *   "command": "cd \"$CLAUDE_PROJECT_DIR\" && ./node_modules/.bin/probity-claude"
@@ -47,7 +58,7 @@ import {
 } from 'node:fs'
 import { createRequire } from 'node:module'
 import { tmpdir } from 'node:os'
-import { basename, dirname, join } from 'node:path'
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 /** The sub-agent transcript for a payload, or null to keep the original. */
@@ -134,6 +145,75 @@ export function preparePayload(raw, limits = {}) {
   }
 }
 
+const CONFIG_NAMES = ['ts', 'mts', 'js', 'mjs'].map((ext) => `probity.config.${ext}`)
+
+function canonical(path) {
+  // Resolve symlinks on the longest existing prefix (a file being
+  // created does not exist yet), so paths compare like the project dir.
+  let head = resolve(path)
+  const tail = []
+  while (!existsSync(head) && dirname(head) !== head) {
+    tail.unshift(basename(head))
+    head = dirname(head)
+  }
+  try {
+    head = realpathSync(head)
+  } catch {
+    // keep the resolved path
+  }
+  return join(head, ...tail)
+}
+
+function isBelow(parent, child) {
+  const path = relative(parent, child)
+  return path !== '' && path !== '..' && !path.startsWith(`..${sep}`) && !isAbsolute(path)
+}
+
+// The directory a command explicitly acts in: `git -C <dir>`, else a
+// leading `cd <dir> &&`; null when it names none. Mirrors the commit
+// gates' commitDirectory (rules/commit-target.ts), so a worktree session
+// that commits in the main checkout is judged there.
+function commandDirectory(command) {
+  const unquote = (value) => value.replace(/^(['"])(.*)\1$/, '$2')
+  const gitDashC = command.match(/\bgit\s+-C\s+("[^"]+"|'[^']+'|\S+)/)
+  const cd = command.match(/^\s*cd\s+("[^"]+"|'[^']+'|[^\s;&|]+)\s*(?:&&|;)/)
+  const target = gitDashC?.[1] ?? cd?.[1]
+  return target ? unquote(target) : null
+}
+
+/**
+ * The git worktree to run Probity in for this payload, or null to stay
+ * in `projectDir`: the nearest directory holding `.git` above the edited
+ * file (for a command, the session's cwd), when it lies below
+ * `projectDir` and has its own Probity config. A command's directory is
+ * its `git -C <dir>` or leading `cd <dir> &&`, else the session's cwd.
+ */
+export function probityDirectory(payload, projectDir) {
+  const input = payload?.tool_input ?? {}
+  const cwd = typeof payload?.cwd === 'string' ? payload.cwd : null
+  const file = [input.file_path, input.notebook_path].find((value) => typeof value === 'string')
+  const base = cwd ?? projectDir
+  let start
+  if (file) start = dirname(isAbsolute(file) ? file : resolve(base, file))
+  else if (typeof input.command === 'string') start = resolve(base, commandDirectory(input.command) ?? '.')
+  else if (cwd) start = cwd
+  else return null
+  const project = canonical(projectDir)
+  for (let dir = canonical(start); isBelow(project, dir); dir = dirname(dir)) {
+    if (existsSync(join(dir, '.git'))) {
+      return CONFIG_NAMES.some((name) => existsSync(join(dir, name))) ? dir : null
+    }
+  }
+  return null
+}
+
+/** `args` with a relative `--debug <path>` anchored to `projectDir`, so the log stays put when Probity runs elsewhere. */
+export function debugArgs(args, projectDir) {
+  return args.map((arg, i) =>
+    args[i - 1] === '--debug' && !isAbsolute(arg) ? join(projectDir, arg) : arg,
+  )
+}
+
 function probityBin() {
   // @nizos/probity doesn't export its package.json, so resolve the main
   // entry and walk up to the package root for the bin path.
@@ -156,9 +236,18 @@ function probityBin() {
 async function main() {
   const chunks = []
   for await (const chunk of process.stdin) chunks.push(chunk)
-  const { input, cleanup } = preparePayload(Buffer.concat(chunks).toString('utf8'))
+  const raw = Buffer.concat(chunks).toString('utf8')
+  const { input, cleanup } = preparePayload(raw)
+  let payload
+  try {
+    payload = JSON.parse(raw)
+  } catch {
+    payload = null
+  }
+  const projectDir = process.cwd()
+  const workDir = probityDirectory(payload, projectDir) ?? projectDir
 
-  const args = process.argv.slice(2)
+  const args = debugArgs(process.argv.slice(2), projectDir)
   if (!args.includes('--agent')) args.unshift('--agent', 'claude-code')
 
   let bin
@@ -169,7 +258,10 @@ async function main() {
     cleanup()
     process.exit(2)
   }
-  const child = spawn(process.execPath, [bin, ...args], { stdio: ['pipe', 'inherit', 'inherit'] })
+  const child = spawn(process.execPath, [bin, ...args], {
+    cwd: workDir,
+    stdio: ['pipe', 'inherit', 'inherit'],
+  })
   child.stdin.end(input)
   child.on('exit', (code, signal) => {
     cleanup()