rulereceipt 0.1.53 → 0.1.55

package/dist/checks/shellCommand.js

@@ -31,13 +31,76 @@ export function withoutHeredocs(command) {
                 closing = null;
             continue;
         }
-        const open = line.match(/<<-?\s*(?:'([^']+)'|"([^"]+)"|([A-Za-z_][A-Za-z0-9_]*))/);
+        // A heredoc opener: `<<WORD`, `<<-WORD`, `<<'WORD'`, `<<"WORD"`, and the
+        // backslash-escaped `<<\WORD` (valid POSIX, same "no expansion" effect as
+        // quoting). All spellings must strip the body, or a command that WRITES a
+        // command is misread as one that RUNS it.
+        const open = line.match(/<<-?\s*(?:'([^']+)'|"([^"]+)"|\\([A-Za-z_][A-Za-z0-9_]*)|([A-Za-z_][A-Za-z0-9_]*))/);
         if (open) {
-            closing = open[1] ?? open[2] ?? open[3];
-            out.push(line.slice(0, open.index));
-            continue;
+            const delimiter = open[1] ?? open[2] ?? open[3] ?? open[4] ?? null;
+            const at = open.index ?? 0;
+            const before = line.slice(0, at);
+            const afterDelim = line.slice(at + open[0].length);
+            // Only a REAL opener starts a body. `echo "see <<EOF"` merely mentions
+            // one — treating it as an opener silently deletes every following line,
+            // which hid real later commands from every caller. A genuine opener is
+            // not inside an already-open quote, and is followed only by an optional
+            // redirect/target (`<<EOF > out.txt`), never by more words.
+            if (delimiter !== null && isHeredocOpener(before, afterDelim)) {
+                closing = delimiter;
+                out.push(line.slice(0, at));
+                continue;
+            }
         }
         out.push(line);
     }
     return out.join("\n");
 }
