@patdown/rules 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,5 @@
+# @patdown/rules
+
+Rule types and markdown loading for [patdown](https://github.com/tyler-dot-earth/patdown).
+
+Install the CLI as `patdown`. Import this package when writing a custom rule-source adapter.

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { parseMarkdownPatdownRules } from '#src/markdown-patdown-rule-parser';
+export { defaultPatdownRulesFileName, type PatdownRule, type PatdownRulesDocument, } from '#src/patdown-rule';
+export { defaultPatdownYesThreshold, decodePatdownYesThreshold, decodePatdownYesThresholdText, patdownJudgmentIsYes, PatdownYesThresholdInvalid, type PatdownYesThreshold, } from '#src/patdown-yes-threshold';
+export { findPatdownRulesFilePath, MarkdownPatdownRuleSourceLive, PatdownRuleSource, PatdownRulesFileMissing, PatdownRulesReadFailed, PatdownRulesLoadFailed, resolvePatdownRulesFilePath, } from '#src/patdown-rule-source';
+//# 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,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAE7E,OAAO,EACN,2BAA2B,EAC3B,KAAK,WAAW,EAChB,KAAK,oBAAoB,GACzB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACN,0BAA0B,EAC1B,yBAAyB,EACzB,6BAA6B,EAC7B,oBAAoB,EACpB,0BAA0B,EAC1B,KAAK,mBAAmB,GACxB,MAAM,4BAA4B,CAAA;AAEnC,OAAO,EACN,wBAAwB,EACxB,6BAA6B,EAC7B,iBAAiB,EACjB,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,EACtB,2BAA2B,GAC3B,MAAM,0BAA0B,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { parseMarkdownPatdownRules } from '#src/markdown-patdown-rule-parser';
+export { defaultPatdownRulesFileName, } from '#src/patdown-rule';
+export { defaultPatdownYesThreshold, decodePatdownYesThreshold, decodePatdownYesThresholdText, patdownJudgmentIsYes, PatdownYesThresholdInvalid, } from '#src/patdown-yes-threshold';
+export { findPatdownRulesFilePath, MarkdownPatdownRuleSourceLive, PatdownRuleSource, PatdownRulesFileMissing, PatdownRulesReadFailed, PatdownRulesLoadFailed, resolvePatdownRulesFilePath, } from '#src/patdown-rule-source';

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-patdown-rule-parser.d.ts","sourceRoot":"","sources":["../src/markdown-patdown-rule-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AA+KpD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,CAiBtF"}

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

@@ -0,0 +1,124 @@
+import { decodePatdownYesThresholdText, PatdownYesThresholdInvalid, } from '#src/patdown-yes-threshold';
+const atxHeadingPattern = /^#\s+(.*)$/u;
+const globLinePattern = /^globs:\s*(.*)$/u;
+const yesThresholdLinePattern = /^yes-threshold:\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 yesThresholdFromLine(line) {
+    const match = yesThresholdLinePattern.exec(line);
+    return match === null ? undefined : (match[1] ?? '');
+}
+function skipBlankPrefix(lines) {
+    let index = 0;
+    while (index < lines.length && lines[index]?.trim() === '') {
+        index += 1;
+    }
+    return index;
+}
+function decodeRuleYesThreshold(title, rawThreshold) {
+    const decoded = decodePatdownYesThresholdText(rawThreshold, `rule ${JSON.stringify(title)} yes-threshold`);
+    if (decoded instanceof PatdownYesThresholdInvalid)
+        throw decoded;
+    return decoded;
+}
+function applyRuleMetadataLine(title, line, globs, yesThreshold) {
+    const globValues = globValuesFromLine(line);
+    if (globValues !== undefined) {
+        globs.push(...globValues);
+        return { consumed: true, yesThreshold };
+    }
+    const rawThreshold = yesThresholdFromLine(line);
+    if (rawThreshold === undefined)
+        return { consumed: false, yesThreshold };
+    if (yesThreshold !== undefined) {
+        throw new Error(`patdown: rule ${JSON.stringify(title)} has more than one yes-threshold line`);
+    }
+    return { consumed: true, yesThreshold: decodeRuleYesThreshold(title, rawThreshold) };
+}
+function splitMetadataFromRuleBody(title, lines) {
+    let index = skipBlankPrefix(lines);
+    const globs = [];
+    let yesThreshold;
+    while (index < lines.length) {
+        const applied = applyRuleMetadataLine(title, lines[index] ?? '', globs, yesThreshold);
+        if (!applied.consumed)
+            break;
+        yesThreshold = applied.yesThreshold;
+        index += 1;
+    }
+    const bodyParts = {
+        patdownRuleBody: lines.slice(index).join('\n').trim(),
+        patdownRuleGlobs: globs,
+    };
+    if (yesThreshold !== undefined) {
+        return { ...bodyParts, patdownRuleYesThreshold: yesThreshold };
+    }
+    return bodyParts;
+}
+function finishPatdownRule(title, lines) {
+    const bodyParts = splitMetadataFromRuleBody(title, lines);
+    const rule = {
+        patdownRuleBody: bodyParts.patdownRuleBody,
+        patdownRuleGlobs: bodyParts.patdownRuleGlobs,
+        patdownRuleTitle: title,
+    };
+    if (bodyParts.patdownRuleYesThreshold !== undefined) {
+        return { ...rule, patdownRuleYesThreshold: bodyParts.patdownRuleYesThreshold };
+    }
+    return rule;
+}
+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(finishPatdownRule(state.currentTitle, state.currentLines));
+        }
+        state.currentTitle = headingTitle;
+        state.currentLines = [];
+        return;
+    }
+    if (state.currentTitle !== undefined)
+        state.currentLines.push(line);
+}
+/**
+ * Parse fuzzy patdown rules from a markdown document. Text above the first `# heading` is ignored.
+ * Headings inside fenced code are ignored.
+ */
+export function parseMarkdownPatdownRules(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(finishPatdownRule(state.currentTitle, state.currentLines));
+    }
+    return state.rules;
+}

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-rule-source.d.ts

