patdown 0.3.1

package/LICENSE

@@ -0,0 +1,13 @@
+Zero-Clause BSD
+=============
+
+Permission to use, copy, modify, and/or distribute this software for
+any purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
+FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
+DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,201 @@
+# patdown
+
+Standalone CLI that lints a tree against fuzzy rules in one markdown file. Wrap it as a hook, plugin, or extension.
+
+The judge is swappable. The default backend currently uses TypeSafe/Jev; rules and CLI commands use a provider-neutral interface.
+
+## Install
+
+```
+npx patdown --help
+pnpm add -D patdown
+```
+
+Requires Node.js >=22.22.2. The library entry is `patdown`; rule adapters import `@patdown/rules`.
+
+## Requirements
+
+Node.js **>=22.22.2** and pnpm **11.8.0**. CI runs checks and built-CLI smoke tests on Node 22.22.2 and Node 24. Releases through v0.2.2 require Node >=24.18.0 and use `#/` import aliases that Node 22 rejects.
+
+## Commands
+
+```
+pnpm -w patdown
+pnpm -w patdown -- --rules ./rules.md
+pnpm -w patdown -- rules
+pnpm -w patdown -- ask "Is this markdown heading title case?" --input-text "# Hello World"
+pnpm -w patdown -- ask "Is this urgent?" --input-text "ASAP" --verbose
+pnpm -w patdown -- --yes-threshold 0.9
+```
+
+Default command lints from the current directory. `rules` prints what it loaded. `ask` answers a yes/no question, no files involved. It prints `yes` or `no`; `--verbose` also shows the estimated probability of yes and the cutoff. The old `--noul` and `--state` flags have been replaced by a positional question and `--input-text`.
+
+To judge piped output, use `--stdin`. For example, after building with `pnpm -w build` or running any `pnpm -w patdown` command:
+
+```sh
+git diff --cached | node apps/patdown/dist/patdown-cli-bin.js ask "Does this diff introduce debugging statements?" --stdin
+printf 'ASAP: production is down\n' | node apps/patdown/dist/patdown-cli-bin.js ask "Is this urgent?" --stdin
+```
+
+These send the piped content to the configured judge. Do not pipe secrets. `--stdin` reads UTF-8 text through EOF, preserving newlines; it cannot be combined with `--input-text`. Without either option, the input is an empty string. `ask` reports yes/no without treating yes as a failing exit status.
+
+Walks up from cwd looking for `AGENTS.PATDOWN.md`. `--rules` skips that walk and uses the path you pass.
+
+## Adapters
+
+The default rule source parses markdown. Swap it with a module that exports `PatdownRuleSourceLive`, an Effect Layer for `PatdownRuleSource`.
+
+```
+pnpm -w patdown -- --adapter ./patdown-yaml-rules.js
+```
+
+Or in the nearest `package.json` walking up from cwd:
+
+```
+{
+  "patdown": {
+    "adapter": "./patdown-yaml-rules.js",
+    "yesThreshold": 0.9
+  }
+}
+```
+
+`--adapter` wins over package.json. `--rules` is still passed to the adapter as an override path.
+
+```
+import { PatdownRuleSource } from '@patdown/rules'
+import { Effect, Layer } from 'effect'
+
+export const PatdownRuleSourceLive = Layer.succeed(PatdownRuleSource, {
+  loadPatdownRules: () =>
+    Effect.succeed({
+      patdownRules: [
+        {
+          patdownRuleTitle: 'No title case',
+          patdownRuleBody: 'Headings use sentence case.',
+          patdownRuleGlobs: ['**/*.md'],
+        },
+      ],
+      patdownRulesFilePath: 'yaml-rules',
+    }),
+})
+```
+
+Load files however you want inside `loadPatdownRules`. `@patdown/rules` exports `findPatdownRulesFilePath` if you still want to walk up for a filename.
+
+If you wrap the CLI as a hook and already have a layer, skip discovery:
+
+```
+import { Effect } from 'effect'
+import { runPatdownCli } from 'patdown'
+
+await Effect.runPromise(runPatdownCli(PatdownRuleSourceLive))
+```
+
+See [the adapter guide](docs/rule-source-adapters.md) for the interface, a multi-file parser, resolution rules, resource lifetimes, and local development setup. Adapters execute trusted local code. Install the CLI from npm as `patdown`; adapters import `@patdown/rules` and may import `patdown` for types.
+
+## Rules
+
+One `# heading` per rule. Optional `globs:` and `yes-threshold:` lines sit immediately under the heading, in either order. Commas or spaces, extra `globs:` lines stack. A second `yes-threshold:` line is an error. Text above the first heading is ignored. Headings inside fenced code are ignored. Only `#` headings start rules; `##` and deeper headings stay in the rule body, so sections like `## Not allowed` and `## Exceptions` are fine.
+
+```
+# No title case
+globs: **/*.md
+yes-threshold: 0.9
+
+Markdown headings must use sentence case, not title case.
+```
+
+No globs means `**/*`. Globs are relative to cwd, not to the rules file. Always skipped: `.git`, `.turbo`, `coverage`, `dist`, `node_modules`.
+
+## Lint
+
+Each matched file goes to the judge as "does this file violate the following patdown rule?" The evaluated text is `path:` plus the file contents. One file at a time.
+
+A rule with no matches prints `patdown: no files matched ...` and does not fail.
+
+```
+FAIL README.md: No title case
+patdown: failed
+```
+
+Exit 1 on a violation, a missing rules file, a read error, an invalid cutoff, or a judge error. Add `--verbose` to show probabilities. Patdown counts estimated P(yes) strictly above the cutoff as yes; for lint, yes means violation. Default cutoff is 0.85. Override it with `--yes-threshold`, package.json `patdown.yesThreshold`, or a per-rule `yes-threshold:` line. The flag wins over package.json; a per-rule value wins for that rule only. `1` is rejected because nothing can exceed it. This cutoff belongs to patdown, not the provider.
+
+See [judge providers](docs/judge-providers.md) for custom layers and the planned Effect Decision integration.
+
+## Large inputs and API errors
+
+Jev has a token budget, not a fixed safe diff size. Direct testing of `jev-1.13.0` accepted a 96,768-byte synthetic diff but rejected 97,536 bytes with HTTP 400 and `max_tokens_exceeded`; a larger, low-token input still succeeded. Different text, questions, and models can move that boundary.
+
+The Jev client reports HTTP status, recognized provider error codes, input byte count, and a TypeSafe request ID when available. It distinguishes token limits from HTTP payload, authentication, rate/quota, and server failures without printing raw response bodies. It does not silently truncate input.
+
+See [the measured results and live probe commands](docs/jev-input-limits.md), including how to compare a separate Vercel AI Gateway integration.
+
+## Custom output
+
+Embedded callers can replace `PatdownOutput` instead of using the default yes/no and lint formatting. Pass an output Layer as the fourth argument to `runPatdownCli`:
+
+```ts
+import { Console, Effect, Layer } from 'effect'
+import { PatdownOutput, patdownJudgmentIsYes, runPatdownCli } from 'patdown'
+
+const JsonOutputLive = Layer.succeed(PatdownOutput, {
+	writeAnswer: (judgment, _verbose) =>
+		Console.log(
+			JSON.stringify({
+				answer: patdownJudgmentIsYes(judgment) ? 'yes' : 'no',
+				yesProbability: judgment.yesProbability,
+			}),
+		),
+	writeLintResult: (result, _verbose) => Console.log(JSON.stringify(result)),
+	writeRulesDocument: (document) => Console.log(JSON.stringify(document)),
+	writeNoFilesMatched: (ruleTitle) => Console.log(JSON.stringify({ skipped: ruleTitle })),
+	writeLintOk: Console.log(JSON.stringify({ status: 'ok' })),
+	writeLintFailed: Console.log(JSON.stringify({ status: 'failed' })),
+})
+
+await Effect.runPromise(
+	runPatdownCli(
+		undefined, // default rule-source discovery
+		process.argv.slice(2),
+		undefined, // default judge
+		JsonOutputLive,
+	),
+)
+```
+
+The output service receives structured judgments and lint results, including probabilities even when `--verbose` is off. Your layer decides what to print, collect, or omit. Formatting does not change the cutoff or exit status. The example emits one JSON object per output event, not a single JSON document for the entire run.
+
+This is an embedding API, not a `--format` flag or dynamically discovered output plugin. Supply any dependencies inside your output layer; its effects must handle their own failures. CLI help, argument errors, and loading/provider errors still use the CLI's existing help/stderr paths rather than this service. Install `patdown` from npm for embeddings. Custom adapters still need a matching Effect version.
+
+## Env
+
+With the default TypeSafe backend, `TYPESAFE_API_KEY` is required for lint and `ask`. Optional `TYPESAFE_BASE_URL` (default `https://api.typesafe.ai`) and `TYPESAFE_DEFAULT_MODEL` (default `jev-latest`).
+
+`pnpm -w patdown` forwards `TYPESAFE_*` through Turbo.
+
+## Release
+
+Version lives in `apps/patdown/package.json`. That is what `patdown --version` prints.
+
+```
+pnpm -w release patch
+pnpm -w release minor
+pnpm -w release major
+```
+
+First write and commit `releases/vX.Y.Z.md` with the next version's notes. The release command requires a clean tree and validates those notes before changing anything. It runs `pnpm check`, bumps the CLI version, commits, tags `vX.Y.Z`, and pushes to `github` and `gitea` if present. With `gh` available, it watches the matching Release workflow.
+
+The tag workflow runs checks again, creates a GitHub Release using the checked-in notes, and publishes `patdown`, `@patdown/rules`, and `@patdown/jev` to npm. See [the release process](releases/README.md) for the metadata format and backfilling published notes.
+
+Pull requests and pushes to `main` run `pnpm check`. That is oxlint, tests, and typecheck. Not the fuzzy linter.
+
+## Related
+
+Inspired by [pi-warden](https://github.com/DevMortimer/pi-warden). Same idea, inside pi.
+
+[Abide](https://github.com/coldteadotai/abide) is a similar Jev-backed checker. It hooks into coding agents, reads project instruction files, and asks Jev whether each edit or turn broke a rule.
+
+Name inspired by It's Always Sunny in Philadelphia
+
+<img width="511" height="415" alt="image" src="https://github.com/user-attachments/assets/f7c73138-3914-4fbd-9e6b-7a37d161334a" />

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+import { PatdownRuleSource } from '@patdown/rules';
+import { FileSystem, Path, Stdio } from 'effect';
+import { Command } from 'effect/unstable/cli';
+import { PatdownJudge } from '#src/patdown-judge';
+import { PatdownOutput } from '#src/patdown-output';
+type PatdownLintServices = FileSystem.FileSystem | Stdio.Stdio | PatdownJudge | Path.Path | PatdownOutput | PatdownRuleSource;
+/** Builds commands with optional adapter discovery for embedded callers. */
+export declare function makePatdownCommand(discoverAdapters?: boolean): Command.Command<'patdown', never, object, never, PatdownLintServices>;
+/** Default commands use explicit or package.json adapter discovery. */
+export declare const patdownCommand: Command.Command<"patdown", never, object, never, PatdownLintServices>;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,iBAAiB,EAKjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAU,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACxD,OAAO,EAAY,OAAO,EAAQ,MAAM,qBAAqB,CAAA;AAE7D,OAAO,EAAE,YAAY,EAAuC,MAAM,oBAAoB,CAAA;AAEtF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AA4BnD,KAAK,mBAAmB,GACrB,UAAU,CAAC,UAAU,GACrB,KAAK,CAAC,KAAK,GACX,YAAY,GACZ,IAAI,CAAC,IAAI,GACT,aAAa,GACb,iBAAiB,CAAA;AAmBpB,4EAA4E;AAC5E,wBAAgB,kBAAkB,CACjC,gBAAgB,GAAE,OAAc,GAC9B,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAAC,CA6GvE;AAED,uEAAuE;AACvE,eAAO,MAAM,cAAc,uEAAuB,CAAA"}

package/dist/cli.js

@@ -0,0 +1,85 @@
+import { PatdownRuleSource, PatdownRulesFileMissing, PatdownRulesReadFailed, PatdownRulesLoadFailed, PatdownYesThresholdInvalid, } from '@patdown/rules';
+import { Effect, FileSystem, Path, Stdio } from 'effect';
+import { Argument, Command, Flag } from 'effect/unstable/cli';
+import { PatdownJudge, PatdownJudgeFailed, askPatdownJudge } from '#src/patdown-judge';
+import { runPatdownLint } from '#src/patdown-lint';
+import { PatdownOutput } from '#src/patdown-output';
+import { readPatdownQuestionInput } from '#src/patdown-question-input';
+import { loadConfiguredPatdownRules } from '#src/patdown-rule-source-adapter';
+import { resolvePatdownYesThreshold } from '#src/patdown-yes-threshold-config';
+const failPatdown = (message) => Effect.sync(() => {
+    process.exitCode = 1;
+    process.stderr.write(`${message}\n`);
+});
+const rulesFileFlag = Flag.optional(Flag.string('rules')).pipe(Flag.withDescription('Path passed to the rule source. Markdown skips the AGENTS.PATDOWN.md walk'));
+const verboseFlag = Flag.boolean('verbose').pipe(Flag.withDefault(false), Flag.withDescription('Show estimated yes probabilities and the decision cutoff'));
+const adapterFlag = Flag.optional(Flag.string('adapter')).pipe(Flag.withDescription('Module exporting PatdownRuleSourceLive, replacingkdown rule parsing'));
+const yesThresholdFlag = Flag.optional(Flag.float('yes-threshold')).pipe(Flag.withDescription('Minimum exclusive P(yes) for yes; default 0.85, overridable per rule'));
+function finishPatdownLint(failed) {
+    return Effect.gen(function* () {
+        const output = yield* PatdownOutput;
+        if (failed) {
+            yield* output.writeLintFailed;
+            yield* Effect.sync(() => {
+                process.exitCode = 1;
+            });
+            return;
+        }
+        yield* output.writeLintOk;
+    });
+}
+/** Builds commands with optional adapter discovery for embedded callers. */
+export function makePatdownCommand(discoverAdapters = true) {
+    const rulesCommand = Command.make('rules', { adapter: adapterFlag, rules: rulesFileFlag }, ({ rules, adapter, }) => Effect.gen(function* () {
+        const patdownRuleSource = yield* PatdownRuleSource;
+        const output = yield* PatdownOutput;
+        const document = yield* discoverAdapters
+            ? loadConfiguredPatdownRules(adapter, rules)
+            : patdownRuleSource.loadPatdownRules(rules);
+        yield* output.writeRulesDocument(document);
+    }).pipe(Effect.catchTags({
+        PatdownRulesFileMissing: (error) => failPatdown(error.message),
+        PatdownRulesReadFailed: (error) => failPatdown(error.message),
+        PatdownRulesLoadFailed: (error) => failPatdown(error.message),
+        PatdownYesThresholdInvalid: (error) => failPatdown(error.message),
+    }))).pipe(Command.withDescription('Load and print patdown rules'));
+    const askCommand = Command.make('ask', {
+        question: Argument.string('question'),
+        verbose: verboseFlag,
+        yesThreshold: yesThresholdFlag,
+        inputText: Flag.optional(Flag.string('input-text')).pipe(Flag.withDescription('Text to evaluate')),
+        stdin: Flag.boolean('stdin').pipe(Flag.withDefault(false), Flag.withDescription('Read UTF-8 text from piped or redirected stdin')),
+    }, ({ question, inputText, stdin, verbose, yesThreshold, }) => Effect.gen(function* () {
+        const output = yield* PatdownOutput;
+        const text = yield* readPatdownQuestionInput(inputText, stdin);
+        const cutoff = yield* resolvePatdownYesThreshold(yesThreshold);
+        const answer = yield* askPatdownJudge(question, text);
+        yield* output.writeAnswer(answer, verbose, cutoff);
+    }).pipe(Effect.catchTags({
+        PatdownJudgeFailed: (error) => failPatdown(error.message),
+        PatdownYesThresholdInvalid: (error) => failPatdown(error.message),
+    }))).pipe(Command.withDescription('Ask a yes/no question about text'));
+    /** Root Effect CLI command for patdown. Default action lints files against AGENTS.PATDOWN.md. */
+    return Command.make('patdown', {
+        adapter: adapterFlag,
+        rules: rulesFileFlag,
+        verbose: verboseFlag,
+        yesThreshold: yesThresholdFlag,
+    }, ({ rules, adapter, verbose, yesThreshold }) => Effect.gen(function* () {
+        const patdownRuleSource = yield* PatdownRuleSource;
+        const cutoff = yield* resolvePatdownYesThreshold(yesThreshold);
+        const document = yield* discoverAdapters
+            ? loadConfiguredPatdownRules(adapter, rules)
+            : patdownRuleSource.loadPatdownRules(rules);
+        const failed = yield* runPatdownLint(document, verbose, cutoff);
+        yield* finishPatdownLint(failed);
+    }).pipe(Effect.catchTags({
+        PatdownRulesLoadFailed: (error) => failPatdown(error.message),
+        PatdownJudgeFailed: (error) => failPatdown(error.message),
+        PatdownYesThresholdInvalid: (error) => failPatdown(error.message),
+        PatdownRulesFileMissing: (error) => failPatdown(error.message),
+        PatdownRulesReadFailed: (error) => failPatdown(error.message),
+    }))).pipe(Command.withDescription('Lint a tree against fuzzykdown rules'), Command.withShortDescription('Patdown CLI'), Command.withSubcommands([askCommand, rulesCommand]));
+}
+/** Default commands use explicit or package.json adapter discovery. */
+export const patdownCommand = makePatdownCommand();

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { patdownCommand, makePatdownCommand } from '#src/cli';
+export { PatdownOutput, PatdownOutputLive, type PatdownLintResult } from '#src/patdown-output';
+export type { PatdownRuleSourceLayer } from '#src/patdown-rule-source-adapter';
+export { runPatdownCli } from '#src/run-patdown-cli';
+export { PatdownJudge, PatdownJudgeFailed, PatdownJudgmentSchema, askPatdownJudge, patdownJudgmentIsYes, patdownYesThreshold, type PatdownJudgment, } from '#src/patdown-judge';
+export { defaultPatdownYesThreshold, decodePatdownYesThreshold, PatdownYesThresholdInvalid, type PatdownYesThreshold, } from '@patdown/rules';
+export { TypeSafeJudgeLive } from '#src/typesafe-judge';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE7D,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE9F,YAAY,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAE9E,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD,OAAO,EACN,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,eAAe,GACpB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACN,0BAA0B,EAC1B,yBAAyB,EACzB,0BAA0B,EAC1B,KAAK,mBAAmB,GACxB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { patdownCommand, makePatdownCommand } from '#src/cli';
+export { PatdownOutput, PatdownOutputLive } from '#src/patdown-output';
+export { runPatdownCli } from '#src/run-patdown-cli';
+export { PatdownJudge, PatdownJudgeFailed, PatdownJudgmentSchema, askPatdownJudge, patdownJudgmentIsYes, patdownYesThreshold, } from '#src/patdown-judge';
+export { defaultPatdownYesThreshold, decodePatdownYesThreshold, PatdownYesThresholdInvalid, } from '@patdown/rules';
+export { TypeSafeJudgeLive } from '#src/typesafe-judge';

package/dist/markdown-squint-rule-parser.d.ts

@@ -0,0 +1,7 @@
+import type { SquintRule } from '#/squint-rule';
+/**
+ * Parse fuzzy squint rules from a markdown document. Text above the first `# heading` is ignored.
+ * Headings inside fenced code are ignored.
+ */
+export declare function parseMarkdownSquintRules(markdown: string): ReadonlyArray<SquintRule>;
+//# sourceMappingURL=markdown-squint-rule-parser.d.ts.map

package/dist/markdown-squint-rule-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-squint-rule-parser.d.ts","sourceRoot":"","sources":["../src/markdown-squint-rule-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAuG/C;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,CAiBpF"}

package/dist/markdown-squint-rule-parser.js

@@ -0,0 +1,85 @@
+const atxHeadingPattern = /^#\s+(.*)$/u;
+const globLinePattern = /^globs:\s*(.*)$/u;
+function isFenceToggleLine(line) {
+    return line.startsWith('```');
+}
+function atxHeadingTitle(line) {
+    const match = atxHeadingPattern.exec(line);
+    if (match === null)
+        return undefined;
+    const title = match[1]?.trim() ?? '';
+    return title.length === 0 ? undefined : title;
+}
+function splitGlobList(raw) {
+    return raw.split(/[,\s]+/u).filter((part) => part.length > 0);
+}
+function globValuesFromLine(line) {
+    const match = globLinePattern.exec(line);
+    if (match === null)
+        return undefined;
+    return splitGlobList(match[1] ?? '');
+}
+function splitGlobsFromRuleBody(lines) {
+    let index = 0;
+    while (index < lines.length && lines[index]?.trim() === '') {
+        index += 1;
+    }
+    const globs = [];
+    while (index < lines.length) {
+        const globValues = globValuesFromLine(lines[index] ?? '');
+        if (globValues === undefined)
+            break;
+        globs.push(...globValues);
+        index += 1;
+    }
+    return {
+        squintRuleBody: lines.slice(index).join('\n').trim(),
+        squintRuleGlobs: globs,
+    };
+}
+function finishSquintRule(title, lines) {
+    const bodyParts = splitGlobsFromRuleBody(lines);
+    return {
+        squintRuleBody: bodyParts.squintRuleBody,
+        squintRuleGlobs: bodyParts.squintRuleGlobs,
+        squintRuleTitle: title,
+    };
+}
+function applyMarkdownLine(state, line) {
+    if (isFenceToggleLine(line)) {
+        state.inFence = !state.inFence;
+        if (state.currentTitle !== undefined)
+            state.currentLines.push(line);
+        return;
+    }
+    const headingTitle = state.inFence ? undefined : atxHeadingTitle(line);
+    if (headingTitle !== undefined) {
+        if (state.currentTitle !== undefined) {
+            state.rules.push(finishSquintRule(state.currentTitle, state.currentLines));
+        }
+        state.currentTitle = headingTitle;
+        state.currentLines = [];
+        return;
+    }
+    if (state.currentTitle !== undefined)
+        state.currentLines.push(line);
+}
+/**
+ * Parse fuzzy squint rules from a markdown document. Text above the first `# heading` is ignored.
+ * Headings inside fenced code are ignored.
+ */
+export function parseMarkdownSquintRules(markdown) {
+    const state = {
+        currentLines: [],
+        currentTitle: undefined,
+        inFence: false,
+        rules: [],
+    };
+    for (const line of markdown.split(/\r?\n/u)) {
+        applyMarkdownLine(state, line);
+    }
+    if (state.currentTitle !== undefined) {
+        state.rules.push(finishSquintRule(state.currentTitle, state.currentLines));
+    }
+    return state.rules;
+}

package/dist/patdown-cli-bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=patdown-cli-bin.d.ts.map

package/dist/patdown-cli-bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-cli-bin.d.ts","sourceRoot":"","sources":["../src/patdown-cli-bin.ts"],"names":[],"mappings":""}

package/dist/patdown-cli-bin.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { NodeRuntime } from '@effect/platform-node';
+import { runPatdownCli } from '#src/run-patdown-cli';
+NodeRuntime.runMain(runPatdownCli());

package/dist/patdown-cli-version.d.ts

@@ -0,0 +1,3 @@
+/** Version printed by `patdown --version`. Comes from apps/patdown/package.json. */
+export declare const patdownCliVersion: string;
+//# sourceMappingURL=patdown-cli-version.d.ts.map

package/dist/patdown-cli-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-cli-version.d.ts","sourceRoot":"","sources":["../src/patdown-cli-version.ts"],"names":[],"mappings":"AAsBA,oFAAoF;AACpF,eAAO,MAAM,iBAAiB,QAAiC,CAAA"}

package/dist/patdown-cli-version.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Schema } from 'effect';
+const PatdownCliPackageJsonSchema = Schema.Struct({
+    version: Schema.NonEmptyString,
+});
+function readPatdownCliPackageVersion() {
+    const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    try {
+        return Schema.decodeUnknownSync(PatdownCliPackageJsonSchema)(JSON.parse(readFileSync(packageJsonPath, 'utf8'))).version;
+    }
+    catch {
+        throw new Error(`patdown: failed to read CLI version from ${packageJsonPath}`);
+    }
+}
+/** Version printed by `patdown --version`. Comes from apps/patdown/package.json. */
+export const patdownCliVersion = readPatdownCliPackageVersion();

package/dist/patdown-judge.d.ts

@@ -0,0 +1,30 @@
+import { type PatdownYesThreshold } from '@patdown/rules';
+import { Context, Effect, Schema } from 'effect';
+/** Provider-neutral estimate. This is P(yes), not confidence in whichever answer wins. */
+export declare const PatdownJudgmentSchema: Schema.Struct<{
+    readonly yesProbability: Schema.Finite;
+}>;
+/** A judge estimates the probability that the question is true of the supplied text. */
+export type PatdownJudgment = typeof PatdownJudgmentSchema.Type;
+declare const PatdownJudgeFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PatdownJudgeFailed";
+} & Readonly<A>;
+/** Provider or response validation failure, independent of the backend. */
+export declare class PatdownJudgeFailed extends PatdownJudgeFailed_base<{
+    readonly message: string;
+}> {
+}
+declare const PatdownJudge_base: Context.ServiceClass<PatdownJudge, "@patdown/cli/PatdownJudge", {
+    readonly ask: (question: string, inputText: string) => Effect.Effect<PatdownJudgment, PatdownJudgeFailed>;
+}>;
+/** Swappable judge service. Providers supply their own transport dependencies internally. */
+export declare class PatdownJudge extends PatdownJudge_base {
+}
+/** Default cutoff, still used when no flag, package.json, or per-rule value is set. */
+export declare const patdownYesThreshold = 0.85;
+/** Applies a cutoff to a validated probability. Equality is not yes. */
+export declare function patdownJudgmentIsYes(judgment: PatdownJudgment, yesThreshold?: PatdownYesThreshold): boolean;
+/** Validates custom judge responses at the service boundary before applying policy or printing. */
+export declare function askPatdownJudge(question: string, inputText: string): Effect.Effect<PatdownJudgment, PatdownJudgeFailed, PatdownJudge>;
+export {};
+//# sourceMappingURL=patdown-judge.d.ts.map

