agentic-qe 3.15.16 → 3.15.18

package/dist/shared/test-runner-project.js

@@ -14,12 +14,33 @@
  * A run from the current working directory is kept whenever that directory is
  * already inside the file's runner project (a single-project repository, or a
  * server started inside the package), so those runs behave as before.
+ *
+ * #1272: a package with its own config runs from that package, even when the
+ * root config also lists it in `test.projects` (or a `vitest.workspace.*`).
+ * Settings that only the root config adds to that project (its setup files,
+ * aliases or environment) are then not applied; the package's own config is
+ * what runs. A package without its own config still runs from the root.
+ *
+ * #1272: `vite.config.*` counts only when its text contains `test:`. The
+ * config is code, and reading what it exports would mean running it, so a
+ * `test` block built some other way (spread from another module, say) is not
+ * seen and a `test:` that only appears in a comment is. Name the runner config
+ * `vitest.config.*` for an exact match.
+ *
+ * #1248: a Python test file belongs to the nearest directory with pytest
+ * configuration instead (`pytest.ini`, `pyproject.toml` with
+ * `[tool.pytest.ini_options]`, `setup.cfg` with `[tool:pytest]`, `tox.ini`
+ * with `[pytest]`), and JavaScript files ignore that configuration. A
+ * `conftest.py` marks a pytest project for detection but is not a directory
+ * to run from: it is often in `tests/`, and pytest started there would not
+ * have the project root on `sys.path`.
  */
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import * as path from 'node:path';
 import { findProjectRoot } from '../kernel/project-root.js';
 import { CallerInputError } from './error-utils.js';
 import { requirePayloadFiles, requirePayloadPath } from './io/payload-path-guard.js';
+import { isPythonTestFile } from './pytest-junit-report.js';
 import { safeJsonParse } from './safe-json.js';
 import { runnerFilePath } from './test-runner-args.js';
 import { ok, err } from './types/index.js';
@@ -63,36 +84,112 @@ function readSmallFile(file) {
     }
 }
 /**
- * True when a package.json in `dir` holds runner configuration (a top-level
- * `jest` or `vitest` key). Listing a runner as a dependency or in
- * `scripts.test` does not: in a workspace the packages do that while the root
- * config defines their projects and setup.
+ * Runners a package.json in `dir` configures (a top-level `jest` or `vitest`
+ * key). Listing a runner as a dependency or in `scripts.test` does not count:
+ * in a workspace the packages do that while the root config defines their
+ * projects and setup.
  */
