@goodbones/oxlint 0.1.0-beta.1 → 0.1.0-beta.10

package/src/config-loader.ts

@@ -1,17 +1,33 @@
 import * as path from "node:path";
 
+import { astGrepMatcher } from "@goodbones/ast-grep";
 import {
-  DEFAULT_CONFIG_FILENAME,
+  findManifestFile,
+  loadCampaignFunctions,
   type LoadedPolicy,
   loadPolicy,
   makeFileSystemLive,
+  makeReportSourceLive,
   readManifestFile,
+  reportSpecsOf,
+  ReportUnavailable,
 } from "@goodbones/core";
 import { typescriptLanguage } from "@goodbones/typescript";
 import * as Result from "effect/Result";
 
 export type { LoadedPolicy } from "@goodbones/core";
-export { DEFAULT_CONFIG_FILENAME } from "@goodbones/core";
+
+// The clock the campaigns are judged by; `ARCHITECTURE_NOW` pins it, as it
+// does for the CLI.
+const hostNow = (): number => {
+  const pinned = process.env.ARCHITECTURE_NOW;
+  if (pinned === undefined || pinned === "") return Date.now();
+  const parsed = /^\d+$/.test(pinned) ? Number(pinned) : Date.parse(pinned);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`ARCHITECTURE_NOW is ${JSON.stringify(pinned)}, which is not a date.`);
+  }
+  return parsed;
+};
 
 // The plugin's composition root: read the manifest file, construct the
 // language packs and the live file system, and hand them to the loader. A load
@@ -20,16 +36,53 @@ export { DEFAULT_CONFIG_FILENAME } from "@goodbones/core";
 // indistinguishable from a clean codebase.
 export const loadPolicyFromFile = async (
   repoRoot: string,
-  configFilename: string = DEFAULT_CONFIG_FILENAME,
+  configFilename?: string,
 ): Promise<LoadedPolicy> => {
-  const configPath = path.resolve(repoRoot, configFilename);
+  // Named, or discovered: architecture.yaml, .yml, .json, or .config.mjs,
+  // exactly one of which may be present.
+  const configPath =
+    configFilename === undefined
+      ? findManifestFile(repoRoot)
+      : path.resolve(repoRoot, configFilename);
+  const read = await readManifestFile(configPath);
+  // The `fn` terms are imported here, before the policy loads, as the CLI
+  // does; the pack is composed with ast-grep for the campaigns family's
+  // `syntax` term, and the plugin parses with it for that family only.
+  const { functions, manifest } = await loadCampaignFunctions(configPath, read.manifest);
   const loaded = loadPolicy({
     repoRoot,
     configPath,
-    manifest: await readManifestFile(configPath),
-    languages: [typescriptLanguage()],
+    manifest,
+    locate: read.locate,
+    languages: [typescriptLanguage({ syntax: astGrepMatcher() })],
     fileSystem: makeFileSystemLive(repoRoot),
+    functions,
+    // A `report` command runs once per process — once per editor session
+    // for oxlint's language server, which then sees that report until it
+    // restarts. A report the build writes to a file is the predictable form.
+    reports: makeReportSourceLive(repoRoot),
+    now: hostNow(),
   });
   if (Result.isFailure(loaded)) throw loaded.failure;
-  return loaded.success;
+  const policy = loaded.success;
+  // Every `report` a campaign names is read now, while oxlint has linted
+  // nothing. A `command` forks this process, and once the linter is running
+  // Linux can refuse the fork: the linter's per-thread AST buffers merge
+  // into one mapping larger than RAM and swap together, which the default
+  // overcommit heuristic refuses to duplicate. The source keeps the answer,
+  // and a failure, so the rules read what was read here — a term's several
+  // commands run at once. A report that cannot be read is not a load
+  // failure — the campaigns rule reports it once, on the first file a
+  // campaign naming it selects; one that does not parse is.
+  await Promise.all(
+    reportSpecsOf(policy.campaignRules).map(async (spec) => {
+      if (policy.reports.read !== undefined) return policy.reports.read(spec);
+      try {
+        policy.reports.diagnosticsOf(spec, "");
+      } catch (cause) {
+        if (!(cause instanceof ReportUnavailable)) throw cause;
+      }
+    }),
+  );
+  return policy;
 };