@@ -0,0 +1,53 @@
+import { Context, Effect, FileSystem, Layer, Option, Path } from 'effect';
+import { type PatdownRulesDocument } from '#src/patdown-rule';
+import { PatdownYesThresholdInvalid } from '#src/patdown-yes-threshold';
+declare const PatdownRulesFileMissing_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: "PatdownRulesFileMissing";
+} & Readonly<A>;
+/** No AGENTS.PATDOWN.md (or override path) existed walking up from the start directory. */
+export declare class PatdownRulesFileMissing extends PatdownRulesFileMissing_base<{
+    readonly patdownRulesFileName: string;
+    readonly startDirectory: string;
+}> {
+    get message(): string;
+}
+declare const PatdownRulesReadFailed_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: "PatdownRulesReadFailed";
+} & Readonly<A>;
+/** The rules file existed but could not be read. */
+export declare class PatdownRulesReadFailed extends PatdownRulesReadFailed_base<{
+    readonly patdownRulesFilePath: string;
+}> {
+    get message(): string;
+}
+declare const PatdownRulesLoadFailed_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: "PatdownRulesLoadFailed";
+} & Readonly<A>;
+/**
+ * Adapter discovery, parsing, or loading failed. Preserve the source-specific diagnostic in
+ * message.
+ */
+export declare class PatdownRulesLoadFailed extends PatdownRulesLoadFailed_base<{
+    readonly message: string;
+}> {
+}
+declare const PatdownRuleSource_base: Context.ServiceClass<PatdownRuleSource, "@patdown/rules/PatdownRuleSource", {
+    readonly loadPatdownRules: (rulesFilePathOverride: Option.Option<string>) => Effect.Effect<PatdownRulesDocument, PatdownRulesFileMissing | PatdownRulesReadFailed | PatdownRulesLoadFailed | PatdownYesThresholdInvalid, FileSystem.FileSystem | Path.Path>;
+}>;
+/**
+ * Loads fuzzy patdown rules for a run. Provide a live layer to parse markdown, YAML, frontmatter
+ * files, or any other source. The shipped CLI defaults to MarkdownPatdownRuleSourceLive.
+ */
+export declare class PatdownRuleSource extends PatdownRuleSource_base {
+}
+/** Walks up from startDirectory until fileName exists. Adapters can reuse this for other filenames. */
+export declare function findPatdownRulesFilePath(startDirectory: string, fileName: string): Effect.Effect<string, PatdownRulesFileMissing | PatdownRulesReadFailed, FileSystem.FileSystem | Path.Path>;
+/**
+ * Resolves --rules to an existing path, or walks up for rulesFileName (AGENTS.PATDOWN.md by
+ * default).
+ */
+export declare function resolvePatdownRulesFilePath(rulesFilePathOverride: Option.Option<string>, rulesFileName?: string): Effect.Effect<string, PatdownRulesFileMissing | PatdownRulesReadFailed, FileSystem.FileSystem | Path.Path>;
+/** Live patdown rule source that reads markdown (`AGENTS.PATDOWN.md` by default). */
+export declare const MarkdownPatdownRuleSourceLive: Layer.Layer<PatdownRuleSource, never, never>;
+export {};
+//# sourceMappingURL=patdown-rule-source.d.ts.map

