slopbrick 0.11.0

package/dist/index.d.cts

@@ -0,0 +1,1289 @@
+export { CACHE_FILENAME, CONSTITUTION_FILENAME, ComponentFingerprint, ConstitutionFile, FileMtimeEntry, INVENTORY_FILENAME, InventoryFile, MEMORY_SCHEMA_VERSION, MemoryCategory, MemoryPattern, cachePath, constitutionPath, invalidateFile, inventoryPath, isComponentFingerprint, isConstitutionFile, isFileMtimeEntry, isInventoryFile, isInventoryFresh, isMemoryPattern, loadConstitution, loadInventory, saveConstitution, saveInventory } from '@usebrick/core';
+
+/**
+ * Constitution declared by the user (or auto-detected from package.json).
+ * Each allow-list field is a list of canonical names — agents and
+ * reviewers can match against import strings without needing the
+ * original package name. For example, `@reduxjs/toolkit` and `redux`
+ * both surface as `'redux'` under `stateManagement`.
+ *
+ * `forbidden` is the deny-list: bare package specifiers and `@scope/`
+ * prefixes that the project has decided are off-limits. Matched against
+ * imports during `slop_check_constitution` and the `slopbrick drift`
+ * command.
+ */
+interface Constitution {
+    /** State-management libraries, e.g. 'zustand', 'redux', 'jotai'. */
+    stateManagement?: string[];
+    /** Data-fetching / server-state libraries, e.g. 'react-query', 'swr'. */
+    dataFetching?: string[];
+    /** UI component libraries, e.g. 'shadcn', 'radix', 'mui'. */
+    uiLibrary?: string[];
+    /** Form + schema-validation libraries, e.g. 'react-hook-form', 'zod'. */
+    forms?: string[];
+    /** Styling solutions, e.g. 'tailwind', 'styled-components', 'emotion'. */
+    styling?: string[];
+    /** Routing libraries, e.g. 'next', 'react-router', 'tanstack-router'. */
+    routing?: string[];
+    /** Free-form user-declared categories, keyed by category name. */
+    custom?: Record<string, string[]>;
+    /**
+     * Explicit deny-list of bare package specifiers and `@scope/`
+     * prefixes. Anything in this list is forbidden — even if it would
+     * otherwise match a canonical category. Matching rules (see
+     * `matchForbidden`):
+     *  - `forbidden: ['moment']` matches `moment` exactly.
+     *  - `forbidden: ['@types/']` matches any `@types/...` import.
+     *  - `forbidden: ['lodash']` matches `lodash` but not `lodash-es`.
+     */
+    forbidden?: string[];
+}
+
+type BusinessLogicCategory = 'pricing' | 'validation' | 'formatting';
+interface BusinessLogicIssue {
+    category: BusinessLogicCategory;
+    filePath: string;
+    line: number;
+    column: number;
+    ruleId: string;
+    message: string;
+    advice?: string;
+}
+
+interface CategoryDeduction {
+    category: string;
+    count: number;
+    /** Weight per unit (per-extra or per-N-findings). */
+    weight: number;
+    /** Total deduction applied to the score. */
+    deduction: number;
+    /** Human-readable summary, e.g. "3 modal systems, 2 beyond baseline". */
+    summary: string;
+    /** Concrete findings (filenames, category labels, etc.). */
+    findings: string[];
+}
+
+interface FileMeta {
+    /** Absolute path to the file (or relative path from cwd, whichever the
+     *  caller passed in). */
+    path: string;
+    /** Lines of code, used by sizeNormalisation in the aggregator. */
+    loc: number;
+    /** File extension including the leading dot (".tsx", ".vue"). Empty
+     *  string for extension-less files that were sniffed by `discover.ts`. */
+    extension: string;
+    /** Derived from extension (or config.framework as fallback). */
+    framework: Framework$1;
+}
+interface ImportSpecifier {
+    /** Imported symbol name (`Button`, `useState`, `* as Foo`). */
+    name: string;
+    isDefault: boolean;
+    /** `import { X as Y }` — the local alias. */
+    alias?: string;
+}
+interface ImportRecord {
+    /** Import source as written. `'@/components/ui/button'`, `'react'`, `'./x'`. */
+    source: string;
+    specifiers: ImportSpecifier[];
+    /** True if the source matches a prefix in `config.allowedImports`.
+     *  Always false for relative or third-party imports. */
+    isAllowed: boolean;
+    /** Source location. */
+    line: number;
+    column: number;
+}
+interface ComponentProp {
+    name: string;
+    /** Inferred type as a string. We don't parse the actual TS type — we
+     *  surface the literal type annotation when present. */
+    type: string;
+    isRequired: boolean;
+}
+interface ComponentRecord {
+    /** Component name if it can be derived (function name, default export
+     *  alias). Empty string for anonymous components. */
+    name: string;
+    isExported: boolean;
+    /** Component body line count. */
+    loc: number;
+    /** True for `'use client'` components and any non-server-compatible
+     *  component (wrapped in `memo()`, `forwardRef()`, etc.). */
+    isClientComponent: boolean;
+    /** True if the source has `'use server'` directive. */
+    isServerComponent: boolean;
+    /** Declared props. Empty array for components without typed props. */
+    props: ComponentProp[];
+    /**
+     *  `logic/reactive-hook-soup`'s per-component useEffect count. */
+    hookCalls: Array<{
+        name: string;
+        line: number;
+        column: number;
+    }>;
+    /** Source location of the component declaration. */
+    line: number;
+    column: number;
+}
+interface JsxElementRecord {
+    /** Element tag name: `'div'`, `'Button'`, `'AlertDialog'`. */
+    tag: string;
+    /** True if the tag is an HTML primitive (`div`, `span`, `button`). False
+     *  if it's a user component or imported component. */
+    isPrimitive: boolean;
+    /** Extracted className tokens (split by whitespace, no empty strings). */
+    classNames: string[];
+    /** Tailwind arbitrary values extracted from classNames (`'p-[13px]'`,
+     *  `'mt-[10vh]'`, `'bg-[#fff]'`). Empty array if none. */
+    arbitraryValues: string[];
+    /** Parsed `style={{...}}` props as a flat key→value map. */
+    inlineStyles: Record<string, string>;
+    /** True for `<button>`, `<a>`, `<input>`, `<select>`, `<textarea>`,
+     *  and elements with `role="button"`. */
+    interactive: boolean;
+    /** ARIA-related props on this element (`'aria-label'`, `'role'`). */
+    ariaProps: string[];
+    /** Raw attributes. String-valued entries hold the attribute value;
+     *  boolean attributes (e.g. `disabled`) appear as `key: undefined` so
+     *  `Object.keys(attributes)` exposes them. Rules use truthy checks. */
+    attributes: Record<string, string | undefined>;
+    /** Source location. */
+    line: number;
+    column: number;
+}
+interface JsxTree {
+    elements: JsxElementRecord[];
+    /** Maximum depth of nested JSX elements anywhere in the file. */
+    maxNestingDepth: number;
+}
+type HookLocation = 'component-body' | 'useEffect' | 'handler' | 'callback';
+interface HookRecord {
+    /** Hook name: `'useState'`, `'useEffect'`, `'useMemo'`, custom hooks. */
+    name: string;
+    /** Dependency array contents. Empty array means no deps. `undefined`
+     *  means deps couldn't be inferred (e.g. spread). */
+    dependencies: unknown[];
+    /** Return type as a string (best-effort inference). */
+    returnType: string;
+    /** Where the hook was called. */
+    location: HookLocation;
+    line: number;
+    column: number;
+}
+interface StateVariableRecord {
+    /** Variable name (`'count'`). */
+    name: string;
+    /** Setter name (`'setCount'`). Empty string if no setter. */
+    setter: string;
+    /** True if the value is referenced anywhere in JSX. */
+    isUsedInJSX: boolean;
+    /** True if the value is never read AND the setter is never called. */
+    isZombie: boolean;
+    line: number;
+    column: number;
+}
+interface DefensiveCheckRecord {
+    type: 'nullish' | 'typeof' | 'truthy';
+    /** The expression being checked (`'user'`, `'data?.x'`). */
+    target: string;
+    /** True if the check is redundant because the framework already
+     *  guarantees the value (e.g. optional chaining on a non-nullable). */
+    isGhost: boolean;
+    line: number;
+    column: number;
+}
+interface ApiCallRecord {
+    /** Method or path: `'fetch'`, `'axios.get'`, `'/api/users'`. */
+    method: string;
+    /** Where the call lives. */
+    location: HookLocation;
+    /** True for direct calls inside component body (not wrapped in a hook
+     *  or async handler). Triggers `logic/boundary-violation`. */
+    isDirect: boolean;
+    line: number;
+    column: number;
+}
+interface DesignTokens {
+    /** Numeric spacing values used in the file (e.g. `[4, 8, 12, 16, 13]`).
+     *  Used by entropy rules and `spacing-grid` validation. */
+    spacingUsage: number[];
+    /** Color values: `'zinc-900'`, `'#fff'`, `'hsl(0 0% 0%)'`, `'rgb(...)'`. */
+    colorValues: string[];
+    /** Font sizes used in inline styles and classNames. */
+    fontSizes: string[];
+    /** Border radius values used in the file. */
+    borderRadius: string[];
+}
+interface ScanFactsV2 {
+    file: FileMeta;
+    imports: ImportRecord[];
+    components: ComponentRecord[];
+    jsx: JsxTree;
+    logic: {
+        hooks: HookRecord[];
+        stateVariables: StateVariableRecord[];
+        defensiveChecks: DefensiveCheckRecord[];
+        apiCalls: ApiCallRecord[];
+        logicalExpressions: LogicalExpressionFact[];
+        keyProps: KeyPropFact[];
+        optimisticUpdates: OptimisticUpdateFact[];
+    };
+    designTokens: DesignTokens;
+    /**
+     *  templates. Replaces the synthetic `<template>` elements that the
+     *  migration injected into `jsx.elements`. */
+    templateClassNames: ClassNameFact[];
+    /**
+     *  multiple-components-per-file. */
+    componentSizes: ComponentSizeFact[];
+    astroComponents: AstroComponentFact[];
+    /**
+     *  comments (and block equivalents). Issues matching these are filtered
+     *  out before scoring. */
+    disabledRules: DisabledLintRuleFact[];
+    /** Optional source text (cached for `unified-diff`, `formatAdvice`,
+     *  and `--suggest` output). Not all rules need this. */
+    _source?: string;
+}
+
+interface SignalStrength {
+    /** TP per AI file. Higher = catches more AI tells. */
+    recall: number;
+    /** FP per human file. Higher = false alarms. */
+    fpRate: number;
+    /** recall / fpRate (capped at 99 if no FPs observed). Higher = cleaner signal. */
+    ratio: number;
+    /** recall / (recall + fpRate). 0..1. Higher = more reliable. */
+    precision: number;
+    /** ISO timestamp of last calibration that produced these numbers. */
+    lastCalibratedAt: string;
+    /**
+     * v0.9.3: when `true`, the scan engine applies `'off'` to this rule by
+     * default — user must explicitly opt back in via
+     * `slopbrick.config.mjs`'s `rules:` block. Set for:
+     *   - INVERTED rules (lift < 1.0 — fires MORE on human code than AI;
+     *     actively misleading when surfaced as AI detectors)
+     *   - NOISY rules (recall < 0.1 — fires too rarely on AI code to be
+     *     a useful default; engineers will dismiss after the 3rd false
+     *     sense of "it doesn't matter")
+     * User `rules: { 'rule/id': 'medium' }` overrides the default-off.
+     * Omitted (= undefined) means the rule keeps its factory default.
+     */
+    defaultOff?: boolean;
+}
+
+declare const VERSION = "0.10.0";
+/**
+ * Categorical bucket for the AI Maintenance Cost score.
+ *
+ *   low       — ship as-is, revisit quarterly
+ *   medium    — schedule cleanup work
+ *   high      — block new feature work in the affected subsystem
+ *   critical  — dedicated refactor sprint required
+ *
+ * Deliberately a categorical label (not numeric). Same reasoning as
+ * `aiSecurityRisk`: a single bucket is harder to game than a number,
+ * and a manager can read "AI Maintenance Cost: HIGH" in two seconds.
+ *
+ * The numeric `health` (0-100, higher = better) and `monthlyUSD`
+ * (estimated monthly cost to fix the underlying issues) are exposed
+ * alongside the label for agents and trend pipelines that need them.
+ */
+type AiMaintenanceCost = 'low' | 'medium' | 'high' | 'critical';
+/** Per-axis contribution to the AI Maintenance Cost score. */
+interface MaintenanceAxisHealth {
+    /** Stable axis name (`slopIndex`, `architectureConsistency`, `aiSecurityRisk`, ...). */
+    axis: string;
+    /** Display label printed by the pretty reporter. */
+    label: string;
+    /** 0-100, higher = better. Derived from the underlying signal. */
+    health: number;
+    /** How this was derived, e.g. `100 - slopIndex (inverted)`. */
+    source: string;
+}
+/** Inputs to the pure `computeAiMaintenanceCost` function. Every axis is optional. */
+interface MaintenanceAxes {
+    /** 0-100, lower = better. The headline `slopIndex` from `ProjectReport`. */
+    slopIndex?: number;
+    /** 0-100, higher = better. From `buildArchitectureScore`. */
+    architectureConsistency?: number;
+    /** Categorical — mapped to numeric via `MAINTENANCE_SECURITY_NUMERIC`. */
+    aiSecurityRisk?: 'low' | 'medium' | 'high' | 'critical';
+    /** Total constitution violations (sum across categories). */
+    constitutionViolations?: number;
+    /** Spacing + radius scale violation counts. */
+    designTokenDrift?: {
+        spacing: number;
+        radius: number;
+    };
+    /** Total high-severity issues across the scan. Extra penalty. */
+    highSeverityIssueCount?: number;
+    /** Approximate LoC; defaults to 0 if unknown (small-project path). */
+    linesOfCode?: number;
+    /** False when the user has not declared a constitution / design tokens
+     * (no drift run). When true, applies the 1.5–2.5× AI multiplier. */
+    hasAiSignals?: boolean;
+}
+/** Result returned by `computeAiMaintenanceCost` + `computeAiMaintenanceCostFromReport`. */
+interface AiMaintenanceCostResult {
+    /** Categorical headline. */
+    cost: AiMaintenanceCost;
+    /** Weighted health in 0-100 (higher = better). Bucket is derived from this. */
+    health: number;
+    /** Estimated monthly USD cost to fix the underlying issues.
+     *  Anchored to Sonar's $306K/yr/MLoC baseline ($25.50/1k LoC/month)
+     *  with the CodeClimate grade→minutes mapping for per-issue cost. */
+    monthlyUSD: number;
+    /** Per-axis breakdown, sorted by health ascending (worst first). */
+    axes: MaintenanceAxisHealth[];
+    /** Per-bucket advice for managers. */
+    advice: string;
+}
+/**
+ * Categorical drift band on the doc-freshness score.
+ *   low       — 80-100
+ *   medium    — 60-79
+ *   high      — 40-59
+ *   critical  — 0-39
+ *
+ * Drives the `--strict` exit code for `slopbrick docs` (high/critical = 1).
+ */
+type DocDriftLevel = 'low' | 'medium' | 'high' | 'critical';
+/** A single doc-drift finding — one rule firing on one line. */
+interface DocFinding {
+    ruleId: 'docs/stale-package-reference' | 'docs/stale-function-reference' | 'docs/expired-code-example' | 'docs/broken-link';
+    severity: 'low' | 'medium' | 'high';
+    docFile: string;
+    line: number;
+    column: number;
+    message: string;
+    advice: string;
+    /** For `stale-package-reference`: the package the doc references. */
+    package?: string;
+    /** For `stale-function-reference`: the identifier. */
+    identifier?: string;
+    /** For `broken-link`: the unresolved link target. */
+    link?: string;
+}
+/**
+ * Categorical drift band on the db-health score.
+ *   low       — 80-100
+ *   medium    — 60-79
+ *   high      — 40-59
+ *   critical  — 0-39
+ */
+type DbDriftLevel = 'low' | 'medium' | 'high' | 'critical';
+/** A single db-health finding — one rule firing on one table/file. */
+interface DbFinding {
+    ruleId: 'db/missing-fk-index' | 'db/duplicate-index' | 'db/missing-not-null' | 'db/enum-sprawl' | 'db/naming-inconsistency' | 'db/sql-concat';
+    severity: 'low' | 'medium' | 'high';
+    dbFile: string;
+    line: number;
+    column: number;
+    message: string;
+    advice: string;
+    /** For rules that target a specific table. */
+    table?: string;
+    /** For column-level rules. */
+    columnName?: string;
+}
+/**
+ * Letter-grade band on the composite Repository Health score.
+ * Drives the `aiDebt` field — same categorical shape as `aiSecurityRisk`.
+ *
+ *   low       — 80-100  (clean; safe to ship)
+ *   medium    — 60-79   (manageable; revisit quarterly)
+ *   high      — 40-59   (block new feature work in affected subsystems)
+ *   critical  — 0-39    (dedicated refactor sprint required)
+ */
+type AiDebt = 'low' | 'medium' | 'high' | 'critical';
+/** Numeric mapping for categorical `aiSecurityRisk` used in the composite. */
+declare const AI_SECURITY_NUMERIC: Record<'low' | 'medium' | 'high' | 'critical', number>;
+/** Inputs to the pure `buildRepositoryHealth` function. Every input is optional. */
+interface RepositoryHealthInputs {
+    /** 0-100, lower = better. Inverted to 100 - x for the composite. */
+    slopIndex?: number;
+    /** 0-100, higher = better. */
+    architectureConsistency?: number;
+    /** Categorical — mapped via AI_SECURITY_NUMERIC. */
+    aiSecurityRisk?: 'low' | 'medium' | 'high' | 'critical';
+    /** Spacing + radius scale violation counts. */
+    designTokenViolations?: {
+        spacing: number;
+        radius: number;
+    };
+    /** Total high-severity issue count (extra penalty). */
+    highSeverityIssueCount?: number;
+    /** 0-100, higher = better. From `slopbrick test` (Phase 5). */
+    testQuality?: number;
+    /** 0-100, higher = better. From `slopbrick business-logic` (Phase 7). */
+    businessLogicCoherence?: number;
+    /** 0-100, higher = better. From `slopbrick docs` (Phase 6). */
+    docFreshness?: number;
+    /** 0-100, higher = better. From `slopbrick db` (Phase 8). */
+    dbHealth?: number;
+    /** v0.10 — MDL log-likelihood ratio from `computeMDLikelihood`.
+     *  Positive = rule-firing evidence favors m_ai; negative favors
+     *  m_human. Surfaced on the result for reporting; NOT folded into
+     *  the weighted-average composite (which is heuristic and remains
+     *  unchanged in this phase). Caller computes the ratio from the
+     *  distinct `ruleId` set across the report's issues. */
+    mdlLogRatio?: number;
+}
+/** Result returned by `buildRepositoryHealth` + `buildRepositoryHealthFromReport`. */
+interface RepositoryHealth {
+    /** Composite 0-100 score (higher = better). */
+    score: number;
+    /** Letter-grade band derived from `score`. */
+    aiDebt: AiDebt;
+    /** Per-axis contribution breakdown (axis → 0-100, higher = better). */
+    breakdown: Record<string, number>;
+    /** Per-axis weight actually applied (post-renormalization). */
+    appliedWeights: Record<string, number>;
+    /** Warnings for managers (e.g. "Critical security risk overrides everything"). */
+    warnings: string[];
+    /** One-line summary. */
+    headline: string;
+    /** v0.10 — MDL log-likelihood ratio (positive = m_ai evidence).
+     *  Surfaced when the caller passed `mdlLogRatio` to
+     *  `buildRepositoryHealth`. Not folded into the weighted-average
+     *  composite in this phase (kept separate so the heuristic score
+     *  can be audited independently of the MDL axis). */
+    mdlLogRatio?: number;
+}
+/** Default weights — sum to 1.0. Optional axes are skipped, and the
+ *  remaining weights renormalize to 1.0. Tuned to give `aiSecurityRisk`
+ *  the heaviest weight (it is the catastrophic single-event dimension)
+ *  while still letting slopIndex + architecture drive most cases. */
+declare const REPOSITORY_HEALTH_WEIGHTS: {
+    readonly slopIndex: 0.2;
+    readonly architectureConsistency: 0.2;
+    readonly aiSecurityRisk: 0.2;
+    readonly designTokenViolations: 0.1;
+    readonly testQuality: 0.1;
+    readonly businessLogicCoherence: 0.1;
+    readonly docFreshness: 0.05;
+    readonly dbHealth: 0.05;
+};
+
+type Severity = 'low' | 'medium' | 'high';
+type RuleSeverity = Severity | 'auto';
+type Category = 'visual' | 'typo' | 'wcag' | 'layout' | 'component' | 'logic' | 'arch' | 'perf' | 'security' | 'test' | 'docs' | 'db';
+/**
+ * `react` covers `.tsx`, `.jsx`, `.ts`, `.js`. Other values are detected
+ * by file extension. Unknown extensions fall back to `'react'`.
+ */
+type Framework$1 = 'react' | 'vue' | 'svelte' | 'astro' | 'html';
+interface FixSuggestion {
+    kind: 'insert' | 'replace' | 'css-anchor';
+    description: string;
+    targetFile?: string;
+    anchor?: string;
+    oldValue?: string;
+    newValue?: string;
+}
+interface Issue {
+    ruleId: string;
+    category: Category;
+    severity: Severity;
+    aiSpecific: boolean;
+    filePath?: string;
+    message: string;
+    line: number;
+    column: number;
+    advice?: string;
+    fixHint?: string;
+    fix?: FixSuggestion;
+    fixes?: FixSuggestion[];
+    signalStrength?: SignalStrength;
+}
+interface CachedFile {
+    hash: string;
+    issueCount: number;
+    lastScannedAt: string;
+}
+interface ScanCache {
+    version: string;
+    generatedAt: string;
+    files: Record<string, CachedFile>;
+}
+interface ClassNameFact {
+    value: string;
+    line: number;
+    column: number;
+}
+interface ElementFact {
+    tag: string;
+    attributes: Record<string, string | undefined>;
+    classNames: ClassNameFact[];
+    eventHandlers: string[];
+    line: number;
+    column: number;
+}
+interface HookFact {
+    name: string;
+    line: number;
+    column: number;
+    hasDependencyArray?: boolean;
+    body?: string;
+    componentLine?: number;
+    dependencies?: string[];
+}
+interface HookCallFact {
+    name: string;
+    callee: string;
+    line: number;
+    column: number;
+    inConditional: boolean;
+    inLoop: boolean;
+    inNestedFunction: boolean;
+}
+interface FetchCallFact {
+    line: number;
+    column: number;
+    hasAbortSignal: boolean;
+    checksOk: boolean;
+    /**
+     * The URL argument to fetch(), if it could be extracted as a string literal.
+     * Dynamic expressions (template strings, variables) are left undefined.
+     */
+    url?: string;
+    /**
+     * The `credentials` option if explicitly set ('omit' | 'same-origin' | 'include').
+     * Undefined when not specified.
+     */
+    credentials?: 'omit' | 'same-origin' | 'include';
+    /** HTTP method (uppercase) when explicitly set as the second argument. */
+    method?: string;
+}
+interface DisabledLintRuleFact {
+    ruleId: string;
+    line: number;
+    column: number;
+    scope: 'line' | 'next-line' | 'block';
+}
+interface EvalCallFact {
+    kind: 'eval' | 'new-function' | 'function-constructor';
+    line: number;
+    column: number;
+}
+interface PropMutationFact {
+    target: string;
+    line: number;
+    column: number;
+}
+interface DangerouslySetInnerHtmlFact {
+    line: number;
+    column: number;
+}
+interface OptimisticUpdateFact {
+    setterName: string;
+    line: number;
+    column: number;
+    hasCatchRollback?: boolean;
+}
+interface StateBinding {
+    valueName?: string;
+    setterName?: string;
+    line: number;
+    column: number;
+    valueReferenced: boolean;
+    setterReferenced: boolean;
+}
+interface PropPassThroughFact {
+    propName: string;
+    toTag: string;
+    line: number;
+    column: number;
+}
+interface ComponentFacts {
+    name?: string;
+    line: number;
+    column: number;
+    endLine: number;
+    isServerComponent: boolean;
+    isMemoWrapped?: boolean;
+    hookCalls: HookFact[];
+    stateBindings: StateBinding[];
+    propBindings: string[];
+    propPassThroughs: PropPassThroughFact[];
+    propUsages: string[];
+}
+interface LogicalExpressionFact {
+    depth: number;
+    line: number;
+    column: number;
+    text: string;
+    isOptionalChainLike: boolean;
+}
+interface StylePropFact {
+    source: string;
+    line: number;
+    column: number;
+}
+interface AstroComponentFact {
+    tag: string;
+    hasClientDirective: boolean;
+    hasEventHandler: boolean;
+    line: number;
+    column: number;
+}
+interface ConsoleCallFact {
+    method: 'log' | 'warn' | 'error' | 'info' | 'debug';
+    line: number;
+    column: number;
+}
+interface DialogCallFact {
+    method: 'alert' | 'confirm' | 'prompt';
+    line: number;
+    column: number;
+}
+interface StringLiteralFact {
+    value: string;
+    line: number;
+    column: number;
+}
+interface JsxTextLiteralFact {
+    value: string;
+    line: number;
+    column: number;
+    parentTag?: string;
+}
+interface CommentFact {
+    kind: 'Line' | 'Block';
+    value: string;
+    line: number;
+    column: number;
+}
+interface StateBindingFact {
+    valueName: string;
+    setterName: string;
+    line: number;
+    column: number;
+}
+interface JsxAttributeStringLiteralFact {
+    value: string;
+    attribute: string;
+    line: number;
+    column: number;
+}
+interface TamaguiStylePropFact {
+    name: string;
+    value: string;
+    line: number;
+    column: number;
+}
+interface KeyPropFact {
+    tag: string;
+    valueType: 'index' | 'missing' | 'stable' | 'unknown';
+    line: number;
+    column: number;
+}
+interface InlineEventHandlerFact {
+    tag: string;
+    event: string;
+    source: string;
+    line: number;
+    column: number;
+    hasMemoParent?: boolean;
+}
+interface UseEffectBodyFact {
+    line: number;
+    column: number;
+    source: string;
+}
+interface DomQueryFact {
+    method: string;
+    line: number;
+    column: number;
+}
+interface ExplicitAnyFact {
+    line: number;
+    column: number;
+    kind?: 'keyword' | 'missing-annotation';
+}
+interface NonNullAssertionFact {
+    line: number;
+    column: number;
+}
+interface ComponentSizeFact {
+    name?: string;
+    lineCount: number;
+    jsxBranchCount: number;
+    line: number;
+    column: number;
+}
+interface HookDependencyArrayFact {
+    hookName: string;
+    depsSource: string;
+    line: number;
+    column: number;
+}
+/**
+ * flat-shape fields have been removed; consumers must read from `v2`.
+ * See src/engine/types.ts for the grouped shape definition.
+ */
+interface ScanFacts {
+    /** Absolute file path. */
+    filePath: string;
+    v2: ScanFactsV2;
+}
+interface ImportFact {
+    source: string;
+    line: number;
+    column: number;
+    importedNames?: string[];
+}
+interface FileScanResult {
+    filePath: string;
+    componentCount: number;
+    issues: Issue[];
+    parseError?: string;
+    gapValues?: string[];
+    styleSources?: string[];
+    elementTags?: string[];
+    unmatchedStringLiterals?: string[];
+    /**
+     *  `// slopbrick-disable` directive filtering. */
+    facts?: ScanFacts;
+}
+interface ComponentScore {
+    filePath: string;
+    rawScore: number;
+    componentScore: number;
+    adjustedScore: number;
+    componentCount: number;
+}
+interface BaselineMeta {
+    active: boolean;
+    version: string;
+    baselineRevision: number;
+    createdAt: string;
+}
+interface ProjectReport {
+    version: string;
+    generatedAt: string;
+    configPath?: string;
+    slopIndex: number;
+    assemblyHealth: number;
+    totalScore: number;
+    categoryScores: Record<Category, number>;
+    /** Phase 2 §10: composite subscores. Each is in 0-100 (capped).
+     *  slopIndex = 0.40 × boundaryScore + 0.35 × contextScore + 0.25 × visualScore. */
+    boundaryScore: number;
+    contextScore: number;
+    visualScore: number;
+    /** Phase 2 §10: ruleId → subscore bucket, used by the composite formula.
+     *  Each issue contributes to exactly one bucket. */
+    subscores?: Record<string, number>;
+    /** Architecture Consistency Score (0-100). 100 = one modal system, one
+     * button variant, one api client, one state lib, one fetch lib, no
+     * off-scale values. Optional because it requires a deeper scan and
+     * is only computed when the project has source files. */
+    architectureConsistency?: number;
+    /** Per-category deductions behind the architecture score. */
+    architectureDeductions?: CategoryDeduction[];
+    /** AI Security Risk — categorical severity for security findings
+     * disproportionately introduced by AI-generated code. Independent
+     * from slopIndex (mixing them would let a project hide one with
+     * the other). Drives the `slopbrick security` subcommand and the
+     * security column in scan reports. */
+    aiSecurityRisk?: 'low' | 'medium' | 'high' | 'critical';
+    /** Count of security findings broken down by severity. */
+    aiSecurityFindings?: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+    /** Phase 7: Business Logic Coherence (0-100). 100 = no anti-pattern
+     * findings across pricing/validation/formatting. Higher is better.
+     * Independent of slopIndex + architectureConsistency. Drives the
+     * `slopbrick business-logic` subcommand. */
+    businessLogicCoherence?: number;
+    /** Phase 7: per-issue list backing the business-logic score. */
+    businessLogicIssues?: BusinessLogicIssue[];
+    /** Phase 5 — Test Quality Score (0-100, lower = more issues). Higher is better.
+     * Independent from slopIndex — derived from the four `test/*` rules when
+     * `slopbrick test` runs. Surfaced in the JSON report and the dedicated
+     * subcommand's pretty output. */
+    testQuality?: number;
+    /** Phase Memo #4 — AI Maintenance Cost (categorical headline + numeric breakdown).
+     *  Derived from the existing signals in this report (no new file scanning).
+     *  Present when `slopbrick scan` or `slopbrick maintenance-cost` runs. */
+    aiMaintenanceCost?: AiMaintenanceCostResult;
+    /** Phase 6 — Documentation Freshness (0-100, higher = better). 100 = no
+     *  stale references found in doc files; 0 = every rule fired on every
+     *  file. Independent of slopIndex — derived from the four `docs/*`
+     *  rules. Surfaced in `slopbrick scan` and the dedicated `slopbrick
+     *  docs` subcommand. */
+    docFreshness?: number;
+    /** Categorical drift band, derived from `docFreshness`. */
+    docDrift?: DocDriftLevel;
+    /** Per-finding list behind the doc-freshness score. */
+    docFindings?: DocFinding[];
+    /** Phase 8 — Database Health (0-100, higher = better). Static-only
+     *  analysis via `pgsql-parser` (libpg_query port). 100 = no anti-patterns
+     *  found in SQL / Prisma / Drizzle schema files. */
+    dbHealth?: number;
+    /** Categorical drift band, derived from `dbHealth`. */
+    dbDrift?: DbDriftLevel;
+    /** Per-finding list behind the db-health score. */
+    dbFindings?: DbFinding[];
+    /** Phase 12 — Repository Health (composite 0-100). The endgame score
+     *  that aggregates every prior sub-score into one number a manager
+     *  reads in two seconds. Always informational; --strict for CI gating. */
+    repositoryHealth?: number;
+    /** Categorical AI Debt band, derived from `repositoryHealth`. */
+    aiDebt?: AiDebt;
+    /** Per-axis breakdown of the composite. */
+    repositoryHealthBreakdown?: Record<string, number>;
+    /** Warnings emitted during composite computation. */
+    repositoryHealthWarnings?: string[];
+    /** v0.9.1 — Repository Coherence (0-100, higher = better). The headline
+     *  score under the new "Repository Coherence Scanner" framing. Composite
+     *  of Architecture Consistency (50%), Pattern Fragmentation (30%),
+     *  Constitution Violations (10%), and AI Debt (10%). Distinct from
+     *  `repositoryHealth` (the older catch-all composite) and from
+     *  `slopIndex` (the per-rule aggregate). */
+    coherence?: number;
+    /** Per-axis breakdown of the Coherence composite. Each input 0-100. */
+    coherenceBreakdown?: {
+        /** Architecture Consistency (existing score, fed in unchanged). */
+        architectureConsistency: number;
+        /** Pattern Fragmentation (inverted to 0-100, higher = better). */
+        patternFragmentation: number;
+        /** Constitution violations count mapped to 0-100. 100 = none. */
+        constitutionMapped: number;
+        /** AI Debt letter band mapped to 0-100. A→95, B→85, C→70, D→50, F→25. */
+        aiDebtMapped: number;
+    };
+    /** Weights actually applied to the Coherence composite (post-renormalization). */
+    coherenceWeights?: {
+        architectureConsistency: number;
+        patternFragmentation: number;
+        constitutionMapped: number;
+        aiDebtMapped: number;
+    };
+    /** v0.9.1 — Code Hygiene domain score (0-100, higher = better). Aggregates
+     *  the 31 "Supporting" rules across logic/test/typo/visual/layout that
+     *  don't fit the Coherence lens but are still useful findings. */
+    codeHygiene?: number;
+    /** Accessibility domain score (0-100, higher = better). Derived from
+     *  the four `wcag/*` rules. */
+    accessibility?: number;
+    /** Performance domain score (0-100, higher = better). Derived from
+     *  the `perf/*` rules. */
+    performance?: number;
+    /** Per-domain issue counts (after the v0.9.1 rule classification). */
+    domainIssues?: Record<string, number>;
+    /** v0.9.2 — Cross-file pattern drift signals. Each signal is a stem
+     *  (concept) realized as 2+ distinct patterns in the same category
+     *  across files. The lens answer: "did this code introduce a new
+     *  pattern when an existing pattern already existed?" */
+    crossFileDrift?: Array<{
+        category: 'modal' | 'button' | 'api' | 'state' | 'dataFetching' | 'service' | 'route' | 'ormModel';
+        stem: string;
+        variants: string[];
+        files: string[];
+    }>;
+    /** v0.9.2 — Cross-category drift: stems that appear in 2+ categories
+     *  with 2+ variants each. E.g. service.User + ormModel.User = same
+     *  conceptual entity spanning 2 roles. */
+    crossCategoryDrift?: Array<{
+        stem: string;
+        byCategory: Record<string, string[]>;
+        files: string[];
+    }>;
+    p90Score: number;
+    peakScore: number;
+    componentCount: number;
+    fileCount: number;
+    components: ComponentScore[];
+    issues: Issue[];
+    parseErrors?: Array<{
+        filePath: string;
+        error: string;
+    }>;
+    baseline?: BaselineMeta;
+    thresholds: {
+        meanSlop: number;
+        p90Slop: number;
+        individualSlopThreshold: number;
+    };
+    /** Research/flywheel snapshot — present when the flywheel directory has artifacts. */
+    research?: ResearchMetrics;
+    topOffenders?: TopOffender[];
+    /**
+     * v0.10.1 — PR Slop Score. Aggregate weighted issue count for the
+     * `--diff <ref>` mode (the VibeDrift-compatible git-ref filter).
+     * Computed as Σ(SEVERITY_WEIGHTS[issue.severity]) for issues in
+     * files changed since the ref. SEVERITY_WEIGHTS = { high: 10,
+     * medium: 5, low: 1 }. Only present when `diffRef` was supplied.
+     * The CI threshold (config.prScoreThreshold) gates on this.
+     */
+    prSlopScore?: number;
+    /** v0.10.1 — the git ref supplied to --diff <ref>. Undefined for full scans. */
+    diffRef?: string;
+}
+interface TopOffender {
+    filePath: string;
+    /** Count of issues attributed to this file (from per-file results). */
+    issueCount: number;
+    /** Adjusted score for the file (post-baseline, post-framework-multiplier). */
+    adjustedScore: number;
+}
+interface BaselineCache {
+    version: string;
+    config_hash: string;
+    git_head: string;
+    baseline_created: string;
+    baseline_revision: number;
+    totalComponentCount: number;
+    scores: Record<string, {
+        baselineScore: number;
+        componentCount: number;
+    }>;
+}
+interface SlopAuditRun {
+    timestamp: string;
+    version: string;
+    slopIndex: number;
+    categoryScores: Record<Category, number>;
+    topOffenseIds: string[];
+    thresholdExceeded: boolean;
+}
+interface AutoTunedRule {
+    ruleId: string;
+    severity: Severity;
+    reason: string;
+}
+interface RuleSuggestion {
+    pattern: string;
+    example: string;
+    count: number;
+    suggestedRuleId: string;
+}
+/**
+ * Optional research/flywheel metrics. Surfaced in the JSON report and the
+ * flywheel summary when present. Generated by the
+ * `research generate | analyze | candidates` pipeline.
+ */
+interface ResearchMetrics {
+    generatedSampleCount: number;
+    generatedRuleCoverage: number;
+    /** Number of fingerprint clusters that turned into candidate rules. */
+    candidateYield: number;
+    /** When the research artifacts were last refreshed. */
+    updatedAt: string;
+}
+interface FlywheelState {
+    version: string;
+    updatedAt: string;
+    autoTuned: AutoTunedRule[];
+    research?: ResearchMetrics;
+}
+interface FlywheelOutput {
+    autoTuned: AutoTunedRule[];
+    hotspotIssues: Issue[];
+    suggestions: RuleSuggestion[];
+    research?: ResearchMetrics;
+}
+interface MagicNumberSpacingConfig {
+    ignoreProperties?: string[];
+    ignoreZero?: boolean;
+}
+interface RuleContext {
+    config: ResolvedConfig;
+    filePath: string;
+    cwd: string;
+    framework?: string;
+    uiLibraries?: string[];
+    hasTailwind?: boolean;
+    supportsRsc?: boolean;
+    hotspotIssues?: Issue[];
+}
+interface Rule<Context = unknown> {
+    id: string;
+    category: Category;
+    severity: Severity;
+    aiSpecific: boolean;
+    /** Round 25: short description shown by `slopbrick rules` and used in docs. */
+    description?: string;
+    create(context: RuleContext): Context;
+    analyze(context: Context, facts: ScanFacts): Issue[];
+}
+interface ResolvedConfig {
+    framework?: string;
+    hasTailwind?: boolean;
+    supportsRsc?: boolean;
+    uiLibraries?: string[];
+    include: string[];
+    exclude: string[];
+    rules: Record<string, RuleSeverity | 'off'>;
+    categoryWeights?: Record<Category, number>;
+    /**
+     *  Defaults to { boundary: 0.40, context: 0.35, visual: 0.25 } when unset. */
+    compositeWeights?: {
+        boundary: number;
+        context: number;
+        visual: number;
+    };
+    frameworkMultipliers: Record<string, number>;
+    ruleConfig: Record<string, unknown>;
+    gapTokens?: string[];
+    globalCssTarget?: string;
+    projectMemory?: boolean;
+    telemetry?: boolean;
+    thresholds: {
+        meanSlop: number;
+        p90Slop: number;
+        individualSlopThreshold: number;
+        /** Round 20: per-category thresholds (security fails, typo warns). Optional. */
+        categoryThresholds?: Partial<Record<Category, number>>;
+    };
+    spacingScale?: number[];
+    /**
+     * Declared border-radius scale in rem (Tailwind default) plus the
+     * string 'full' for the 9999px utility. Numeric values that don't
+     * fall on the scale (after px→rem conversion) trigger the
+     * `visual/radius-scale-violation` rule.
+     */
+    radiusScale?: (number | 'full')[];
+    typographyScale?: string[];
+    arbitraryValueAllowlist: (string | RegExp)[];
+    clampAllowlist?: (string | RegExp)[];
+    /** Phase 2 §10: allowed import paths from brick.config.json. Imports
+     *  from `@/components/*` not matching these patterns are flagged by
+     *  `context/import-path-mismatch`. */
+    allowedImports?: string[];
+    wcag: {
+        targetSizeExemptSelectors: string[];
+        targetSizeRequireTailwind?: boolean;
+    };
+    /**
+     * Declared repository constitution: "this repo uses Zustand for
+     * state, shadcn for UI, react-query for data fetching" plus an
+     * explicit deny-list of forbidden packages. Drives the `slop_suggest`
+     * and `slop_check_constitution` MCP tools and the
+     * `slopbrick drift` reporter. Auto-detected from package.json when
+     * unset; user declarations always win (including explicit empty
+     * arrays, which mean "we deliberately don't use this category").
+     */
+    constitution?: Constitution;
+    /**
+     * PR slop score threshold (Phase 11). `slopbrick pr` exits 1 when
+     * the PR introduces more than this many weighted slop points across
+     * the changed files. Default: 20. Lower it to fail PRs that add any
+     * meaningful slop; raise it to be more permissive. Overridden on
+     * the CLI by `--threshold <n>`.
+     */
+    prScoreThreshold?: number;
+    /**
+     * Phase 5 — Test Intelligence opt-in toggles. The four `test/*`
+     * rules are safe-by-default (each rule short-circuits on non-test
+     * files via `isTestFile()`), but `test/missing-edge-case` walks
+     * production code to find untested branches. Off by default —
+     * opt-in per project.
+     */
+    testIntelligence?: {
+        /** Walk production AST to find branches without test coverage. */
+        missingEdgeCase?: boolean;
+    };
+}
+
+type Framework = 'react' | 'vue' | 'svelte' | 'solid' | 'qwik' | 'astro' | 'react-native' | 'expo';
+type StylingSolution = 'tailwind' | 'css-modules' | 'styled-components' | 'emotion' | 'panda' | 'other';
+type UiLibrary = 'shadcn/ui' | 'mui' | 'chakra' | 'radix' | 'tamagui' | 'nativewind';
+type Strictness = 'strict' | 'balanced' | 'permissive';
+interface WizardAnswers {
+    framework: Framework;
+    styling: StylingSolution;
+    uiLibraries: UiLibrary[];
+    strictness: Strictness;
+}
+declare const DEFAULT_CONFIG: ResolvedConfig;
+
+declare function loadConfig(cwd: string): Promise<ResolvedConfig>;
+
+interface ScanProjectOptions {
+    cwd: string;
+    framework?: string;
+    include?: string[];
+    exclude?: string[];
+    aiOnly?: boolean;
+    humanOnly?: boolean;
+    ignoreWcag22?: boolean;
+    since?: string;
+    staged?: boolean;
+    changed?: boolean;
+    /** v0.10.1: VibeDrift-compatible git-ref filter. When set, only files
+     * changed since this ref are scanned and the report includes a
+     * PR Slop Score. Equivalent to --since <ref> + PR Slop Score. */
+    diffRef?: string;
+    incremental?: boolean;
+    cachePath?: string;
+    tokens?: string;
+    threadCount?: number;
+    tighten?: boolean;
+    workerScript?: string;
+    strict?: boolean;
+    noIncrease?: boolean;
+    cache?: boolean;
+    telemetry?: boolean;
+}
+declare function scanProject(options: ScanProjectOptions): Promise<ProjectReport>;
+
+declare function runInitWizard(cwd: string, detected: Partial<ResolvedConfig>, options?: {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}): Promise<WizardAnswers>;
+
+declare function runCli({ start }: {
+    start: number;
+}): Promise<void>;
+
+declare function thresholdExceeded(report: ProjectReport, config: ResolvedConfig): boolean;
+declare function failedThresholdCount(report: ProjectReport, config: ResolvedConfig): number;
+declare function baselineStatusMessage(baseline: BaselineMeta): string;
+interface StagedGatingResult {
+    failed: boolean;
+    reason?: string;
+}
+/**
+ * Decide whether a staged set of changed files should block the commit.
+ *
+ * Without a baseline, falls back to per-file threshold checks. With a
+ * baseline, simulates the post-change project state (new + modified -
+ * deleted components) and compares the hypothetical mean to the
+ * configured `meanSlop`.
+ */
+declare function stagedGating(scores: ComponentScore[], config: ResolvedConfig, baseline: BaselineCache | undefined, cwd: string): StagedGatingResult;
+interface IssueFilterOptions {
+    aiOnly?: boolean;
+    humanOnly?: boolean;
+    ignoreWcag22?: boolean;
+    rule?: string;
+}
+declare function filterIssues(issues: Issue[], options: IssueFilterOptions): Issue[];
+/**
+ * Drop issues suppressed by inline `// slopbrick-disable[-next-line]`
+ * or block directives at or above the issue's line. Project-level rules
+ * (no filePath) are never suppressed.
+ */
+declare function filterByDisabledDirectives(result: FileScanResult, disabledRules: readonly {
+    ruleId: string;
+    scope: 'line' | 'next-line' | 'block';
+    line: number;
+}[]): void;
+declare function serializeConfig(config: ResolvedConfig): string;
+type ReportReadResult = {
+    ok: true;
+    report: ProjectReport;
+} | {
+    ok: false;
+    error: string;
+};
+declare function readReportFile(path: string): ReportReadResult;
+declare function formatReportFromFile(report: ProjectReport, sourcePath: string): string;
+
+declare function colorForSlop(slopIndex: number): string;
+declare function formatBadge(report: ProjectReport): string;
+/** Render an array of values as a Unicode sparkline (▁▂▃▄▅▆▇█). */
+declare function formatSparkline(values: number[]): string;
+
+/**
+ * v0.10.1: `find_similar_function` engine.
+ *
+ * Given a function/component signature (name + parameter list + hooks
+ * used), find the most similar existing implementations across the
+ * codebase. Foundation for the GIR (Give-Implementation-Reference)
+ * pattern in `slop_suggest` and the BRICK Platform.
+ *
+ * Algorithm (no LLMs, no embeddings — hash-based AST fingerprinting
+ * per Chilowicz 2009, "Syntax Tree Fingerprinting for Code Clone
+ * Detection"; also see Maurer 2017 for a modern take on the same
+ * approach applied to JS/TS):
+ *
+ *   1. Walk the codebase and extract each function/component signature.
+ *      Signature = (name, normalized param list, hooks used, props).
+ *   2. Compute a deterministic fingerprint per signature:
+ *      fingerprint = sha256(sorted(hooks) | sorted(props) | sorted(params))
+ *   3. Given a query signature, compute Jaccard similarity to every
+ *      extracted signature over the union of (hooks ∪ props ∪ params).
+ *   4. Return top-k matches sorted by similarity desc.
+ *
+ * Why this matters: AI agents writing new code ask "does this pattern
+ * already exist?" before inventing new ones. `find_similar_function`
+ * is the deterministic, citation-backed answer — no LLM hallucination,
+ * no embedding dependency, fast even on 100k+ files.
+ */
+/**
+ * Normalized signature for a single function/component in the codebase.
+ */
+interface ComponentSignature {
+    /** Function/component name (PascalCase for components, camelCase for hooks). */
+    name: string;
+    /** Absolute path of the file the signature lives in. */
+    file: string;
+    /** Path relative to the workspace, for display in results. */
+    fileRel: string;
+    /** Line number (1-indexed) where the signature is defined. */
+    line: number;
+    /** Sorted, deduplicated parameter names (without `:` types). */
+    params: string[];
+    /** React hooks used (useState, useEffect, etc.). */
+    hooks: string[];
+    /** Component props accepted (for React components). */
+    props: string[];
+}
+/** A single result from `findSimilarFunctions`. */
+interface SimilarMatch {
+    /** The matched signature. */
+    signature: ComponentSignature;
+    /** Jaccard similarity in [0, 1]. 1 = identical feature set, 0 = disjoint. */
+    similarity: number;
+    /** Stable fingerprint hash. Two identical signatures always match. */
+    fingerprint: string;
+}
+/** Query for `findSimilarFunctions`. */
+interface FindSimilarQuery {
+    /** Optional name filter (exact match). */
+    name?: string;
+    /** Optional hooks filter (e.g., ['useState', 'useEffect']). */
+    hooks?: string[];
+    /** Optional props filter. */
+    props?: string[];
+    /** Optional params filter. */
+    params?: string[];
+    /** Top-k results to return. Default 10. Capped at 50. */
+    limit?: number;
+    /** Workspace directory to search. */
+    workspaceDir: string;
+}
+/**
+ * Extract every component/function signature from a single source string.
+ * Pure function — no I/O.
+ */
+declare function extractSignatures(source: string, filePath: string, workspaceDir: string): ComponentSignature[];
+/** Stable fingerprint: sha256 over sorted feature set. */
+declare function fingerprintSignature(sig: Pick<ComponentSignature, 'hooks' | 'props' | 'params'>): string;
+/**
+ * Jaccard similarity over the union of (hooks ∪ props ∪ params).
+ * Returns 0..1. Identical sets → 1. Disjoint → 0.
+ */
+declare function signatureSimilarity(a: Pick<ComponentSignature, 'hooks' | 'props' | 'params'>, b: Pick<ComponentSignature, 'hooks' | 'props' | 'params'>): number;
+/**
+ * Walk the workspace, extract signatures from every included file, and
+ * return top-k matches sorted by Jaccard similarity desc.
+ *
+ * Pure-ish: the file walking uses async I/O but the similarity math is
+ * synchronous (it's microseconds per signature, even on 10k files).
+ */
+declare function findSimilarFunctions(query: FindSimilarQuery, options?: {
+    cwd?: string;
+    include?: string[];
+    exclude?: string[];
+}): Promise<SimilarMatch[]>;
+
+export { AI_SECURITY_NUMERIC, type AiDebt, type AiMaintenanceCost, type AiMaintenanceCostResult, type AstroComponentFact, type AutoTunedRule, type BaselineCache, type BaselineMeta, type CachedFile, type Category, type ClassNameFact, type CommentFact, type ComponentFacts, type ComponentScore, type ComponentSignature, type ComponentSizeFact, type ConsoleCallFact, type Constitution, DEFAULT_CONFIG, type DangerouslySetInnerHtmlFact, type DbDriftLevel, type DbFinding, type DialogCallFact, type DisabledLintRuleFact, type DocDriftLevel, type DocFinding, type DomQueryFact, type ElementFact, type EvalCallFact, type ExplicitAnyFact, type FetchCallFact, type FileScanResult, type FindSimilarQuery, type FixSuggestion, type FlywheelOutput, type FlywheelState, type Framework$1 as Framework, type HookCallFact, type HookDependencyArrayFact, type HookFact, type ImportFact, type InlineEventHandlerFact, type Issue, type JsxAttributeStringLiteralFact, type JsxTextLiteralFact, type KeyPropFact, type LogicalExpressionFact, type MagicNumberSpacingConfig, type MaintenanceAxes, type MaintenanceAxisHealth, type NonNullAssertionFact, type OptimisticUpdateFact, type ProjectReport, type PropMutationFact, type PropPassThroughFact, REPOSITORY_HEALTH_WEIGHTS, type ReportReadResult, type RepositoryHealth, type RepositoryHealthInputs, type ResearchMetrics, type ResolvedConfig, type Rule, type RuleContext, type RuleSeverity, type RuleSuggestion, type ScanCache, type ScanFacts, type ScanProjectOptions, type Severity, type SimilarMatch, type SlopAuditRun, type StateBinding, type StateBindingFact, type StringLiteralFact, type StylePropFact, type TamaguiStylePropFact, type TopOffender, type UseEffectBodyFact, VERSION, baselineStatusMessage, colorForSlop, extractSignatures, failedThresholdCount, filterByDisabledDirectives, filterIssues, findSimilarFunctions, fingerprintSignature, formatBadge, formatReportFromFile, formatSparkline, loadConfig, readReportFile, runCli, runInitWizard, scanProject, serializeConfig, signatureSimilarity, stagedGating, thresholdExceeded };