agentic-qe 3.10.2 → 3.10.4

package/dist/coordination/queen-coordinator.js

@@ -768,6 +768,7 @@ export class QueenCoordinator {
     // Uses arrow-captured `self` to correctly proxy mutable counters.
     // ============================================================================
     createEventHandlerContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- self captured for returned handler context
         const self = this;
         return {
             config: self.config, tasks: self.tasks,
@@ -791,6 +792,7 @@ export class QueenCoordinator {
         };
     }
     createTaskContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- self captured for returned handler context
         const self = this;
         return {
             config: self.config, tasks: self.tasks,
@@ -821,6 +823,7 @@ export class QueenCoordinator {
         };
     }
     createWorkStealingContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- self captured for returned handler context
         const self = this;
         return {
             config: self.config, domainQueues: self.domainQueues,
@@ -836,6 +839,7 @@ export class QueenCoordinator {
         };
     }
     createMetricsContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- self captured for returned handler context
         const self = this;
         return {
             config: self.config, memory: self.memory,

package/dist/coordination/queen-work-stealing.js

@@ -55,8 +55,7 @@ export async function triggerWorkStealing(ctx) {
 export function startWorkStealingTimer(config, doStealing) {
     let workStealingFailures = 0;
     const maxConsecutiveFailures = 10;
-    let timer;
-    timer = setInterval(async () => {
+    const timer = setInterval(async () => {
         try {
             await doStealing();
             workStealingFailures = 0;

package/dist/domains/chaos-resilience/coordinator.js

@@ -554,8 +554,8 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             let lastExperimentDate;
             let lastLoadTestDate;
             let activeIncidents = 0;
-            let totalRecoveryTime = 0;
-            let recoveryCount = 0;
+            const totalRecoveryTime = 0;
+            const recoveryCount = 0;
             let failedChanges = 0;
             let totalChanges = 0;
             // Process experiment results
@@ -932,22 +932,26 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             let strategy = 'default';
             switch (prediction.action.type) {
                 case 'allocate':
-                    const allocValue = typeof prediction.action.value === 'object' ? prediction.action.value : null;
-                    if (allocValue && 'agentType' in allocValue && allocValue.agentType === 'tester') {
-                        // Allocate more tests to high-risk services (no failover, databases)
-                        const criticalServices = services.filter((s) => !s.hasFailover || s.type === 'database').slice(0, 3);
-                        selectedExperiments = this.generateExperimentsForServices(criticalServices, ['latency', 'error']);
-                        strategy = 'allocate-critical';
+                    {
+                        const allocValue = typeof prediction.action.value === 'object' ? prediction.action.value : null;
+                        if (allocValue && 'agentType' in allocValue && allocValue.agentType === 'tester') {
+                            // Allocate more tests to high-risk services (no failover, databases)
+                            const criticalServices = services.filter((s) => !s.hasFailover || s.type === 'database').slice(0, 3);
+                            selectedExperiments = this.generateExperimentsForServices(criticalServices, ['latency', 'error']);
+                            strategy = 'allocate-critical';
+                        }
+                        break;
                     }
-                    break;
                 case 'reallocate':
-                    const reallocValue = typeof prediction.action.value === 'object' ? prediction.action.value : null;
-                    if (reallocValue && 'domain' in reallocValue && reallocValue.domain === 'test-execution') {
-                        // Reallocate to test different fault types
-                        selectedExperiments = this.generateExperimentsForServices(services.slice(0, 5), ['cpu-stress', 'memory-stress']);
-                        strategy = 'reallocate-resource-stress';
+                    {
+                        const reallocValue = typeof prediction.action.value === 'object' ? prediction.action.value : null;
+                        if (reallocValue && 'domain' in reallocValue && reallocValue.domain === 'test-execution') {
+                            // Reallocate to test different fault types
+                            selectedExperiments = this.generateExperimentsForServices(services.slice(0, 5), ['cpu-stress', 'memory-stress']);
+                            strategy = 'reallocate-resource-stress';
+                        }
+                        break;
                     }
-                    break;
                 case 'scale-up':
                     // Scale up experiment count
                     selectedExperiments = this.generateExperimentsForServices(services, ['latency', 'error', 'timeout']);

package/dist/domains/chaos-resilience/services/chaos-engineer.js

@@ -659,6 +659,7 @@ Provide:
             const busyStart = Date.now();
             while (Date.now() - busyStart < busyTime) {
                 // Busy loop - CPU intensive operations
+                // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- intentional CPU busy-loop
                 secureRandom() * secureRandom();
             }
             // Note: Idle time is handled by the interval itself (10ms interval)
@@ -799,8 +800,10 @@ Provide:
             case 'gte':
                 return actual >= value;
             case 'between':
-                const [min, max] = value;
-                return actual >= min && actual <= max;
+                {
+                    const [min, max] = value;
+                    return actual >= min && actual <= max;
+                }
             default:
                 return false;
         }

package/dist/domains/chaos-resilience/services/load-tester.js

@@ -375,20 +375,24 @@ export class LoadTesterService {
                 }
                 return max;
             case 'step':
-                const steps = 5;
-                const stepDuration = duration / steps;
-                const currentStep = Math.floor(elapsedTime / stepDuration);
-                const stepSize = (max - start) / steps;
-                return Math.round(start + stepSize * currentStep);
+                {
+                    const steps = 5;
+                    const stepDuration = duration / steps;
+                    const currentStep = Math.floor(elapsedTime / stepDuration);
+                    const stepSize = (max - start) / steps;
+                    return Math.round(start + stepSize * currentStep);
+                }
             case 'spike':
                 // Create periodic spikes
-                const spikeInterval = 30000; // 30 seconds
-                const spikeDuration = 5000; // 5 second spike
-                const timeInCycle = elapsedTime % spikeInterval;
-                if (timeInCycle < spikeDuration) {
-                    return max;
+                {
+                    const spikeInterval = 30000; // 30 seconds
+                    const spikeDuration = 5000; // 5 second spike
+                    const timeInCycle = elapsedTime % spikeInterval;
+                    if (timeInCycle < spikeDuration) {
+                        return max;
+                    }
+                    return start;
                 }
-                return start;
             default:
                 return max;
         }

package/dist/domains/code-intelligence/interfaces.d.ts

@@ -27,6 +27,11 @@ export interface IndexResult {
     edgesCreated: number;
     duration: number;
     errors: IndexError[];
+    /**
+     * Non-fatal warnings surfaced during indexing — e.g. files whose language has
+     * no dependency extractor, so `deps`/`impact` will show 0 edges for them (#511).
+     */
+    warnings?: string[];
 }
 export interface IndexError {
     file: string;

package/dist/domains/code-intelligence/services/c4-model/index.js

@@ -1042,14 +1042,20 @@ export class C4ModelService {
     getDiagramPreview(stored) {
         switch (stored.type) {
             case 'context':
-                const ctx = stored.model;
-                return `System: ${ctx.system.name}, External: ${ctx.externalSystems.length}`;
+                {
+                    const ctx = stored.model;
+                    return `System: ${ctx.system.name}, External: ${ctx.externalSystems.length}`;
+                }
             case 'container':
-                const cnt = stored.model;
-                return `Containers: ${cnt.containers.length}, External: ${cnt.externalSystems.length}`;
+                {
+                    const cnt = stored.model;
+                    return `Containers: ${cnt.containers.length}, External: ${cnt.externalSystems.length}`;
+                }
             case 'component':
-                const cmp = stored.model;
-                return `Components: ${cmp.components.length}, Relations: ${cmp.relationships.length}`;
+                {
+                    const cmp = stored.model;
+                    return `Components: ${cmp.components.length}, Relations: ${cmp.relationships.length}`;
+                }
             default:
                 return 'No preview available';
         }

package/dist/domains/code-intelligence/services/impact-analyzer.js

@@ -128,9 +128,13 @@ export class ImpactAnalyzerService {
                 ];
                 // Search memory for matching test files
                 for (const pattern of possibleTestPatterns) {
-                    const keys = await this.memory.search(`code-intelligence:kg:node:*${pattern}*`, 10);
+                    const keys = await this.memory.search(`code-intelligence:kg:node:*${pattern}*`, 10, 
+                    // KG persists under its own namespace (#511 parity) — read it there.
+                    { namespace: 'code-intelligence:kg' });
                     for (const key of keys) {
-                        const node = await this.memory.get(key);
+                        const node = await this.memory.get(key, {
+                            namespace: 'code-intelligence:kg',
+                        });
                         if (node?.properties?.path && this.isTestFile(node.properties.path)) {
                             impactedTests.add(node.properties.path);
                         }

package/dist/domains/code-intelligence/services/knowledge-graph.d.ts

@@ -55,6 +55,13 @@ export declare class KnowledgeGraphService implements IKnowledgeGraphService {
     private readonly memory;
     private readonly nodeCache;
     private readonly edgeIndex;
+    /**
+     * Lazily-hydrated flat list of all persisted edges (#511).
+     * Edges are persisted per-process during index(); cross-process reads
+     * (deps/search/impact) hydrate this once and filter by source/target.
+     * Invalidated on createEdge()/clear() to avoid serving stale data.
+     */
+    private allEdgesCache?;
     private readonly tsParser;
     private readonly fileReader;
     private readonly embedder;
@@ -70,6 +77,16 @@ export declare class KnowledgeGraphService implements IKnowledgeGraphService {
      * Type guard to check if the argument is KnowledgeGraphDependencies
      */
     private isKnowledgeGraphDependencies;
+    /**
+     * Storage options that pin every KG kv operation to a fixed, tool-independent
+     * namespace (the configured `code-intelligence:kg`) instead of the backend's
+     * default (`qe-kernel` for the CLI, `mcp-tools` for MCP). This gives CLI↔MCP
+     * parity — a graph indexed by one tool is readable by the other — and makes
+     * the init existence checks (`SELECT ... WHERE namespace = 'code-intelligence:kg'`)
+     * actually find the data (#511). Reads and writes MUST both pass this, or a
+     * write under the namespace cannot be read back (issue #491 Bug 2).
+     */
+    private get nsOpts();
     /**
      * Index files into the knowledge graph
      */
@@ -90,10 +107,25 @@ export declare class KnowledgeGraphService implements IKnowledgeGraphService {
      * Get edges for a node
      */
     getEdges(nodeId: string, direction: 'incoming' | 'outgoing' | 'both'): Promise<KGEdge[]>;
+    /**
+     * Load all persisted edges into a flat cache (#511).
+     * Cached for the lifetime of the read; invalidated by createEdge()/clear().
+     */
+    private loadAllEdges;
     /**
      * Clear the knowledge graph
      */
     clear(): Promise<void>;
+    /**
+     * Remove a single file's contribution to the graph (#511).
+     *
+     * Deletes the file node, its entity nodes, and edges that ORIGINATE from the
+     * file or its entities (contains + outgoing imports). Incoming edges (other
+     * files importing this one) are left intact — they belong to those files and
+     * remain valid until those files are themselves re-indexed. Used for
+     * incremental re-indexing so stale entities/imports don't persist.
+     */
+    private removeFileFromGraph;
     /**
      * Check if LLM extraction is available and enabled
      */
@@ -151,6 +183,16 @@ export declare class KnowledgeGraphService implements IKnowledgeGraphService {
     private generateQueryEmbedding;
     private fallbackEmbedding;
     private pathToNodeId;
+    /**
+     * Resolve an import specifier to a concrete file path (#511).
+     *
+     * Relative specifiers ('./math', '../util') are resolved against the
+     * importing file's directory and probed for the usual TS/JS extensions and
+     * index files, so the resulting node id matches the imported file's node.
+     * Bare package specifiers ('react', '@scope/pkg') are returned unchanged and
+     * become external dependency nodes.
+     */
+    private resolveImportPath;
     private nodeIdToPath;
     private getFileName;
     private getFileExtension;