package/dist/patdown-rule-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-rule-source.d.ts","sourceRoot":"","sources":["../src/patdown-rule-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG/E,OAAO,EAA+B,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAC1F,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAA;;;;AAEvE,2FAA2F;AAC3F,qBAAa,uBAAwB,SAAQ,6BAA4C;IACxF,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAC/B,CAAC;IACD,IAAa,OAAO,IAAI,MAAM,CAE7B;CACD;;;;AAED,oDAAoD;AACpD,qBAAa,sBAAuB,SAAQ,4BAA2C;IACtF,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;CACrC,CAAC;IACD,IAAa,OAAO,IAAI,MAAM,CAE7B;CACD;;;;AAED;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,4BAA2C;IACtF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACxB,CAAC;CAAG;;+BASwB,CAC1B,qBAAqB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KACxC,MAAM,CAAC,MAAM,CACjB,oBAAoB,EAClB,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,0BAA0B,EAC5B,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CACjC;;AAhBH;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,sBAcA;CAAG;AAY1C,uGAAuG;AACvG,wBAAgB,wBAAwB,CACvC,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,CACf,MAAM,EACN,uBAAuB,GAAG,sBAAsB,EAChD,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CACjC,CAsBA;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAC1C,qBAAqB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAC5C,aAAa,GAAE,MAAoC,GACjD,MAAM,CAAC,MAAM,CACf,MAAM,EACN,uBAAuB,GAAG,sBAAsB,EAChD,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CACjC,CAkBA;AAqCD,qFAAqF;AACrF,eAAO,MAAM,6BAA6B,8CAExC,CAAA"}

package/dist/patdown-rule-source.js