package/src/exports-rule.ts

@@ -1,97 +1,29 @@
 import {
-  type Binding,
   evaluateSelectedBindings,
   exportRulesSelecting,
   formatMessage,
   type LoadedPolicy,
   type SelectedExportRule,
 } from "@goodbones/core";
+import type { ReadBinding, ReadEdge } from "@goodbones/typescript";
 import * as Result from "effect/Result";
 
 import {
-  type CallNode,
+  at,
+  factsOfProgram,
   type Fixer,
-  type ImportEqualsNode,
-  importEqualsSpecifierOf,
-  type ImportExpressionNode,
-  importExpressionSpecifierOf,
   type OxlintRule,
-  type ReportableNode,
-  requireSpecifierOf,
+  type Program,
   type RuleContext,
   toRepoRelative,
 } from "./oxlint-api.js";
 
-type NamedNode = ReportableNode & { readonly name?: unknown; readonly value?: unknown };
-
-type SpecifierNode = ReportableNode & {
-  readonly type: string;
-  readonly imported?: NamedNode | null;
-  readonly local?: NamedNode | null;
-};
-
-type DeclarationNode = ReportableNode & {
-  readonly source?: { readonly value?: unknown } | null;
-  readonly specifiers?: ReadonlyArray<SpecifierNode> | null;
-};
-
-const nameOf = (node: NamedNode | null | undefined): string | null => {
-  if (node === null || node === undefined) return null;
-  if (typeof node.name === "string") return node.name;
-  // `import { "a-b" as ab }` — a string-literal export name.
-  return typeof node.value === "string" ? node.value : null;
-};
-
-type Bound = Binding & { readonly node: ReportableNode; readonly local: string };
-
-// The whole module, as one binding. `export * from "m"`, `export * as ns from
-// "m"`, `import x = require("m")`, `import("m")` and `require("m")` all carry
-// every export of `m` at once, exactly as `import * as ns` does — and are the
-// same way around a rule about a name. A side-effect import carries nothing.
-const wholeModule = (node: ReportableNode, local = ""): Bound => ({
-  symbol: "*",
-  kind: "namespace",
-  node,
-  local,
-});
-
-type ExportAllNode = DeclarationNode & { readonly exported?: NamedNode | null };
-
-const boundOf = (specifier: SpecifierNode): Bound | null => {
-  const local = nameOf(specifier.local) ?? "";
-  switch (specifier.type) {
-    case "ImportSpecifier": {
-      const symbol = nameOf(specifier.imported);
-      return symbol === null ? null : { symbol, kind: "named", node: specifier, local };
-    }
-    case "ImportDefaultSpecifier":
-      return { symbol: "default", kind: "default", node: specifier, local };
-    case "ImportNamespaceSpecifier":
-      return { symbol: "*", kind: "namespace", node: specifier, local };
-    // `export { a } from "…"` — `local` is the name in the source module.
-    case "ExportSpecifier": {
-      const symbol = nameOf(specifier.local);
-      return symbol === null ? null : { symbol, kind: "named", node: specifier, local: symbol };
-    }
-    default:
-      return null;
-  }
-};
-
-const specifierOf = (node: DeclarationNode): string | null => {
-  const value = node.source?.value;
-  return typeof value === "string" ? value : null;
-};
-
-const boundSpecifiers = (node: DeclarationNode): ReadonlyArray<Bound> =>
-  (node.specifiers ?? []).map(boundOf).filter((one): one is Bound => one !== null);
-
 // `import { A, B as C } from "pkg"` becomes `import * as A from "pkg/A"` and
 // `import * as C from "pkg/B"`. Only whole-declaration rewrites are offered: a
 // declaration mixing restricted named imports with a default or namespace one
 // would need comma surgery inside the braces, and a fix that is subtly wrong is
 // worse than a diagnostic the author resolves by hand.
