lanekeep 0.7.0 → 0.8.0

package/index.d.ts

@@ -78,8 +78,27 @@ export interface RuleCard {
   }
 }
 
-/** Cheap rejections applied before a file is parsed. */
+/** Cheap rejections applied before a file is read or parsed. */
 export interface Gates {
+  /**
+   * Glob patterns a file's path must match for the rule to consider it.
+   *
+   * The path is relative to the project root, and the pattern must match the whole path —
+   * anchored, not a substring search. Patterns use the `globset` dialect, matched
+   * case-sensitively: `*` matches any run of characters (including `/`), `?` any single
+   * character, `[ab]`/`[!ab]` character classes and `{a,b}` alternates work, and `**`
+   * recurses directories — `src/**` admits everything under `src`, and `**` in front
+   * of `*.test.ts` admits a test file at any depth.
+   */
+  pathMatches?: string[]
+  /**
+   * Glob patterns that skip a file — a path matching any of these is never parsed. Checked
+   * before `pathMatches` and winning over it: a path a `pathMatches` pattern would have
+   * admitted is still skipped when a `pathNotMatches` pattern matches it.
+   *
+   * Same dialect and anchoring as `pathMatches`.
+   */
+  pathNotMatches?: string[]
   /**
    * Literal substrings a file's raw bytes must contain. A file missing any one of them is
    * never parsed.
@@ -90,6 +109,12 @@ export interface Gates {
    * form; omit the gate when no single substring covers every case.
    */
   fileContains?: string[]
+  /**
+   * Literal substrings that skip a file — a file whose raw bytes contain **any** of them is
+   * never parsed. The mirror image of `fileContains`'s *and*: where that gate requires every
+   * listed substring, this one rejects on the first that is present.
+   */
+  fileNotContains?: string[]
 }
 
 /** A replacement a rule offers for a violation. */
@@ -151,6 +176,21 @@ export interface NodeLocation {
   column: number
 }
 
+/**
+ * A subtree's structural fingerprint: identifiers and literal values erased.
+ *
+ * Computed host-side in one walk, so a rule does not pay a per-node boundary crossing to
+ * inspect a tree's shape. Two functions differing only in identifier names, literal values
+ * or comments hash identically; differing in an operator or a statement, differently. A
+ * dead handle yields `undefined`, like `kind` and `loc`.
+ */
+export interface StructureFingerprint {
+  /** blake3 of the normalized fold, lowercase hex. */
+  hash: string
+  /** How many nodes the fold covered — the thresholding input. */
+  nodes: number
+}
+
 /** A rule's RuleContext surface. */
 export interface RuleContext {
   readonly filePath: string
@@ -165,6 +205,7 @@ export interface RuleContext {
   children(n: Node): Node[]
   namedChildren(n: Node): Node[]
   ancestors(n: Node): Node[]
+  structureFingerprint(n: Node): StructureFingerprint | undefined
   resolvesToImport(n: Node, module: string, name?: string): boolean
   isImportedFrom(n: Node, pattern: string): boolean
   bindingKind(n: Node): BindingKind | undefined
@@ -227,8 +268,21 @@ export interface Rule {
    * Rust matches it across a single shared parse and only matches reach `check`, which is
    * what keeps a JavaScript rule affordable. Write the narrowest query that captures what
    * you need; `check` then only refines.
+   *
+   * A single string applies to every declared language. An object maps each declared
+   * language to its own query — required when the grammars do not share node vocabulary
+   * (Python spells a call `call`, the other supported grammars say `call_expression`).
+   * Every declared language must have an entry and every entry must name a declared
+   * language; a mismatch is a config-load error naming the language.
+   *
+   * Text predicates filter matches in Rust before the handler, so a predicate can only
+   * narrow, never widen, what `check` sees: `#eq?`, `#not-eq?`, `#match?`, `#not-match?`,
+   * `#any-of?` and `#not-any-of?` are supported (plus the `any-` forms of `eq?`/`match?`).
+   * `#match?`/`#not-match?` run on the `regex` crate, which is deterministic and supports
+   * no backreferences or lookaround. `#is?`, `#is-not?`, `#set!`, or an operator the
+   * binding does not know is refused at compile time.
    */
-  query: string
+  query: string | Partial<Record<LanguageId, string>>
   /** A per-invocation budget overriding the default, in milliseconds. */
   timeout?: number
   /** Called once per query match. */
@@ -254,6 +308,15 @@ export interface Config {
     /** Wall-clock, for the whole run. */
     global?: number
   }
+  /** Policy for suppression directives. All off by default. */
+  suppressions?: {
+    /** A valid directive with no `expires:` is reported. */
+    requireExpiry?: boolean
+    /** An expiry more than this many days after today is reported. */
+    maxExpiryDays?: number
+    /** Any whole-file directive is reported. */
+    forbidFileScope?: boolean
+  }
   /** The rules to run, in order. */
   rules: Rule[]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lanekeep",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Deterministic, AST-based architectural conformance checking",
   "license": "MIT OR Apache-2.0",
   "repository": {
@@ -23,10 +23,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@lanekeep/darwin-arm64": "0.7.0",
-    "@lanekeep/linux-arm64": "0.7.0",
-    "@lanekeep/linux-x64": "0.7.0",
-    "@lanekeep/win32-x64": "0.7.0"
+    "@lanekeep/darwin-arm64": "0.8.0",
+    "@lanekeep/linux-arm64": "0.8.0",
+    "@lanekeep/linux-x64": "0.8.0",
+    "@lanekeep/win32-x64": "0.8.0"
   },
   "main": "index.js",
   "types": "index.d.ts",