package/dist/patdown-judge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-judge.d.ts","sourceRoot":"","sources":["../src/patdown-judge.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,KAAK,mBAAmB,EACxB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEtD,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB;;EAEhC,CAAA;AAEF,wFAAwF;AACxF,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAA;;;;AAE/D,2EAA2E;AAC3E,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACxB,CAAC;CAAG;;kBAMW,CACb,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,KACb,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,kBAAkB,CAAC;;AAPzD,6FAA6F;AAC7F,qBAAa,YAAa,SAAQ,iBAQF;CAAG;AAEnC,uFAAuF;AACvF,eAAO,MAAM,mBAAmB,OAA6B,CAAA;AAE7D,wEAAwE;AACxE,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,eAAe,EACzB,YAAY,GAAE,mBAAgD,GAC5D,OAAO,CAET;AAED,mGAAmG;AACnG,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,kBAAkB,EAAE,YAAY,CAAC,CAYlE"}

package/dist/patdown-judge.js

@@ -0,0 +1,26 @@
+import { defaultPatdownYesThreshold, patdownJudgmentIsYes as comparePatdownYesProbability, } from '@patdown/rules';
+import { Context, Data, Effect, Schema } from 'effect';
+/** Provider-neutral estimate. This is P(yes), not confidence in whichever answer wins. */
+export const PatdownJudgmentSchema = Schema.Struct({
+    yesProbability: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1 })),
+});
+/** Provider or response validation failure, independent of the backend. */
+export class PatdownJudgeFailed extends Data.TaggedError('PatdownJudgeFailed') {
+}
+/** Swappable judge service. Providers supply their own transport dependencies internally. */
+export class PatdownJudge extends Context.Service()('@patdown/cli/PatdownJudge') {
+}
+/** Default cutoff, still used when no flag, package.json, or per-rule value is set. */
+export const patdownYesThreshold = defaultPatdownYesThreshold;
+/** Applies a cutoff to a validated probability. Equality is not yes. */
+export function patdownJudgmentIsYes(judgment, yesThreshold = defaultPatdownYesThreshold) {
+    return comparePatdownYesProbability(judgment.yesProbability, yesThreshold);
+}
+/** Validates custom judge responses at the service boundary before applying policy or printing. */
+export function askPatdownJudge(question, inputText) {
+    return Effect.gen(function* () {
+        const judge = yield* PatdownJudge;
+        const answer = yield* judge.ask(question, inputText);
+        return yield* Schema.decodeEffect(PatdownJudgmentSchema)(answer).pipe(Effect.mapError(() => new PatdownJudgeFailed({ message: 'patdown: judge returned an invalid yes probability' })));
+    });
+}

