patdown 0.3.1

package/dist/patdown-output.d.ts

@@ -0,0 +1,27 @@
+import type { PatdownRulesDocument } from '@patdown/rules';
+import { type PatdownYesThreshold } from '@patdown/rules';
+import { Context, Effect, Layer } from 'effect';
+import { type PatdownJudgment } from '#src/patdown-judge';
+/** One file/rule result; probability estimates a violation, not correctness of the verdict. */
+export type PatdownLintResult = {
+    readonly violated: boolean;
+    readonly ruleTitle: string;
+    readonly filePath: string;
+    readonly violationProbability: number;
+    readonly yesThreshold: PatdownYesThreshold;
+};
+declare const PatdownOutput_base: Context.ServiceClass<PatdownOutput, "@patdown/cli/PatdownOutput", {
+    readonly writeLintFailed: Effect.Effect<void>;
+    readonly writeLintOk: Effect.Effect<void>;
+    readonly writeLintResult: (result: PatdownLintResult, verbose: boolean) => Effect.Effect<void>;
+    readonly writeNoFilesMatched: (ruleTitle: string) => Effect.Effect<void>;
+    readonly writeAnswer: (judgment: PatdownJudgment, verbose: boolean, yesThreshold?: PatdownYesThreshold) => Effect.Effect<void>;
+    readonly writeRulesDocument: (document: PatdownRulesDocument) => Effect.Effect<void>;
+}>;
+/** Swappable output service. Probability details are opt-in. */
+export declare class PatdownOutput extends PatdownOutput_base {
+}
+/** Default human-readable output, without provider-specific vocabulary. */
+export declare const PatdownOutputLive: Layer.Layer<PatdownOutput, never, never>;
+export {};
+//# sourceMappingURL=patdown-output.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-output.d.ts","sourceRoot":"","sources":["../src/patdown-output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EAA8B,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACrF,OAAO,EAAW,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAExD,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAE/E,+FAA+F;AAC/F,MAAM,MAAM,iBAAiB,GAAG;IAC/B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAA;CAC1C,CAAA;;8BAmD2B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;0BACvB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;8BACf,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;kCAChE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;0BAClD,CACrB,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,OAAO,EAChB,YAAY,CAAC,EAAE,mBAAmB,KAC9B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;iCACK,CAAC,QAAQ,EAAE,oBAAoB,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;;AAbtF,gEAAgE;AAChE,qBAAa,aAAc,SAAQ,kBAcF;CAAG;AAEpC,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,0CAQ5B,CAAA"}

package/dist/patdown-output.js

@@ -0,0 +1,45 @@
+import { defaultPatdownYesThreshold } from '@patdown/rules';
+import { Console, Context, Effect, Layer } from 'effect';
+import { patdownJudgmentIsYes } from '#src/patdown-judge';
+function formatPatdownProbability(probability, yesThreshold) {
+    return `estimated P(yes): ${String(probability)}; cutoff: >${String(yesThreshold)}`;
+}
+function formatPatdownAnswer(judgment, verbose, yesThreshold) {
+    const answer = patdownJudgmentIsYes(judgment, yesThreshold) ? 'yes' : 'no';
+    return verbose
+        ? `${answer} (${formatPatdownProbability(judgment.yesProbability, yesThreshold)})`
+        : answer;
+}
+function formatPatdownLintResult(result, verbose) {
+    const verdict = result.violated ? 'FAIL' : 'PASS';
+    const line = `${verdict} ${result.filePath}: ${result.ruleTitle}`;
+    return verbose
+        ? `${line} (${formatPatdownProbability(result.violationProbability, result.yesThreshold)})`
+        : line;
+}
+function formatPatdownRulesDocument(document) {
+    const lines = [
+        `patdown: ${String(document.patdownRules.length)} rules from ${document.patdownRulesFilePath}`,
+    ];
+    for (const rule of document.patdownRules) {
+        lines.push('');
+        lines.push(rule.patdownRuleTitle);
+        lines.push(`globs: ${rule.patdownRuleGlobs.length === 0 ? '*' : rule.patdownRuleGlobs.join(' ')}`);
+        if (rule.patdownRuleYesThreshold !== undefined) {
+            lines.push(`yes-threshold: ${String(rule.patdownRuleYesThreshold)}`);
+        }
+    }
+    return lines.join('\n');
+}
+/** Swappable output service. Probability details are opt-in. */
+export class PatdownOutput extends Context.Service()('@patdown/cli/PatdownOutput') {
+}
+/** Default human-readable output, without provider-specific vocabulary. */
+export const PatdownOutputLive = Layer.succeed(PatdownOutput, {
+    writeLintFailed: Console.log('patdown: failed'),
+    writeLintOk: Console.log('patdown: ok'),
+    writeLintResult: (result, verbose) => Console.log(formatPatdownLintResult(result, verbose)),
+    writeNoFilesMatched: (title) => Console.log(`patdown: no files matched ${title}`),
+    writeAnswer: (judgment, verbose, yesThreshold = defaultPatdownYesThreshold) => Console.log(formatPatdownAnswer(judgment, verbose, yesThreshold)),
+    writeRulesDocument: (document) => Console.log(formatPatdownRulesDocument(document)),
+});