-const subpathNamespaceImport = (specifier: string, bound: ReadonlyArray<Bound>): string =>
+const subpathNamespaceImport = (specifier: string, bound: ReadonlyArray<ReadBinding>): string =>
   bound
     .map((binding) => `import * as ${binding.local} from "${specifier}/${binding.symbol}";`)
     .join("\n");
@@ -111,20 +43,16 @@ export const makeExportsRule = (policy: LoadedPolicy): OxlintRule => ({
     let importer = "";
     let selected: ReadonlyArray<SelectedExportRule> = [];
 
-    // `fixable` is whether a rewrite could apply: only an `import` declaration
-    // can be rewritten into subpath namespace imports. `export *` and the
-    // whole-module forms are reported and left for the author.
-    const check = (
-      node: ReportableNode,
-      specifierValue: string | null,
-      bound: ReadonlyArray<Bound>,
-      fixable: boolean,
-    ): void => {
-      if (specifierValue === null || bound.length === 0) return;
+    // Only an `import` declaration can be rewritten into subpath namespace
+    // imports. `export *` and the whole-module forms are reported and left
+    // for the author.
+    const check = (edge: ReadEdge): void => {
+      const { bindings: bound, node, specifier } = edge;
+      if (bound.length === 0) return;
 
       const outcome = evaluateSelectedBindings(selected, policy.resolver, {
         importer,
-        specifier: specifierValue,
+        specifier,
         bindings: bound,
       });
 
@@ -136,30 +64,30 @@ export const makeExportsRule = (policy: LoadedPolicy): OxlintRule => ({
 
       for (const { bindings, rule, violation } of outcome.success) {
         if (policy.baseline.isBaselined(violation)) continue;
-        const offending = bound.filter((one: Bound) =>
+        const offending = bound.filter((one) =>
           bindings.some((binding) => binding.symbol === one.symbol && binding.kind === one.kind),
         );
         // The rewrite is `import * as X from "pkg/<name>"`, which only means
         // something for a named binding — a namespace one has no name to put
         // in the subpath.
         const rewritable =
-          fixable &&
+          edge.form === "import" &&
           rule.fix === "subpath-namespace-import" &&
           offending.length === bound.length &&
           offending.every((one) => one.kind === "named");
 
         if (rewritable) {
           context.report({
-            node,
+            node: at(node),
             message: formatMessage(violation),
             fix: (fixer: Fixer) =>
-              fixer.replaceText(node, subpathNamespaceImport(specifierValue, offending)),
+              fixer.replaceText(at(node), subpathNamespaceImport(specifier, offending)),
           });
           continue;
         }
 
         context.report({
-          node: offending[0]?.node ?? node,
+          node: at(offending[0]?.node ?? node),
           message: formatMessage(violation),
         });
       }
@@ -172,23 +100,8 @@ export const makeExportsRule = (policy: LoadedPolicy): OxlintRule => ({
         selected = exportRulesSelecting(policy.exportRules, importer);
         return selected.length > 0;
       },
-      ImportDeclaration(node: DeclarationNode) {
-        check(node, specifierOf(node), boundSpecifiers(node), true);
-      },
-      ExportNamedDeclaration(node: DeclarationNode) {
-        check(node, specifierOf(node), boundSpecifiers(node), false);
-      },
-      ExportAllDeclaration(node: ExportAllNode) {
-        check(node, specifierOf(node), [wholeModule(node, nameOf(node.exported) ?? "")], false);
-      },
-      ImportExpression(node: ImportExpressionNode) {
-        check(node, importExpressionSpecifierOf(node), [wholeModule(node)], false);
-      },
-      CallExpression(node: CallNode) {
-        check(node, requireSpecifierOf(node), [wholeModule(node)], false);
-      },
-      TSImportEqualsDeclaration(node: ImportEqualsNode) {
-        check(node, importEqualsSpecifierOf(node), [wholeModule(node)], false);
+      Program(node: Program) {
+        for (const edge of factsOfProgram(importer, node).edges) check(edge);
       },
     };
   },

package/src/imports-rule.ts

@@ -5,20 +5,15 @@ import {
   rulesSelecting,
   type SelectedRule,
 } from "@goodbones/core";
+import type { ReadEdge } from "@goodbones/typescript";
 import * as Result from "effect/Result";
 
 import {
-  type CallNode,
-  type ImportEqualsNode,
-  importEqualsSpecifierOf,
-  type ImportExpressionNode,
-  importExpressionSpecifierOf,
+  at,
+  factsOfProgram,
   type OxlintRule,
-  type ReportableNode,
-  requireSpecifierOf,
+  type Program,
   type RuleContext,
-  type SourceNode,
-  specifierOf,
   toRepoRelative,
 } from "./oxlint-api.js";
 
@@ -44,32 +39,29 @@ export const makeImportsRule = (policy: LoadedPolicy): OxlintRule => ({
     let importer = "";
     let selected: ReadonlyArray<SelectedRule> = [];
 
-    const check = (node: ReportableNode, specifier: string | null): void => {
-      if (specifier === null) return;
-
+    const check = (edge: ReadEdge): void => {
+      const { specifier } = edge;
       const outcome = evaluateSelectedEdge(selected, policy.resolver, { importer, specifier });
 
       if (Result.isFailure(outcome)) {
         if (policy.config.resolve.unresolved === "off") return;
         if (policy.ignoreUnresolved.some((pattern) => pattern.test(specifier))) return;
-        context.report({ node, message: unresolvedMessage(specifier, outcome.failure.detail) });
+        context.report({
+          node: at(edge.node),
+          message: unresolvedMessage(specifier, outcome.failure.detail),
+        });
         return;
       }
 
       for (const violation of outcome.success) {
         if (policy.baseline.isBaselined(violation)) continue;
-        context.report({ node, message: formatMessage(violation) });
+        context.report({ node: at(edge.node), message: formatMessage(violation) });
       }
     };
 
-    const checkSource = (node: SourceNode): void => {
-      check(node, specifierOf(node));
-    };
-
-    // Every form that names a module is an edge. The CLI adapter reads the same
-    // five out of TypeScript's tree, and the parity suite holds the two to it: a
-    // `require` the plugin skipped would be a rule that enforces nothing under
-    // `oxlint` while failing under `architecture check`.
+    // Every form that names a module is an edge, and the pack's reader is
+    // what says which forms those are — the same reader the CLI reads a file
+    // through, so a form one host sees the other sees too.
     return {
       before() {
         importer = toRepoRelative(policy.repoRoot, context.filename);
@@ -77,19 +69,8 @@ export const makeImportsRule = (policy: LoadedPolicy): OxlintRule => ({
         selected = rulesSelecting(policy.importRules, importer);
         return selected.length > 0;
       },
-      ImportDeclaration: checkSource,
-      ExportNamedDeclaration: checkSource,
-      ExportAllDeclaration: checkSource,
-      // `import("m")` with a literal argument. A computed one is not a fact a
-      // static policy can speak about, in either adapter.
-      ImportExpression(node: ImportExpressionNode) {
-        check(node, importExpressionSpecifierOf(node));
-      },
-      CallExpression(node: CallNode) {
-        check(node, requireSpecifierOf(node));
-      },
-      TSImportEqualsDeclaration(node: ImportEqualsNode) {
-        check(node, importEqualsSpecifierOf(node));
+      Program(node: Program) {
+        for (const edge of factsOfProgram(importer, node).edges) check(edge);
       },
     };
   },

package/src/members-rule.ts

@@ -1,6 +1,5 @@
 import {
   type CompiledMemberRule,
-  type DeclarationKind,
   evaluateMemberSite,
   formatMessage,
   type LoadedPolicy,
@@ -8,112 +7,14 @@ import {
 } from "@goodbones/core";
 
 import {
+  at,
+  factsOfProgram,
   type OxlintRule,
-  type ReportableNode,
+  type Program,
   type RuleContext,
   toRepoRelative,
 } from "./oxlint-api.js";
 
-type NamedNode = ReportableNode & {
-  readonly type: string;
-  readonly name?: unknown;
-  readonly value?: unknown;
-};
-
-type MemberNode = ReportableNode & {
-  readonly type: string;
-  readonly key?: (NamedNode & { readonly type?: string }) | null;
-  readonly computed?: boolean;
-  // A class method's kind: `method`, `get`, `set` or `constructor`.
-  readonly kind?: string;
-};
-
-// A type, as far as this rule reads it: a literal with members, or an
-// intersection / union / parenthesised type wrapping others.
-type TypeNode = ReportableNode & {
-  readonly type: string;
-  readonly members?: ReadonlyArray<MemberNode>;
-  readonly types?: ReadonlyArray<TypeNode>;
-  readonly typeAnnotation?: TypeNode | null;
-};
-
-type TypeAliasNode = ReportableNode & {
-  readonly id?: NamedNode | null;
-  readonly typeAnnotation?: TypeNode | null;
-};
-
-// Every visitor takes the whole `Node` union, so `body` is typed to admit a
-// function body as readily as an interface's, and narrowed below.
-type InterfaceNode = ReportableNode & {
-  readonly id?: NamedNode | null;
-  readonly body?: { readonly type?: string; readonly body?: unknown } | null;
-};
-
-type ClassNode = InterfaceNode;
-
-const isMemberList = (value: unknown): value is ReadonlyArray<MemberNode> => Array.isArray(value);
-
-type CallNode = ReportableNode & {
-  readonly callee?:
-    | (ReportableNode & {
-        readonly type: string;
-        readonly name?: unknown;
-        readonly computed?: boolean;
-        readonly property?: (NamedNode & { readonly type: string }) | null;
-      })
-    | null;
-};
-
-// The member shapes that carry a name a vocabulary rule can speak about: a
-// property or method signature in a type, a property, method or accessor in a
-// class. Mirrors the CLI's `isNamedMember`.
-const DECLARED_MEMBER_TYPES = new Set([
-  "TSPropertySignature",
-  "TSMethodSignature",
-  "PropertyDefinition",
-  "MethodDefinition",
-  "TSAbstractPropertyDefinition",
-  "TSAbstractMethodDefinition",
-]);
-
-// The type literals written in a type, through intersections, unions and
-// parentheses. A reference is not followed: its members are declared where it
-// is, and reported there under its own name. Mirrors the CLI's `literalsOf`.
-const literalsOf = (node: TypeNode | null | undefined): ReadonlyArray<TypeNode> => {
-  if (node === null || node === undefined) return [];
-  switch (node.type) {
-    case "TSTypeLiteral":
-      return [node];
-    case "TSIntersectionType":
-    case "TSUnionType":
-      return (node.types ?? []).flatMap(literalsOf);
-    case "TSParenthesizedType":
-      return literalsOf(node.typeAnnotation);
-    default:
-      return [];
-  }
-};
-
-const nameOf = (node: NamedNode | null | undefined): string | null => {
-  if (node === null || node === undefined) return null;
-  if (typeof node.name === "string") return node.name;
-  return typeof node.value === "string" ? node.value : null;
-};
-
-// The name a call is made by: `f()` and `x.f()` are both `f`. `x[f]()` and
-// `x["f"]()` are not — a computed property is not a name a vocabulary rule can
-// speak about — and neither is a private `x.#f()`. The CLI reads the same
-// three cases out of TypeScript's tree; the parity suite keeps them agreeing.
-const calleeName = (node: CallNode): string | null => {
-  const callee = node.callee;
-  if (callee === null || callee === undefined) return null;
-  if (callee.type === "Identifier" && typeof callee.name === "string") return callee.name;
-  if (callee.type !== "MemberExpression" || callee.computed === true) return null;
-  const property = callee.property;
-  if (property?.type !== "Identifier") return null;
-  return nameOf(property);
-};
-
 export const makeMembersRule = (policy: LoadedPolicy): OxlintRule => ({
   meta: {
     type: "problem" as const,
@@ -128,42 +29,8 @@ export const makeMembersRule = (policy: LoadedPolicy): OxlintRule => ({
     let file = "";
     let selected: ReadonlyArray<CompiledMemberRule> = [];
 
-    const report = (
-      node: ReportableNode,
-      name: string,
-      declaration?: { readonly name: string; readonly declares: DeclarationKind },
-    ): void => {
-      const violations = evaluateMemberSite(selected, {
-        file,
-        subject: declaration === undefined ? "calls" : "members",
-        name,
-        ...(declaration === undefined
-          ? {}
-          : { in: declaration.name, declares: declaration.declares }),
-      });
-      for (const violation of violations) {
-        if (policy.baseline.isBaselined(violation)) continue;
-        context.report({ node, message: formatMessage(violation) });
-      }
-    };
-
-    // The members written in a declaration, under that declaration's name and
-    // kind. A computed key is not a name a vocabulary rule can speak about;
-    // neither is a private `#name`, an index, call or construct signature, or
-    // a constructor.
-    const declared = (
-      declaration: string,
-      declares: DeclarationKind,
-      members: ReadonlyArray<MemberNode>,
-    ): void => {
-      for (const member of members) {
-        if (member.computed === true || !DECLARED_MEMBER_TYPES.has(member.type)) continue;
-        if (member.key?.type === "PrivateIdentifier" || member.kind === "constructor") continue;
-        const name = nameOf(member.key);
-        if (name !== null) report(member.key ?? member, name, { name: declaration, declares });
-      }
-    };
-
+    // A declared member is reported at its key, a call at the call — the nodes
+    // the pack's reader hands back with each site.
     return {
       before() {
         file = toRepoRelative(policy.repoRoot, context.filename);
@@ -171,35 +38,14 @@ export const makeMembersRule = (policy: LoadedPolicy): OxlintRule => ({
         selected = memberRulesSelecting(policy.memberRules, file);
         return selected.length > 0;
       },
-
-      TSTypeAliasDeclaration(node: TypeAliasNode) {
-        const declaration = nameOf(node.id);
-        if (declaration === null) return;
-        for (const literal of literalsOf(node.typeAnnotation)) {
-          declared(declaration, "type", literal.members ?? []);
+      Program(node: Program) {
+        for (const site of factsOfProgram(file, node).memberSites) {
+          for (const violation of evaluateMemberSite(selected, site)) {
+            if (policy.baseline.isBaselined(violation)) continue;
+            context.report({ node: at(site.node), message: formatMessage(violation) });
+          }
         }
       },
-
-      TSInterfaceDeclaration(node: InterfaceNode) {
-        const declaration = nameOf(node.id);
-        const members = node.body?.body;
-        if (declaration === null || !isMemberList(members)) return;
-        declared(declaration, "interface", members);
-      },
-
-      // A named class only, as the CLI reads it: an anonymous default class has
-      // no name for `in`, and a class expression is a value.
-      ClassDeclaration(node: ClassNode) {
-        const declaration = nameOf(node.id);
-        const members = node.body?.body;
-        if (declaration === null || !isMemberList(members)) return;
-        declared(declaration, "class", members);
-      },
-
-      CallExpression(node: CallNode) {
-        const name = calleeName(node);
-        if (name !== null) report(node, name);
-      },
     };
   },
 });