@webpresso/agent-kit 0.21.0

package/dist/esm/config/oxlint/query-patterns.d.ts

@@ -0,0 +1,25 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-adhoc-useQuery': {
+            create(context: any): {
+                CallExpression?: undefined;
+            } | {
+                CallExpression(node: any): void;
+            };
+        };
+        'no-isLoading-on-queries': {
+            create(context: any): {
+                VariableDeclarator?: undefined;
+                MemberExpression?: undefined;
+            } | {
+                VariableDeclarator(node: any): void;
+                MemberExpression(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=query-patterns.d.ts.map

package/dist/esm/config/oxlint/query-patterns.js

@@ -0,0 +1,126 @@
+// @ts-nocheck
+const QUERY_HOOK_NAMES = new Set(['useQuery', 'useSuspenseQuery', 'useInfiniteQuery']);
+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 isClientQuerySurface(filename) {
+    const normalized = normalizeFilename(filename);
+    if (!/\.tsx?$/.test(normalized))
+        return false;
+    if (normalized.includes('/.webpresso/generated/'))
+        return false;
+    const isWebAppSurface = normalized.includes('/apps/web/') && normalized.includes('/app/');
+    const isFeatureSurface = normalized.includes('/packages/feature/') && normalized.includes('/src/');
+    return isWebAppSurface || isFeatureSurface;
+}
+function getCalleeName(callee) {
+    if (!callee)
+        return null;
+    if (callee.type === 'Identifier')
+        return callee.name;
+    if (callee.type === 'MemberExpression' &&
+        !callee.computed &&
+        callee.property?.type === 'Identifier') {
+        return callee.property.name;
+    }
+    return null;
+}
+function isQueryHookCall(node) {
+    return node?.type === 'CallExpression' && QUERY_HOOK_NAMES.has(getCalleeName(node.callee));
+}
+function isTrackedQueryResult(init, queryResultBindings) {
+    return init?.type === 'Identifier' && queryResultBindings.has(init.name);
+}
+function isIsLoadingProperty(property) {
+    return ((property?.type === 'Identifier' && property.name === 'isLoading') ||
+        (property?.type === 'Literal' && property.value === 'isLoading'));
+}
+function reportAdhocQuery(context, node) {
+    context.report({
+        node,
+        message: 'TanStack Query hard cut: pass a named query options identifier to useQuery/useSuspenseQuery/useInfiniteQuery instead of an inline object literal.',
+    });
+}
+function reportIsLoading(context, node) {
+    context.report({
+        node,
+        message: 'TanStack Query hard cut: use isPending (or domain-specific derived state) instead of isLoading on query results.',
+    });
+}
+const noAdhocUseQuery = {
+    create(context) {
+        if (!isClientQuerySurface(getFilename(context))) {
+            return {};
+        }
+        return {
+            CallExpression(node) {
+                if (!isQueryHookCall(node))
+                    return;
+                const firstArgument = node.arguments[0];
+                if (firstArgument?.type !== 'ObjectExpression')
+                    return;
+                reportAdhocQuery(context, firstArgument);
+            },
+        };
+    },
+};
+const noIsLoadingOnQueries = {
+    create(context) {
+        if (!isClientQuerySurface(getFilename(context))) {
+            return {};
+        }
+        const queryResultBindings = new Set();
+        function trackQueryResultBinding(id, init) {
+            if (id?.type !== 'Identifier')
+                return;
+            if (!isQueryHookCall(init))
+                return;
+            queryResultBindings.add(id.name);
+        }
+        function reportObjectPattern(node) {
+            for (const property of node.properties ?? []) {
+                if (property?.type !== 'Property')
+                    continue;
+                if (!isIsLoadingProperty(property.key))
+                    continue;
+                reportIsLoading(context, property.key);
+            }
+        }
+        return {
+            VariableDeclarator(node) {
+                trackQueryResultBinding(node.id, node.init);
+                if (node.id?.type !== 'ObjectPattern')
+                    return;
+                if (!isQueryHookCall(node.init) && !isTrackedQueryResult(node.init, queryResultBindings))
+                    return;
+                reportObjectPattern(node.id);
+            },
+            MemberExpression(node) {
+                if (node.computed)
+                    return;
+                if (!isIsLoadingProperty(node.property))
+                    return;
+                if (node.object?.type !== 'Identifier')
+                    return;
+                if (!queryResultBindings.has(node.object.name))
+                    return;
+                reportIsLoading(context, node.property);
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: 'webpresso-query-patterns' },
+    rules: {
+        'no-adhoc-useQuery': noAdhocUseQuery,
+        'no-isLoading-on-queries': noIsLoadingOnQueries,
+    },
+};
+export default plugin;
+//# sourceMappingURL=query-patterns.js.map

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

@@ -0,0 +1,36 @@
+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;
+//# sourceMappingURL=testing-quality.d.ts.map

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

@@ -0,0 +1,187 @@
+// @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;
+//# sourceMappingURL=testing-quality.js.map

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

@@ -0,0 +1,36 @@
+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;
+//# sourceMappingURL=tier-boundaries.d.ts.map

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

@@ -0,0 +1,134 @@
+// @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;
+//# sourceMappingURL=tier-boundaries.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * Shared mutation-testing defaults for Webpresso packages.
+ *
+ * Import and extend this in package-root `stryker.config.mjs` files:
+ *
+ * @example
+ * import { baseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default {
+ *   ...baseConfig,
+ *   vitest: { configFile: 'vitest.node.config.ts' },
+ *   mutate: ['src/**\/*.ts', '!src/**\/*.test.ts'],
+ * }
+ */
+export declare const baseConfig: {
+    packageManager: string;
+    testRunner: string;
+    plugins: string[];
+    ignorePatterns: string[];
+    mutate: string[];
+    concurrency: number;
+    timeoutMS: number;
+    dryRunTimeoutMinutes: number;
+    ignoreStatic: boolean;
+    thresholds: {
+        high: number;
+        low: number;
+        break: number;
+    };
+    mutator: {
+        excludedMutations: string[];
+    };
+    reporters: string[];
+    htmlReporter: {
+        fileName: string;
+    };
+    jsonReporter: {
+        fileName: string;
+    };
+    incremental: boolean;
+    incrementalFile: string;
+};
+export default baseConfig;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/config/stryker/index.js

@@ -0,0 +1,79 @@
+/**
+ * Shared mutation-testing defaults for Webpresso packages.
+ *
+ * Import and extend this in package-root `stryker.config.mjs` files:
+ *
+ * @example
+ * import { baseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default {
+ *   ...baseConfig,
+ *   vitest: { configFile: 'vitest.node.config.ts' },
+ *   mutate: ['src/**\/*.ts', '!src/**\/*.test.ts'],
+ * }
+ */
+export const baseConfig = {
+    packageManager: 'pnpm',
+    testRunner: 'vitest',
+    plugins: ['@stryker-mutator/vitest-runner'],
+    ignorePatterns: [
+        '**/.git/**',
+        '**/node_modules/**',
+        '**/.stryker-tmp/**',
+        '**/.agent/**',
+        '**/.agents/**',
+        '**/.claude/**',
+        '**/.codex/**',
+        '**/.cursor/**',
+        '**/.gemini/**',
+        '**/.windsurf/**',
+        '**/.opencode/**',
+        '**/.omx/**',
+        '**/dist/**',
+        '**/coverage/**',
+        '**/*.d.ts',
+    ],
+    // Default mutate patterns - exclude all test files.
+    // Individual packages can override or extend these patterns.
+    mutate: [
+        'src/**/*.ts',
+        'src/**/*.tsx',
+        '!src/**/*.test.ts',
+        '!src/**/*.test.tsx',
+        '!src/**/*.spec.ts',
+        '!src/**/*.spec.tsx',
+        '!src/**/*.d.ts',
+    ],
+    // Performance settings.
+    concurrency: 4,
+    timeoutMS: 60000,
+    dryRunTimeoutMinutes: 10,
+    // Static mutants (module-level constants) can't be activated per-test — they require
+    // a fresh process per mutant, which is extremely slow. Ignore them instead.
+    ignoreStatic: true,
+    // Quality thresholds.
+    thresholds: {
+        high: 85,
+        low: 80,
+        break: 75,
+    },
+    // Exclude cosmetic mutations that don't affect behavior.
+    // This focuses mutation testing on actual business logic.
+    mutator: {
+        excludedMutations: ['StringLiteral', 'ArrayDeclaration'],
+    },
+    // Reporting.
+    reporters: ['html', 'clear-text', 'progress-append-only', 'json'],
+    htmlReporter: {
+        fileName: 'reports/mutation/mutation-report.html',
+    },
+    jsonReporter: {
+        fileName: 'reports/mutation/mutation-report.json',
+    },
+    // Incremental mutation testing - caches results to avoid re-running unchanged code.
+    // Results stored in reports/stryker-incremental.json.
+    incremental: true,
+    incrementalFile: 'reports/stryker-incremental.json',
+};
+export default baseConfig;
+//# sourceMappingURL=index.js.map

package/dist/esm/config/test-preset/index.d.ts

@@ -0,0 +1,2 @@
+export { createNodeTestPreset, defineTestPreset, type DefineConfigCompatible, type TestPresetOptions, } from './vitest.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/config/test-preset/index.js

@@ -0,0 +1,2 @@
+export { createNodeTestPreset, defineTestPreset, } from './vitest.js';
+//# sourceMappingURL=index.js.map