@@ -0,0 +1,98 @@
+import { Context, Data, Effect, FileSystem, Layer, Option, Path } from 'effect';
+import { parseMarkdownPatdownRules } from '#src/markdown-patdown-rule-parser';
+import { defaultPatdownRulesFileName } from '#src/patdown-rule';
+import { PatdownYesThresholdInvalid } from '#src/patdown-yes-threshold';
+/** No AGENTS.PATDOWN.md (or override path) existed walking up from the start directory. */
+export class PatdownRulesFileMissing extends Data.TaggedError('PatdownRulesFileMissing') {
+    get message() {
+        return `patdown: no ${this.patdownRulesFileName} found walking up from ${this.startDirectory}`;
+    }
+}
+/** The rules file existed but could not be read. */
+export class PatdownRulesReadFailed extends Data.TaggedError('PatdownRulesReadFailed') {
+    get message() {
+        return `patdown: failed to read ${this.patdownRulesFilePath}`;
+    }
+}
+/**
+ * Adapter discovery, parsing, or loading failed. Preserve the source-specific diagnostic in
+ * message.
+ */
+export class PatdownRulesLoadFailed extends Data.TaggedError('PatdownRulesLoadFailed') {
+}
+/**
+ * Loads fuzzy patdown rules for a run. Provide a live layer to parse markdown, YAML, frontmatter
+ * files, or any other source. The shipped CLI defaults to MarkdownPatdownRuleSourceLive.
+ */
+export class PatdownRuleSource extends Context.Service()('@patdown/rules/PatdownRuleSource') {
+}
+function pathExists(filePath) {
+    return FileSystem.FileSystem.use((fileSystem) => fileSystem
+        .exists(filePath)
+        .pipe(Effect.mapError(() => new PatdownRulesReadFailed({ patdownRulesFilePath: filePath }))));
+}
+/** Walks up from startDirectory until fileName exists. Adapters can reuse this for other filenames. */
+export function findPatdownRulesFilePath(startDirectory, fileName) {
+    return Effect.gen(function* () {
+        const path = yield* Path.Path;
+        let directory = startDirectory;
+        while (true) {
+            const candidate = path.join(directory, fileName);
+            if (yield* pathExists(candidate))
+                return candidate;
+            const parent = path.dirname(directory);
+            if (parent === directory) {
+                return yield* new PatdownRulesFileMissing({
+                    patdownRulesFileName: fileName,
+                    startDirectory,
+                });
+            }
+            directory = parent;
+        }
+    });
+}
+/**
+ * Resolves --rules to an existing path, or walks up for rulesFileName (AGENTS.PATDOWN.md by
+ * default).
+ */
+export function resolvePatdownRulesFilePath(rulesFilePathOverride, rulesFileName = defaultPatdownRulesFileName) {
+    return Effect.gen(function* () {
+        const path = yield* Path.Path;
+        const startDirectory = path.resolve('.');
+        if (Option.isNone(rulesFilePathOverride)) {
+            return yield* findPatdownRulesFilePath(startDirectory, rulesFileName);
+        }
+        const candidate = path.resolve(startDirectory, rulesFilePathOverride.value);
+        if (yield* pathExists(candidate))
+            return candidate;
+        return yield* new PatdownRulesFileMissing({
+            patdownRulesFileName: rulesFilePathOverride.value,
+            startDirectory,
+        });
+    });
+}
+function loadMarkdownPatdownRules(rulesFilePathOverride) {
+    return Effect.gen(function* () {
+        const patdownRulesFilePath = yield* resolvePatdownRulesFilePath(rulesFilePathOverride);
+        const fileSystem = yield* FileSystem.FileSystem;
+        const markdown = yield* fileSystem
+            .readFileString(patdownRulesFilePath)
+            .pipe(Effect.mapError(() => new PatdownRulesReadFailed({ patdownRulesFilePath })));
+        const parsed = yield* Effect.try({
+            try: () => parseMarkdownPatdownRules(markdown),
+            catch: (cause) => cause instanceof PatdownYesThresholdInvalid
+                ? cause
+                : new PatdownRulesLoadFailed({
+                    message: cause instanceof Error ? cause.message : String(cause),
+                }),
+        });
+        return {
+            patdownRules: parsed,
+            patdownRulesFilePath,
+        };
+    });
+}
+/** Live patdown rule source that reads markdown (`AGENTS.PATDOWN.md` by default). */
+export const MarkdownPatdownRuleSourceLive = Layer.succeed(PatdownRuleSource, {
+    loadPatdownRules: loadMarkdownPatdownRules,
+});

