code-auditor-mcp 4.1.1 → 5.0.2

package/dist/analyzers/receiverRoot.d.ts

@@ -0,0 +1,348 @@
+/**
+ * Receiver root resolution — Spec 69 §10 S5e.
+ *
+ * cannot-fire keys to the *receiver's root resolution being inconclusive*, not
+ * to the callee's method name. Every query-candidate receiver resolves to a root
+ * identifier, and that root gets one of three dispositions:
+ *
+ *   • `handle`     — the root resolves to a DB handle (package import, DB-handle
+ *                    type annotation, wrapper class/function, or form-5 function
+ *                    return). The finding path extracts it; no coverage offset.
+ *   • `not-handle` — the root resolves to something that is *definitively* not a
+ *                    DB handle: an ambient global (no binding anywhere in the
+ *                    file's scope chain), a literal / primitive / object / array
+ *                    declaration, a non-DB-typed parameter, or a non-DB
+ *                    constructor (`new URLSearchParams()`).
+ *                    `clean` is the *correct* outcome, not a silent one.
+ *   • `unproven`   — the root resolves to something genuinely undetermined: a
+ *                    `any`/`unknown` type, an un-annotated parameter, an
+ *                    un-annotated factory return, an unresolvable import, or an
+ *                    unrecognized bare-specifier package (Spec 70 R4 — not in the
+ *                    database-packages manifest). This is the cannot-fire surface
+ *                    (Spec 69 §10 S5a).
+ *
+ * There is NO identifier list on either side. A global is `not-handle` because it
+ * resolved to the global scope (no binding), not because it was enumerated; a
+ * name is `handle` because it resolved to a DB package/type/wrapper, not because
+ * it *looks* like `db`.
+ */
+import type { AST, LanguageAdapter, ASTNode } from '../languages/types.js';
+import type { ProvenanceEvidence } from './provenance.js';
+/** A receiver root's disposition (Spec 69 §10 S5e). */
+export type RootDisposition = 'handle' | 'not-handle' | 'unproven';
+/**
+ * Where an import specifier resolves — the one specifier-resolution seam (Spec 70
+ * B1): relative, tsconfig-`paths` alias, bare (tsconfig-`paths` → in-repo, else
+ * node_modules vendor `.d.ts`), and the `@/`/`~/` fallback all answer through one
+ * `resolveSpecifier`. `classifyImportSource` reads `in-repo` to abstain on an
+ * unwalked export chain; Item 1 reads `vendor` to resolve a base class to its
+ * declaration. `unresolved` means no in-repo file and no node_modules type
+ * declaration existed.
+ */
+export type SpecifierResolution = {
+    readonly kind: 'in-repo';
+    readonly path: string;
+} | {
+    readonly kind: 'vendor';
+    readonly path: string;
+} | {
+    readonly kind: 'unresolved';
+};
+/**
+ * The fold-time heritage seam (Spec 70 Q3, Item 1): resolve `this.<field>` on a
+ * worker base class to its declared field type by reading the base class's
+ * declaration in the project's declared dependencies' `.d.ts` and substituting
+ * the heritage's type arguments. Returns `null` (abstain) when the base class,
+ * the field, or a referenced type argument cannot be resolved — never a guessed
+ * clean. Absent from the env (the Go path, the build-side R3 fold, and callers
+ * with no declared dependencies), the classifier abstains on every heritage arm.
+ */
+export type HeritageFieldResolver = (base: string, field: string, args: readonly string[]) => string | null;
+/** How a name is bound in the file's scope chain. */
+export type BindingKind = 'import' | 'variable' | 'parameter' | 'field' | 'function' | 'class' | 'type';
+/** How an import binding's specifier was written (Spec 70 criterion 10). A
+ *  default/namespace import's local name is arbitrary (it is the package's
+ *  handle), while a named import's name is the handle only when the manifest
+ *  lists it. */
+export type ImportKind = 'default' | 'named' | 'namespace';
+/**
+ * A serializable description of a binding's initializer/value expression,
+ * extracted from the AST while it lives so a binding can outlive its file
+ * without carrying a tree-sitter node (Spec 70 — no AST outliving its file).
+ *
+ * Classification (which depends on the file's provenance + bindings, unknown at
+ * extraction time) is deferred to {@link classifyValue}; the descriptor carries
+ * only names and structure, never a node.
+ */
+export type ValueDescriptor = {
+    readonly kind: 'literal';
+} | {
+    readonly kind: 'identifier';
+    readonly name: string;
+} | {
+    readonly kind: 'new';
+    readonly ctorName: string | null;
+} | {
+    readonly kind: 'call';
+    readonly calleeKind: 'identifier' | 'member' | 'other';
+    readonly calleeName: string | null;
+    readonly receiverRoot: string | null;
+} | {
+    readonly kind: 'member';
+    readonly root: string | null;
+} | {
+    readonly kind: 'as';
+    readonly typeText: string | null;
+    readonly operand: ValueDescriptor | null;
+} | {
+    readonly kind: 'unwrap';
+    readonly operand: ValueDescriptor | null;
+} | {
+    readonly kind: 'function';
+} | {
+    readonly kind: 'other';
+};
+/** A single binding: how a name is declared in a file. */
+export interface Binding {
+    kind: BindingKind;
+    /** Import source specifier (kind === 'import'). */
+    source?: string;
+    /** How an import was written (kind === 'import'): default / named / namespace.
+     *  Absent on older/foreign bindings, read as `named` by the classifier. */
+    importKind?: ImportKind;
+    /** Type-annotation text (variable / parameter / field / function return). */
+    typeText?: string;
+    /** Initializer / value expression, as a serializable descriptor (variable /
+     *  field). Never a live AST node — the binding may outlive its file's tree. */
+    value?: ValueDescriptor;
+    /**
+     * The binding's enclosing scope — the start byte offset of the enclosing
+     * function (`range[0]`), `0` for top-level. Two same-named bindings in
+     * different functions are distinct bindings, not a collision; a flat
+     * name-keyed map collapses them, so the classifier keys on scope when a
+     * reference's scope is known. Absent on older/foreign bindings (read as
+     * scope-agnostic by the classifier — falls back to the flat lookup).
+     */
+    scope?: number;
+}
+/** Per-file resolution inputs the classifier reads. */
+export interface RootResolutionEnv {
+    /** Already-provenanced DB handles (package imports + propagation + wrappers). */
+    provenance: ReadonlyMap<string, ProvenanceEvidence>;
+    /** name → binding (import / declaration / parameter / field). */
+    bindings: ReadonlyMap<string, Binding>;
+    /**
+     * name → (enclosing scope → binding), the scope-keyed index that disambiguates
+     * two same-named bindings in different functions. When a reference carries a
+     * `scope` (the classifier's `opts.scope`), the lookup prefers the binding with
+     * that exact scope and falls back to the flat `bindings` map (a same-name
+     * binding in an enclosing scope). Absent on the Go env and in callers that
+     * classify with no reference scope — the flat lookup then applies unchanged.
+     */
+    bindingsByScope?: ReadonlyMap<string, ReadonlyMap<number, Binding>>;
+    /**
+     * Resolve an import specifier through the one specifier-resolution seam (Spec
+     * 70 B1): relative, tsconfig-`paths` alias, bare (tsconfig-`paths` → in-repo,
+     * else node_modules vendor `.d.ts`), and the `@/`/`~/` fallback. Returns a
+     * tagged `SpecifierResolution`, or null when no resolver was threaded (the Go
+     * path and bare-root callers abstain). `classifyImportSource` reads `in-repo`
+     * to abstain on an unwalked export chain; the base-class heritage reader reads
+     * `vendor` to resolve a declaration (Spec 70 Q/B2).
+     */
+    resolveImport?: (source: string) => SpecifierResolution | null;
+    /**
+     * Interface / type-alias field types, keyed `interfaceName → fieldName → typeText`
+     * (`interface Env { DB: D1Database }` → `Env → { DB: 'D1Database' }`). The
+     * member-chain resolution arm (Spec 70 decision B3) reads this to resolve a
+     * member receiver (`env.DB`) through its interface's field type — `env` typed
+     * `Env` is not a handle, but `Env.DB` is `D1Database`, which is. Absent in the
+     * Go env and in callers that classify a bare root with no member chain.
+     */
+    interfaceFields?: ReadonlyMap<string, ReadonlyMap<string, string>>;
+    /**
+     * Project-level declared type packages — package.json `dependencies` ∪
+     * `devDependencies` ∪ tsconfig `compilerOptions.types`. The ambient arm of
+     * `classifyTypeText` (an unbound DB-handle type name) credits `handle` only
+     * when a manifest package that declares the name is present here; absent, the
+     * arm abstains (`unproven`) — no declared dependency, no ambient credit (Spec
+     * 70 criterion 9, Item 3).
+     */
+    declaredTypePackages?: ReadonlySet<string>;
+    /**
+     * The fold-time heritage seam (Spec 70 Q3, Item 1): resolve `this.<field>` on
+     * a worker base class to its declared field type by reading the base class's
+     * declaration in the project's declared dependencies' `.d.ts` and substituting
+     * the heritage's type arguments. Absent (Go env, build-side R3 fold, callers
+     * with no declared dependencies), the heritage arm in {@link classifyRootIdentifier}
+     * abstains (`unproven`). Built once per project by `makeHeritageResolver` in
+     * `receiverResolution.ts`.
+     */
+    resolveHeritageField?: HeritageFieldResolver;
+    /**
+     * Out-param populated by `classifyTypeText` when it rejects the ambient arm:
+     * an unbound DB-handle type name whose declaring package is not a declared
+     * dependency. `resolveRoot` clears it before classifying and reads it to give
+     * the cannot-fire reason "the type name resolved to nothing" instead of the
+     * generic binding cause.
+     */
+    ambientRejectionReason?: string;
+    /**
+     * Out-param populated by `classifyImportSource` when an import resolved to an
+     * in-repo file whose export chain is not walked here (Spec 70 B1): the
+     * disposition is `unproven`, and `resolveRoot` reads this to give the
+     * cannot-fire reason "resolves to in-repo file … whose export chain is not
+     * walked here" instead of the generic binding cause.
+     */
+    importResolutionReason?: string;
+    /**
+     * Out-param populated by `classifyImportSource` when an import's bare package
+     * name is a *declared* dependency of the project yet absent from the database
+     * manifest (Fix 2): the disposition is `not-handle` — the declaration resolves
+     * to a known non-database package, which is resolution disproving — and
+     * `resolveRoot` reads this to give the verdict reason "resolves to `<pkg>`, a
+     * declared non-database package" instead of the bare disposition string.
+     */
+    importNotHandleReason?: string;
+    /** The adapter + source text for reading value/type node text. */
+    adapter: LanguageAdapter;
+    sourceCode: string;
+}
+/** Collapse the full binding list into the flat name-keyed map — first wins
+ *  (declaration order). This is the legacy `buildBindingEnv` the classifier
+ *  reads when a reference's scope is unknown; the scope-aware `resolveBinding`
+ *  prefers `buildBindingScopeIndex` and falls back here for an enclosing scope.
+ *
+ * @param ast the parsed file AST
+ * @param adapter the language adapter (imports + declaration walk)
+ * @param sourceCode the file source text
+ * @returns the flat name → first-wins binding map */
+export declare function buildBindingEnv(ast: AST, adapter: LanguageAdapter, sourceCode: string): Map<string, Binding>;
+/** The scope-keyed binding index: name → (enclosing scope → binding), with *no*
+ *  name collapse. The classifier's scope-aware lookup reads this to resolve a
+ *  reference to the same-scoped binding when two same-named bindings live in
+ *  different functions; a scope with no entry for the name falls back to the
+ *  flat `buildBindingEnv` map (a same-name binding in an enclosing scope).
+ *
+ * @param ast the parsed file AST
+ * @param adapter the language adapter (imports + declaration walk)
+ * @param sourceCode the file source text
+ * @returns name → (enclosing scope → binding), no name collapse */
+export declare function buildBindingScopeIndex(ast: AST, adapter: LanguageAdapter, sourceCode: string): Map<string, Map<number, Binding>>;
+/**
+ * Extract interface and type-alias field-type maps (`Env → { DB: 'D1Database' }`)
+ * for the member-chain resolution arm (Spec 70 decision B3). Walks
+ * `interface_declaration` bodies (`interface_body`) and `type_alias_declaration`
+ * object-literal bodies (`object_type`) for `property_signature` nodes, mapping
+ * each declared field name to its type text. A name with a body but no typed
+ * fields still yields a (possibly empty) entry — the entry's presence tells
+ * {@link classifyMemberPath} the name is a *known* interface, so an unknown
+ * field cannot-fire rather than falls back to the bare type name.
+ *
+ * @param ast the parsed file AST to walk for interface/type-alias declarations
+ * @param adapter the language adapter used to find and read declaration nodes
+ * @param sourceCode the file source text for reading node text
+ * @returns a name → field-name → type-text map for every interface/type alias
+ */
+export declare function extractInterfaceFields(ast: AST, adapter: LanguageAdapter, sourceCode: string): Map<string, Map<string, string>>;
+/**
+ * Classify a bare root identifier's disposition under the file's resolution env.
+ *
+ * @param name the bare root identifier to classify
+ * @param env the file's resolution environment (provenance, bindings, adapter)
+ * @param depth recursion guard; classification gives up past depth 8
+ * @param opts `thisField` marks the name as a `this.<field>` reference;
+ *            `memberPath` is the receiver's member chain after the root
+ *            (e.g. `env.DB.prepare` → `['DB']`), resolved through the root's
+ *            interface field types when present (Spec 70 decision B3)
+ * @returns `handle`, `not-handle`, or `unproven`
+ */
+export declare function classifyRootIdentifier(name: string, env: RootResolutionEnv, depth?: number, opts?: {
+    thisField?: boolean;
+    memberPath?: readonly string[];
+    thisHeritage?: string | null;
+    scope?: number;
+}): RootDisposition;
+/**
+ * Derive the receiver's member path after the root from the site strings (Spec 70
+ * decision B3). `receiver` is the member-chain text left of the method (`env.DB`
+ * for `env.DB.prepare`); `root` is its leftmost identifier (`env`); the path is
+ * the non-root segments (`['DB']`). A `this`/`super`-rooted receiver has no
+ * resolvable member path (its `thisField` guard already leaves it unproven), and
+ * any segment that is not a plain identifier (a method name, an index, a call
+ * result) is dropped to empty — only declared interface fields are resolvable.
+ *
+ * @param root the receiver's leftmost identifier
+ * @param receiver the member-chain text left of the method
+ * @param thisField true when the receiver is a `this`/`super` field
+ * @returns the non-root member-path segments, or an empty array when not resolvable
+ */
+export declare function deriveMemberPath(root: string, receiver: string, thisField: boolean): readonly string[];
+/**
+ * Derive the member path after the root for a `this`/`super`-rooted receiver
+ * (Spec 70 Q3): `this.env.DB` → root `env`, path `['DB']`. Unlike
+ * {@link deriveMemberPath} (which returns `[]` for a `this`-rooted receiver), the
+ * `this.`/`super.` prefix is stripped first so the root's member chain is
+ * recoverable — it resolves through the root's base-class field type (`this.env`
+ * is `Env`) and then the same interface-field seam as B3.
+ *
+ * @param root the receiver's leftmost identifier (after the `this.`/`super.` strip)
+ * @param receiver the member-chain text left of the method
+ * @returns the member-path segments after the root, or an empty array when not resolvable
+ */
+export declare function deriveThisMemberPath(root: string, receiver: string): readonly string[];
+/**
+ * True when a receiver root is DB-shaped — its disposition is `handle` or
+ * `unproven` — never a name list. This is the package-discriminant replacement
+ * for the deleted `DB_CALL_METHODS` / `isDbShapedMethod` candidacy filters: a
+ * call is a DB/ORM candidate when its receiver resolves to a DB package/handle
+ * or to something unresolved, and NOT when it resolves to a provably non-DB
+ * receiver (a JS global, primitive, or Node builtin). `join` is
+ * `Array.prototype.join` (root `Array` → not-handle) and also `SQL JOIN`
+ * (root `db` → handle) — the receiver's resolution, not the method name,
+ * distinguishes them.
+ *
+ * @param root the bare receiver-root identifier to classify
+ * @param env the file's resolution environment (provenance, bindings, adapter)
+ * @returns true unless the root provably resolves to a non-DB receiver
+ */
+export declare function isDbShapedRoot(root: string, env: RootResolutionEnv, opts?: {
+    thisField?: boolean;
+}): boolean;
+/**
+ * Strip a module specifier to its bare package name — `@scope/pkg/sub` →
+ * `@scope/pkg`, `pkg/sub` → `pkg` — or `null` when the specifier is not a bare
+ * package (a relative/alias/absolute path such as `./x`, `../x`, `@/x`, `~/x`,
+ * or `/x`). The Fix 2 / Fix 1 discriminant: a bare package name is a *package*
+ * the project declares (or an unrecognized one reached by resolution); a
+ * relative/alias path is an in-repo file, whose export chain is not walked here.
+ * @param specifier the module specifier to strip
+ * @returns the bare package name, or `null` when `specifier` is not a bare package
+ */
+export declare function barePackageName(specifier: string): string | null;
+/**
+ * Resolve a member/selector chain to its root identifier name (the leftmost
+ * segment, descending through call expressions for builder chains). Returns the
+ * bare name (`"db"` for `db.select().from()`, `"page"` for `page.locator()`), or
+ * `null` when the root is a literal (array/object/string) or otherwise not an
+ * identifier.
+ *
+ * @param callee the member/selector/identifier expression to resolve
+ * @param adapter the language adapter used to read children and text
+ * @param sourceCode the file source text for reading node text
+ * @returns the leftmost identifier name, or null for a non-identifier root
+ */
+export declare function resolveReceiverRoot(callee: ASTNode, adapter: LanguageAdapter, sourceCode: string): string | null;
+/**
+ * The enclosing class declaration's `extends` clause text
+ * (`WorkflowEntrypoint<Env>`), or null when the node is not inside a class or
+ * the class has no base class. The smallest enclosing class wins (nested classes
+ * resolve to the innermost), matching the deleted form-3 producer.
+ *
+ * @param ast the parsed file AST searched for enclosing classes
+ * @param adapter the language adapter used to find and read class nodes
+ * @param node the node whose enclosing class heritage is sought
+ * @param sourceCode the file source text for reading the heritage text
+ * @returns the enclosing class's `extends` clause text, or null when none applies
+ */
+export declare function findEnclosingClassHeritage(ast: AST, adapter: LanguageAdapter, node: ASTNode, sourceCode: string): string | null;
+//# sourceMappingURL=receiverRoot.d.ts.map

package/dist/analyzers/receiverRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receiverRoot.d.ts","sourceRoot":"","sources":["../../src/analyzers/receiverRoot.ts"],"names":[],"mappings":"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"}