package/dist/patdown-package-config.d.ts

@@ -0,0 +1,15 @@
+import { PatdownRulesLoadFailed, PatdownYesThresholdInvalid, type PatdownYesThreshold } from '@patdown/rules';
+import { Effect, FileSystem } from 'effect';
+export type PatdownPackageConfig = {
+    readonly adapter?: string;
+    readonly fromDirectory: string;
+    readonly yesThreshold?: PatdownYesThreshold;
+};
+/**
+ * Walks from cwd for package.json `patdown` settings. A nearer file without adapter/yesThreshold
+ * does not hide a parent that has them. Invalid JSON fails immediately.
+ */
+export declare function discoverPatdownPackageConfig(startDirectory?: string): Effect.Effect<PatdownPackageConfig | null, PatdownRulesLoadFailed | PatdownYesThresholdInvalid, FileSystem.FileSystem>;
+/** Reads only a cutoff from package.json. Broken adapter config is skipped for `ask`. */
+export declare function discoverPatdownYesThresholdConfig(startDirectory?: string): Effect.Effect<PatdownYesThreshold | null, PatdownYesThresholdInvalid, FileSystem.FileSystem>;
+//# sourceMappingURL=patdown-package-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-package-config.d.ts","sourceRoot":"","sources":["../src/patdown-package-config.ts"],"names":[],"mappings":"AAEA,OAAO,EAEN,sBAAsB,EACtB,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,MAAM,QAAQ,CAAA;AAanD,MAAM,MAAM,oBAAoB,GAAG;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAA;CAC3C,CAAA;AAoID;;;GAGG;AACH,wBAAgB,4BAA4B,CAC3C,cAAc,GAAE,MAAsB,GACpC,MAAM,CAAC,MAAM,CACf,oBAAoB,GAAG,IAAI,EAC3B,sBAAsB,GAAG,0BAA0B,EACnD,UAAU,CAAC,UAAU,CACrB,CAgCA;AAED,yFAAyF;AACzF,wBAAgB,iCAAiC,CAChD,cAAc,GAAE,MAAsB,GACpC,MAAM,CAAC,MAAM,CAAC,mBAAmB,GAAG,IAAI,EAAE,0BAA0B,EAAE,UAAU,CAAC,UAAU,CAAC,CAmB9F"}

package/dist/patdown-package-config.js