package/dist/patdown-rule.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One fuzzy patdown rule loaded from a rules file. Globs are optional; an empty list means the rule
+ * applies to the whole run.
+ */
+export type PatdownRule = {
+    readonly patdownRuleBody: string;
+    readonly patdownRuleGlobs: ReadonlyArray<string>;
+    readonly patdownRuleTitle: string;
+    readonly patdownRuleYesThreshold?: number;
+};
+/**
+ * Parsed patdown rules plus an origin path for output. Adapters may use a file, a directory, or
+ * another source label.
+ */
+export type PatdownRulesDocument = {
+    readonly patdownRules: ReadonlyArray<PatdownRule>;
+    readonly patdownRulesFilePath: string;
+};
+/** Default markdown rules file name walked from the working directory. */
+export declare const defaultPatdownRulesFileName = "AGENTS.PATDOWN.md";
+//# sourceMappingURL=patdown-rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-rule.d.ts","sourceRoot":"","sources":["../src/patdown-rule.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAChD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAA;CACzC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAClC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;IACjD,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;CACrC,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,2BAA2B,sBAAsB,CAAA"}

package/dist/patdown-rule.js

@@ -0,0 +1,2 @@
+/** Default markdown rules file name walked from the working directory. */
+export const defaultPatdownRulesFileName = 'AGENTS.PATDOWN.md';

package/dist/patdown-yes-threshold.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from 'effect';
+/** Default cutoff: only probabilities strictly above this count as yes. */
+export declare const defaultPatdownYesThreshold = 0.85;
+declare const PatdownYesThresholdInvalid_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: "PatdownYesThresholdInvalid";
+} & Readonly<A>;
+/** Invalid cutoff from a flag, package.json, or rule metadata. */
+export declare class PatdownYesThresholdInvalid extends PatdownYesThresholdInvalid_base<{
+    readonly message: string;
+}> {
+}
+declare const PatdownYesThresholdNumberSchema: Schema.Finite;
+/** Finite number in `[0, 1)`. Equality uses the same cutoff as `> threshold`. */
+export type PatdownYesThreshold = typeof PatdownYesThresholdNumberSchema.Type;
+/** Decode a CLI, config, or metadata number. 1 is rejected because nothing can exceed it. */
+export declare function decodePatdownYesThreshold(value: number, source: string): PatdownYesThreshold | PatdownYesThresholdInvalid;
+/** Decode a `yes-threshold:` line. */
+export declare function decodePatdownYesThresholdText(value: string, source: string): PatdownYesThreshold | PatdownYesThresholdInvalid;
+/** Shared yes policy: yes iff estimated P(yes) is strictly above the cutoff. */
+export declare function patdownJudgmentIsYes(yesProbability: number, yesThreshold?: PatdownYesThreshold): boolean;
+export {};
+//# sourceMappingURL=patdown-yes-threshold.d.ts.map

package/dist/patdown-yes-threshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-yes-threshold.d.ts","sourceRoot":"","sources":["../src/patdown-yes-threshold.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE7C,2EAA2E;AAC3E,eAAO,MAAM,0BAA0B,OAAO,CAAA;;;;AAE9C,kEAAkE;AAClE,qBAAa,0BAA2B,SAAQ,gCAA+C;IAC9F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACxB,CAAC;CAAG;AAEL,QAAA,MAAM,+BAA+B,eAEpC,CAAA;AAMD,iFAAiF;AACjF,MAAM,MAAM,mBAAmB,GAAG,OAAO,+BAA+B,CAAC,IAAI,CAAA;AA8B7E,6FAA6F;AAC7F,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACZ,mBAAmB,GAAG,0BAA0B,CAElD;AAED,sCAAsC;AACtC,wBAAgB,6BAA6B,CAC5C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACZ,mBAAmB,GAAG,0BAA0B,CAElD;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CACnC,cAAc,EAAE,MAAM,EACtB,YAAY,GAAE,mBAAgD,GAC5D,OAAO,CAET"}

package/dist/patdown-yes-threshold.js