package/dist/patdown-lint.d.ts

@@ -0,0 +1,7 @@
+import { PatdownYesThresholdInvalid, type PatdownRulesDocument, type PatdownYesThreshold } from '@patdown/rules';
+import { Effect, FileSystem, Path } from 'effect';
+import { PatdownJudge, PatdownJudgeFailed } from '#src/patdown-judge';
+import { PatdownOutput } from '#src/patdown-output';
+/** Lint files matched by each rule's globs. A yes judgment means a violation. */
+export declare function runPatdownLint(document: PatdownRulesDocument, verbose?: boolean, yesThreshold?: PatdownYesThreshold): Effect.Effect<boolean, PatdownJudgeFailed | PatdownYesThresholdInvalid, FileSystem.FileSystem | PatdownJudge | Path.Path | PatdownOutput>;
+//# sourceMappingURL=patdown-lint.d.ts.map

package/dist/patdown-lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-lint.d.ts","sourceRoot":"","sources":["../src/patdown-lint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,0BAA0B,EAE1B,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAEjD,OAAO,EACN,YAAY,EACZ,kBAAkB,EAGlB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AA0InD,iFAAiF;AACjF,wBAAgB,cAAc,CAC7B,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,GAAE,OAAe,EACxB,YAAY,GAAE,mBAAgD,GAC5D,MAAM,CAAC,MAAM,CACf,OAAO,EACP,kBAAkB,GAAG,0BAA0B,EAC/C,UAAU,CAAC,UAAU,GAAG,YAAY,GAAG,IAAI,CAAC,IAAI,GAAG,aAAa,CAChE,CAaA"}