@@ -0,0 +1,123 @@
+import { dirname, join, resolve } from 'node:path';
+import { decodePatdownYesThreshold, PatdownRulesLoadFailed, PatdownYesThresholdInvalid, } from '@patdown/rules';
+import { Effect, FileSystem, Schema } from 'effect';
+const PatdownPackageJsonSchema = Schema.fromJsonString(Schema.Struct({
+    patdown: Schema.optionalKey(Schema.Struct({
+        adapter: Schema.optionalKey(Schema.NonEmptyString),
+        yesThreshold: Schema.optionalKey(Schema.Finite),
+    })),
+}));
+function decodeConfiguredYesThreshold(value, filename) {
+    const decoded = decodePatdownYesThreshold(value, `package.json ${filename} patdown.yesThreshold`);
+    return decoded instanceof PatdownYesThresholdInvalid
+        ? Effect.fail(decoded)
+        : Effect.succeed(decoded);
+}
+function failedPackageJson(filename) {
+    return new PatdownRulesLoadFailed({
+        message: `patdown: failed to read ${filename}`,
+    });
+}
+function decodedPackageJson(adapter, yesThreshold) {
+    const decoded = {};
+    return {
+        ...(adapter === undefined ? decoded : { ...decoded, adapter }),
+        ...(yesThreshold === undefined ? decoded : { ...decoded, yesThreshold }),
+    };
+}
+function readPatdownPackageJson(filename) {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const exists = yield* fs
+            .exists(filename)
+            .pipe(Effect.mapError(() => failedPackageJson(filename)));
+        if (!exists)
+            return null;
+        const text = yield* fs
+            .readFileString(filename)
+            .pipe(Effect.mapError(() => failedPackageJson(filename)));
+        const decoded = yield* Schema.decodeEffect(PatdownPackageJsonSchema)(text).pipe(Effect.mapError((cause) => new PatdownRulesLoadFailed({
+            message: `patdown: invalid adapter config ${filename}: ${String(cause)}`,
+        })));
+        if (decoded.patdown === undefined)
+            return {};
+        return decodedPackageJson(decoded.patdown.adapter, decoded.patdown.yesThreshold);
+    });
+}
+function collectPackageConfig(directory, adapter, yesThresholdValue, decoded) {
+    const nextAdapter = adapter ??
+        (decoded.adapter === undefined
+            ? undefined
+            : { moduleSpecifier: decoded.adapter, fromDirectory: directory });
+    const nextYesThreshold = yesThresholdValue ??
+        (decoded.yesThreshold === undefined
+            ? undefined
+            : { value: decoded.yesThreshold, filename: join(directory, 'package.json') });
+    const collected = {
+        adapter: nextAdapter,
+        yesThresholdValue: nextYesThreshold,
+    };
+    return collected;
+}
+function packageConfigFromDiscovery(directory, adapter, yesThreshold) {
+    const config = {
+        fromDirectory: adapter?.fromDirectory ?? directory,
+    };
+    if (adapter !== undefined && yesThreshold !== undefined) {
+        return { ...config, adapter: adapter.moduleSpecifier, yesThreshold };
+    }
+    if (adapter !== undefined) {
+        return { ...config, adapter: adapter.moduleSpecifier };
+    }
+    if (yesThreshold !== undefined) {
+        return { ...config, yesThreshold };
+    }
+    return config;
+}
+/**
+ * Walks from cwd for package.json `patdown` settings. A nearer file without adapter/yesThreshold
+ * does not hide a parent that has them. Invalid JSON fails immediately.
+ */
+export function discoverPatdownPackageConfig(startDirectory = process.cwd()) {
+    return Effect.gen(function* () {
+        let directory = resolve(startDirectory);
+        let adapter;
+        let yesThresholdValue;
+        while (adapter === undefined || yesThresholdValue === undefined) {
+            const filename = join(directory, 'package.json');
+            const decoded = yield* readPatdownPackageJson(filename);
+            if (decoded !== null) {
+                const collected = collectPackageConfig(directory, adapter, yesThresholdValue, decoded);
+                adapter = collected.adapter;
+                yesThresholdValue = collected.yesThresholdValue;
+            }
+            const parent = dirname(directory);
+            if (parent === directory)
+                break;
+            directory = parent;
+        }
+        if (adapter === undefined && yesThresholdValue === undefined)
+            return null;
+        const yesThreshold = yesThresholdValue === undefined
+            ? undefined
+            : yield* decodeConfiguredYesThreshold(yesThresholdValue.value, yesThresholdValue.filename);
+        return packageConfigFromDiscovery(directory, adapter, yesThreshold);
+    });
+}
+/** Reads only a cutoff from package.json. Broken adapter config is skipped for `ask`. */
+export function discoverPatdownYesThresholdConfig(startDirectory = process.cwd()) {
+    return Effect.gen(function* () {
+        let directory = resolve(startDirectory);
+        while (true) {
+            const filename = join(directory, 'package.json');
+            const decoded = yield* readPatdownPackageJson(filename).pipe(Effect.orElseSucceed(() => null));
+            if (decoded?.yesThreshold !== undefined) {
+                return yield* decodeConfiguredYesThreshold(decoded.yesThreshold, filename);
+            }
+            const parent = dirname(directory);
+            if (parent === directory)
+                return null;
+            directory = parent;
+        }
+    });
+}