@@ -0,0 +1,37 @@
+import { Data, Result, Schema } from 'effect';
+/** Default cutoff: only probabilities strictly above this count as yes. */
+export const defaultPatdownYesThreshold = 0.85;
+/** Invalid cutoff from a flag, package.json, or rule metadata. */
+export class PatdownYesThresholdInvalid extends Data.TaggedError('PatdownYesThresholdInvalid') {
+}
+const PatdownYesThresholdNumberSchema = Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1, exclusiveMaximum: true }));
+const PatdownYesThresholdTextSchema = Schema.FiniteFromString.pipe(Schema.decodeTo(PatdownYesThresholdNumberSchema));
+function invalidPatdownYesThreshold(source, value) {
+    return new PatdownYesThresholdInvalid({
+        message: `patdown: ${source} must be a finite number in [0, 1); received ${value}`,
+    });
+}
+function decodeYesThresholdNumber(value, source) {
+    const decoded = Schema.decodeResult(PatdownYesThresholdNumberSchema)(value);
+    if (Result.isSuccess(decoded))
+        return decoded.success;
+    return invalidPatdownYesThreshold(source, String(value));
+}
+function decodeYesThresholdText(value, source) {
+    const decoded = Schema.decodeResult(PatdownYesThresholdTextSchema)(value.trim());
+    if (Result.isSuccess(decoded))
+        return decoded.success;
+    return invalidPatdownYesThreshold(source, JSON.stringify(value));
+}
+/** Decode a CLI, config, or metadata number. 1 is rejected because nothing can exceed it. */
+export function decodePatdownYesThreshold(value, source) {
+    return decodeYesThresholdNumber(value, source);
+}
+/** Decode a `yes-threshold:` line. */
+export function decodePatdownYesThresholdText(value, source) {
+    return decodeYesThresholdText(value, source);
+}
+/** Shared yes policy: yes iff estimated P(yes) is strictly above the cutoff. */
+export function patdownJudgmentIsYes(yesProbability, yesThreshold = defaultPatdownYesThreshold) {
+    return yesProbability > yesThreshold;
+}

package/dist/squint-rule-source.d.ts

@@ -0,0 +1,34 @@
+import { Context, Effect, FileSystem, Layer, Option, Path } from 'effect';
+import { type SquintRulesDocument } from '#/squint-rule';
+declare const SquintRulesFileMissing_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: "SquintRulesFileMissing";
+} & Readonly<A>;
+/** No AGENTS.SQUINT.md (or override path) existed walking up from the start directory. */
+export declare class SquintRulesFileMissing extends SquintRulesFileMissing_base<{
+    readonly squintRulesFileName: string;
+    readonly startDirectory: string;
+}> {
+    get message(): string;
+}
+declare const SquintRulesReadFailed_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: "SquintRulesReadFailed";
+} & Readonly<A>;
+/** The rules file existed but could not be read. */
+export declare class SquintRulesReadFailed extends SquintRulesReadFailed_base<{
+    readonly squintRulesFilePath: string;
+}> {
+    get message(): string;
+}
+declare const SquintRuleSource_base: Context.ServiceClass<SquintRuleSource, "@squint/rules/SquintRuleSource", {
+    readonly loadSquintRules: (rulesFilePathOverride: Option.Option<string>) => Effect.Effect<SquintRulesDocument, SquintRulesFileMissing | SquintRulesReadFailed, FileSystem.FileSystem | Path.Path>;
+}>;
+/**
+ * Loads fuzzy squint rules for a run. Swap the live layer to change file format without touching
+ * the CLI command.
+ */
+export declare class SquintRuleSource extends SquintRuleSource_base {
+}
+/** Live squint rule source that reads markdown (`AGENTS.SQUINT.md` by default). */
+export declare const MarkdownSquintRuleSourceLive: Layer.Layer<SquintRuleSource, never, never>;
+export {};
+//# sourceMappingURL=squint-rule-source.d.ts.map