+/**
+ * Is a matched `<<WORD` an actual heredoc opener, given the text before it and
+ * the text after the delimiter token? Rejects a `<<WORD` sitting inside an
+ * already-open quote (it is data), and one followed by more command words
+ * (also not a real opener).
+ */
+function isHeredocOpener(before, afterDelim) {
+    const singles = (before.match(/'/g) ?? []).length;
+    const doubles = (before.match(/"/g) ?? []).length;
+    if (singles % 2 === 1 || doubles % 2 === 1)
+        return false;
+    return /^\s*(?:[0-9]*>>?\s*[^\s<>|;&]+\s*)?$/.test(afterDelim);
+}
+/**
+ * Splits a shell command into the pieces that run separately.
+ *
+ * Crude by design — not a shell parser. Heredoc bodies are stripped first, so
+ * a command that only WRITES another command is not split into it. Shared by
+ * every checker that needs to reason about what a compound command actually
+ * runs (proposedAction, attribution).
+ */
+export function segments(command) {
+    return withoutHeredocs(command)
+        .split(/\n|&&|\|\||[;|]/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+/** The executable a segment invokes, with env assignments and `sudo` skipped. */
+export function leadingCommand(segment) {
+    const words = segment.split(/\s+/).filter(Boolean);
+    let i = 0;
+    while (i < words.length && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(words[i]) || words[i] === "sudo" || words[i] === "command" || words[i] === "time"))
+        i++;
+    return (words[i] ?? "").replace(/^.*\//, "");
+}
+/**
+ * Blanks out a git/gh commit or PR MESSAGE, leaving the command around it.
+ *
+ * A `-m "…"` / `--message "…"` value is text the author wrote, not a command
+ * being run, and not a path being touched — a message that quotes `rm …` or
+ * names a protected file must not be read as doing either. Shared so every
+ * checker that scans a Bash command string strips it the same way (this was
+ * present only in proposedAction, so fileLifecycle and testCommands each
+ * false-matched on commit-message text — findings 2026-09-26).
+ */
+export function withoutCommitMessage(command) {
+    return command.replace(/(-m|--message)(=|\s+)(['"])(?:\\.|(?!\3)[\s\S])*\3/g, "$1 <message>");
+}

package/dist/checks/testCommands.js

@@ -1,4 +1,13 @@
-import { withoutHeredocs } from "./shellCommand.js";
+import { withoutHeredocs, withoutCommitMessage } from "./shellCommand.js";
+/**
+ * What a shell command actually RUNS, for test-detection: heredoc bodies
+ * stripped (a command that writes `npm test` is not one that runs it) and
+ * commit/PR messages blanked (a commit message naming `jest`/`vitest` — e.g. a
+ * migration commit — is not a test run; finding #6, 2026-09-26).
+ */
+function runnableText(command) {
+    return withoutCommitMessage(withoutHeredocs(command));
+}
 /**
  * Commands that run a project's test suite.
  *
@@ -38,7 +47,7 @@ export const TEST_COMMAND = /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|verify
  */
 export function countTestRuns(command) {
     const global = new RegExp(TEST_COMMAND.source, "gi");
-    return (withoutHeredocs(command).match(global) ?? []).length;
+    return (runnableText(command).match(global) ?? []).length;
 }
 /** The first test command run in this session, or null if none ran. */
 export function findTestRun(events) {
@@ -47,7 +56,7 @@ export function findTestRun(events) {
             continue;
         const input = event.input;
         const command = input && typeof input.command === "string" ? input.command : "";
-        if (command && TEST_COMMAND.test(withoutHeredocs(command)))
+        if (command && TEST_COMMAND.test(runnableText(command)))
             return command;
     }
     return null;

package/dist/cli.js

@@ -6,7 +6,8 @@ import { join, dirname, resolve, isAbsolute } from "node:path";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { parseClaudeMd } from "./parsers/readClaudeMd.js";
-import { readLatestTranscript, readTranscriptFromFile, findLatestSessionFile, subagentNote } from "./parsers/transcriptParser.js";
+import { subagentNote } from "./parsers/transcriptParser.js";
+import { findLatestSession, sessionSourceNote, parseSessionFile } from "./adapters/index.js";
 import { loadRules } from "./rules.js";
 import { adviseRules } from "./checkability.js";
 import { shadowedAgentsMd } from "./shadowedAgents.js";
@@ -162,10 +163,15 @@ async function runCheck(opts) {
     // Code variant used ~/.claude-office/ instead of ~/.claude/ — the
     // multi-root scan in transcriptParser.ts now catches that automatically,
     // but this flag stays as a fallback for whatever variant shows up next).
-    const sessionFilePath = transcriptOverride ?? findLatestSessionFile(cwd);
+    // Auto-detect the session across every supported tool (Claude Code, Codex),
+    // newest-modified wins — the same rule the Claude reader already applies
+    // across .claude vs .claude-office, now extended across tools. A
+    // Claude-only machine picks exactly the file and events it always did.
+    const latestSession = transcriptOverride ? null : findLatestSession(cwd);
+    const sessionFilePath = transcriptOverride ?? latestSession?.file ?? null;
     if (!sessionFilePath) {
-        console.log("No Claude Code session found for this project yet.\n" +
-            "Run Claude Code here at least once, then try `rulereceipt check` again — " +
+        console.log("No coding-agent session found for this project yet.\n" +
+            "Run Claude Code (or Codex) here at least once, then try `rulereceipt check` again — " +
             "or pass --transcript <path-to-.jsonl> directly if your session lives somewhere non-standard.");
         // Exiting 0 here is right for a person running this locally for the
         // first time — nothing is wrong, there is simply nothing yet. It is
@@ -179,7 +185,11 @@ async function runCheck(opts) {
         }
         return;
     }
-    const events = transcriptOverride ? readTranscriptFromFile(sessionFilePath) : readLatestTranscript(cwd);
+    const events = transcriptOverride
+        ? parseSessionFile(sessionFilePath) // sniffs Claude vs Codex format
+        : latestSession
+            ? latestSession.adapter.parse(latestSession.file)
+            : [];
     // A session file with nothing in it produces a report full of PASSes,
     // because no forbidden action appears in an empty session. That is
     // technically true and badly misleading: "we found no proof of
@@ -290,6 +300,11 @@ async function runCheck(opts) {
     }
     else {
         console.log(reportText);
+        // Name the tool when it is not the default Claude Code, so a Codex run is
+        // not silently reported as if it were a Claude session.
+        const sourceNote = transcriptOverride ? null : sessionSourceNote(cwd);
+        if (sourceNote)
+            console.log(`\n${sourceNote}`);
         const subNote = subagentNote(sessionFilePath);
         if (subNote)
             console.log(`\n${subNote}`);

package/dist/parsers/readClaudeMd.d.ts

@@ -1,19 +1,2 @@
 import type { Rule } from "../types.js";
-/**
- * The filesystem half of rules-file parsing, deliberately kept in its own
- * module.
- *
- * claudeMdParser.ts must stay free of Node imports so it can be bundled
- * for the browser — the in-page checker on the site claims the pasted file
- * never leaves the page, and that is only true while nothing reachable
- * from the parser can perform I/O. Keeping the one readFileSync here
- * means a bundler cannot pull `node:fs` in behind it, and a future import
- * that breaks the guarantee has to be added here, visibly, rather than
- * appearing by accident in the parser.
- */
-/**
- * Reads a rules file from disk. Thin wrapper: an unreadable file is an
- * empty rule list, never a throw, because a missing global CLAUDE.md is a
- * normal state rather than an error.
- */
 export declare function parseClaudeMd(filePath: string, source: "global" | "project"): Rule[];

package/dist/parsers/readClaudeMd.js

@@ -17,6 +17,25 @@ import { parseClaudeMdText } from "./claudeMdParser.js";
  * empty rule list, never a throw, because a missing global CLAUDE.md is a
  * normal state rather than an error.
  */
+/**
+ * Strips a leading YAML frontmatter block (`---\n…\n---`) if present.
+ *
+ * Cursor's `.mdc` rule files open with a frontmatter block (description,
+ * globs, alwaysApply) that is metadata, not a rule — without this it parses
+ * as prose and surfaces `alwaysApply: true` as a checkable "rule". Kept in
+ * the filesystem reader (not the browser parser) so the parser stays
+ * Node-free. Only strips a block that starts on the very first line, so a
+ * `---` divider mid-document is untouched.
+ */
+function stripFrontmatter(raw) {
+    if (!/^---\r?\n/.test(raw))
+        return raw;
+    const end = raw.indexOf("\n---", 3);
+    if (end === -1)
+        return raw;
+    const after = raw.indexOf("\n", end + 1);
+    return after === -1 ? "" : raw.slice(after + 1);
+}
 export function parseClaudeMd(filePath, source) {
     let raw;
     try {
@@ -25,5 +44,5 @@ export function parseClaudeMd(filePath, source) {
     catch {
         return [];
     }
-    return parseClaudeMdText(raw, source);
+    return parseClaudeMdText(stripFrontmatter(raw), source);
 }

package/dist/parsers/readMemory.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare function loadMemoryRules(cwd: string): Rule[];

package/dist/parsers/readMemory.js

@@ -0,0 +1,99 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+import { findClaudeHomeDirNames } from "./transcriptParser.js";
+/**
+ * Claude Code's memory as a rule source.
+ *
+ * Memory lives per-project at:
+ *   <claude-home>/projects/<cwd with every "/" -> "-">/memory/*.md
+ * with an index `MEMORY.md` and one file per memory. Each file opens with a
+ * frontmatter block:
+ *   ---
+ *   name: <slug>
+ *   description: <one line>
+ *   metadata:
+ *     type: user | feedback | project | reference
+ *   ---
+ *   <body>
+ *
+ * Why this matters: teams increasingly move standing corrections into memory
+ * ("after any correction, update memory"), so a rule the user actually holds
+ * the agent to can live here and nowhere in CLAUDE.md. Without reading it the
+ * tool goes stale — it reports a clean session while missing the very rule the
+ * user cares most about.
+ *
+ * What counts as a rule: `feedback` (guidance on how to work — corrections and
+ * confirmed approaches) and `project` (ongoing constraints) can carry
+ * directives, so they are read. `user` (who the user is) and `reference`
+ * (pointers/URLs) never are, and are skipped by type. Anything that slips
+ * through and is not actually a directive is dropped downstream by the same
+ * not-a-rule filter every rules file goes through — so a plain fact in memory
+ * never becomes a checkable rule.
+ *
+ * Scope: non-office homes only. Reading office memory into this project is the
+ * exact office/personal mixing this project forbids, so any `.claude*` home
+ * whose name contains "office" is skipped.
+ */
+// Types whose memories can be rules. `user`/`reference` are excluded by
+// omission; an untyped memory is kept and left to the not-a-rule filter.
+const RULE_MEMORY_TYPES = new Set(["feedback", "project"]);
+function parseMemoryFile(raw) {
+    const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m)
+        return { type: null, name: null, description: null, body: raw.trim() };
+    const front = m[1];
+    const body = m[2].trim();
+    const type = front.match(/^\s*type:\s*(user|feedback|project|reference)\b/im)?.[1]?.toLowerCase() ?? null;
+    const name = front.match(/^\s*name:\s*(.+)$/im)?.[1]?.trim() ?? null;
+    const description = front.match(/^\s*description:\s*(.+)$/im)?.[1]?.trim() ?? null;
+    return { type, name, description, body };
+}
+export function loadMemoryRules(cwd) {
+    const rules = [];
+    const seenIds = new Set();
+    const encoded = cwd.replace(/\//g, "-");
+    for (const dirName of findClaudeHomeDirNames()) {
+        if (/office/i.test(dirName))
+            continue; // never office (project rule)
+        const memoryDir = join(homedir(), dirName, "projects", encoded, "memory");
+        let files;
+        try {
+            if (!statSync(memoryDir).isDirectory())
+                continue;
+            files = readdirSync(memoryDir)
+                .filter((f) => f.toLowerCase().endsWith(".md") && f !== "MEMORY.md")
+                .sort();
+        }
+        catch {
+            continue; // no memory dir for this project under this home: normal
+        }
+        for (const file of files) {
+            let raw;
+            try {
+                raw = readFileSync(join(memoryDir, file), "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const { type, name, description, body } = parseMemoryFile(raw);
+            // Skip identity/pointer memories by declared type; keep feedback/project
+            // and untyped (the not-a-rule filter drops any non-directive body later).
+            if (type !== null && !RULE_MEMORY_TYPES.has(type))
+                continue;
+            if (!body)
+                continue;
+            const id = `memory:${name ?? basename(file, ".md")}`;
+            if (seenIds.has(id))
+                continue; // same memory reachable from two homes
+            seenIds.add(id);
+            rules.push({
+                id,
+                title: description ?? name ?? basename(file, ".md"),
+                text: body,
+                source: "project",
+            });
+        }
+    }
+    return rules;
+}

package/dist/report/complianceReport.js

@@ -1,7 +1,7 @@
 import { basename } from "node:path";
 import { loadRules } from "../rules.js";
 import { evaluateSession } from "../evaluate.js";
-import { readTranscriptFromFile, listAllSessionFiles } from "../parsers/transcriptParser.js";
+import { listAllSessions } from "../adapters/index.js";
 function needsReview(rule) {
     return {
         ruleId: rule.id, ruleTitle: rule.title, ruleSource: rule.source,
@@ -11,12 +11,15 @@ function needsReview(rule) {
 }
 export async function auditSessions(cwd, limit) {
     const rules = loadRules(cwd);
-    const files = listAllSessionFiles(cwd).slice(0, Math.max(1, limit));
+    // Every session across all supported tools (Claude Code, Codex), newest
+    // first — the report audits a Codex session the same way it audits a Claude
+    // one, since the engine is agent-neutral.
+    const found = listAllSessions(cwd).slice(0, Math.max(1, limit));
     const sessions = [];
     const byRule = new Map();
     let totalViolations = 0;
-    for (const file of files) {
-        const events = readTranscriptFromFile(file);
+    for (const { adapter, file } of found) {
+        const events = adapter.parse(file);
         if (events.length === 0)
             continue;
         const { results } = await evaluateSession(cwd, rules, events, false, needsReview);

package/dist/rules.js

@@ -3,6 +3,7 @@ import { dirname, join, parse, resolve } from "node:path";
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { parseClaudeMd } from "./parsers/readClaudeMd.js";
 import { findClaudeHomeDirNames } from "./parsers/transcriptParser.js";
+import { loadMemoryRules } from "./parsers/readMemory.js";
 /**
  * Every place Claude Code actually reads a rule from, at one directory
  * level. Order mirrors the documented load order, broadest first.
@@ -15,22 +16,24 @@ import { findClaudeHomeDirNames } from "./parsers/transcriptParser.js";
  */
 const RULE_DIRS = [join(".claude", "rules")];
 /**
- * Lists the markdown files in a rules directory, if it exists.
+ * Lists the rule-doc files in a directory, if it exists.
  *
  * Sorted so the same project always produces the same rule order — rule
  * ids are positional, and an unstable order would renumber rules between
  * runs on different machines, making two reports of the same session
- * impossible to compare. Non-markdown files are skipped: a rules
- * directory legitimately holds README fragments and notes.
+ * impossible to compare. Only the given extensions count: a rules
+ * directory legitimately holds README fragments and notes. `.mdc` is
+ * Cursor's rule-file extension (Markdown + a YAML frontmatter block, which
+ * the reader strips).
  */
-function markdownFilesIn(dir) {
+function markdownFilesIn(dir, exts = [".md"]) {
     if (!existsSync(dir))
         return [];
     try {
         if (!statSync(dir).isDirectory())
             return [];
         return readdirSync(dir)
-            .filter((f) => f.toLowerCase().endsWith(".md"))
+            .filter((f) => exts.some((e) => f.toLowerCase().endsWith(e)))
             .sort()
             .map((f) => join(dir, f));
     }
@@ -65,6 +68,33 @@ function ruleFilesAtLevel(dir) {
     // documented, so both are kept rather than guessing at a shadow rule.
     push("CLAUDE.local.md");
     push("AGENTS.local.md");
+    // Non-Claude rule-file conventions (added 2026-09-26 for multi-tool
+    // support). Each is a plain text/markdown file needing no special access,
+    // read IN ADDITION to Claude's files when present — a rule the project
+    // wrote is a rule to check, and silently ignoring one is the "clean report
+    // on rules never opened" failure this module already guards against. The
+    // engine (classify.ts) is agent-neutral, so it does not matter which tool a
+    // rule was authored for. Precedence is FIXED and documented so rule ids stay
+    // deterministic: Claude family (above), then Cursor, Copilot, Windsurf.
+    //
+    // Cursor: the modern `.cursor/rules/*.mdc|.md` directory SHADOWS the legacy
+    // single `.cursorrules` file — Cursor itself deprecated `.cursorrules` in
+    // favour of the directory, so reading both would double-count. Same
+    // shadow shape as CLAUDE.md over AGENTS.md above.
+    const cursorRules = markdownFilesIn(join(dir, ".cursor", "rules"), [".mdc", ".md"]);
+    if (cursorRules.length > 0)
+        found.push(...cursorRules);
+    else
+        push(".cursorrules");
+    // GitHub Copilot: repo-level custom instructions.
+    push(join(".github", "copilot-instructions.md"));
+    // Windsurf (Codeium): single rules file.
+    push(".windsurfrules");
+    // Google's newer agent convention (agy) / "agents rules": .agents/rules/*.md,
+    // each with a `trigger:` frontmatter block (stripped by the reader).
+    found.push(...markdownFilesIn(join(dir, ".agents", "rules"), [".md"]));
+    // Gemini CLI: single rules file (its AGENTS.md equivalent).
+    push("GEMINI.md");
     return found;
 }
 /**
@@ -148,5 +178,10 @@ export function loadRules(cwd) {
     }
     for (const path of findProjectRuleFiles(cwd))
         read(path, "project");
+    // Claude Code memory (feedback/project memories) as a rule source, so a
+    // standing correction the user moved into memory is still checked and the
+    // tool does not go stale against it. Non-office homes only; ids are
+    // "memory:<name>", distinct from file-rule ids, so no dedup collision.
+    rules.push(...loadMemoryRules(cwd));
     return rules;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rulereceipt",
-  "version": "0.1.53",
-  "description": "Checks whether a Claude Code session actually followed your CLAUDE.md / AGENTS.md rules, with evidence.",
+  "version": "0.1.55",
+  "description": "Checks whether your AI coding agent followed your rules, with evidence. Works with Claude Code (Codex in testing); reads CLAUDE.md, AGENTS.md, Cursor, Copilot and Windsurf rules.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rulereceipt/rulereceipt.git"
@@ -13,7 +13,13 @@
   "keywords": [
     "claude-code",
     "claude",
+    "codex",
+    "cursor",
+    "copilot",
+    "windsurf",
+    "gemini",
     "agents",
+    "agents-md",
     "ai-agent",
     "code-review",
     "audit",