package/dist/patdown-question-input.d.ts

@@ -0,0 +1,5 @@
+import { Effect, Option, Stdio } from 'effect';
+import { PatdownJudgeFailed } from '#src/patdown-judge';
+/** Reads piped UTF-8 input only when requested; explicit text and stdin are mutually exclusive. */
+export declare function readPatdownQuestionInput(inputText: Option.Option<string>, stdin: boolean): Effect.Effect<string, PatdownJudgeFailed, Stdio.Stdio>;
+//# sourceMappingURL=patdown-question-input.d.ts.map

package/dist/patdown-question-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-question-input.d.ts","sourceRoot":"","sources":["../src/patdown-question-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAA;AAEtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAEvD,mGAAmG;AACnG,wBAAgB,wBAAwB,CACvC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAChC,KAAK,EAAE,OAAO,GACZ,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,KAAK,CAAC,CAwBxD"}

package/dist/patdown-question-input.js

@@ -0,0 +1,21 @@
+import { Effect, Option, Stdio, Stream } from 'effect';
+import { PatdownJudgeFailed } from '#src/patdown-judge';
+/** Reads piped UTF-8 input only when requested; explicit text and stdin are mutually exclusive. */
+export function readPatdownQuestionInput(inputText, stdin) {
+    return Effect.gen(function* () {
+        if (stdin && Option.isSome(inputText)) {
+            return yield* new PatdownJudgeFailed({
+                message: 'patdown: choose either --input-text or --stdin, not both',
+            });
+        }
+        if (!stdin)
+            return Option.getOrElse(inputText, () => '');
+        const stdio = yield* Stdio.Stdio;
+        if (yield* stdio.stdinIsTerminal) {
+            return yield* new PatdownJudgeFailed({
+                message: 'patdown: --stdin requires piped or redirected input',
+            });
+        }
+        return yield* stdio.stdin.pipe(Stream.decodeText(), Stream.mkString, Effect.mapError(() => new PatdownJudgeFailed({ message: 'patdown: failed to read stdin' })));
+    });
+}

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