-function packageConfiguresRunner(dir) {
+function packageRunnerKeys(dir) {
     const text = readSmallFile(path.join(dir, 'package.json'));
     if (text === undefined)
-        return false;
+        return [];
     let pkg;
     try {
         pkg = safeJsonParse(text);
     }
     catch {
-        return false;
+        return [];
     }
     if (!pkg || typeof pkg !== 'object')
-        return false;
-    return pkg.jest !== undefined || pkg.vitest !== undefined;
+        return [];
+    return ['vitest', 'jest'].filter(key => pkg[key] !== undefined);
+}
+/** True when a `vite.config.*` in `dir` mentions `test:` (see the header note). */
+function viteConfiguresTest(dir) {
+    return VITE_CONFIG_FILES.some(name => {
+        const text = readSmallFile(path.join(dir, name));
+        return text !== undefined && /\btest\s*:/.test(text);
+    });
+}
+/** The runners whose configuration `dir` holds. */
+function configuredRunners(dir) {
+    const runners = new Set(packageRunnerKeys(dir));
+    for (const name of RUNNER_CONFIG_FILES) {
+        if (existsSync(path.join(dir, name)))
+            runners.add(name.startsWith('jest.') ? 'jest' : 'vitest');
+    }
+    if (!runners.has('vitest') && viteConfiguresTest(dir))
+        runners.add('vitest');
+    return runners;
 }
 /** True when `dir` holds a Vitest or Jest configuration. */
 export function isRunnerProjectDir(dir) {
-    if (RUNNER_CONFIG_FILES.some(name => existsSync(path.join(dir, name))))
+    return configuredRunners(dir).size > 0;
+}
+/** pytest configuration files, and the section each must contain (none: always). */
+const PYTEST_CONFIG_SECTIONS = [
+    ['pytest.ini', undefined],
+    ['pyproject.toml', /^\s*\[tool\.pytest(?:\.ini_options)?\]/m],
+    ['tox.ini', /^\s*\[pytest\]/m],
+    ['setup.cfg', /^\s*\[tool:pytest\]/m],
+];
+/**
+ * #1248: true when `dir` holds pytest configuration; with `conftest`, a
+ * `conftest.py` counts too (see the header note).
+ */
+export function isPytestProjectDir(dir, conftest = false) {
+    if (conftest && existsSync(path.join(dir, 'conftest.py')))
         return true;
-    for (const name of VITE_CONFIG_FILES) {
+    return PYTEST_CONFIG_SECTIONS.some(([name, section]) => {
+        if (!section)
+            return existsSync(path.join(dir, name));
         const text = readSmallFile(path.join(dir, name));
-        if (text !== undefined && /\btest\s*:/.test(text))
+        return text !== undefined && section.test(text);
+    });
+}
+/**
+ * #1248: true when `dir`, or a directory above it no higher than `boundary`,
+ * is configured for pytest (including a `conftest.py`).
+ */
+export function isPytestProject(dir, boundary = findProjectRoot()) {
+    const root = realDir(boundary);
+    let current = realDir(dir);
+    const bounded = isWithin(root, current);
+    for (;;) {
+        if (isPytestProjectDir(current, true))
             return true;
+        if (!bounded || current === root)
+            return false;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return false;
+        current = parent;
+    }
+}
+/**
+ * #1272: the runner configured by the runner project that `dir` belongs to:
+ * the nearest directory at or above `dir`, no higher than `boundary`, with
+ * runner configuration. Jest config (`jest.config.*`, or a `jest` key in
+ * package.json) means jest; Vitest config (`vitest.config.*`,
+ * `vitest.workspace.*`, a `vite.config.*` with `test`, or a `vitest` key)
+ * means vitest. Undefined when no project is found or it configures both, so
+ * the caller keeps its own choice.
+ */
+export function runnerFrameworkFor(dir, boundary = findProjectRoot()) {
+    const root = realDir(boundary);
+    let current = realDir(dir);
+    const bounded = isWithin(root, current);
+    for (;;) {
+        const runners = configuredRunners(current);
+        if (runners.size > 0)
+            return runners.size === 1 ? [...runners][0] : undefined;
+        if (!bounded || current === root)
+            return undefined;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
     }
-    return packageConfiguresRunner(dir);
 }
 /**
  * The nearest directory at or above `file` with runner configuration, searching no
@@ -104,11 +201,14 @@ export function findRunnerProjectDir(file, boundary, cwd = process.cwd(), checke
     let dir = path.dirname(runnerFilePath(file, cwd));
     if (!isWithin(root, dir))
         return undefined;
+    // #1248: Python files run from pytest config, other files from Vitest/Jest config.
+    const python = isPythonTestFile(file);
     for (;;) {
-        let isProject = checked.get(dir);
+        const key = python ? `pytest:${dir}` : dir;
+        let isProject = checked.get(key);
         if (isProject === undefined) {
-            isProject = isRunnerProjectDir(dir);
-            checked.set(dir, isProject);
+            isProject = python ? isPytestProjectDir(dir) : isRunnerProjectDir(dir);
+            checked.set(key, isProject);
         }
         if (isProject)
             return dir;
@@ -134,7 +234,8 @@ export function runnerCwdFor(file, options = {}) {
 }
 /**
  * Group `files` by the directory each must run from, in first-seen order.
- * Files keep the spelling they were given.
+ * Files keep the spelling they were given. #1248: Python files never share a
+ * group with other files, since only pytest runs them.
  */
 export function groupByRunnerProject(files, options = {}) {
     const resolved = {
@@ -145,13 +246,14 @@ export function groupByRunnerProject(files, options = {}) {
     const groups = new Map();
     for (const file of files) {
         const cwd = runnerCwdFor(file, resolved);
-        const group = groups.get(cwd);
+        const key = `${isPythonTestFile(file) ? 'py' : 'js'}\0${cwd}`;
+        const group = groups.get(key);
         if (group)
-            group.push(file);
+            group.files.push(file);
         else
-            groups.set(cwd, [file]);
+            groups.set(key, { cwd, files: [file] });
     }
-    return [...groups].map(([cwd, groupFiles]) => ({ cwd, files: groupFiles }));
+    return [...groups.values()];
 }
 /**
  * Handler-side check for an execute-tests payload. `testFiles` must name
@@ -166,6 +268,22 @@ export async function requireTestRunTargets(taskType, testFiles, projectRoot) {
         const confined = await requirePayloadFiles(taskType, 'testFiles', testFiles, fileOptions);
         return confined.success ? ok({ testFiles: confined.value }) : confined;
     }
+    const checked = await requireRunProjectRoot(taskType, projectRoot);
+    if (!checked.success)
+        return checked;
+    const root = checked.value;
+    const confined = await requirePayloadFiles(taskType, 'testFiles', testFiles, { ...fileOptions, basePath: root });
+    if (!confined.success)
+        return confined;
+    return ok({ testFiles: confined.value.map(file => path.resolve(root, file)), projectRoot: root });
+}
+/**
+ * An explicit `projectRoot` (MCP `test_execute_parallel`, CLI
+ * `aqe test execute --project-root`): a directory inside the project, checked
+ * by realpath so `..`, an outside absolute path or a symlink pointing out is
+ * refused. Returns the absolute directory.
+ */
+export async function requireRunProjectRoot(taskType, projectRoot) {
     const checked = await requirePayloadPath(taskType, 'projectRoot', projectRoot, { allowDirectory: true });
     if (!checked.success)
         return checked;
@@ -178,9 +296,6 @@ export async function requireTestRunTargets(taskType, testFiles, projectRoot) {
     if (!isDirectory) {
         return err(new CallerInputError(`Invalid ${taskType} payload: 'projectRoot' must be a directory inside the project.`));
     }
-    const confined = await requirePayloadFiles(taskType, 'testFiles', testFiles, { ...fileOptions, basePath: root });
-    if (!confined.success)
-        return confined;
-    return ok({ testFiles: confined.value.map(file => path.resolve(root, file)), projectRoot: root });
+    return ok(root);
 }
 //# sourceMappingURL=test-runner-project.js.map

package/dist/sync/claude-flow-bridge.js

@@ -152,8 +152,8 @@ export async function syncClaudeFlowToAQE(options = {}) {
         // Import safe database opener
         const { openDatabase } = await import('../shared/safe-db.js');
         const db = openDatabase(aqeDbPath);
+        // #1164: openDatabase() set the journal mode (retrying contention, honouring AQE_DISABLE_WAL).
         try {
-            db.pragma('journal_mode = WAL');
             // Prepare insert statements
             const insertKv = db.prepare(`
         INSERT OR REPLACE INTO kv_store (key, namespace, value, expires_at, created_at)

package/dist/sync/readers/sqlite-reader.js

@@ -37,11 +37,10 @@ export class SQLiteReader {
             throw new Error(`SQLite database not found: ${this.dbPath}`);
         }
         try {
-            // Open read-only
+            // Open read-only. Never set journal_mode/synchronous here: switching the
+            // journal mode is a write, so it fails with SQLITE_READONLY on a
+            // rollback-journal source (#1320). A reader must leave the source as-is.
             this.db = openDatabase(this.dbPath, { readonly: true });
-            // Enable performance settings for reads
-            this.db.pragma('journal_mode = WAL');
-            this.db.pragma('synchronous = NORMAL');
             console.log(`[SQLiteReader:${this.name}] Initialized: ${this.dbPath}`);
         }
         catch (error) {

package/dist/sync/writers/sqlite-writer.js

@@ -31,8 +31,8 @@ export class SQLiteWriter {
             throw new Error(`SQLite database not found: ${this.dbPath}. Run 'aqe init' to create it.`);
         }
         try {
+            // #1164: openDatabase() set the journal mode (retrying contention, honouring AQE_DISABLE_WAL).
             this.db = openDatabase(this.dbPath);
-            this.db.pragma('journal_mode = WAL');
             this.db.pragma('synchronous = NORMAL');
             logger.debug(`Opened SQLite database: ${this.dbPath}`);
         }

package/dist/workers/interfaces.d.ts

@@ -55,8 +55,8 @@ export interface WorkerMetrics {
     readonly itemsAnalyzed: number;
     /** Number of issues found */
     readonly issuesFound: number;
-    /** Health score (0-100) */
-    readonly healthScore: number;
+    /** Health score (0-100); `null` when nothing was measured (#1137) */
+    readonly healthScore: number | null;
     /** Trend direction */
     readonly trend: 'improving' | 'stable' | 'degrading';
     /** Domain-specific metrics */

package/dist/workers/quality-daemon/git-watcher.d.ts

@@ -28,6 +28,8 @@ export declare class GitWatcher {
     private debounceTimer;
     private _running;
     private _polling;
+    /** Ref changes to read again after git timed out on them (fs.watch mode). */
+    private readonly retryTimers;
     constructor(queue: PriorityQueue, options?: GitWatcherOptions);
     get running(): boolean;
     /**
@@ -45,6 +47,12 @@ export declare class GitWatcher {
     poll(): Promise<string[]>;
     private handleRefChange;
     private processRefChange;
+    /**
+     * Enqueue the files changed from `lastHash` (the last head seen) to
+     * `commitHash`, or in `commitHash` alone. Returns false when git timed out,
+     * so the caller keeps `lastHash` and tries again (#1165). When git fails,
+     * the changed files are left unknown rather than reported as none.
+     */
     private enqueueCommitAnalysis;
     private snapshotHeads;
 }

package/dist/workers/quality-daemon/git-watcher.js

@@ -9,7 +9,7 @@ import { watch } from 'fs';
 import { resolve, join } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { getGitRefError } from '../../shared/git/ref-validation.js';
-import { runGit } from '../../shared/git/git-process.js';
+import { GitTimeoutError, runGit } from '../../shared/git/git-process.js';
 /** A hung git must not stall the watcher; its process group is stopped (#1115). */
 const GIT_TIMEOUT_MS = 10_000;
 const DEFAULTS = {
@@ -30,6 +30,8 @@ export class GitWatcher {
     debounceTimer;
     _running = false;
     _polling = false;
+    /** Ref changes to read again after git timed out on them (fs.watch mode). */
+    retryTimers = new Set();
     constructor(queue, options) {
         this.queue = queue;
         this.options = { ...DEFAULTS, ...options };
@@ -87,6 +89,9 @@ export class GitWatcher {
             this.watcher.close();
             this.watcher = undefined;
         }
+        for (const timer of this.retryTimers)
+            clearTimeout(timer);
+        this.retryTimers.clear();
         this._running = false;
     }
     /**
@@ -111,8 +116,11 @@ export class GitWatcher {
                 const [branch, hash] = line.split(' ');
                 const lastHash = this.lastKnownHeads.get(branch);
                 if (lastHash && lastHash !== hash) {
+                    // #1165: on a git timeout keep the old head, so the next poll
+                    // covers this commit too.
+                    if (!(await this.enqueueCommitAnalysis(branch, hash, lastHash)))
+                        continue;
                     changedBranches.push(branch);
-                    await this.enqueueCommitAnalysis(branch, hash);
                 }
                 this.lastKnownHeads.set(branch, hash);
             }
@@ -152,37 +160,70 @@ export class GitWatcher {
         const lastHash = this.lastKnownHeads.get(branch);
         if (lastHash === newHash)
             return; // no change
+        if (!(await this.enqueueCommitAnalysis(branch, newHash, lastHash))) {
+            // #1165: git timed out; keep the old head and read the ref again later.
+            const timer = setTimeout(() => {
+                this.retryTimers.delete(timer);
+                this.processRefChange(filename).catch((err) => {
+                    console.debug('[GitWatcher] Error processing ref change:', err);
+                });
+            }, this.options.pollIntervalMs);
+            timer.unref?.();
+            this.retryTimers.add(timer);
+            return;
+        }
         this.lastKnownHeads.set(branch, newHash);
-        await this.enqueueCommitAnalysis(branch, newHash);
     }
-    async enqueueCommitAnalysis(branch, commitHash) {
+    /**
+     * Enqueue the files changed from `lastHash` (the last head seen) to
+     * `commitHash`, or in `commitHash` alone. Returns false when git timed out,
+     * so the caller keeps `lastHash` and tries again (#1165). When git fails,
+     * the changed files are left unknown rather than reported as none.
+     */
+    async enqueueCommitAnalysis(branch, commitHash, lastHash) {
         // The hash is read from a ref file; never let an option-shaped value
         // (e.g. `--output=<path>`) reach `git diff-tree` (issue #960).
         if (getGitRefError(commitHash, 'commit hash'))
-            return;
-        let changedFiles = [];
-        try {
+            return true;
+        const since = lastHash && !getGitRefError(lastHash, 'commit hash') ? lastHash : undefined;
+        const diffTree = async (revisions) => {
             const stdout = await runGit([
                 'diff-tree',
                 '--no-commit-id',
                 '--name-only',
                 '-r',
-                commitHash,
+                ...revisions,
             ], { cwd: this.options.repoRoot, timeout: GIT_TIMEOUT_MS });
-            changedFiles = stdout
+            return stdout
                 .trim()
                 .split('\n')
                 .filter(Boolean)
                 .slice(0, this.options.maxChangedFiles);
+        };
+        let changedFiles;
+        try {
+            // From the last head seen, so commits between two polls are not skipped.
+            changedFiles = await diffTree(since ? [since, commitHash] : ['--root', commitHash]);
         }
-        catch {
-            // fallback: empty changed files list
+        catch (error) {
+            if (error instanceof GitTimeoutError)
+                return false;
+            // The last head can be gone after a force-push and gc; fall back to this commit.
+            if (since) {
+                try {
+                    changedFiles = await diffTree(['--root', commitHash]);
+                }
+                catch (fallbackError) {
+                    if (fallbackError instanceof GitTimeoutError)
+                        return false;
+                }
+            }
         }
         const payload = {
             type: 'git_commit',
             branch,
             commitHash,
-            changedFiles,
+            ...(changedFiles ? { changedFiles } : {}),
         };
         const item = {
             id: `git-${commitHash}-${Date.now()}`,
@@ -193,6 +234,7 @@ export class GitWatcher {
             ttlMs: 5 * 60 * 1000, // 5 min TTL
         };
         this.queue.enqueue(item);
+        return true;
     }
     async snapshotHeads() {
         try {

package/dist/workers/quality-daemon/index.js

@@ -203,7 +203,7 @@ export class QualityDaemon {
                             });
                         }
                         if (delta.newGaps.length > 0) {
-                            const suggestions = await this.testSuggester.suggest(delta.newGaps, payload.changedFiles, memory);
+                            const suggestions = await this.testSuggester.suggest(delta.newGaps, payload.changedFiles ?? [], memory);
                             this._suggestionsGenerated += suggestions.length;
                             if (suggestions.length > 0) {
                                 await this.notificationService.send({

package/dist/workers/quality-daemon/priority-queue.d.ts

@@ -23,7 +23,8 @@ export interface GitCommitPayload {
     readonly type: 'git_commit';
     readonly branch: string;
     readonly commitHash: string;
-    readonly changedFiles: string[];
+    /** Files changed since the last commit seen; absent when git could not list them (#1165). */
+    readonly changedFiles?: string[];
 }
 export interface CoverageDeltaPayload {
     readonly type: 'coverage_delta';

package/dist/workers/workers/defect-predictor.d.ts

@@ -18,6 +18,10 @@
  * A `defect:predictions` record without
  * the measured stamp (the invented one written by <= 3.15.6) is ignored and
  * replaced by the next measured run.
+ *
+ * #1137: the latest run of every target is reported, so predicting `src/b`
+ * after `src/a` keeps `src/a`'s files; a file named by several targets takes
+ * its prediction from the newest run that names it.
  */
 import { BaseWorker } from '../base-worker';
 import { WorkerContext, WorkerResult } from '../interfaces';
@@ -31,11 +35,12 @@ export declare class DefectPredictorWorker extends BaseWorker {
      */
     private markPreviousStale;
     /**
-     * #1043: the most recent prediction run the defect-intelligence predictor
+     * #1043: the most recent prediction runs the defect-intelligence predictor
      * recorded, restricted to regular files whose real path is inside the
-     * project root. `measured` is `null` when there is no such prediction;
-     * `unusable` describes an ambiguous newest timestamp or a newest prediction
-     * none of whose files qualify.
+     * project root. #1137: the latest run of each target contributes, and a
+     * file takes its prediction from the newest run naming it. `measured` is
+     * `null` when no file qualifies; `unusable` then describes the newest run
+     * (or its ambiguous timestamp).
      */
     private readLatestPrediction;
     private analyzeHighRiskPredictions;