package/dist/squint-rule-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squint-rule-source.d.ts","sourceRoot":"","sources":["../src/squint-rule-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG/E,OAAO,EAA8B,KAAK,mBAAmB,EAAE,MAAM,eAAe,CAAA;;;;AAEpF,0FAA0F;AAC1F,qBAAa,sBAAuB,SAAQ,4BAA2C;IACtF,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAA;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAC/B,CAAC;IACD,IAAa,OAAO,IAAI,MAAM,CAE7B;CACD;;;;AAED,oDAAoD;AACpD,qBAAa,qBAAsB,SAAQ,2BAA0C;IACpF,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAA;CACpC,CAAC;IACD,IAAa,OAAO,IAAI,MAAM,CAE7B;CACD;;8BAS2B,CACzB,qBAAqB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KACxC,MAAM,CAAC,MAAM,CACjB,mBAAmB,EACnB,sBAAsB,GAAG,qBAAqB,EAC9C,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CACjC;;AAbH;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,qBAWD;CAAG;AA2FxC,mFAAmF;AACnF,eAAO,MAAM,4BAA4B,6CAEvC,CAAA"}

package/dist/squint-rule-source.js

@@ -0,0 +1,78 @@
+import { Context, Data, Effect, FileSystem, Layer, Option, Path } from 'effect';
+import { parseMarkdownSquintRules } from '#/markdown-squint-rule-parser';
+import { defaultSquintRulesFileName } from '#/squint-rule';
+/** No AGENTS.SQUINT.md (or override path) existed walking up from the start directory. */
+export class SquintRulesFileMissing extends Data.TaggedError('SquintRulesFileMissing') {
+    get message() {
+        return `squint: no ${this.squintRulesFileName} found walking up from ${this.startDirectory}`;
+    }
+}
+/** The rules file existed but could not be read. */
+export class SquintRulesReadFailed extends Data.TaggedError('SquintRulesReadFailed') {
+    get message() {
+        return `squint: failed to read ${this.squintRulesFilePath}`;
+    }
+}
+/**
+ * Loads fuzzy squint rules for a run. Swap the live layer to change file format without touching
+ * the CLI command.
+ */
+export class SquintRuleSource extends Context.Service()('@squint/rules/SquintRuleSource') {
+}
+function pathExists(filePath) {
+    return FileSystem.FileSystem.use((fileSystem) => fileSystem
+        .exists(filePath)
+        .pipe(Effect.mapError(() => new SquintRulesReadFailed({ squintRulesFilePath: filePath }))));
+}
+function findSquintRulesFilePath(startDirectory, fileName) {
+    return Effect.gen(function* () {
+        const path = yield* Path.Path;
+        let directory = startDirectory;
+        while (true) {
+            const candidate = path.join(directory, fileName);
+            if (yield* pathExists(candidate))
+                return candidate;
+            const parent = path.dirname(directory);
+            if (parent === directory) {
+                return yield* new SquintRulesFileMissing({
+                    squintRulesFileName: fileName,
+                    startDirectory,
+                });
+            }
+            directory = parent;
+        }
+    });
+}
+function resolveSquintRulesFilePath(rulesFilePathOverride) {
+    return Effect.gen(function* () {
+        const path = yield* Path.Path;
+        const startDirectory = path.resolve('.');
+        if (Option.isNone(rulesFilePathOverride)) {
+            return yield* findSquintRulesFilePath(startDirectory, defaultSquintRulesFileName);
+        }
+        const candidate = path.resolve(startDirectory, rulesFilePathOverride.value);
+        if (yield* pathExists(candidate))
+            return candidate;
+        return yield* new SquintRulesFileMissing({
+            squintRulesFileName: rulesFilePathOverride.value,
+            startDirectory,
+        });
+    });
+}
+function loadMarkdownSquintRules(rulesFilePathOverride) {
+    return Effect.gen(function* () {
+        const squintRulesFilePath = yield* resolveSquintRulesFilePath(rulesFilePathOverride);
+        const fileSystem = yield* FileSystem.FileSystem;
+        const markdown = yield* fileSystem
+            .readFileString(squintRulesFilePath)
+            .pipe(Effect.mapError(() => new SquintRulesReadFailed({ squintRulesFilePath })));
+        return {
+            squintRules: parseMarkdownSquintRules(markdown),
+            squintRulesFilePath,
+        };
+    });
+}
+/** Live squint rule source that reads markdown (`AGENTS.SQUINT.md` by default). */
+export const MarkdownSquintRuleSourceLive = Layer.succeed(SquintRuleSource, {
+    loadSquintRules: loadMarkdownSquintRules,
+});

