@geonosis/oxlint-plugin-biological-architecture 3.0.0 → 3.2.0

package/dist/rules/lib/workspace-members.js

@@ -0,0 +1,115 @@
+// src/rules/lib/workspace-members.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { readManifest } from "./module-text.js";
+var MARKERS = ["pnpm-workspace.yaml", "package.json"];
+var SKIPPED = new Set(["node_modules", ".git"]);
+var listed = (text) => {
+  const lines = text.split(`
+`);
+  const start = lines.findIndex((line) => /^packages\s*:/.test(line));
+  if (start === -1)
+    return [];
+  const globs = [];
+  for (const line of lines.slice(start + 1)) {
+    if (line.trim() === "" || line.trim().startsWith("#"))
+      continue;
+    const item = /^\s*-\s*(.+?)\s*(?:\s#.*)?$/.exec(line)?.[1];
+    if (item === undefined)
+      break;
+    globs.push(item.replace(/^(["'])(.*)\1$/, "$2"));
+  }
+  return globs;
+};
+var globsOf = (marker, text) => {
+  if (marker === "pnpm-workspace.yaml")
+    return listed(text);
+  let manifest;
+  try {
+    manifest = JSON.parse(text);
+  } catch {
+    return;
+  }
+  const declared = manifest.workspaces;
+  const globs = Array.isArray(declared) ? declared : typeof declared === "object" && declared !== null ? declared.packages : undefined;
+  return Array.isArray(globs) ? globs.filter((one) => typeof one === "string") : undefined;
+};
+var directoriesIn = (dir) => {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !SKIPPED.has(entry.name)).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+};
+var expand = (base, segments) => {
+  const [head, ...rest] = segments;
+  if (head === undefined)
+    return [base];
+  if (head === "**") {
+    const here = expand(base, rest);
+    const below = directoriesIn(base).flatMap((name) => expand(join(base, name), segments));
+    return [...here, ...below];
+  }
+  if (head === "*")
+    return directoriesIn(base).flatMap((name) => expand(join(base, name), rest));
+  return expand(join(base, head), rest);
+};
+var memberDirs = (root, globs) => {
+  const excluded = new Set(globs.filter((one) => one.startsWith("!")).flatMap((one) => expand(root, one.slice(1).replace(/^\.\//, "").split("/"))));
+  return globs.filter((one) => !one.startsWith("!")).flatMap((one) => expand(root, one.replace(/^\.\//, "").replace(/\/$/, "").split("/"))).filter((dir) => !excluded.has(dir));
+};
+var nameOf = (manifest) => {
+  const name = readManifest(manifest)?.name;
+  return typeof name === "string" ? name : undefined;
+};
+var cache = new Map;
+var rootAbove = (from) => {
+  let dir = dirname(from);
+  for (;; ) {
+    for (const marker of MARKERS) {
+      const path = join(dir, marker);
+      if (!existsSync(path))
+        continue;
+      let text;
+      try {
+        text = readFileSync(path, "utf8");
+      } catch {
+        continue;
+      }
+      const globs = globsOf(marker, text);
+      if (globs !== undefined && globs.length > 0)
+        return { marker, root: dir };
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+};
+var membersFrom = (from) => {
+  const found = rootAbove(from);
+  if (found === undefined)
+    return;
+  const marker = join(found.root, found.marker);
+  const stamp = statSync(marker).mtimeMs;
+  const held = cache.get(marker);
+  if (held?.stamp === stamp)
+    return held.members;
+  const globs = globsOf(found.marker, readFileSync(marker, "utf8")) ?? [];
+  const names = new Map;
+  for (const dir of memberDirs(found.root, globs)) {
+    const manifest = join(dir, "package.json");
+    const name = existsSync(manifest) ? nameOf(manifest) : undefined;
+    if (name !== undefined && !names.has(name))
+      names.set(name, manifest);
+  }
+  const members = { names, root: found.root };
+  cache.set(marker, { members, stamp });
+  return members;
+};
+var workspaceMemberNamed = (from, name) => membersFrom(from)?.names.get(name);
+var hasWorkspaceAbove = (from) => rootAbove(from) !== undefined;
+export {
+  hasWorkspaceAbove,
+  workspaceMemberNamed
+};

package/dist/rules/list-take-without-order.js

@@ -1,16 +1,10 @@
 // src/rules/list-take-without-order.ts
 import { propertyNameOf, walkNode } from "./lib/nodes.js";
+import { keyNameOf } from "./lib/objects.js";
 import { bagOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 var CALLEES = [String.raw`^(?:\w+\.)?list[A-Z]`, String.raw`^(?:\w+\.)?graph$`];
 var ORDER_KEYS = ["order", "orderBy"];
-var TAKE = "take";
-var keyNameOf = (node) => {
-  const key = node.key;
-  if (key?.type === "Identifier" && typeof key.name === "string")
-    return key.name;
-  return key?.type === "Literal" && typeof key.value === "string" ? key.value : null;
-};
 var spellingOf = (callee) => {
   if (callee === undefined)
     return null;
@@ -42,7 +36,7 @@ var listTakeWithoutOrder = {
             if (inner.type !== "Property")
               return;
             const key = keyNameOf(inner);
-            if (key === TAKE)
+            if (key === "take")
               takes = true;
             if (key !== null && orderKeys.includes(key))
               orders = true;

package/dist/rules/max-comment-density.d.ts

@@ -1,22 +1,7 @@
-type Comment = {
-    type: string;
-    value: string;
-    loc: {
-        start: {
-            line: number;
-        };
-        end: {
-            line: number;
-        };
-    };
-};
-type SourceCode = {
-    text?: string;
+import { type SourceCode as CommentSource } from './lib/comments.js';
+type SourceCode = CommentSource & {
     lines?: string[];
-    getAllComments?: () => Comment[];
-    ast?: {
-        comments?: Comment[];
-    };
+    text?: string;
 };
 declare const maxCommentDensity: {
     create(context: {

package/dist/rules/max-comment-density.js

@@ -1,5 +1,6 @@
 // src/rules/max-comment-density.ts
-import { normalise } from "./lib/paths.js";
+import { commentsOf } from "./lib/comments.js";
+import { matchesAny, normalise } from "./lib/paths.js";
 var exemptFiles = [
   /\/__tests__\//,
   /\.config\.(ts|mjs|js)$/,
@@ -11,13 +12,12 @@ var commentCeilingPercent = 10;
 var commentBlockCeilingLines = 3;
 var commentLinesAlwaysAllowed = 3;
 var directive = /^\s*(eslint|oxlint|biome|prettier|@ts-|c8 |v8 |istanbul )/;
-var commentsOf = (sourceCode) => sourceCode.getAllComments?.() ?? sourceCode.ast?.comments ?? [];
 var lineCount = (sourceCode) => sourceCode.lines?.length ?? (sourceCode.text ?? "").split(`
 `).length;
 var maxCommentDensity = {
   create(context) {
     const normalized = normalise(context.filename);
-    if (exemptFiles.some((file) => file.test(normalized)))
+    if (matchesAny(exemptFiles, normalized))
       return {};
     return {
       Program(node) {

package/dist/rules/molecule-atoms-only.d.ts

@@ -9,6 +9,7 @@ declare const moleculeAtomsOnly: {
         }) => void;
     }): import('./lib/visitors.js').Visitor;
     fixShape: string;
+    probe?: ((options: readonly unknown[]) => import('./lib/probe.js').Probe | import('./lib/probe.js').ProbeTree) | undefined;
     meta: {
         docs: {
             description: string;

package/dist/rules/molecule-atoms-only.js

@@ -1,24 +1,28 @@
 // src/rules/molecule-atoms-only.ts
 import { directionRule } from "./lib/direction-rule.js";
+import { inTiersAbove, APP_FOLDER, STORES_FOLDER } from "./lib/tiers.js";
 var FORBIDDEN_PATTERNS = [
   /(?:^|\/)components\/ui\//,
-  /(?:^|\/)compounds\//,
-  /(?:^|\/)organelles\//,
-  /(?:^|\/)cells\//,
-  /(?:^|\/)tissues\//,
-  /(?:^|\/)stores\//,
+  STORES_FOLDER,
   /(?:^|[/@])domains(?:\/|$)/,
-  /\/app\//
+  APP_FOLDER
 ];
 var moleculeAtomsOnly = directionRule({
   description: "Molecules are inert combinations of atoms. They must not import compounds, organelles, cells, tissues, stores, domains, or the raw state-bearing components/ui primitives — composing a stateful primitive makes the file a cell.",
   fixShape: `A molecule combines atoms and other molecules and nothing else — no compound, organelle, cell,
 tissue, store or domain, and no state-bearing \`components/ui\` primitive (Calendar, Popover, Carousel).
 Composing a stateful primitive makes the file a cell. \`export … from\` is checked like an import.`,
-  forbidden: (target) => FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
+  forbidden: (target) => inTiersAbove(target.path, "molecules") || FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
   messages: {
     forbidden: "Molecules cannot import from {{source}}. Molecules are inert atom-combinations — state-bearing primitives (components/ui) and higher tiers belong in a cell."
   },
+  probe: () => ({
+    path: "src/molecules/geonosis-probe.tsx",
+    source: `import { Up } from '../compounds/geonosis-up'
+
+export const GeonosisProbe = Up
+`
+  }),
   scope: "molecules",
   typeOnly: "visit"
 });

package/dist/rules/molecule-must-compose.d.ts

@@ -1,10 +1,11 @@
 import { type RuleContext } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
 import { type CompositionImportNode, type JsxOpeningElementNode } from './lib/render-tracking.js';
 declare const moleculeMustCompose: {
     create(context: RuleContext): {
-        'Program:exit'?: undefined;
         ImportDeclaration?: undefined;
         JSXOpeningElement?: undefined;
+        'Program:exit'?: undefined;
     } | {
         ImportDeclaration(node: CompositionImportNode): void;
         JSXOpeningElement(node: JsxOpeningElementNode): void;
@@ -21,5 +22,6 @@ declare const moleculeMustCompose: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default moleculeMustCompose;

package/dist/rules/molecule-must-compose.js

@@ -1,26 +1,18 @@
 // src/rules/molecule-must-compose.ts
-import { normalise } from "./lib/paths.js";
+import { normalise, fileOf } from "./lib/paths.js";
 import { launderedHomesOf } from "./lib/reexports.js";
 import {
   collectCompositionLocals,
   rendersAnyOf,
   rootTagNameOf
 } from "./lib/render-tracking.js";
-function isCompositionSource(src) {
-  if (/\/(atoms|molecules)(\/|$)/.test(src))
-    return true;
-  if (/^\.\/[^/]+$/.test(src))
-    return true;
-  if (src.startsWith("@radix-ui/") || src === "radix-ui" || src.startsWith("radix-ui/"))
-    return true;
-  if (src.startsWith("@react-email/"))
-    return true;
-  return false;
-}
+import { folderOf, tierFolderOf } from "./lib/tiers.js";
+var isCompositionSource = (src) => folderOf(src, ["atoms", "molecules"]) !== undefined || /^\.\/[^/]+$/.test(src) || src.startsWith("@radix-ui/") || src === "radix-ui" || src.startsWith("radix-ui/") || src.startsWith("@react-email/");
 var moleculeMustCompose = {
   create(context) {
     const filename = normalise(context.filename);
-    const isMolecule = /\/molecules\/(?!index\.)[^/]+\.tsx?$/.test(filename) && !filename.endsWith(".types.ts");
+    const basename = fileOf(filename);
+    const isMolecule = tierFolderOf(filename) === "molecules" && !basename.startsWith("index.") && /\.tsx?$/.test(basename) && !basename.endsWith(".types.ts");
     if (!isMolecule)
       return {};
     const laundered = launderedHomesOf(filename);
@@ -28,7 +20,6 @@ var moleculeMustCompose = {
       return {};
     const bioImportLocals = new Set;
     const renderedTagNames = new Set;
-    let programNode = null;
     return {
       ImportDeclaration(node) {
         collectCompositionLocals(node, isCompositionSource, bioImportLocals);
@@ -39,14 +30,8 @@ var moleculeMustCompose = {
           renderedTagNames.add(root);
       },
       "Program:exit"(node) {
-        programNode = node;
         if (!rendersAnyOf(bioImportLocals, renderedTagNames)) {
-          const shortName = filename.split("/").pop() || filename;
-          context.report({
-            data: { filename: shortName },
-            messageId: "missingComposition",
-            node: programNode
-          });
+          context.report({ data: { filename: basename }, messageId: "missingComposition", node });
         }
       }
     };
@@ -65,6 +50,17 @@ of a molecule that moved is not a second molecule, and one line re-exporting an
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/molecules/geonosis-probe.tsx",
+      source: `import { Atom } from '../atoms/geonosis-atom'
+
+export function GeonosisProbe() {
+  return <div>{String(Atom)}</div>
+}
+`
+    };
   }
 };
 var molecule_must_compose_default = moleculeMustCompose;

package/dist/rules/mutating-step-declares-retry.d.ts

@@ -1,16 +1,10 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The call names that generate a service write. Default: what `MedusaService` generates. */
     mutationPrefixes?: string[];
-    /** The config key a step's retry budget is written under. Default: Medusa's `maxRetries`. */
     retryKey?: string;
-    /**
-     * The key that holds the NUMBER when the budget is an object. Default: `limit`, which is how
-     * `@geonosis/workflows` spells it (`retry: { limit, backoff }`).
-     */
     retryLimitKey?: string;
-    /** The call names that define a step. Default: Medusa's `createStep`. */
     stepFactories?: string[];
 }
 declare const mutatingStepDeclaresRetry: {
@@ -53,5 +47,6 @@ declare const mutatingStepDeclaresRetry: {
         }[];
         type: 'problem';
     };
+    probe(options: readonly unknown[]): Probe;
 };
 export default mutatingStepDeclaresRetry;

package/dist/rules/mutating-step-declares-retry.js

@@ -1,20 +1,28 @@
 // src/rules/mutating-step-declares-retry.ts
-import { mutationPrefixesOf, writesWith } from "./lib/mutations.js";
+import { DEFAULT_MUTATION_PREFIXES, mutationPrefixesOf, writesWith } from "./lib/mutations.js";
 import { walkNode } from "./lib/nodes.js";
 import { propertiesOf, valueOf } from "./lib/objects.js";
 import { requireOption } from "./lib/options.js";
+import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
-import { argumentsOf, configOf, isStepCall, stepFactoriesOf, stepNameOf } from "./lib/steps.js";
+import {
+  argumentsOf,
+  configOf,
+  DEFAULT_STEP_FACTORIES,
+  isStepCall,
+  stepFactoriesOf,
+  stepNameOf
+} from "./lib/steps.js";
 var RULE = "mutating-step-declares-retry";
 var DEFAULT_RETRY_KEY = "maxRetries";
 var DEFAULT_RETRY_LIMIT_KEY = "limit";
-var NO_RETRY = 0;
 var mutatingStepDeclaresRetry = {
   create(context) {
-    const factories = stepFactoriesOf(RULE, context.options?.[0]?.stepFactories);
-    const isWrite = writesWith(mutationPrefixesOf(RULE, context.options?.[0]?.mutationPrefixes));
-    const retryKey = requireOption(RULE, context.options?.[0]?.retryKey ?? DEFAULT_RETRY_KEY, "retryKey");
-    const retryLimitKey = requireOption(RULE, context.options?.[0]?.retryLimitKey ?? DEFAULT_RETRY_LIMIT_KEY, "retryLimitKey");
+    const bag = context.options?.[0] ?? {};
+    const factories = stepFactoriesOf(RULE, bag.stepFactories);
+    const isWrite = writesWith(mutationPrefixesOf(RULE, bag.mutationPrefixes));
+    const retryKey = requireOption(RULE, bag.retryKey ?? DEFAULT_RETRY_KEY, "retryKey");
+    const retryLimitKey = requireOption(RULE, bag.retryLimitKey ?? DEFAULT_RETRY_LIMIT_KEY, "retryLimitKey");
     return {
       CallExpression(node) {
         if (!isStepCall(node, factories))
@@ -43,11 +51,9 @@ var mutatingStepDeclaresRetry = {
         }
         const nested = propertiesOf(budget);
         const declared = nested === null ? budget : valueOf(nested, retryLimitKey);
-        if (declared === undefined)
+        if (declared?.type !== "Literal" || typeof declared.value !== "number")
           return;
-        if (declared.type !== "Literal" || typeof declared.value !== "number")
-          return;
-        if (declared.value > NO_RETRY)
+        if (declared.value > 0)
           return;
         context.report({
           data: { budget: String(declared.value), key: retryKey, step },
@@ -84,6 +90,18 @@ if the repo wraps \`createStep\`, and \`mutationPrefixes\` if its writes are nam
       stepFactories: STRINGS
     }),
     type: "problem"
+  },
+  probe(options) {
+    const bag = bagOf(options);
+    const factory = firstOf(bag.stepFactories, DEFAULT_STEP_FACTORIES);
+    const write = firstOf(bag.mutationPrefixes, DEFAULT_MUTATION_PREFIXES);
+    return {
+      path: "geonosis-probe-step.ts",
+      source: `export const geonosisProbe = ${factory}('geonosis-probe', async () => {
+  await service.${write}Probe()
+})
+`
+    };
   }
 };
 var mutating_step_declares_retry_default = mutatingStepDeclaresRetry;

package/dist/rules/named-when-block.d.ts

@@ -2,7 +2,6 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The call names that open a conditional block. Default: Medusa's `when`. */
     blocks?: string[];
 }
 declare const namedWhenBlock: {
@@ -31,7 +30,6 @@ declare const namedWhenBlock: {
         }[];
         type: 'problem';
     };
-    /** The unnamed overload, told by ARITY — two arguments, which is the shape that fires. */
     probe(options: readonly unknown[]): Probe;
 };
 export default namedWhenBlock;

package/dist/rules/named-when-block.js

@@ -2,7 +2,7 @@
 import { calleeNameOf } from "./lib/nodes.js";
 import { requireOption } from "./lib/options.js";
 import { bagOf, firstOf } from "./lib/probe.js";
-import { STRINGS } from "./lib/schema.js";
+import { optionsBag, STRINGS } from "./lib/schema.js";
 var RULE = "named-when-block";
 var DEFAULT_BLOCKS = ["when"];
 var NAMED = 3;
@@ -35,13 +35,7 @@ name.`,
     messages: {
       unnamed: "`{{block}}()` is called without a name, so its step is registered as `when-then-{ulid}` — a fresh identity every process. A run resumed after a restart cannot find the checkpoint it was at. Pass a stable name as the first argument."
     },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { blocks: STRINGS },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ blocks: STRINGS }),
     type: "problem"
   },
   probe(options) {

package/dist/rules/next-route-segment-is-thin-delegate.d.ts

@@ -1,22 +1,6 @@
 import { type RuleContext } from './lib/context.js';
-interface ImportSpecifier {
-    imported?: {
-        name?: string;
-        type: string;
-    };
-    local?: {
-        name?: string;
-        type: string;
-    };
-    type: string;
-}
-interface ImportNode {
-    source: {
-        value: string;
-    };
-    specifiers?: ImportSpecifier[];
-    type: string;
-}
+import { type ModuleNode } from './lib/imports.js';
+import { type Probe } from './lib/probe.js';
 interface FunctionDeclLike {
     body?: {
         body?: unknown[];
@@ -37,7 +21,7 @@ declare const nextRouteSegmentIsThinDelegate: {
         ExportDefaultDeclaration?: undefined;
     } | {
         ExportDefaultDeclaration(node: ExportDefaultDeclNode): void;
-        ImportDeclaration(node: ImportNode): void;
+        ImportDeclaration(node: ModuleNode): void;
     };
     fixShape: string;
     meta: {
@@ -52,5 +36,6 @@ declare const nextRouteSegmentIsThinDelegate: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default nextRouteSegmentIsThinDelegate;