@kweaver-ai/kweaver-sdk 0.8.1 → 0.8.3

package/dist/trace-ai/eval-set/builder.d.ts

@@ -0,0 +1,36 @@
+/**
+ * M5 eval-set builder — orchestrates build:
+ *   picker → ensureQueryId → redact → write (with conflict resolution) → validate
+ *
+ * `ensureQueryId` is the deterministic hash-based ID generator (inline here,
+ * not a separate file — spec doc §9 "反过度工程" decision).
+ */
+import type { BuildResult } from "./types.js";
+import { type ConflictStrategy } from "./output-writer.js";
+export declare class BuilderError extends Error {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+export type BuildSource = {
+    kind: "diagnosis";
+    path: string;
+} | {
+    kind: "queries";
+    path: string;
+};
+export interface BuildOpts {
+    source: BuildSource;
+    outDir: string;
+    evalSetId: string;
+    onConflict: ConflictStrategy;
+    /** From `--redaction-rules=<path>` */
+    redactionRulesCliFlag: string | undefined;
+    /** From CWD: usually `path.join(process.cwd(), "redaction-rules")` — caller passes resolved path */
+    repoDir: string | undefined;
+}
+export declare function ensureQueryId(c: {
+    query_id: string;
+    input: unknown;
+    tags?: string[];
+}): string;
+export declare function build(opts: BuildOpts): Promise<BuildResult>;

package/dist/trace-ai/eval-set/builder.js

@@ -0,0 +1,126 @@
+/**
+ * M5 eval-set builder — orchestrates build:
+ *   picker → ensureQueryId → redact → write (with conflict resolution) → validate
+ *
+ * `ensureQueryId` is the deterministic hash-based ID generator (inline here,
+ * not a separate file — spec doc §9 "反过度工程" decision).
+ */
+import { createHash } from "node:crypto";
+import { liftFromQueriesFile, liftFromDiagnosis, QueryPickerError } from "./query-picker.js";
+import { loadRules, applyRules, RedactorError } from "./redactor.js";
+import { writeEvalSet, WriterError } from "./output-writer.js";
+export class BuilderError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "BuilderError";
+    }
+}
+/**
+ * Canonical JSON serialization for hashing — keys sorted, no whitespace.
+ * Ensures hash(case) is stable across runs.
+ */
+function canonicalJson(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return "[" + value.map(canonicalJson).join(",") + "]";
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return "{" + keys.map((k) => JSON.stringify(k) + ":" + canonicalJson(obj[k])).join(",") + "}";
+}
+export function ensureQueryId(c) {
+    if (c.query_id && c.query_id.length > 0)
+        return c.query_id;
+    const seed = canonicalJson({ input: c.input, tags: c.tags ?? [] });
+    return createHash("sha256").update(seed).digest("hex").slice(0, 12);
+}
+function redactCase(c, applyFn) {
+    const redacted = {
+        query_id: c.query_id,
+        input: { user_message: applyFn(c.input.user_message) },
+        tags: c.tags,
+    };
+    if (c.reference) {
+        redacted.reference = { answer: applyFn(c.reference.answer) };
+    }
+    if (c.assertions) {
+        redacted.assertions = c.assertions; // assertions strings (regex / value) intentionally NOT redacted
+        // — they are user-authored test expectations, not raw PII
+    }
+    return redacted;
+}
+export async function build(opts) {
+    // Stage 1: pick cases
+    let lifted;
+    let skippedFindingsCount = 0;
+    try {
+        if (opts.source.kind === "queries") {
+            lifted = await liftFromQueriesFile(opts.source.path);
+        }
+        else {
+            const r = await liftFromDiagnosis(opts.source.path);
+            lifted = r.cases;
+            skippedFindingsCount = r.skipped_findings_count;
+        }
+    }
+    catch (e) {
+        if (e instanceof QueryPickerError) {
+            throw new BuilderError(`picker failed: ${e.message}`, e);
+        }
+        throw e;
+    }
+    // Stage 2: ensure query_id
+    const withIds = lifted.map((c) => ({ ...c, query_id: ensureQueryId(c) }));
+    // Stage 3: redact
+    let rulesResult;
+    try {
+        rulesResult = await loadRules({
+            cliFlag: opts.redactionRulesCliFlag,
+            repoDir: opts.repoDir,
+        });
+    }
+    catch (e) {
+        if (e instanceof RedactorError) {
+            throw new BuilderError(`redactor failed: ${e.message}`, e);
+        }
+        throw e;
+    }
+    const apply = (s) => applyRules(s, rulesResult.rules);
+    const redacted = withIds.map((c) => redactCase(c, apply));
+    // Stage 3.5: guard against 0-cases lift (better UX than letting writer fail
+    // with cryptic "Too small: expected array to have >=1 items"). Common cause:
+    // --diagnosis= where every finding has query=null (e.g. runtime doesn't emit
+    // gen_ai.input.messages) or empty assertions[].
+    if (redacted.length === 0) {
+        const sourceLabel = opts.source.kind === "diagnosis" ? "--diagnosis=" : "--queries=";
+        const skippedNote = skippedFindingsCount > 0
+            ? `\n  Skipped ${skippedFindingsCount} finding(s) — common causes:\n    - findings have query: null (M4 trace runtime doesn't emit gen_ai.input.messages)\n    - findings have empty assertions[]`
+            : "";
+        throw new BuilderError(`lifted 0 eval-cases from ${sourceLabel}${opts.source.path}.${skippedNote}\n  Alternatives: use --queries=<file> to provide queries manually, or upgrade M4 trace runtime to emit gen_ai.input.messages.`);
+    }
+    // Stage 4: write + conflict + validate
+    let writeRes;
+    try {
+        writeRes = await writeEvalSet({
+            outDir: opts.outDir,
+            evalSetId: opts.evalSetId,
+            newCases: redacted,
+            onConflict: opts.onConflict,
+        });
+    }
+    catch (e) {
+        if (e instanceof WriterError) {
+            throw new BuilderError(`writer failed: ${e.message}`, e);
+        }
+        throw e;
+    }
+    return {
+        cases_written: writeRes.cases_written,
+        cases_skipped: writeRes.cases_skipped + skippedFindingsCount,
+        conflicts: writeRes.conflicts,
+        shard_paths: writeRes.shard_paths,
+        redaction_rules_source: rulesResult.source,
+    };
+}

