agentic-qe 3.9.17 → 3.9.18

package/dist/coordination/handlers/test-execution-handlers.js

@@ -8,6 +8,49 @@ import { v4 as uuidv4 } from 'uuid';
 import * as fs from 'fs/promises';
 import { ok, err } from '../../shared/types';
 import { toError } from '../../shared/error-utils.js';
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Rewrite any temp-source references in a generated test so the user gets a
+ * test that imports from the original source path (when known) or a clear
+ * placeholder. Without this, generated tests reference the throwaway
+ * `/tmp/aqe-temp-*` file we created for analysis — that file is unlinked
+ * after generation, so the test would never run as-emitted.
+ *
+ * The generator may emit the temp path with the original extension
+ * (`/tmp/aqe-temp-X.ts`), with a substituted extension
+ * (`/tmp/aqe-temp-X.test.ts`), or extension-stripped (TS import convention:
+ * `/tmp/aqe-temp-X`). All three forms must be rewritten.
+ *
+ * Exported for unit testing (bug #1 regression).
+ */
+export function rewriteTempPathsInGeneratedTest(testCode, sourceFile, tempPath, originalFilePath) {
+    if (!tempPath) {
+        return { testCode, sourceFile };
+    }
+    // For the user's import target we strip the source extension when the
+    // original is a path (TS imports omit `.ts`); preserve it otherwise.
+    const stripExt = (p) => p.replace(/\.[a-z]+$/i, '');
+    const replacement = originalFilePath
+        ? (originalFilePath.match(/\.(ts|tsx|js|jsx|mjs|cjs)$/i) ? stripExt(originalFilePath) : originalFilePath)
+        : './module-under-test';
+    const todoComment = originalFilePath
+        ? ''
+        : `// TODO: replace './module-under-test' with the actual import path of the module under test\n`;
+    // Build a regex that matches the temp path with any (or no) extension suffix.
+    // Order matters: replace extension-bearing forms before extension-less, since
+    // the extension-less form is a prefix of the others.
+    const tempBase = stripExt(tempPath);
+    const tempBaseEscaped = escapeRegExp(tempBase);
+    // Matches: <base>.<ext> | <base>.<ext>.<ext> | <base>
+    const anyForm = new RegExp(tempBaseEscaped + '(?:\\.[a-zA-Z]+){0,2}', 'g');
+    const newCode = testCode
+        ? todoComment + testCode.replace(anyForm, replacement)
+        : testCode;
+    const newRef = sourceFile === tempPath ? (originalFilePath || sourceFile) : sourceFile;
+    return { testCode: newCode, sourceFile: newRef };
+}
 export function registerTestExecutionHandlers(ctx) {
     // Register test generation handler - REAL IMPLEMENTATION
     ctx.registerHandler('generate-tests', async (task) => {
@@ -16,6 +59,7 @@ export function registerTestExecutionHandlers(ctx) {
             const generator = ctx.getTestGenerator();
             // Determine source files to analyze
             let sourceFiles = [];
+            let tempPath;
             if (payload.sourceFiles && payload.sourceFiles.length > 0) {
                 sourceFiles = payload.sourceFiles;
             }
@@ -32,7 +76,7 @@ export function registerTestExecutionHandlers(ctx) {
                     cpp: '.cpp', c: '.c', scala: '.scala',
                 };
                 const ext = langExtMap[payload.language?.toLowerCase() || 'typescript'] || '.ts';
-                const tempPath = `/tmp/aqe-temp-${uuidv4()}${ext}`;
+                tempPath = `/tmp/aqe-temp-${uuidv4()}${ext}`;
                 await fs.writeFile(tempPath, payload.sourceCode, 'utf-8');
                 sourceFiles = [tempPath];
             }
@@ -46,30 +90,54 @@ export function registerTestExecutionHandlers(ctx) {
                     warning: 'No source files or code provided for test generation. Provide sourceCode, filePath, or sourceFiles in the payload.',
                 });
             }
-            // Use the real TestGeneratorService
+            // Use the real TestGeneratorService.
+            // Bug #1 fix: when we wrote a temp file for analysis, tell the generator
+            // to bake a sensible logical import path into the emitted tests instead
+            // of the throwaway temp path. If the user supplied filePath, use that;
+            // otherwise use a placeholder the user can edit.
             const framework = (payload.framework || 'vitest');
+            const importPathOverrides = tempPath
+                ? { [tempPath]: payload.filePath
+                        ? payload.filePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, '')
+                        : './module-under-test' }
+                : undefined;
             const result = await generator.generateTests({
                 sourceFiles,
                 testType: payload.testType || 'unit',
                 framework,
                 coverageTarget: payload.coverageGoal || 80,
                 patterns: [],
+                importPathOverrides,
             });
+            // Always clean up the temp file we created — even on failure
+            if (tempPath) {
+                try {
+                    await fs.unlink(tempPath);
+                }
+                catch { /* best-effort */ }
+            }
             if (!result.success) {
                 return result;
             }
             const generatedTests = result.value;
-            return ok({
-                testsGenerated: generatedTests.tests.length,
-                coverageEstimate: generatedTests.coverageEstimate,
-                tests: generatedTests.tests.map(t => ({
+            // Rewrite any temp-path references in generated tests so users get tests
+            // that reference a real source path (or a clear placeholder) rather than
+            // a /tmp/aqe-temp-* path that never existed in their codebase.
+            const tests = generatedTests.tests.map(t => {
+                const rewritten = rewriteTempPathsInGeneratedTest(t.testCode, t.sourceFile, tempPath, payload.filePath);
+                return {
                     name: t.name,
                     file: t.testFile,
                     type: t.type,
-                    sourceFile: t.sourceFile,
+                    sourceFile: rewritten.sourceFile,
                     assertions: t.assertions,
-                    testCode: t.testCode,
-                })),
+                    testCode: rewritten.testCode,
+                };
+            });
+            return ok({
+                testsGenerated: tests.length,
+                coverageEstimate: generatedTests.coverageEstimate,
+                tests,
                 patternsUsed: generatedTests.patternsUsed,
             });
         }

package/dist/domains/test-generation/generators/jest-vitest-generator.js

@@ -52,8 +52,15 @@ export class JestVitestGenerator extends BaseTestGenerator {
         const patternComment = this.generatePatternComment(patterns);
         const exports = this.extractExports(analysis.functions, analysis.classes);
         const importStatement = this.generateImportStatement(exports, importPath, moduleName);
-        const mockImport = this.framework === 'vitest' ? ', vi' : '';
-        let testCode = `${patternComment}import { describe, it, expect, beforeEach${mockImport} } from '${this.framework}';
+        // Per-framework imports:
+        // - vitest: `import { ..., vi } from 'vitest'` (vi is the mock util)
+        // - jest:   `import { ..., jest } from '@jest/globals'`
+        //   (jest 28+ provides @jest/globals; importing from 'jest' is invalid —
+        //    it's a CLI package, not a runtime export. Globals work too but
+        //    explicit imports match vitest style and are TS-friendly.)
+        const mockImport = this.framework === 'vitest' ? ', vi' : ', jest';
+        const importSource = this.framework === 'vitest' ? 'vitest' : '@jest/globals';
+        let testCode = `${patternComment}import { describe, it, expect, beforeEach${mockImport} } from '${importSource}';
 ${importStatement}
 `;
         // KG: Generate mock declarations for external (non-relative) dependencies only.
@@ -274,7 +281,10 @@ ${importStatement}
             callerTest += `      expect(publicKeys.length).toBeGreaterThan(0);\n`;
             callerTest += `    });\n`;
         }
-        return `${patternComment}import { ${moduleName} } from '${importPath}';
+        const stubImportSource = this.framework === 'vitest' ? 'vitest' : '@jest/globals';
+        const stubMockImport = this.framework === 'vitest' ? ', vi' : ', jest';
+        return `${patternComment}import { describe, it, expect, beforeEach${stubMockImport} } from '${stubImportSource}';
+import { ${moduleName} } from '${importPath}';
 ${mockDeclarations}
 describe('${moduleName}', () => {
 ${similarityComment}  describe('${testType} tests', () => {

package/dist/domains/test-generation/interfaces.d.ts

@@ -26,6 +26,18 @@ export interface IGenerateTestsRequest {
     projectRoot?: string;
     compileValidation?: boolean;
     maxCompileRetries?: number;
+    /**
+     * Map of sourceFile path → import path to bake into generated test imports.
+     * Use this when the file at `sourceFiles[i]` is a temporary copy of source
+     * (e.g. an inline-source MCP call) and the generated tests should reference
+     * a different logical path. If a file is not in the map, the import path
+     * is derived from the source file path as before.
+     *
+     * Example:
+     *   { '/tmp/aqe-temp-abc.ts': './src/services/auth' }
+     * → generated test emits `import { ... } from './src/services/auth'`
+     */
+    importPathOverrides?: Record<string, string>;
 }
 export interface IGeneratedTests {
     tests: IGeneratedTest[];

package/dist/domains/test-generation/services/test-generator.js

@@ -420,7 +420,11 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
         }
         const generator = this.generatorFactory.create(framework);
         const moduleName = this.extractModuleName(sourceFile);
-        const importPath = this.getImportPath(sourceFile);
+        // Bug #1 fix: prefer caller-supplied import path override when present
+        // (used by MCP handler when sourceCode is written to a temp file but the
+        // generated tests should reference the original logical path).
+        const importPath = originalRequest?.importPathOverrides?.[sourceFile]
+            ?? this.getImportPath(sourceFile);
         const context = {
             moduleName,
             importPath,

package/dist/governance/continue-gate-integration.d.ts

@@ -79,6 +79,19 @@ export declare class ContinueGateIntegration {
      *
      * ContinueDecision has: { decision, reasons, metrics, recommendedAction }
      * We map to: { shouldContinue, reason, throttleMs, escalate, reworkRatio }
+     *
+     * Decision semantics:
+     * - 'continue', 'checkpoint': proceed normally
+     * - 'throttle': proceed but caller should slow down (soft signal — not a block).
+     *   The recommended action is "slow down", not "abort". Treating throttle as
+     *   a hard rejection would cause legitimate work to be denied; the caller can
+     *   apply the throttleMs as a backoff hint between subsequent calls.
+     * - 'pause', 'stop': block this task
+     *
+     * NOTE: With totalTokensUsed pinned to 0 in the caller (no real token
+     * telemetry yet), the guidance gate's budget-slope detector cannot fire,
+     * so 'throttle' from this path is rare in practice — it would only fire
+     * if some other slowdown signal (not budget) were configured.
      */
     private mapGuidanceDecision;
     /**

package/dist/governance/continue-gate-integration.js

@@ -142,6 +142,17 @@ export class ContinueGateIntegration {
         if (this.guidanceContinueGate && localDecision.shouldContinue && !localDecision.reason) {
             try {
                 const reworkRatio = this.calculateReworkRatio(history.slice(-10));
+                // ADR-058 NOTE: We do NOT track real per-action token usage here.
+                // Passing a synthetic estimate (e.g. history.length * 500) to the
+                // guidance gate causes the linear-regression slope detector to fire
+                // on the first multi-step interaction (slope = 500 vs 0.02 threshold),
+                // which would block legitimate one-off MCP tool calls.
+                //
+                // Until real token telemetry is wired in, we set totalTokensUsed = 0
+                // and a generous budgetRemaining. This effectively disables the
+                // budget-slope and budget-exhaustion checks (they require non-zero
+                // token data to fire) while keeping the coherence, rework, and
+                // uncertainty checks active — those use real data we DO have.
                 const stepContext = {
                     stepNumber: history.length,
                     totalToolCalls: history.length,
@@ -150,9 +161,9 @@ export class ContinueGateIntegration {
                     uncertaintyScore: reworkRatio,
                     elapsedMs: history.length > 0 ? Date.now() - history[0].timestamp : 0,
                     lastCheckpointStep: 0,
-                    totalTokensUsed: history.length * 500, // Estimate ~500 tokens per action
+                    totalTokensUsed: 0, // No real token telemetry — see comment above
                     budgetRemaining: {
-                        tokens: Math.max(0, (flags.maxConsecutiveRetries * 10 * 500) - (history.length * 500)),
+                        tokens: Number.MAX_SAFE_INTEGER, // Defer budget gating to dedicated cost monitor
                         toolCalls: Math.max(0, (flags.maxConsecutiveRetries * 10) - history.length),
                         timeMs: Math.max(0, flags.idleTimeoutMs - (history.length > 0 ? Date.now() - history[history.length - 1].timestamp : 0)),
                     },
@@ -254,15 +265,27 @@ export class ContinueGateIntegration {
      *
      * ContinueDecision has: { decision, reasons, metrics, recommendedAction }
      * We map to: { shouldContinue, reason, throttleMs, escalate, reworkRatio }
+     *
+     * Decision semantics:
+     * - 'continue', 'checkpoint': proceed normally
+     * - 'throttle': proceed but caller should slow down (soft signal — not a block).
+     *   The recommended action is "slow down", not "abort". Treating throttle as
+     *   a hard rejection would cause legitimate work to be denied; the caller can
+     *   apply the throttleMs as a backoff hint between subsequent calls.
+     * - 'pause', 'stop': block this task
+     *
+     * NOTE: With totalTokensUsed pinned to 0 in the caller (no real token
+     * telemetry yet), the guidance gate's budget-slope detector cannot fire,
+     * so 'throttle' from this path is rare in practice — it would only fire
+     * if some other slowdown signal (not budget) were configured.
      */
     mapGuidanceDecision(decision, agentId) {
         const flags = governanceFlags.getFlags().continueGate;
-        const shouldContinue = decision.decision === 'continue' || decision.decision === 'checkpoint';
+        const isBlocking = decision.decision === 'pause' || decision.decision === 'stop';
+        const shouldContinue = !isBlocking;
         const reason = decision.reasons.length > 0 ? decision.reasons.join('; ') : undefined;
-        // Throttle on 'throttle', 'pause', or 'stop'
-        if (!shouldContinue && flags.throttleOnExceed) {
-            const throttleMs = decision.decision === 'stop' ? 30000 :
-                decision.decision === 'pause' ? 15000 : 5000;
+        if (isBlocking && flags.throttleOnExceed) {
+            const throttleMs = decision.decision === 'stop' ? 30000 : 15000;
             this.throttledAgents.set(agentId, Date.now() + throttleMs);
         }
         return {
@@ -271,7 +294,7 @@ export class ContinueGateIntegration {
             throttleMs: decision.decision === 'throttle' ? 5000 :
                 decision.decision === 'pause' ? 15000 :
                     decision.decision === 'stop' ? 30000 : undefined,
-            escalate: decision.decision === 'stop' || decision.decision === 'pause',
+            escalate: isBlocking,
             reworkRatio: decision.metrics.reworkRatio,
         };
     }