npm - tamperward - Versions diffs - 1.2.1 → 1.4.0 - Mend

tamperward 1.2.1 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/README.md CHANGED Viewed

@@ -102,7 +102,7 @@ with the same engine it ships.
 - `src/engine.ts` — runs the enabled rules over `Change[]`; honours `policy.ignore`.
 - `src/cli/` — `tamperward check --staged | --worktree | --diff <base>...<head>`,
   exit 1 on any blocking finding.
-- `test/` — 235 tests, including the AST-vs-regex, self-hosting precision, and
+- `test/` — 259 tests, including the AST-vs-regex, self-hosting precision, and
   pre-go-live audit regression cases, and the renderer accessibility contract.
 - `src/adapters/claude/` + `src/cli/hook.ts` — the agent layer: `tamperward hook claude`
@@ -119,6 +119,11 @@ enforcement-point wiring, and the proof harness.
 ## Use
 ```bash
+npx tamperward init                          # wire all four enforcement points in one
+                                             # command: policy file, Claude Code hooks,
+                                             # pre-commit, CI. Idempotent; --dry-run to
+                                             # preview; never overwrites your files.
 npx tamperward check --staged                # pre-commit view
 npx tamperward check --diff "main...HEAD"    # CI view — the authority for main
 ```

package/dist/cli/index.js CHANGED Viewed