package/dist/patdown-lint.js

@@ -0,0 +1,89 @@
+import { defaultPatdownYesThreshold, PatdownYesThresholdInvalid, } from '@patdown/rules';
+import { Effect, FileSystem, Path } from 'effect';
+import { PatdownJudge, PatdownJudgeFailed, askPatdownJudge, patdownJudgmentIsYes, } from '#src/patdown-judge';
+import { PatdownOutput } from '#src/patdown-output';
+import { decodePatdownRuleYesThreshold } from '#src/patdown-yes-threshold-config';
+const patdownGlobExcludes = [
+    '**/.git/**',
+    '**/.turbo/**',
+    '**/coverage/**',
+    '**/dist/**',
+    '**/node_modules/**',
+];
+function patdownGlobPatterns(globs) {
+    return globs.length === 0 ? ['**/*'] : globs;
+}
+function patdownViolationInstructions(rule) {
+    return [
+        'Does this file violate the following patdown rule? Answer yes only if there is a clear violation.',
+        '',
+        `# ${rule.patdownRuleTitle}`,
+        '',
+        rule.patdownRuleBody,
+    ].join('\n');
+}
+function patdownFileState(relativePath, contents) {
+    return `path: ${relativePath}\n\n${contents}`;
+}
+function globPatdownRuleFiles(cwd, globs) {
+    return Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const patterns = patdownGlobPatterns(globs);
+        const matches = [];
+        for (const pattern of patterns) {
+            const found = yield* fileSystem
+                .glob(pattern, {
+                exclude: patdownGlobExcludes,
+                root: cwd,
+            })
+                .pipe(Effect.orElseSucceed(() => []));
+            matches.push(...found);
+        }
+        return [...new Set(matches)].toSorted();
+    });
+}
+function lintPatdownRuleFile(rule, filePath, options) {
+    return Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const output = yield* PatdownOutput;
+        const relativePath = path.relative(options.cwd, filePath);
+        const contents = yield* fileSystem.readFileString(filePath).pipe(Effect.mapError(() => new PatdownJudgeFailed({
+            message: `patdown: failed to read ${relativePath}`,
+        })));
+        const answer = yield* askPatdownJudge(patdownViolationInstructions(rule), patdownFileState(relativePath, contents));
+        const failed = patdownJudgmentIsYes(answer, options.yesThreshold);
+        yield* output.writeLintResult({
+            violated: failed,
+            ruleTitle: rule.patdownRuleTitle,
+            filePath: relativePath,
+            violationProbability: answer.yesProbability,
+            yesThreshold: options.yesThreshold,
+        }, options.verbose);
+        return failed;
+    });
+}
+function lintPatdownRule(rule, cwd, verbose, defaultYesThreshold) {
+    return Effect.gen(function* () {
+        const output = yield* PatdownOutput;
+        const files = yield* globPatdownRuleFiles(cwd, rule.patdownRuleGlobs);
+        const yesThreshold = rule.patdownRuleYesThreshold === undefined
+            ? defaultYesThreshold
+            : yield* decodePatdownRuleYesThreshold(rule.patdownRuleYesThreshold, rule.patdownRuleTitle);
+        if (files.length === 0) {
+            yield* output.writeNoFilesMatched(rule.patdownRuleTitle);
+            return false;
+        }
+        const failures = yield* Effect.forEach(files, (filePath) => lintPatdownRuleFile(rule, filePath, { cwd, verbose, yesThreshold }), { concurrency: 1 });
+        return failures.some((failed) => failed);
+    });
+}
+/** Lint files matched by each rule's globs. A yes judgment means a violation. */
+export function runPatdownLint(document, verbose = false, yesThreshold = defaultPatdownYesThreshold) {
+    return Effect.gen(function* () {
+        const path = yield* Path.Path;
+        const cwd = path.resolve('.');
+        const failures = yield* Effect.forEach(document.patdownRules, (rule) => lintPatdownRule(rule, cwd, verbose, yesThreshold), { concurrency: 1 });
+        return failures.some((failed) => failed);
+    });
+}