package/dist/trace-ai/eval-set/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * M5 eval-set module — public exports.
+ *
+ * Consumers (commands/trace.ts, tests, future M6 reuse) import from this
+ * barrel; internal modules cross-import via direct paths.
+ */
+export type { EvalCase, EvalCaseInput, EvalReference, EvalAssertion, AssertionType, EvalSetIndex, EvalSetIndexShard, BuildResult, RedactionRule, } from "./types.js";
+export { build, ensureQueryId, BuilderError } from "./builder.js";
+export type { BuildOpts, BuildSource } from "./builder.js";
+export { run as runTest } from "./test-runner.js";
+export type { RunOpts, RunnerDeps } from "./test-runner.js";
+export { evaluateAssertion } from "./assertion-evaluator.js";
+export type { AssertionContext, AssertionResult, SemanticMatchProvider, SemanticMatchVerdict, } from "./assertion-evaluator.js";
+export { createBuiltinSemanticMatchProvider, ANSWER_MATCH_REFERENCE_REF, AnswerMatchOutputSchema, } from "./semantic-match-provider.js";
+export type { CreateSemanticMatchProviderOpts } from "./semantic-match-provider.js";

package/dist/trace-ai/eval-set/index.js

@@ -0,0 +1,10 @@
+/**
+ * M5 eval-set module — public exports.
+ *
+ * Consumers (commands/trace.ts, tests, future M6 reuse) import from this
+ * barrel; internal modules cross-import via direct paths.
+ */
+export { build, ensureQueryId, BuilderError } from "./builder.js";
+export { run as runTest } from "./test-runner.js";
+export { evaluateAssertion } from "./assertion-evaluator.js";
+export { createBuiltinSemanticMatchProvider, ANSWER_MATCH_REFERENCE_REF, AnswerMatchOutputSchema, } from "./semantic-match-provider.js";

