no-mistakes 0.93.0 → 0.95.0

package/analyze-project-types.d.ts

@@ -55,13 +55,14 @@ type BatchedServerRouteRelatedOptions = BatchedProjectOptions &
   ({ files: string[] } | { roots: string[] });
 type BatchedReactUsagesOptions = Pick<
   ProjectOptions,
-  "root" | "tsconfig" | "config" | "targets" | "include"
+  "root" | "tsconfig" | "config" | "targets" | "include" | "effort"
 > &
   Required<Pick<ProjectOptions, "target">>;
 type BatchedCheckOptions = Pick<
   CheckOptions,
-  "root" | "tsconfig" | "config" | "includeSuppressed" | "includeRunnerConfigDeadlines"
->;
+  "root" | "tsconfig" | "config" | "includeSuppressed" | "effort"
+> &
+  Pick<CheckOptions, "includeRunnerConfigDeadlines" | "includeSqlVerdicts">;
 type BatchedQueryFileOptions<T> = Omit<T, "root" | "tsconfig">;
 type BatchedRootConfigOptions<T> = Omit<T, "root" | "config">;
 type BatchedRootTsConfigOptions<T> = Omit<T, "root" | "tsconfig" | "config">;
@@ -84,7 +85,7 @@ export type AnalyzeProjectReportRequest =
   | ({ type: "serverRouteRelated"; id?: string } & BatchedServerRouteRelatedOptions)
   | ({ type: "reactAnalyze" | "reactCheck"; id?: string } & Pick<
       ProjectOptions,
-      "targets" | "depth" | "assertNoFetch"
+      "targets" | "depth" | "assertNoFetch" | "effort"
     >)
   | ({ type: "reactUsages"; id?: string } & BatchedReactUsagesOptions)
   | ({

package/check-report-types.d.ts

@@ -1,20 +1,69 @@
 import type { QueueCheckFinding } from "./queue-report-types";
 import type { ReactViolation } from "./react-report-types";
+import type { Effort } from "./traversal-types";
+
+/** A low-effort rule that used maximum analysis because a required partner was unavailable. */
+export interface AnalysisFallback {
+  /** Canonical rule identifier. */
+  rule: string;
+  /** Required partner check that could not be validated in scope. */
+  partner: string;
+  requested: Effort;
+  effective: Effort;
+}
 
 export interface CheckReport {
   react: ReactViolation[];
   queues: QueueCheckFinding[];
   rules: RuleFinding[];
   integration: IntegrationFinding[];
+  /** Partner-backed low-effort rules that fell back to maximum analysis; omitted when empty. */
+  analysisFallbacks?: AnalysisFallback[];
   /** Present only when requested; declaration evidence, not runtime closure. */
   runnerConfigDeadlines?: RunnerConfigDeadlineEvidence[];
   codebase: UniqueExportFinding[];
   warnings: string[];
+  /**
+   * SQL-looking member `.query` calls that were not proven to be executors.
+   * Omitted when zero. Not a failure and not part of `warnings`.
+   */
+  unprovenMemberQuerySql?: number;
   advisories: RuleFinding[];
+  /** Present only when `includeSqlVerdicts` is requested, including an empty array. */
+  sqlVerdicts?: SqlObligationVerdict[];
   /** Present when `includeSuppressed` is requested; empty when no directives matched. */
   suppressed?: SuppressedFinding[];
 }
 
+export type SqlVerdictStatus = "violation" | "proven-clear" | "abstain";
+export type SqlEvidenceKind = "exact" | "exhaustive-union" | "verified-prefix" | "policy-exemption";
+export interface SqlExecutorProfile {
+  importSpecifier: string;
+  executorNames: string[];
+  executorFactoryNames: string[];
+  executorTypeNames: string[];
+  trustedSqlTags: { module: string; name: string }[];
+}
+/** Zero-based ordinal among enabled applications of the same rule in config order. */
+export interface SqlRuleApplication {
+  index: number;
+  name?: string;
+}
+export interface SqlObligationVerdict {
+  profile: SqlExecutorProfile;
+  rule: string;
+  application?: SqlRuleApplication;
+  subcheck: string;
+  file: string;
+  span: [number, number];
+  status: SqlVerdictStatus;
+  advisory: boolean;
+  evidence?: SqlEvidenceKind;
+  knownPrefix?: string;
+  helperLines?: number[];
+  residualReasons?: string[];
+}
+
 export interface SuppressedFinding {
   domain: "react" | "queues" | "rules" | "filesystem" | "integration" | "codebase" | "advisories";
   rule: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.93.0",
+  "version": "0.95.0",
   "description": "Deterministic impact maps, test plans, Playwright coverage, and repository checks for coding agents",
   "license": "MIT",
   "repository": {
@@ -65,9 +65,9 @@
     }
   },
   "optionalDependencies": {
-    "no-mistakes-darwin-arm64": "0.93.0",
-    "no-mistakes-linux-arm64-gnu": "0.93.0",
-    "no-mistakes-linux-x64-gnu": "0.93.0",
-    "no-mistakes-win32-x64-msvc": "0.93.0"
+    "no-mistakes-darwin-arm64": "0.95.0",
+    "no-mistakes-linux-arm64-gnu": "0.95.0",
+    "no-mistakes-linux-x64-gnu": "0.95.0",
+    "no-mistakes-win32-x64-msvc": "0.95.0"
   }
 }

package/postgres-query-annotation-types.d.ts

@@ -1,5 +1,7 @@
-/** Policy for executor SQL whose leading text cannot be proven. Defaults to `report`. */
-export type PostgresUnanalyzableSql = "report" | "ignore";
+import type { Effort, Unanalyzable } from "./traversal-types";
+
+/** Backward-compatible SQL-specific name for the shared unanalyzable policy. */
+export type PostgresUnanalyzableSql = Unanalyzable;
 
 /** Configuration options for the `postgres-require-query-annotation` check rule. */
 export interface PostgresRequireQueryAnnotationOptions {
@@ -9,6 +11,9 @@ export interface PostgresRequireQueryAnnotationOptions {
   executorNames?: string[];
   executorFactoryNames?: string[];
   executorTypeNames?: string[];
+  /** @deprecated At effort "low" only; ignored there and warns when configured. Still used at effort "max". */
   trustedSqlTags?: { module: string; name: string }[];
+  effort?: Effort;
+  unanalyzable?: Unanalyzable;
   unanalyzableSql?: PostgresUnanalyzableSql;
 }

package/swift-command-types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Literal per-package Swift runner argv from `tests.swift.baseCommands`.
+ * Keys are declared `tests.swift.packages` paths. Omitted packages use
+ * `["swift", "test"]`.
+ */
+export interface SwiftPackageBaseCommands {
+  [packageRoot: string]: string[];
+}

package/symbol-traversal-types.d.ts

@@ -0,0 +1,38 @@
+export interface SymbolExport {
+  name: string;
+  kind: string;
+  line: number;
+  reExport?: {
+    source: string;
+    imported: string;
+    resolved?: string;
+  };
+}
+
+export interface SymbolImport {
+  source: string;
+  imported: string;
+  local: string;
+  line: number;
+  typeOnly: boolean;
+  resolved?: string;
+}
+
+export interface SymbolFile {
+  path: string;
+  exports?: SymbolExport[];
+  imports?: SymbolImport[];
+}
+
+export interface SymbolsResult {
+  roots: string[];
+  files: SymbolFile[];
+}
+
+export type {
+  SignatureImpactCaller,
+  SignatureImpactLocation,
+  SignatureImpactResult,
+  SignatureImpactTest,
+  SignatureImpactWarning,
+} from "./signature-impact-types";

package/test-types.d.ts

@@ -101,6 +101,18 @@ export interface TestsTargetsOptions {
   files: string[];
 }
 
+/**
+ * Why dependency coverage in a plan is unfinished.
+ * `fallbackTriggered` is not a substitute for this marker.
+ */
+export type TestPlanIncompletenessKind = "dependency-baseline-missing";
+
+export interface TestPlanIncompleteness {
+  kind: TestPlanIncompletenessKind;
+  /** Root-relative manifests or lockfiles that had no comparison baseline. */
+  files: string[];
+}
+
 export interface TestPlan {
   /** Complete deterministic changed-file inventory, relative to the request root. */
   changedFiles: string[];
@@ -109,6 +121,11 @@ export interface TestPlan {
   warnings: TestPlanWarning[];
   fallbackTriggered: boolean;
   fallbackReason?: string | null;
+  /**
+   * Present when dependency coverage is unfinished. A scoped fallback can
+   * still set `fallbackTriggered` without covering these files.
+   */
+  incomplete?: TestPlanIncompleteness[];
   executionTargets?: GroupedExecutionTarget[];
   comment?: string | null;
 }
@@ -139,6 +156,7 @@ export interface TestExecutionTarget {
   project?: string | null;
   /** Path-prefix display name, such as a Swift package root. */
   name?: string;
+  /** Swift uses {@link SwiftPackageBaseCommands} or `["swift", "test"]`. */
   baseCommand: string[];
   runnerArgs: string[];
 }

package/traversal-types.d.ts

@@ -143,46 +143,21 @@ export type SymbolsSignatureImpactOptions = SymbolsOptions & {
   symbol: string;
 };
 
-export interface SymbolExport {
-  name: string;
-  kind: string;
-  line: number;
-  reExport?: {
-    source: string;
-    imported: string;
-    resolved?: string;
-  };
-}
-
-export interface SymbolImport {
-  source: string;
-  imported: string;
-  local: string;
-  line: number;
-  typeOnly: boolean;
-  resolved?: string;
-}
-
-export interface SymbolFile {
-  path: string;
-  exports?: SymbolExport[];
-  imports?: SymbolImport[];
-}
-
-export interface SymbolsResult {
-  roots: string[];
-  files: SymbolFile[];
-}
-
 export type {
+  SymbolExport,
+  SymbolImport,
+  SymbolFile,
+  SymbolsResult,
   SignatureImpactCaller,
   SignatureImpactLocation,
   SignatureImpactResult,
   SignatureImpactTest,
   SignatureImpactWarning,
-} from "./signature-impact-types";
+} from "./symbol-traversal-types";
 
 export interface ProjectOptions {
+  /** Accepted by shared N-API options; applies to check reports and is ignored by other commands. */
+  effort?: Effort;
   /** Project root. Defaults to the current working directory. */
   root?: string;
   /** Path to tsconfig.json for alias resolution. Searched upward if omitted. */
@@ -202,9 +177,19 @@ export interface ProjectOptions {
   include?: string;
 }
 
+/** Analysis effort for configured rules. `max` preserves the current analysis. */
+export type Effort = "low" | "max";
+
+/** Policy for rule inputs that the selected effort cannot analyze. */
+export type Unanalyzable = "report" | "advise" | "ignore";
+
 export interface CheckOptions extends ProjectOptions {
+  /** Override configured rule effort for this check invocation. Defaults to `max`. */
+  effort?: Effort;
   /** Add deterministic accounting for findings hidden by no-mistakes directives. */
   includeSuppressed?: boolean;
   /** Add declared config evidence; absent slots never imply SDK defaults. */
   includeRunnerConfigDeadlines?: boolean;
+  /** Include per-obligation SQL proof and residual uncertainty in the check report. */
+  includeSqlVerdicts?: boolean;
 }

package/types.d.ts

@@ -4,6 +4,7 @@ export * from "./analyze-project-types";
 export * from "./flow-types";
 export * from "./import-usage-types";
 export * from "./test-types";
+export * from "./swift-command-types";
 export * from "./test-audit-types";
 export * from "./report-types";
 export * from "./server-contract-types";