@webpresso/agent-config 0.4.2 → 0.4.4

package/dist/esm/oxlint/testing-quality.d.ts

@@ -0,0 +1,35 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-weak-assertions": {
+            create(context: any): {
+                CallExpression(node: any): void;
+            };
+        };
+        "no-bare-spy-assertions": {
+            create(context: any): {
+                CallExpression(node: any): void;
+            };
+        };
+        "no-internal-mocks": {
+            create(context: any): {
+                CallExpression(node: any): void;
+            };
+        };
+        "no-real-timers-in-tests": {
+            create(context: any): {
+                NewExpression(node: any): void;
+            };
+        };
+        "no-cold-dynamic-import": {
+            create(context: any): {
+                CallExpression(node: any): void;
+                "CallExpression:exit"(node: any): void;
+                ImportExpression(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;

package/dist/esm/oxlint/testing-quality.js

@@ -0,0 +1,186 @@
+// @ts-nocheck
+// Webpresso testing quality rules — replaces GritQL patterns:
+// - no-weak-assertions (no-tobefalsy, no-tobedefined)
+// - no-bare-spy-assertions
+// - no-internal-mocks
+// - no-real-timers-in-tests
+const noWeakAssertions = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "MemberExpression" || node.callee.property.type !== "Identifier") {
+                    return;
+                }
+                const method = node.callee.property.name;
+                const weak = ["toBeTruthy", "toBeFalsy", "toBeDefined", "toBeUndefined", "toBeTypeOf"];
+                if (!weak.includes(method))
+                    return;
+                if (node.arguments.length > 0 && method !== "toBeTypeOf")
+                    return;
+                const messages = {
+                    toBeTruthy: "Weak assertion: toBeTruthy() matches too many values. Use toBe(true) for strict equality.",
+                    toBeFalsy: "Weak assertion: toBeFalsy() matches too many values. Use toBe(false) for strict equality.",
+                    toBeDefined: "Weak assertion: toBeDefined() allows equivalent mutants. Use toBe(expectedValue) or toEqual(expectedValue).",
+                    toBeUndefined: "Weak assertion: toBeUndefined() allows equivalent mutants. Use toBe(undefined) explicitly.",
+                    toBeTypeOf: "Weak assertion: toBeTypeOf() only checks the type, not the value. Use toBe(expectedValue) or toEqual(expectedValue).",
+                };
+                context.report({ node: node.callee.property, message: messages[method] });
+            },
+        };
+    },
+};
+const noBareSpy = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "MemberExpression" ||
+                    node.callee.property.type !== "Identifier" ||
+                    node.callee.property.name !== "toHaveBeenCalled" ||
+                    node.arguments.length > 0) {
+                    return;
+                }
+                // Allow .not.toHaveBeenCalled()
+                const obj = node.callee.object;
+                if (obj.type === "MemberExpression" &&
+                    obj.property.type === "Identifier" &&
+                    obj.property.name === "not") {
+                    return;
+                }
+                context.report({
+                    node: node.callee.property,
+                    message: "Weak spy assertion: toHaveBeenCalled() without arguments. Use toHaveBeenCalledWith(expected), toHaveBeenNthCalledWith(n, expected), or toHaveBeenCalledTimes(count).",
+                });
+            },
+        };
+    },
+};
+const noInternalMocks = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "MemberExpression" ||
+                    node.callee.object.type !== "Identifier" ||
+                    node.callee.object.name !== "vi" ||
+                    node.callee.property.type !== "Identifier" ||
+                    node.callee.property.name !== "mock") {
+                    return;
+                }
+                const arg = node.arguments[0];
+                if (!arg || arg.type !== "Literal" || typeof arg.value !== "string")
+                    return;
+                if (arg.value.includes("@webpresso")) {
+                    // Allow mocking I/O boundary modules (filesystem loaders/writers)
+                    // These are legitimate mock targets even in unit tests
+                    const ioBoundaryPrefixes = [
+                        "@webpresso/schema/loaders/", // YAML filesystem loaders & writers
+                        "@webpresso/scripts/", // Repo-wide scripts & dev orchestration I/O boundaries
+                    ];
+                    if (ioBoundaryPrefixes.some((prefix) => arg.value.startsWith(prefix)))
+                        return;
+                    context.report({
+                        node: arg,
+                        message: "Mocking internal @webpresso/* package. Use real dependencies (PGlite for DB, real services for logic). Convert to .integration.test.ts if needed.",
+                    });
+                }
+            },
+        };
+    },
+};
+const noRealTimers = {
+    create(context) {
+        return {
+            NewExpression(node) {
+                if (node.callee.type !== "Identifier" || node.callee.name !== "Promise") {
+                    return;
+                }
+                const arg = node.arguments[0];
+                if (!arg || (arg.type !== "ArrowFunctionExpression" && arg.type !== "FunctionExpression")) {
+                    return;
+                }
+                const body = arg.body.type === "CallExpression"
+                    ? arg.body
+                    : arg.body.type === "BlockStatement" &&
+                        arg.body.body.length === 1 &&
+                        arg.body.body[0].type === "ExpressionStatement"
+                        ? arg.body.body[0].expression
+                        : null;
+                if (body &&
+                    body.type === "CallExpression" &&
+                    body.callee.type === "Identifier" &&
+                    body.callee.name === "setTimeout") {
+                    context.report({
+                        node,
+                        message: "setTimeout inside Promise constructor will hang with fake timers. Use await Promise.resolve() for microtask delays, or vi.advanceTimersByTimeAsync() for time-based delays.",
+                    });
+                }
+            },
+        };
+    },
+};
+function isTestCall(node) {
+    const { callee } = node;
+    if (callee.type === "Identifier")
+        return callee.name === "it" || callee.name === "test";
+    return false;
+}
+function isBeforeAllCall(node) {
+    const { callee } = node;
+    return callee.type === "Identifier" && callee.name === "beforeAll";
+}
+const noColdDynamicImport = {
+    create(context) {
+        // Track depth inside it()/test() callback bodies via the linter's own traversal.
+        // Using ':exit' to decrement so we never need to walk the subtree manually
+        // (manual walks hit circular parent back-references in oxlint's proxy AST).
+        let testDepth = 0;
+        let beforeAllDepth = 0;
+        const prewarmedModules = new Set();
+        return {
+            CallExpression(node) {
+                if (isTestCall(node))
+                    testDepth++;
+                if (isBeforeAllCall(node))
+                    beforeAllDepth++;
+            },
+            "CallExpression:exit"(node) {
+                if (isTestCall(node))
+                    testDepth--;
+                if (isBeforeAllCall(node))
+                    beforeAllDepth--;
+            },
+            ImportExpression(node) {
+                const src = node.source;
+                if (src.type !== "Literal" || typeof src.value !== "string")
+                    return;
+                if (!src.value.startsWith("@webpresso/") && !src.value.startsWith("#"))
+                    return;
+                // Track modules pre-warmed in beforeAll
+                if (beforeAllDepth > 0) {
+                    prewarmedModules.add(src.value);
+                    return;
+                }
+                if (testDepth === 0)
+                    return;
+                // Skip if module was pre-warmed via beforeAll
+                if (prewarmedModules.has(src.value))
+                    return;
+                context.report({
+                    node: src,
+                    message: `Dynamic @webpresso/* import inside test body causes cold-start timeouts under parallel execution. ` +
+                        `Add \`beforeAll(() => import('${src.value}'))\` at the top of the file to pre-warm the module cache.`,
+                });
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: "webpresso-testing" },
+    rules: {
+        "no-weak-assertions": noWeakAssertions,
+        "no-bare-spy-assertions": noBareSpy,
+        "no-internal-mocks": noInternalMocks,
+        "no-real-timers-in-tests": noRealTimers,
+        "no-cold-dynamic-import": noColdDynamicImport,
+    },
+};
+export default plugin;

package/dist/esm/oxlint/tier-boundaries.d.ts

@@ -0,0 +1,35 @@
+export declare function resolveFileTierContext(filename: any): {
+    kind: string;
+    packageName: any;
+    tier: number;
+} | {
+    kind: string;
+} | null;
+export declare function resolveImportTierContext(source: any): {
+    kind: string;
+    packageName: any;
+    tier: number;
+} | {
+    kind: string;
+} | null;
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-higher-tier-imports": {
+            create(context: any): {
+                ImportDeclaration?: undefined;
+                ExportNamedDeclaration?: undefined;
+                ExportAllDeclaration?: undefined;
+                ImportExpression?: undefined;
+            } | {
+                ImportDeclaration(node: any): void;
+                ExportNamedDeclaration(node: any): void;
+                ExportAllDeclaration(node: any): void;
+                ImportExpression(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;

package/dist/esm/oxlint/tier-boundaries.js

@@ -0,0 +1,133 @@
+// @ts-nocheck
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+const FALLBACK_PACKAGE_TIERS = {
+    utils: 0,
+    types: 0,
+    database: 1,
+    ui: 1,
+    "app-core": 2,
+    "cli-wp": 3,
+};
+async function loadPackageTiers() {
+    const packageBoundaryModuleUrl = pathToFileURL(resolve(process.cwd(), "package-boundaries.js"));
+    try {
+        const packageBoundaryModule = await import(packageBoundaryModuleUrl.href);
+        return packageBoundaryModule.PACKAGE_TIERS ?? FALLBACK_PACKAGE_TIERS;
+    }
+    catch {
+        return FALLBACK_PACKAGE_TIERS;
+    }
+}
+const PACKAGE_TIERS = await loadPackageTiers();
+function normalizeFilename(filename) {
+    return typeof filename === "string" ? filename.replaceAll("\\", "/") : "";
+}
+function getFilename(context) {
+    if (typeof context.getFilename === "function") {
+        return normalizeFilename(context.getFilename());
+    }
+    return normalizeFilename(context.filename);
+}
+function getPathSegments(filename) {
+    return normalizeFilename(filename).split("/").filter(Boolean);
+}
+function getWorkspacePackageContext(packageName) {
+    const tier = PACKAGE_TIERS[packageName];
+    if (typeof tier !== "number") {
+        return null;
+    }
+    return {
+        kind: "package",
+        packageName,
+        tier,
+    };
+}
+export function resolveFileTierContext(filename) {
+    const segments = getPathSegments(filename);
+    if (segments.includes("infra")) {
+        return { kind: "infra" };
+    }
+    if (segments.includes("packages-public")) {
+        return { kind: "packages-public" };
+    }
+    const packagesIndex = segments.indexOf("packages");
+    if (packagesIndex !== -1 && packagesIndex + 2 < segments.length) {
+        return getWorkspacePackageContext(segments[packagesIndex + 2]);
+    }
+    const appsIndex = segments.indexOf("apps");
+    if (appsIndex !== -1) {
+        const directAppContext = getWorkspacePackageContext(segments[appsIndex + 1]);
+        if (directAppContext) {
+            return directAppContext;
+        }
+        if (appsIndex + 2 < segments.length) {
+            return getWorkspacePackageContext(segments[appsIndex + 2]);
+        }
+    }
+    return null;
+}
+export function resolveImportTierContext(source) {
+    if (typeof source !== "string") {
+        return null;
+    }
+    if (source.startsWith("packages-public/")) {
+        return { kind: "packages-public" };
+    }
+    if (!source.startsWith("@webpresso/")) {
+        return null;
+    }
+    const packageName = source.slice("@webpresso/".length).split("/")[0];
+    return getWorkspacePackageContext(packageName);
+}
+function reportTierViolation(context, node, fromContext, toContext) {
+    context.report({
+        node,
+        message: `Tier boundary violation: "${fromContext.packageName}" (tier ${fromContext.tier}) must not import higher-tier package "${toContext.packageName}" (tier ${toContext.tier}).`,
+    });
+}
+function checkStaticModuleSource(node, callback) {
+    if (!node.source)
+        return;
+    callback(node.source.value, node.source);
+}
+const noHigherTierImports = {
+    create(context) {
+        const fromContext = resolveFileTierContext(getFilename(context));
+        if (!fromContext || fromContext.kind !== "package") {
+            return {};
+        }
+        function checkImport(source, node) {
+            const toContext = resolveImportTierContext(source);
+            if (!toContext || toContext.kind !== "package") {
+                return;
+            }
+            if (toContext.tier > fromContext.tier) {
+                reportTierViolation(context, node, fromContext, toContext);
+            }
+        }
+        return {
+            ImportDeclaration(node) {
+                checkImport(node.source.value, node.source);
+            },
+            ExportNamedDeclaration(node) {
+                checkStaticModuleSource(node, checkImport);
+            },
+            ExportAllDeclaration(node) {
+                checkStaticModuleSource(node, checkImport);
+            },
+            ImportExpression(node) {
+                if (node.source.type !== "Literal")
+                    return;
+                checkImport(node.source.value, node.source);
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: "webpresso-tier-boundaries" },
+    rules: {
+        "no-higher-tier-imports": noHigherTierImports,
+    },
+};
+export default plugin;

package/dist/esm/stryker/index.d.ts

@@ -44,9 +44,20 @@ export declare const baseConfig: {
     incrementalFile: string;
 };
 /**
- * Extends baseConfig with TypeScript checker defaults.
+ * Extends baseConfig for TypeScript packages.
  * Use this in any TypeScript package instead of baseConfig directly.
  *
+ * Does NOT wire `@stryker-mutator/typescript-checker`: that plugin depends on
+ * classic TypeScript compiler-API symbols (`ts.sys`,
+ * `ts.createSolutionBuilderWithWatch`, `ts.createSolutionBuilderWithWatchHost`,
+ * `ts.createEmitAndSemanticDiagnosticsBuilderProgram`,
+ * `ts.parseConfigFileTextToJson`, `ts.formatDiagnostics`) that are all
+ * `undefined` on TypeScript 7.0.2, so wiring it breaks mutation runs on TS7
+ * with a hard failure rather than classifying compile errors. Consumers who
+ * still want mutant type-checking on TS7 must add a consumer-side pnpm
+ * override aliasing the plugin's `typescript` import to
+ * `@typescript/typescript6` themselves.
+ *
  * @example
  * import { typescriptBaseConfig } from '@webpresso/agent-config/stryker'
  *
@@ -57,6 +68,7 @@ export declare const baseConfig: {
 export declare const typescriptBaseConfig: {
     packageManager: string;
     testRunner: string;
+    plugins: string[];
     ignorePatterns: string[];
     mutate: string[];
     concurrency: number;
@@ -83,8 +95,6 @@ export declare const typescriptBaseConfig: {
     };
     incremental: boolean;
     incrementalFile: string;
-    plugins: string[];
-    checkers: string[];
     tsconfigFile: string;
 };
 /**
@@ -101,6 +111,7 @@ export declare const typescriptBaseConfig: {
 export declare const typescriptWorkersBaseConfig: {
     packageManager: string;
     testRunner: string;
+    plugins: string[];
     ignorePatterns: string[];
     mutate: string[];
     concurrency: number;
@@ -124,8 +135,6 @@ export declare const typescriptWorkersBaseConfig: {
     };
     incremental: boolean;
     incrementalFile: string;
-    plugins: string[];
-    checkers: string[];
     tsconfigFile: string;
     vitest: {
         configFile: string;

package/dist/esm/stryker/index.js

@@ -93,9 +93,20 @@ export const baseConfig = {
     incrementalFile: "reports/stryker-incremental.json",
 };
 /**
- * Extends baseConfig with TypeScript checker defaults.
+ * Extends baseConfig for TypeScript packages.
  * Use this in any TypeScript package instead of baseConfig directly.
  *
+ * Does NOT wire `@stryker-mutator/typescript-checker`: that plugin depends on
+ * classic TypeScript compiler-API symbols (`ts.sys`,
+ * `ts.createSolutionBuilderWithWatch`, `ts.createSolutionBuilderWithWatchHost`,
+ * `ts.createEmitAndSemanticDiagnosticsBuilderProgram`,
+ * `ts.parseConfigFileTextToJson`, `ts.formatDiagnostics`) that are all
+ * `undefined` on TypeScript 7.0.2, so wiring it breaks mutation runs on TS7
+ * with a hard failure rather than classifying compile errors. Consumers who
+ * still want mutant type-checking on TS7 must add a consumer-side pnpm
+ * override aliasing the plugin's `typescript` import to
+ * `@typescript/typescript6` themselves.
+ *
  * @example
  * import { typescriptBaseConfig } from '@webpresso/agent-config/stryker'
  *
@@ -105,8 +116,6 @@ export const baseConfig = {
  */
 export const typescriptBaseConfig = {
     ...baseConfig,
-    plugins: [...baseConfig.plugins, "@stryker-mutator/typescript-checker"],
-    checkers: ["typescript"],
     tsconfigFile: "tsconfig.json",
 };
 /**

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@webpresso/agent-config",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "private": false,
-  "description": "Shared vitest, tsconfig, stryker, and workers-test config for webpresso consumers. Binary-free — pure test/config tooling.",
+  "description": "Shared vitest, tsconfig, stryker, workers-test, and oxlint policy plugins for webpresso consumers. Binary-free — pure test/config tooling.",
   "homepage": "https://github.com/webpresso/agent-kit#readme",
   "bugs": {
     "url": "https://github.com/webpresso/agent-kit/issues"
@@ -45,6 +45,72 @@
         "default": "./dist/esm/e2e/index.js"
       }
     },
+    "./oxlint": {
+      "types": "./dist/esm/oxlint/index.d.ts",
+      "import": "./dist/esm/oxlint/index.js",
+      "require": "./dist/esm/oxlint/index.js",
+      "default": "./dist/esm/oxlint/index.js"
+    },
+    "./oxlint/basenames": {
+      "types": "./dist/esm/oxlint/basenames.d.ts",
+      "import": "./dist/esm/oxlint/basenames.js",
+      "require": "./dist/esm/oxlint/basenames.js",
+      "default": "./dist/esm/oxlint/basenames.js"
+    },
+    "./oxlint/code-safety": {
+      "types": "./dist/esm/oxlint/code-safety.d.ts",
+      "import": "./dist/esm/oxlint/code-safety.js",
+      "require": "./dist/esm/oxlint/code-safety.js",
+      "default": "./dist/esm/oxlint/code-safety.js"
+    },
+    "./oxlint/foundation-purity": {
+      "types": "./dist/esm/oxlint/foundation-purity.d.ts",
+      "import": "./dist/esm/oxlint/foundation-purity.js",
+      "require": "./dist/esm/oxlint/foundation-purity.js",
+      "default": "./dist/esm/oxlint/foundation-purity.js"
+    },
+    "./oxlint/graphql-conventions": {
+      "types": "./dist/esm/oxlint/graphql-conventions.d.ts",
+      "import": "./dist/esm/oxlint/graphql-conventions.js",
+      "require": "./dist/esm/oxlint/graphql-conventions.js",
+      "default": "./dist/esm/oxlint/graphql-conventions.js"
+    },
+    "./oxlint/import-hygiene": {
+      "types": "./dist/esm/oxlint/import-hygiene.d.ts",
+      "import": "./dist/esm/oxlint/import-hygiene.js",
+      "require": "./dist/esm/oxlint/import-hygiene.js",
+      "default": "./dist/esm/oxlint/import-hygiene.js"
+    },
+    "./oxlint/monorepo-paths": {
+      "types": "./dist/esm/oxlint/monorepo-paths.d.ts",
+      "import": "./dist/esm/oxlint/monorepo-paths.js",
+      "require": "./dist/esm/oxlint/monorepo-paths.js",
+      "default": "./dist/esm/oxlint/monorepo-paths.js"
+    },
+    "./oxlint/path-roles": {
+      "types": "./dist/esm/oxlint/path-roles.d.ts",
+      "import": "./dist/esm/oxlint/path-roles.js",
+      "require": "./dist/esm/oxlint/path-roles.js",
+      "default": "./dist/esm/oxlint/path-roles.js"
+    },
+    "./oxlint/query-patterns": {
+      "types": "./dist/esm/oxlint/query-patterns.d.ts",
+      "import": "./dist/esm/oxlint/query-patterns.js",
+      "require": "./dist/esm/oxlint/query-patterns.js",
+      "default": "./dist/esm/oxlint/query-patterns.js"
+    },
+    "./oxlint/testing-quality": {
+      "types": "./dist/esm/oxlint/testing-quality.d.ts",
+      "import": "./dist/esm/oxlint/testing-quality.js",
+      "require": "./dist/esm/oxlint/testing-quality.js",
+      "default": "./dist/esm/oxlint/testing-quality.js"
+    },
+    "./oxlint/tier-boundaries": {
+      "types": "./dist/esm/oxlint/tier-boundaries.d.ts",
+      "import": "./dist/esm/oxlint/tier-boundaries.js",
+      "require": "./dist/esm/oxlint/tier-boundaries.js",
+      "default": "./dist/esm/oxlint/tier-boundaries.js"
+    },
     "./playwright/quality-scaffold": {
       "import": {
         "types": "./dist/esm/playwright/quality-scaffold.d.ts",
@@ -177,7 +243,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "tshy && bun scripts/normalize-tsconfig-json-exports.ts",
+    "build": "tshy && bun scripts/normalize-tsconfig-json-exports.ts && bun scripts/normalize-oxlint-exports.ts",
     "prepublishOnly": "vp run build",
     "typecheck": "tsc --noEmit",
     "lint:pkg": "publint && attw --pack . --profile esm-only"
@@ -234,6 +300,17 @@
       "./deploy": "./src/deploy/index.ts",
       "./dev": "./src/dev/index.ts",
       "./e2e": "./src/e2e/index.ts",
+      "./oxlint": "./src/oxlint/index.ts",
+      "./oxlint/basenames": "./src/oxlint/basenames.ts",
+      "./oxlint/code-safety": "./src/oxlint/code-safety.ts",
+      "./oxlint/foundation-purity": "./src/oxlint/foundation-purity.ts",
+      "./oxlint/graphql-conventions": "./src/oxlint/graphql-conventions.ts",
+      "./oxlint/import-hygiene": "./src/oxlint/import-hygiene.ts",
+      "./oxlint/monorepo-paths": "./src/oxlint/monorepo-paths.ts",
+      "./oxlint/path-roles": "./src/oxlint/path-roles.ts",
+      "./oxlint/query-patterns": "./src/oxlint/query-patterns.ts",
+      "./oxlint/testing-quality": "./src/oxlint/testing-quality.ts",
+      "./oxlint/tier-boundaries": "./src/oxlint/tier-boundaries.ts",
       "./playwright/quality-scaffold": "./src/playwright/quality-scaffold.ts",
       "./process": "./src/process/index.ts",
       "./repo-root": "./src/repo-root/index.ts",