package/dist/trace-ai/eval-set/output-writer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * M5 eval-set output writer — handles directory layout, index upsert, shard
+ * merge, on-conflict resolution (fail / skip / overwrite), and .bak preservation.
+ *
+ * MVP layout: always one shard named `cases.yaml`. Users can manually split
+ * into multi-shard later (re-write `index.yaml` to reference more shards)
+ * and call `kweaver trace schema validate` to verify.
+ */
+import type { EvalCase } from "./types.js";
+export declare class WriterError extends Error {
+    readonly conflictIds?: string[] | undefined;
+    constructor(message: string, conflictIds?: string[] | undefined);
+}
+export type ConflictStrategy = "fail" | "skip" | "overwrite";
+export interface WriteEvalSetOpts {
+    outDir: string;
+    evalSetId: string;
+    newCases: EvalCase[];
+    onConflict: ConflictStrategy;
+}
+export interface WriteEvalSetResult {
+    cases_written: number;
+    cases_skipped: number;
+    conflicts: string[];
+    shard_paths: string[];
+}
+export declare function writeEvalSet(opts: WriteEvalSetOpts): Promise<WriteEvalSetResult>;

package/dist/trace-ai/eval-set/output-writer.js

@@ -0,0 +1,126 @@
+/**
+ * M5 eval-set output writer — handles directory layout, index upsert, shard
+ * merge, on-conflict resolution (fail / skip / overwrite), and .bak preservation.
+ *
+ * MVP layout: always one shard named `cases.yaml`. Users can manually split
+ * into multi-shard later (re-write `index.yaml` to reference more shards)
+ * and call `kweaver trace schema validate` to verify.
+ */
+import { readFile, writeFile, copyFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { EvalSetIndexSchema, EvalSetShardSchema } from "./schemas.js";
+export class WriterError extends Error {
+    conflictIds;
+    constructor(message, conflictIds) {
+        super(message);
+        this.conflictIds = conflictIds;
+        this.name = "WriterError";
+    }
+}
+const SHARD_NAME = "cases.yaml";
+const INDEX_NAME = "index.yaml";
+async function fileExists(p) {
+    try {
+        await readFile(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readShardCases(shardPath) {
+    if (!(await fileExists(shardPath)))
+        return [];
+    const raw = await readFile(shardPath, "utf8");
+    const parsed = yaml.load(raw);
+    const r = EvalSetShardSchema.safeParse(parsed);
+    if (!r.success) {
+        throw new WriterError(`existing shard at ${shardPath} fails schema validation: ${r.error.issues[0].message}`);
+    }
+    return r.data.cases;
+}
+export async function writeEvalSet(opts) {
+    const { outDir, evalSetId, newCases, onConflict } = opts;
+    // intra-batch duplicate detection
+    const seenInBatch = new Set();
+    const dupInBatch = [];
+    for (const c of newCases) {
+        if (seenInBatch.has(c.query_id))
+            dupInBatch.push(c.query_id);
+        seenInBatch.add(c.query_id);
+    }
+    if (dupInBatch.length > 0) {
+        throw new WriterError(`intra-batch duplicate query_id(s): ${dupInBatch.join(", ")}`, dupInBatch);
+    }
+    await mkdir(outDir, { recursive: true });
+    const shardPath = path.join(outDir, SHARD_NAME);
+    const existingCases = await readShardCases(shardPath);
+    const existingIds = new Set(existingCases.map((c) => c.query_id));
+    const incomingByConflict = newCases.filter((c) => existingIds.has(c.query_id));
+    const incomingFresh = newCases.filter((c) => !existingIds.has(c.query_id));
+    if (incomingByConflict.length > 0 && onConflict === "fail") {
+        throw new WriterError(`query_id conflict(s): ${incomingByConflict.map((c) => c.query_id).join(", ")}`, incomingByConflict.map((c) => c.query_id));
+    }
+    let mergedCases;
+    let casesWritten = 0;
+    let casesSkipped = 0;
+    if (onConflict === "skip") {
+        mergedCases = [...existingCases, ...incomingFresh];
+        casesWritten = incomingFresh.length;
+        casesSkipped = incomingByConflict.length;
+    }
+    else if (onConflict === "overwrite") {
+        if (incomingByConflict.length > 0 && (await fileExists(shardPath))) {
+            await copyFile(shardPath, shardPath + ".bak");
+        }
+        const overwriteIds = new Set(incomingByConflict.map((c) => c.query_id));
+        const kept = existingCases.filter((c) => !overwriteIds.has(c.query_id));
+        mergedCases = [...kept, ...incomingFresh, ...incomingByConflict];
+        casesWritten = incomingFresh.length + incomingByConflict.length;
+        casesSkipped = 0;
+    }
+    else {
+        // "fail" strategy — no conflicts at this point (would have thrown above)
+        mergedCases = [...existingCases, ...incomingFresh];
+        casesWritten = incomingFresh.length;
+        casesSkipped = 0;
+    }
+    const shardDoc = {
+        schema_version: "trace-eval-set/v1",
+        cases: mergedCases,
+    };
+    const shardCheck = EvalSetShardSchema.safeParse(shardDoc);
+    if (!shardCheck.success) {
+        throw new WriterError(`merged shard fails schema validation: ${shardCheck.error.issues[0].message}`);
+    }
+    await writeFile(shardPath, yaml.dump(shardDoc, { lineWidth: 120, noRefs: true }), "utf8");
+    const indexPath = path.join(outDir, INDEX_NAME);
+    let indexDoc;
+    if (await fileExists(indexPath)) {
+        const raw = await readFile(indexPath, "utf8");
+        const parsed = yaml.load(raw);
+        const r = EvalSetIndexSchema.safeParse(parsed);
+        if (!r.success) {
+            throw new WriterError(`existing index.yaml fails schema validation: ${r.error.issues[0].message}`);
+        }
+        indexDoc = r.data;
+        if (!indexDoc.shards.some((s) => s.path === SHARD_NAME)) {
+            indexDoc.shards.push({ path: SHARD_NAME });
+        }
+    }
+    else {
+        indexDoc = {
+            schema_version: "trace-eval-set-index/v1",
+            eval_set_id: evalSetId,
+            shards: [{ path: SHARD_NAME }],
+        };
+    }
+    await writeFile(indexPath, yaml.dump(indexDoc, { lineWidth: 120, noRefs: true }), "utf8");
+    return {
+        cases_written: casesWritten,
+        cases_skipped: casesSkipped,
+        conflicts: incomingByConflict.map((c) => c.query_id),
+        shard_paths: [shardPath],
+    };
+}

package/dist/trace-ai/eval-set/query-picker.d.ts

@@ -0,0 +1,37 @@
+/**
+ * M5 eval-set query picker — two lift functions:
+ *   - liftFromQueriesFile(path)   reads `trace-eval-set-input/v1` simplified yaml
+ *   - liftFromDiagnosis(dir)      reads M4 diagnose report yamls (added in Task 4)
+ *
+ * Both return EvalCase[] (without query_id auto-fill — that happens in builder.ts).
+ */
+import type { EvalCase } from "./types.js";
+export declare class QueryPickerError extends Error {
+    readonly path?: string | undefined;
+    constructor(message: string, path?: string | undefined);
+}
+export declare function liftFromQueriesFile(filePath: string): Promise<EvalCase[]>;
+export interface LiftFromDiagnosisResult {
+    cases: EvalCase[];
+    skipped_findings_count: number;
+    skipped_findings_summary: string[];
+}
+/**
+ * Read all *.yaml / *.yml files in `dirPath`, validate each as `trace-diagnose-report/v1`,
+ * and extract `findings[*].verify_with.suggested_eval_case` as EvalCases.
+ *
+ * Skips findings where:
+ *   - `suggested_eval_case.query` is null (M4 has no user query → can't construct EvalCase.input)
+ *   - `suggested_eval_case.assertions` is empty (refinement would fail; no reference either)
+ *
+ * Lifts:
+ *   - `EvalCase.input.user_message = suggested_eval_case.query`
+ *   - `EvalCase.query_id = suggested_eval_case.query_id ?? ""` (empty → builder.ensureQueryId fills)
+ *   - `EvalCase.assertions` = M4 string templates wrapped as placeholder `contains` assertions
+ *     with `_note` flagging "convert to structured manually"
+ *   - `EvalCase.reference = undefined` (M4 doesn't emit reference)
+ *
+ * Files that fail to schema-validate cause a fail-fast error (all *.yaml in dir
+ * must be diagnose reports — picker doesn't filter by content).
+ */
+export declare function liftFromDiagnosis(dirPath: string): Promise<LiftFromDiagnosisResult>;

package/dist/trace-ai/eval-set/query-picker.js

@@ -0,0 +1,147 @@
+/**
+ * M5 eval-set query picker — two lift functions:
+ *   - liftFromQueriesFile(path)   reads `trace-eval-set-input/v1` simplified yaml
+ *   - liftFromDiagnosis(dir)      reads M4 diagnose report yamls (added in Task 4)
+ *
+ * Both return EvalCase[] (without query_id auto-fill — that happens in builder.ts).
+ */
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { EvalSetInputSchema } from "./schemas.js";
+import { ReportSchema } from "../diagnose/schemas.js";
+export class QueryPickerError extends Error {
+    path;
+    constructor(message, path) {
+        super(message);
+        this.path = path;
+        this.name = "QueryPickerError";
+    }
+}
+export async function liftFromQueriesFile(filePath) {
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf8");
+    }
+    catch (e) {
+        const err = e;
+        if (err.code === "ENOENT") {
+            throw new QueryPickerError(`file not found: ${filePath}`, filePath);
+        }
+        throw new QueryPickerError(`failed to read ${filePath}: ${err.message}`, filePath);
+    }
+    let parsed;
+    try {
+        parsed = yaml.load(raw);
+    }
+    catch (e) {
+        throw new QueryPickerError(`failed to parse yaml ${filePath}: ${e.message}`, filePath);
+    }
+    const result = EvalSetInputSchema.safeParse(parsed);
+    if (!result.success) {
+        const firstIssue = result.error.issues[0];
+        const where = firstIssue.path.join(".");
+        throw new QueryPickerError(`schema validation failed for ${filePath} at '${where}': ${firstIssue.message}`, filePath);
+    }
+    return result.data.cases.map((c) => ({
+        query_id: c.query_id ?? "", // empty → builder.ensureQueryId fills it; undefined would break downstream
+        input: c.input,
+        reference: c.reference,
+        assertions: c.assertions,
+        tags: c.tags,
+    }));
+}
+/**
+ * Read all *.yaml / *.yml files in `dirPath`, validate each as `trace-diagnose-report/v1`,
+ * and extract `findings[*].verify_with.suggested_eval_case` as EvalCases.
+ *
+ * Skips findings where:
+ *   - `suggested_eval_case.query` is null (M4 has no user query → can't construct EvalCase.input)
+ *   - `suggested_eval_case.assertions` is empty (refinement would fail; no reference either)
+ *
+ * Lifts:
+ *   - `EvalCase.input.user_message = suggested_eval_case.query`
+ *   - `EvalCase.query_id = suggested_eval_case.query_id ?? ""` (empty → builder.ensureQueryId fills)
+ *   - `EvalCase.assertions` = M4 string templates wrapped as placeholder `contains` assertions
+ *     with `_note` flagging "convert to structured manually"
+ *   - `EvalCase.reference = undefined` (M4 doesn't emit reference)
+ *
+ * Files that fail to schema-validate cause a fail-fast error (all *.yaml in dir
+ * must be diagnose reports — picker doesn't filter by content).
+ */
+export async function liftFromDiagnosis(dirPath) {
+    let entries;
+    try {
+        entries = await readdir(dirPath);
+    }
+    catch (e) {
+        const err = e;
+        if (err.code === "ENOENT") {
+            throw new QueryPickerError(`directory not found: ${dirPath}`, dirPath);
+        }
+        throw new QueryPickerError(`failed to read directory ${dirPath}: ${err.message}`, dirPath);
+    }
+    const yamlFiles = entries
+        .filter((e) => e.endsWith(".yaml") || e.endsWith(".yml"))
+        .map((e) => path.join(dirPath, e));
+    // Accumulate by query_id so multiple findings from the same conversation
+    // collapse into one case with merged assertions (avoids intra-batch dup error).
+    const byQueryId = new Map();
+    let skipped = 0;
+    const skippedSummary = [];
+    for (const file of yamlFiles) {
+        let raw;
+        try {
+            raw = await readFile(file, "utf8");
+        }
+        catch (e) {
+            throw new QueryPickerError(`failed to read ${file}: ${e.message}`, file);
+        }
+        let parsed;
+        try {
+            parsed = yaml.load(raw);
+        }
+        catch (e) {
+            throw new QueryPickerError(`failed to parse yaml ${file}: ${e.message}`, file);
+        }
+        const result = ReportSchema.safeParse(parsed);
+        if (!result.success) {
+            const firstIssue = result.error.issues[0];
+            const where = firstIssue.path.join(".");
+            throw new QueryPickerError(`schema validation failed for ${file} at '${where}': ${firstIssue.message}`, file);
+        }
+        for (const finding of result.data.findings) {
+            const sec = finding.verify_with.suggested_eval_case;
+            if (sec.query === null) {
+                skipped += 1;
+                skippedSummary.push(`${path.basename(file)}: rule=${finding.rule_id} (query=null; upgrade M4 trace to populate input.messages)`);
+                continue;
+            }
+            if (sec.assertions.length === 0) {
+                skipped += 1;
+                skippedSummary.push(`${path.basename(file)}: rule=${finding.rule_id} (empty assertions; refinement would fail)`);
+                continue;
+            }
+            const placeholderAssertions = sec.assertions.map((t) => ({
+                type: "contains",
+                value: t,
+                _note: "auto-lifted from M4 assertion template; convert to structured assertion manually",
+            }));
+            const queryId = sec.query_id ?? "";
+            const existing = byQueryId.get(queryId);
+            if (existing) {
+                existing.assertions = [...(existing.assertions ?? []), ...placeholderAssertions];
+            }
+            else {
+                byQueryId.set(queryId, {
+                    query_id: queryId,
+                    input: { user_message: sec.query },
+                    reference: undefined,
+                    assertions: placeholderAssertions,
+                    tags: undefined,
+                });
+            }
+        }
+    }
+    return { cases: [...byQueryId.values()], skipped_findings_count: skipped, skipped_findings_summary: skippedSummary };
+}

package/dist/trace-ai/eval-set/redactor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * M5 eval-set redactor — PII pattern matching + replacement.
+ *
+ * Three rule sources, in priority order (chain):
+ *   1. --redaction-rules=<path>      (CLI flag, highest)
+ *   2. <repo>/redaction-rules/*.yaml (repo-local)
+ *   3. BUILTIN_RULES                 (5 low-fidelity defaults)
+ *
+ * Builtin rules cover common Chinese-context PII: phone / email / id_card /
+ * bank_card / ip. Organizations write more rules in <repo>/redaction-rules/
+ * for their business-specific patterns.
+ *
+ * Rule yaml format:
+ *   rules:
+ *     - name: <id>
+ *       pattern: <regex source string>
+ *       replace: <replacement template; supports {hash6} placeholder>
+ *
+ * Malformed regex causes loadRules to throw RedactorError (no silent fallback).
+ */
+import type { RedactionRule } from "./types.js";
+export declare class RedactorError extends Error {
+    readonly path?: string | undefined;
+    constructor(message: string, path?: string | undefined);
+}
+/**
+ * 5 builtin low-fidelity PII patterns. Tuned for Chinese-context defaults;
+ * organizations override with their own rules in <repo>/redaction-rules/.
+ */
+export declare const BUILTIN_RULES: RedactionRule[];
+export interface LoadRulesOpts {
+    /** From `--redaction-rules=<path>`; highest priority */
+    cliFlag: string | undefined;
+    /** From `<repo>/redaction-rules/` (resolved by caller — usually `path.join(repoRoot, "redaction-rules")`) */
+    repoDir: string | undefined;
+}
+export interface LoadRulesResult {
+    rules: RedactionRule[];
+    source: "cli-flag" | "repo" | "builtin";
+}
+export declare function loadRules(opts: LoadRulesOpts): Promise<LoadRulesResult>;
+export declare function applyRules(text: string, rules: RedactionRule[]): string;