@@ -0,0 +1,10 @@
+import { PatdownRuleSource, PatdownRulesLoadFailed, type PatdownRulesDocument } from '@patdown/rules';
+import { Effect, FileSystem, Layer, Option, Path } from 'effect';
+/**
+ * Adapter layers may acquire resources using FileSystem and Path; provide other dependencies
+ * internally.
+ */
+export type PatdownRuleSourceLayer = Layer.Layer<PatdownRuleSource, PatdownRulesLoadFailed, FileSystem.FileSystem | Path.Path>;
+/** Loads configured rules only for lint/rules. Imported adapter resources close after loading. */
+export declare function loadConfiguredPatdownRules(adapter: Option.Option<string>, rules: Option.Option<string>): Effect.Effect<PatdownRulesDocument, PatdownRulesLoadFailed, PatdownRuleSource | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=patdown-rule-source-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-rule-source-adapter.d.ts","sourceRoot":"","sources":["../src/patdown-rule-source-adapter.ts"],"names":[],"mappings":"AAGA,OAAO,EACN,iBAAiB,EACjB,sBAAsB,EACtB,KAAK,oBAAoB,EACzB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAkB,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAU,MAAM,QAAQ,CAAA;AAmBxF;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,KAAK,CAAC,KAAK,CAC/C,iBAAiB,EACjB,sBAAsB,EACtB,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CACjC,CAAA;AA2DD,kGAAkG;AAClG,wBAAgB,0BAA0B,CACzC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAC1B,MAAM,CAAC,MAAM,CACf,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,GAAG,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CACrD,CA4CA"}

package/dist/patdown-rule-source-adapter.js