package/dist/squint-rule.d.ts

@@ -0,0 +1,17 @@
+/**
+ * One fuzzy squint rule loaded from a rules file. Globs are optional; an empty list means the rule
+ * applies to the whole run.
+ */
+export type SquintRule = {
+    readonly squintRuleBody: string;
+    readonly squintRuleGlobs: ReadonlyArray<string>;
+    readonly squintRuleTitle: string;
+};
+/** Parsed squint rules plus the file they were loaded from. */
+export type SquintRulesDocument = {
+    readonly squintRules: ReadonlyArray<SquintRule>;
+    readonly squintRulesFilePath: string;
+};
+/** Default markdown rules file name walked from the working directory. */
+export declare const defaultSquintRulesFileName = "AGENTS.SQUINT.md";
+//# sourceMappingURL=squint-rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"squint-rule.d.ts","sourceRoot":"","sources":["../src/squint-rule.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC/C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAChC,CAAA;AAED,+DAA+D;AAC/D,MAAM,MAAM,mBAAmB,GAAG;IACjC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAC/C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAA;CACpC,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,0BAA0B,qBAAqB,CAAA"}

package/dist/squint-rule.js

@@ -0,0 +1,2 @@
+/** Default markdown rules file name walked from the working directory. */
+export const defaultSquintRulesFileName = 'AGENTS.SQUINT.md';

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@patdown/rules",
+  "version": "0.3.1",
+  "description": "Fuzzy patdown rule types and markdown rule loading",
+  "homepage": "https://github.com/tyler-dot-earth/patdown",
+  "bugs": {
+    "url": "https://github.com/tyler-dot-earth/patdown/issues"
+  },
+  "license": "0BSD",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tyler-dot-earth/patdown.git",
+    "directory": "packages/patdown-rules"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "imports": {
+    "#src/*": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "test": "./src/*.ts",
+      "node": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "test": "./dist/index.js",
+      "node": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.3",
+    "@vitest/coverage-v8": "^4.1.11",
+    "oxfmt": "^0.65.0",
+    "oxlint": "1.80.0",
+    "oxlint-tsgolint": "^7.0.2001",
+    "typescript": "7.0.2",
+    "vitest": "^4.1.11",
+    "@patdown/oxlint-config": "0.0.0",
+    "@patdown/tsconfig": "0.0.0"
+  },
+  "engines": {
+    "node": ">=22.22.2"
+  },
+  "scripts": {
+    "build": "node ../../scripts/warn-direct-package-task.mjs build && tsc -p tsconfig.build.json",
+    "check": "node ../../scripts/warn-direct-package-task.mjs check && pnpm run lint && pnpm run format:check && pnpm run typecheck && pnpm run test",
+    "clean": "rm -rf dist coverage",
+    "format": "oxfmt --write .",
+    "format:check": "node ../../scripts/warn-direct-package-task.mjs format:check && oxfmt --check .",
+    "lint": "node ../../scripts/warn-direct-package-task.mjs lint && oxlint --disable-nested-config -c ./oxlint.config.ts --tsconfig ./tsconfig.app.json .",
+    "test": "node ../../scripts/warn-direct-package-task.mjs test && vitest run",
+    "typecheck": "node ../../scripts/warn-direct-package-task.mjs typecheck && tsc -p tsconfig.app.json --incremental --tsBuildInfoFile typecheck.app.tsbuildinfo && tsc -p tsconfig.vitest.json --incremental --tsBuildInfoFile typecheck.vitest.tsbuildinfo"
+  }
+}