@@ -371,6 +371,16 @@ function removedLines(c) {
 // src/policy.ts
 import picomatch from "picomatch";
 var POLICY_FILE = ".tamperward.yml";
+var BLOCK_SINCE = {};
+function applyVersionGates(rules, version, gates = BLOCK_SINCE) {
+  const out = { ...rules };
+  for (const [rule, since] of Object.entries(gates)) {
+    if (since > version && out[rule]?.severity === "block") {
+      out[rule] = { ...out[rule], severity: "warn" };
+    }
+  }
+  return out;
+}
 var cache = /* @__PURE__ */ new Map();
 function matcher(glob) {
   let m = cache.get(glob);
@@ -407,9 +417,9 @@ function mergeProtected(base, user) {
   }
   return out;
 }
-function defaultPolicy() {
-  return {
-    version: 1,
+function defaultPolicy(version = 1) {
+  const p = {
+    version,
     protected: {
       // Cover every JS/TS test extension, not just .test.ts — the multi-repo FP study found
       // .test.tsx/.spec.tsx (hono, zustand) slipped the glob, so legit test-file casts blocked
@@ -454,6 +464,8 @@ function defaultPolicy() {
     ignore: [],
     signoff: { requiredFor: ["block"], ledger: ".tamperward/ledger.jsonl" }
   };
+  p.rules = applyVersionGates(p.rules, version);
+  return p;
 }
 // src/detectors/files.ts
@@ -924,8 +936,11 @@ function safeParse(src) {
   }
 }
 function effective(raw) {
-  const base = defaultPolicy();
+  const v = raw.version;
+  const version = typeof v === "number" && Number.isInteger(v) && v >= 1 ? v : 1;
+  const base = defaultPolicy(version);
   return {
+    version,
     rules: { ...base.rules, ...raw.rules ?? {} },
     ignore: raw.ignore ?? base.ignore ?? [],
     protected: mergeProtected(base.protected, raw.protected),
@@ -940,6 +955,11 @@ function policyWeakening(before, after) {
   const be = effective(b);
   const ae = effective(a);
   const reasons = [];
+  if (ae.version < be.version) {
+    reasons.push(
+      `policy version lowered ${be.version} \u2192 ${ae.version} \u2014 un-opts this repo from rule graduations gated above ${ae.version}`
+    );
+  }
   for (const name of /* @__PURE__ */ new Set([...Object.keys(be.rules), ...Object.keys(ae.rules)])) {
     const br = be.rules[name];
     const ar = ae.rules[name];
@@ -1349,11 +1369,19 @@ import { join as join2 } from "node:path";
 import { parse as parse2 } from "yaml";
 var PolicyError = class extends Error {
 };
+function normalizeVersion(v, where = POLICY_FILE) {
+  if (v === void 0 || v === null) return 1;
+  if (typeof v !== "number" || !Number.isInteger(v) || v < 1) {
+    throw new PolicyError(`${where}: version must be a positive integer, got ${JSON.stringify(v)}`);
+  }
+  return v;
+}
 function parsePolicy(raw) {
-  const base = defaultPolicy();
   const r = raw ?? {};
+  const version = normalizeVersion(r.version);
+  const base = defaultPolicy(version);
   return {
-    version: 1,
+    version,
     // Merge with the baseline, never replace. For an integrity tool, a config that sets
     // one rule's severity must NOT silently drop the other nine — nor may naming one
     // protected glob wipe out the rest of its category (see mergeProtected).
@@ -2021,6 +2049,197 @@ Honored at LOCAL pre-commit only. The agent-layer hook ignores this file; CI req
   return 0;
 }
+// src/cli/init.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3, chmodSync } from "node:fs";
+import { dirname as dirname3, join as join6 } from "node:path";
+var HOOK_CMD = "npx --yes tamperward hook claude";
+var SWEEP_CMD = "npx --yes tamperward sweep claude";
+var PRECOMMIT_CMD = "npx --yes tamperward check --staged";
+var MARKER = "# tamperward: block agent shortcuts before they land";
+var POLICY_CONTENT = `# Tamperward policy. The BASELINE (all rules, standard protected globs) applies even
+# without this file \u2014 everything here is an override, so an empty file changes nothing.
+# Docs: https://github.com/hexrift/tamperward#readme
+#
+# version gates rule GRADUATIONS: a baseline rule promoted warn -> block at policy
+# version N blocks only when you declare version >= N. Raising it is opting in.
+version: 1
+# protected:            # categories MERGE with the baseline (additive, never replace)
+#   tests: ['e2e/**']
+# rules:                # an explicit severity wins over the baseline in either direction
+#   snapshot-rewrite: { severity: block }
+# ignore: []            # visible blind spots \u2014 the count is always reported
+`;
+var WORKFLOW_CONTENT = `name: tamperward
+# The CI authority for main: the same engine as the agent hook and pre-commit, run over
+# the PR's commit range. A block fails the check and clears ONLY via the out-of-band
+# label \`tamperward:allow:<rule>\` applied by someone with write access \u2014 never a file
+# the PR itself can commit.
+#
+# labeled/unlabeled re-run the gate because the sign-off is read from the EVENT payload:
+# a label applied after a failure could otherwise never take effect, and REVOKING a
+# sign-off must re-block rather than linger green.
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, labeled, unlabeled]
+permissions:
+  contents: read
+jobs:
+  tamperward:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0 # the range diff needs both endpoints
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+      - name: Resolve out-of-band sign-off from PR labels
+        id: oob
+        env:
+          LABELS: \${{ toJSON(github.event.pull_request.labels.*.name) }}
+        run: |
+          RULES="$(printf '%s' "$LABELS" | jq -r '.[] | select(startswith("tamperward:allow:")) | sub("^tamperward:allow:"; "")' | paste -sd, -)"
+          echo "rules=$RULES" >> "$GITHUB_OUTPUT"
+      - name: Tamperward gate
+        env:
+          TAMPERWARD_OOB_SIGNOFF: \${{ steps.oob.outputs.rules }}
+        run: npx --yes tamperward check --diff "\${{ github.event.pull_request.base.sha }}...\${{ github.event.pull_request.head.sha }}"
+`;
+function planPolicy(cwd) {
+  const path = join6(cwd, POLICY_FILE);
+  if (existsSync5(path)) return { item: "policy", path: POLICY_FILE, status: "ok", detail: "already present \u2014 left untouched" };
+  return {
+    item: "policy",
+    path: POLICY_FILE,
+    status: "create",
+    detail: "baseline policy with commented overrides",
+    apply: () => writeFileSync3(path, POLICY_CONTENT)
+  };
+}
+function planClaudeHooks(cwd) {
+  const rel = ".claude/settings.json";
+  const path = join6(cwd, rel);
+  let settings = {};
+  if (existsSync5(path)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync7(path, "utf8"));
+    } catch {
+      return {
+        item: "agent",
+        path: rel,
+        status: "error",
+        detail: "exists but is not valid JSON \u2014 fix it, then re-run init (refusing to overwrite)"
+      };
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { item: "agent", path: rel, status: "error", detail: "exists but is not a JSON object \u2014 refusing to overwrite" };
+    }
+    settings = parsed;
+  }
+  const hooks = settings.hooks ??= {};
+  const has = (arr, needle) => (arr ?? []).some((m) => (m.hooks ?? []).some((h) => String(h.command ?? "").includes(needle)));
+  const needPre = !has(hooks.PreToolUse, "tamperward hook claude");
+  const needStop = !has(hooks.Stop, "tamperward sweep claude");
+  if (!needPre && !needStop) return { item: "agent", path: rel, status: "ok", detail: "PreToolUse + Stop hooks already wired" };
+  return {
+    item: "agent",
+    path: rel,
+    status: existsSync5(path) ? "update" : "create",
+    detail: `wire ${[needPre && "PreToolUse deny", needStop && "Stop sweep"].filter(Boolean).join(" + ")}`,
+    apply: () => {
+      if (needPre) {
+        (hooks.PreToolUse ??= []).push({
+          matcher: "Bash|Edit|Write|MultiEdit",
+          hooks: [{ type: "command", command: HOOK_CMD }]
+        });
+      }
+      if (needStop) {
+        (hooks.Stop ??= []).push({ hooks: [{ type: "command", command: SWEEP_CMD }] });
+      }
+      mkdirSync3(dirname3(path), { recursive: true });
+      writeFileSync3(path, JSON.stringify(settings, null, 2) + "\n");
+    }
+  };
+}
+function planPreCommit(cwd) {
+  const line = `${MARKER}
+${PRECOMMIT_CMD}
+`;
+  const husky = join6(cwd, ".husky");
+  const gitDir2 = join6(cwd, ".git");
+  const target = existsSync5(husky) ? { rel: ".husky/pre-commit", note: "husky" } : existsSync5(gitDir2) ? { rel: ".git/hooks/pre-commit", note: "plain git hook (local-only: .git/hooks is not committed \u2014 consider husky to share it)" } : null;
+  if (!target) return { item: "pre-commit", path: "(none)", status: "skip", detail: "not a git repo and no .husky/ \u2014 nothing to wire" };
+  const path = join6(cwd, target.rel);
+  const existing = existsSync5(path) ? readFileSync7(path, "utf8") : null;
+  if (existing?.includes("tamperward check --staged")) {
+    return { item: "pre-commit", path: target.rel, status: "ok", detail: "already runs the staged check" };
+  }
+  return {
+    item: "pre-commit",
+    path: target.rel,
+    status: existing === null ? "create" : "update",
+    detail: existing === null ? `create via ${target.note}` : `append the staged check (${target.note})`,
+    apply: () => {
+      mkdirSync3(dirname3(path), { recursive: true });
+      const content = existing === null ? `#!/bin/sh
+${line}` : existing.replace(/\n?$/, "\n") + line;
+      writeFileSync3(path, content);
+      chmodSync(path, 493);
+    }
+  };
+}
+function planWorkflow(cwd) {
+  const rel = ".github/workflows/tamperward.yml";
+  const path = join6(cwd, rel);
+  if (existsSync5(path)) return { item: "ci", path: rel, status: "ok", detail: "workflow already present \u2014 left untouched" };
+  return {
+    item: "ci",
+    path: rel,
+    status: "create",
+    detail: "PR gate with out-of-band label sign-off (re-runs on labeled/unlabeled)",
+    apply: () => {
+      mkdirSync3(dirname3(path), { recursive: true });
+      writeFileSync3(path, WORKFLOW_CONTENT);
+    }
+  };
+}
+function planInit(cwd) {
+  return [planPolicy(cwd), planClaudeHooks(cwd), planPreCommit(cwd), planWorkflow(cwd)];
+}
+function runInit(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const plan = planInit(cwd);
+  const w = process.stdout;
+  for (const a of plan) {
+    const verb = opts.dryRun && (a.status === "create" || a.status === "update") ? `would ${a.status}` : a.status;
+    w.write(`  ${a.item.padEnd(10)} ${verb.padEnd(12)} ${a.path}  \u2014 ${a.detail}
+`);
+    if (!opts.dryRun && a.apply) a.apply();
+  }
+  const errors = plan.filter((a) => a.status === "error");
+  const changed = plan.filter((a) => a.apply).length;
+  if (errors.length) {
+    w.write(`
+tamperward init: ${errors.length} item(s) need your attention above; the rest ${opts.dryRun ? "are planned" : "were applied"}.
+`);
+    return 2;
+  }
+  w.write(
+    changed === 0 ? "\ntamperward init: everything already wired \u2014 nothing to do.\n" : opts.dryRun ? `
+tamperward init: ${changed} change(s) planned. Re-run without --dry-run to apply.
+` : `
+tamperward init: ${changed} change(s) applied. Commit them so the gate travels with the repo.
+`
+  );
+  return 0;
+}
 // src/cli/index.ts
 function parseAllow(args) {
   const o = {};
@@ -2042,6 +2261,15 @@ function runAgentCommand(kind, args) {
   }
   return kind === "hook" ? runHookClaude() : runSweepClaude();
 }
+function parseInit(args) {
+  const o = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--cwd") o.cwd = args[++i];
+    else if (a === "--dry-run") o.dryRun = true;
+  }
+  return o;
+}
 function parseCheck(args) {
   const o = {};
   for (let i = 0; i < args.length; i++) {
@@ -2085,6 +2313,9 @@ Formats:
   tamperward hook claude                    PreToolUse gate (reads hook JSON on stdin)
   tamperward sweep claude                   Stop sweep (re-scan the turn's working tree)
   tamperward allow <rule> --reason "..."    record a human sign-off (local audit ledger)
+  tamperward init [--dry-run]               wire all four enforcement points: policy
+                                            file, Claude Code hooks, pre-commit, CI.
+                                            Idempotent; never overwrites your files.
 Exit code: check \u2192 1 if any blocking finding. hook/sweep \u2192 always 0; a deny is
            emitted as JSON on stdout (exit 2 makes Claude Code ignore the JSON).
@@ -2101,6 +2332,8 @@ function main(argv) {
       return runAgentCommand("sweep", rest);
     case "allow":
       return runAllow(parseAllow(rest));
+    case "init":
+      return runInit(parseInit(rest));
     case void 0:
     case "-h":
     case "--help":

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",