@@ -0,0 +1,83 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { isAbsolute, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { PatdownRuleSource, PatdownRulesLoadFailed, } from '@patdown/rules';
+import { Cause, Context, Effect, FileSystem, Layer, Option, Path, Schema } from 'effect';
+import { resolve as resolveModule } from 'import-meta-resolve';
+import { discoverPatdownPackageConfig } from '#src/patdown-package-config';
+const AdapterModuleSchema = Schema.Struct({ PatdownRuleSourceLive: Schema.Unknown });
+const RulesDocumentSchema = Schema.Struct({
+    patdownRulesFilePath: Schema.String,
+    patdownRules: Schema.Array(Schema.Struct({
+        patdownRuleTitle: Schema.String,
+        patdownRuleBody: Schema.String,
+        patdownRuleGlobs: Schema.Array(Schema.String),
+        patdownRuleYesThreshold: Schema.optionalKey(Schema.Finite),
+    })),
+});
+function importPatdownAdapter(moduleSpecifier, fromDirectory) {
+    return Effect.gen(function* () {
+        const imported = yield* Effect.tryPromise({
+            // Raw module import is the untyped I/O boundary. The next Effect step decodes it,
+            // preserving schema failures in the error channel instead of decoding synchronously here.
+            // oxlint-disable-next-line anti-slop/no-unknown-returns
+            try: async () => {
+                const importUrl = moduleSpecifier.startsWith('.') || isAbsolute(moduleSpecifier)
+                    ? pathToFileURL(resolve(fromDirectory, moduleSpecifier)).href
+                    : resolveModule(moduleSpecifier, pathToFileURL(join(fromDirectory, 'package.json')).href);
+                const exports = await import(__rewriteRelativeImportExtension(importUrl));
+                return exports;
+            },
+            catch: (cause) => new PatdownRulesLoadFailed({
+                message: cause instanceof Error ? cause.message : String(cause),
+            }),
+        });
+        const decoded = yield* Schema.decodeUnknownEffect(AdapterModuleSchema)(imported);
+        if (!Layer.isLayer(decoded.PatdownRuleSourceLive)) {
+            return yield* new PatdownRulesLoadFailed({
+                message: 'patdown: adapter must export a PatdownRuleSourceLive Layer',
+            });
+        }
+        // SAFETY: The boundary retains unknown failures/output. Host requirements alone are asserted;
+        // missing dependencies are caught at build, and service presence and returned rules are checked.
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+        return decoded.PatdownRuleSourceLive;
+    }).pipe(Effect.mapError((cause) => new PatdownRulesLoadFailed({
+        message: `patdown: cannot import adapter ${moduleSpecifier}: ${cause instanceof Error ? cause.message : String(cause)}`,
+    })));
+}
+/** Loads configured rules only for lint/rules. Imported adapter resources close after loading. */
+export function loadConfiguredPatdownRules(adapter, rules) {
+    return Effect.scoped(Effect.gen(function* () {
+        const selected = Option.isSome(adapter)
+            ? { moduleSpecifier: adapter.value, fromDirectory: process.cwd() }
+            : yield* discoverPatdownPackageConfig().pipe(Effect.map((config) => config?.adapter === undefined
+                ? null
+                : { moduleSpecifier: config.adapter, fromDirectory: config.fromDirectory }));
+        if (selected === null) {
+            const source = yield* PatdownRuleSource;
+            return yield* source.loadPatdownRules(rules);
+        }
+        const layer = yield* importPatdownAdapter(selected.moduleSpecifier, selected.fromDirectory);
+        const context = yield* Layer.build(layer);
+        const source = Context.getOption(context, PatdownRuleSource);
+        if (Option.isNone(source)) {
+            return yield* new PatdownRulesLoadFailed({
+                message: 'patdown: adapter Layer did not provide PatdownRuleSource',
+            });
+        }
+        const document = yield* source.value.loadPatdownRules(rules);
+        return yield* Schema.decodeUnknownEffect(RulesDocumentSchema)(document);
+    })).pipe(Effect.catchCause((cause) => Effect.fail(new PatdownRulesLoadFailed({
+        message: `patdown: failed to load rules: ${Cause.prettyErrors(cause)
+            .map((error) => error.message)
+            .join('; ')}`,
+    }))));
+}

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

@@ -0,0 +1,7 @@
+import { PatdownYesThresholdInvalid, type PatdownYesThreshold } from '@patdown/rules';
+import { Effect, FileSystem, Option } from 'effect';
+/** CLI flag wins, then package.json, then the default 0.85 cutoff. */
+export declare function resolvePatdownYesThreshold(flag: Option.Option<number>): Effect.Effect<PatdownYesThreshold, PatdownYesThresholdInvalid, FileSystem.FileSystem>;
+/** Decode a markdown or adapter-supplied per-rule cutoff. */
+export declare function decodePatdownRuleYesThreshold(value: number, ruleTitle: string): Effect.Effect<PatdownYesThreshold, PatdownYesThresholdInvalid>;
+//# sourceMappingURL=patdown-yes-threshold-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patdown-yes-threshold-config.d.ts","sourceRoot":"","sources":["../src/patdown-yes-threshold-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAInD,sEAAsE;AACtE,wBAAgB,0BAA0B,CACzC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GACzB,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,0BAA0B,EAAE,UAAU,CAAC,UAAU,CAAC,CAYvF;AAED,6DAA6D;AAC7D,wBAAgB,6BAA6B,CAC5C,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,0BAA0B,CAAC,CAShE"}

package/dist/patdown-yes-threshold-config.js

@@ -0,0 +1,20 @@
+import { decodePatdownYesThreshold, defaultPatdownYesThreshold, PatdownYesThresholdInvalid, } from '@patdown/rules';
+import { Effect, FileSystem, Option } from 'effect';
+import { discoverPatdownYesThresholdConfig } from '#src/patdown-package-config';
+/** CLI flag wins, then package.json, then the default 0.85 cutoff. */
+export function resolvePatdownYesThreshold(flag) {
+    if (Option.isSome(flag)) {
+        const decoded = decodePatdownYesThreshold(flag.value, '--yes-threshold');
+        return decoded instanceof PatdownYesThresholdInvalid
+            ? Effect.fail(decoded)
+            : Effect.succeed(decoded);
+    }
+    return discoverPatdownYesThresholdConfig().pipe(Effect.map((configured) => configured ?? defaultPatdownYesThreshold));
+}
+/** Decode a markdown or adapter-supplied per-rule cutoff. */
+export function decodePatdownRuleYesThreshold(value, ruleTitle) {
+    const decoded = decodePatdownYesThreshold(value, `rule ${JSON.stringify(ruleTitle)} yes-threshold`);
+    return decoded instanceof PatdownYesThresholdInvalid
+        ? Effect.fail(decoded)
+        : Effect.succeed(decoded);
+}

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

@@ -0,0 +1,12 @@
+import { type PatdownRulesLoadFailed } from '@patdown/rules';
+import { Effect, Layer } from 'effect';
+import type { CliError } from 'effect/unstable/cli/CliError';
+import type { PatdownJudge, PatdownJudgeFailed } from '#src/patdown-judge';
+import { type PatdownOutput } from '#src/patdown-output';
+import type { PatdownRuleSourceLayer } from '#src/patdown-rule-source-adapter';
+/**
+ * Returns a runnable CLI Effect. A supplied rule source disables discovery; argv excludes node and
+ * script. The third and fourth arguments replace the judge and output layers independently.
+ */
+export declare function runPatdownCli(ruleSourceLayer?: PatdownRuleSourceLayer, argv?: readonly string[], judgeLayer?: Layer.Layer<PatdownJudge, PatdownJudgeFailed>, outputLayer?: Layer.Layer<PatdownOutput>): Effect.Effect<void, PatdownRulesLoadFailed | PatdownJudgeFailed | CliError>;
+//# sourceMappingURL=run-patdown-cli.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-patdown-cli.d.ts","sourceRoot":"","sources":["../src/run-patdown-cli.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAC3F,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAEtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAI5D,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAC1E,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAC3E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAG9E;;;GAGG;AACH,wBAAgB,aAAa,CAC5B,eAAe,CAAC,EAAE,sBAAsB,EACxC,IAAI,GAAE,SAAS,MAAM,EAA0B,EAC/C,UAAU,GAAE,KAAK,CAAC,KAAK,CAAC,YAAY,EAAE,kBAAkB,CAAqB,EAC7E,WAAW,GAAE,KAAK,CAAC,KAAK,CAAC,aAAa,CAAqB,GACzD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,sBAAsB,GAAG,kBAAkB,GAAG,QAAQ,CAAC,CAS7E"}

package/dist/run-patdown-cli.js

@@ -0,0 +1,17 @@
+import { NodeServices } from '@effect/platform-node';
+import { MarkdownPatdownRuleSourceLive } from '@patdown/rules';
+import { Effect, Layer } from 'effect';
+import { Command } from 'effect/unstable/cli';
+import { makePatdownCommand } from '#src/cli';
+import { patdownCliVersion } from '#src/patdown-cli-version';
+import { PatdownOutputLive } from '#src/patdown-output';
+import { TypeSafeJudgeLive } from '#src/typesafe-judge';
+/**
+ * Returns a runnable CLI Effect. A supplied rule source disables discovery; argv excludes node and
+ * script. The third and fourth arguments replace the judge and output layers independently.
+ */
+export function runPatdownCli(ruleSourceLayer, argv = process.argv.slice(2), judgeLayer = TypeSafeJudgeLive, outputLayer = PatdownOutputLive) {
+    const command = makePatdownCommand(ruleSourceLayer === undefined);
+    const source = ruleSourceLayer ?? MarkdownPatdownRuleSourceLive;
+    return Command.runWith(command, { version: patdownCliVersion })(argv).pipe(Effect.provide(Layer.mergeAll(source, judgeLayer, outputLayer).pipe(Layer.provideMerge(NodeServices.layer))));
+}

package/dist/squint-lint.d.ts

@@ -0,0 +1,7 @@
+import { JevRequestFailed, JevSystemOne } from '@squint/jev';
+import type { SquintRulesDocument } from '@squint/rules';
+import { Effect, FileSystem, Path } from 'effect';
+import type { HttpClient } from 'effect/unstable/http';
+/** Lint files matched by each rule's globs. Yes on the noul means a violation. */
+export declare function runSquintLint(document: SquintRulesDocument): Effect.Effect<boolean, JevRequestFailed, FileSystem.FileSystem | HttpClient.HttpClient | JevSystemOne | Path.Path>;
+//# sourceMappingURL=squint-lint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"squint-lint.d.ts","sourceRoot":"","sources":["../src/squint-lint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAqC,MAAM,aAAa,CAAA;AAC/F,OAAO,KAAK,EAAc,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACpE,OAAO,EAAW,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAiItD,kFAAkF;AAClF,wBAAgB,aAAa,CAC5B,QAAQ,EAAE,mBAAmB,GAC3B,MAAM,CAAC,MAAM,CACf,OAAO,EACP,gBAAgB,EAChB,UAAU,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,GAAG,YAAY,GAAG,IAAI,CAAC,IAAI,CACxE,CAaA"}

package/dist/squint-lint.js

@@ -0,0 +1,80 @@
+import { JevRequestFailed, JevSystemOne, jevNoulIsYes, jevNoulYesThreshold } from '@squint/jev';
+import { Console, Effect, FileSystem, Path } from 'effect';
+const squintGlobExcludes = [
+    '**/.git/**',
+    '**/.turbo/**',
+    '**/coverage/**',
+    '**/dist/**',
+    '**/node_modules/**',
+];
+function squintGlobPatterns(globs) {
+    return globs.length === 0 ? ['**/*'] : globs;
+}
+function squintViolationInstructions(rule) {
+    return [
+        'Does this file violate the following squint rule? Answer yes only if there is a clear violation.',
+        '',
+        `# ${rule.squintRuleTitle}`,
+        '',
+        rule.squintRuleBody,
+    ].join('\n');
+}
+function squintFileState(relativePath, contents) {
+    return `path: ${relativePath}\n\n${contents}`;
+}
+function renderSquintLintLine(failed, ruleTitle, relativePath, noul) {
+    const verdict = failed ? 'fail' : 'pass';
+    return `squint: ${verdict} ${ruleTitle} ${relativePath} (${String(noul)}, threshold ${String(jevNoulYesThreshold)})`;
+}
+function globSquintRuleFiles(cwd, globs) {
+    return Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const patterns = squintGlobPatterns(globs);
+        const matches = [];
+        for (const pattern of patterns) {
+            const found = yield* fileSystem
+                .glob(pattern, {
+                exclude: squintGlobExcludes,
+                root: cwd,
+            })
+                .pipe(Effect.orElseSucceed(() => []));
+            matches.push(...found);
+        }
+        return [...new Set(matches)].toSorted();
+    });
+}
+function lintSquintRuleFile(rule, cwd, filePath) {
+    return Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const jev = yield* JevSystemOne;
+        const relativePath = path.relative(cwd, filePath);
+        const contents = yield* fileSystem.readFileString(filePath).pipe(Effect.mapError(() => new JevRequestFailed({
+            message: `squint: failed to read ${relativePath}`,
+        })));
+        const answer = yield* jev.askNoul(squintViolationInstructions(rule), squintFileState(relativePath, contents));
+        const failed = jevNoulIsYes(answer.noul);
+        yield* Console.log(renderSquintLintLine(failed, rule.squintRuleTitle, relativePath, answer.noul));
+        return failed;
+    });
+}
+function lintSquintRule(rule, cwd) {
+    return Effect.gen(function* () {
+        const files = yield* globSquintRuleFiles(cwd, rule.squintRuleGlobs);
+        if (files.length === 0) {
+            yield* Console.log(`squint: no files matched ${rule.squintRuleTitle}`);
+            return false;
+        }
+        const failures = yield* Effect.forEach(files, (filePath) => lintSquintRuleFile(rule, cwd, filePath), { concurrency: 1 });
+        return failures.some((failed) => failed);
+    });
+}
+/** Lint files matched by each rule's globs. Yes on the noul means a violation. */
+export function runSquintLint(document) {
+    return Effect.gen(function* () {
+        const path = yield* Path.Path;
+        const cwd = path.resolve('.');
+        const failures = yield* Effect.forEach(document.squintRules, (rule) => lintSquintRule(rule, cwd), { concurrency: 1 });
+        return failures.some((failed) => failed);
+    });
+}

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/cli/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,qBAWH;CAAG;AA2FtC,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/cli/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,
+});