agentic-qe 3.7.21 → 3.8.0

package/dist/cli/index.js

@@ -790,7 +790,6 @@ import { createCoverageCommand } from './commands/coverage.js';
 import { createQualityCommand } from './commands/quality.js';
 import { createSecurityCommand } from './commands/security.js';
 import { createCodeCommand } from './commands/code.js';
-import { createMigrateCommand } from './commands/migrate.js';
 import { createCompletionsCommand } from './commands/completions.js';
 import { createFleetCommand } from './commands/fleet.js';
 import { createValidateSwarmCommand } from './commands/validate-swarm.js';
@@ -803,7 +802,6 @@ program.addCommand(createCoverageCommand(context, cleanupAndExit, ensureInitiali
 program.addCommand(createQualityCommand(context, cleanupAndExit, ensureInitialized));
 program.addCommand(createSecurityCommand(context, cleanupAndExit, ensureInitialized));
 program.addCommand(createCodeCommand(context, cleanupAndExit, ensureInitialized));
-program.addCommand(createMigrateCommand(context, cleanupAndExit, ensureInitialized));
 program.addCommand(createCompletionsCommand(cleanupAndExit));
 program.addCommand(createFleetCommand(context, cleanupAndExit, ensureInitialized, registerDomainWorkflowActions));
 program.addCommand(createValidateSwarmCommand(context, cleanupAndExit, ensureInitialized));
@@ -821,6 +819,8 @@ import { createLearningCommand } from './commands/learning.js';
 import { createMcpCommand } from './commands/mcp.js';
 import { createPlatformCommand } from './commands/platform.js';
 import { createProveCommand } from './commands/prove.js';
+import { createRuVectorCommand } from './commands/ruvector-commands.js';
+import { createAuditCommand } from './commands/audit.js';
 program.addCommand(createTokenUsageCommand());
 program.addCommand(createLLMRouterCommand());
 program.addCommand(createSyncCommands());
@@ -829,6 +829,8 @@ program.addCommand(createLearningCommand());
 program.addCommand(createMcpCommand());
 program.addCommand(createPlatformCommand());
 program.addCommand(createProveCommand(context, cleanupAndExit, ensureInitialized));
+program.addCommand(createRuVectorCommand());
+program.addCommand(createAuditCommand(context, cleanupAndExit, ensureInitialized));
 // ============================================================================
 // Shutdown Handlers
 // ============================================================================

package/dist/context/sources/defect-source.js

@@ -19,8 +19,8 @@ export class DefectContextSource {
             if (!existsSync(dbPath)) {
                 return [];
             }
-            const Database = (await import('better-sqlite3')).default;
-            const db = new Database(dbPath, { readonly: true });
+            const { openDatabase } = await import('../../shared/safe-db.js');
+            const db = openDatabase(dbPath, { readonly: true });
             try {
                 // Check if patterns table exists
                 const tableCheck = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='qe_patterns'").get();

package/dist/context/sources/memory-source.js

@@ -20,8 +20,8 @@ export class MemoryContextSource {
                 return this.fallbackGather(request);
             }
             // Dynamic import to avoid hard dependency
-            const Database = (await import('better-sqlite3')).default;
-            const db = new Database(dbPath, { readonly: true });
+            const { openDatabase } = await import('../../shared/safe-db.js');
+            const db = openDatabase(dbPath, { readonly: true });
             try {
                 // Query patterns relevant to the task domain
                 const domainKeywords = this.extractDomainKeywords(request.taskDescription);

package/dist/context/sources/requirements-source.js

@@ -18,8 +18,8 @@ export class RequirementsContextSource {
             if (!existsSync(dbPath)) {
                 return this.fallbackGather(request);
             }
-            const Database = (await import('better-sqlite3')).default;
-            const db = new Database(dbPath, { readonly: true });
+            const { openDatabase } = await import('../../shared/safe-db.js');
+            const db = openDatabase(dbPath, { readonly: true });
             try {
                 // Check if requirements table exists
                 const tableCheck = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='qe_patterns'").get();

package/dist/coordination/behavior-tree/decorators.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Behavior Tree Decorators
+ *
+ * Decorators wrap a single child node and modify its behavior.
+ * They act as middleware between the parent and child nodes.
+ *
+ * Decorator types:
+ * - Inverter: Flips SUCCESS/FAILURE
+ * - Repeat: Repeats child n times
+ * - UntilFail: Repeats child until it fails
+ * - Timeout: Fails if child takes too long
+ * - Retry: Retries child on failure up to n times
+ */
+import type { BehaviorNode, NodeStatus, SerializedNode } from './nodes.js';
+declare abstract class DecoratorNode implements BehaviorNode {
+    readonly name: string;
+    protected readonly child: BehaviorNode;
+    abstract readonly type: string;
+    constructor(name: string, child: BehaviorNode);
+    abstract tick(): Promise<NodeStatus>;
+    reset(): void;
+    serialize(): SerializedNode;
+}
+/**
+ * Inverter decorator - flips SUCCESS to FAILURE and vice versa.
+ *
+ * RUNNING is passed through unchanged.
+ * Useful for negating conditions (e.g., "if NOT ready, then ...").
+ */
+export declare class InverterNode extends DecoratorNode {
+    readonly type = "Inverter";
+    constructor(name: string, child: BehaviorNode);
+    tick(): Promise<NodeStatus>;
+}
+/**
+ * Repeat decorator - repeats the child node n times.
+ *
+ * - Returns FAILURE immediately if child fails on any iteration
+ * - Returns RUNNING if child returns RUNNING
+ * - Returns SUCCESS after n successful completions
+ */
+export declare class RepeatNode extends DecoratorNode {
+    readonly type = "Repeat";
+    private readonly count;
+    private currentIteration;
+    constructor(name: string, child: BehaviorNode, count: number);
+    tick(): Promise<NodeStatus>;
+    reset(): void;
+    serialize(): SerializedNode;
+}
+/**
+ * UntilFail decorator - repeats the child until it fails.
+ *
+ * - Returns RUNNING as long as child succeeds (will repeat on next tick)
+ * - Returns SUCCESS when child finally fails
+ * - Passes through RUNNING from child
+ *
+ * Note: When used with a single tick() call, this runs the child
+ * repeatedly in a loop until failure. Safeguard with a Timeout decorator
+ * to prevent infinite loops.
+ */
+export declare class UntilFailNode extends DecoratorNode {
+    readonly type = "UntilFail";
+    constructor(name: string, child: BehaviorNode);
+    tick(): Promise<NodeStatus>;
+}
+/**
+ * Timeout decorator - fails if child takes too long.
+ *
+ * - Wraps the child's tick with a timeout
+ * - Returns FAILURE if the timeout is exceeded
+ * - Otherwise passes through the child's result
+ */
+export declare class TimeoutNode extends DecoratorNode {
+    readonly type = "Timeout";
+    private readonly timeoutMs;
+    constructor(name: string, child: BehaviorNode, timeoutMs: number);
+    tick(): Promise<NodeStatus>;
+    serialize(): SerializedNode;
+}
+/**
+ * Retry decorator - retries the child on failure up to n times.
+ *
+ * - Returns SUCCESS immediately on child success
+ * - Returns RUNNING if child is running
+ * - On FAILURE, retries up to maxRetries times before returning FAILURE
+ */
+export declare class RetryNode extends DecoratorNode {
+    readonly type = "Retry";
+    private readonly maxRetries;
+    private currentRetry;
+    constructor(name: string, child: BehaviorNode, maxRetries: number);
+    tick(): Promise<NodeStatus>;
+    reset(): void;
+    serialize(): SerializedNode;
+}
+/** Create an Inverter decorator */
+export declare function inverter(name: string, child: BehaviorNode): InverterNode;
+/** Create a Repeat decorator */
+export declare function repeat(name: string, child: BehaviorNode, count: number): RepeatNode;
+/** Create an UntilFail decorator */
+export declare function untilFail(name: string, child: BehaviorNode): UntilFailNode;
+/** Create a Timeout decorator */
+export declare function timeout(name: string, child: BehaviorNode, timeoutMs: number): TimeoutNode;
+/** Create a Retry decorator */
+export declare function retry(name: string, child: BehaviorNode, maxRetries: number): RetryNode;
+export {};
+//# sourceMappingURL=decorators.d.ts.map

package/dist/coordination/behavior-tree/decorators.js

@@ -0,0 +1,251 @@
+/**
+ * Behavior Tree Decorators
+ *
+ * Decorators wrap a single child node and modify its behavior.
+ * They act as middleware between the parent and child nodes.
+ *
+ * Decorator types:
+ * - Inverter: Flips SUCCESS/FAILURE
+ * - Repeat: Repeats child n times
+ * - UntilFail: Repeats child until it fails
+ * - Timeout: Fails if child takes too long
+ * - Retry: Retries child on failure up to n times
+ */
+import { registerDecoratorFactory } from './nodes.js';
+// ============================================================================
+// Abstract Decorator Base
+// ============================================================================
+class DecoratorNode {
+    name;
+    child;
+    constructor(name, child) {
+        this.name = name;
+        this.child = child;
+    }
+    reset() {
+        this.child.reset();
+    }
+    serialize() {
+        return {
+            type: this.type,
+            name: this.name,
+            children: [this.child.serialize()],
+        };
+    }
+}
+// ============================================================================
+// Decorators
+// ============================================================================
+/**
+ * Inverter decorator - flips SUCCESS to FAILURE and vice versa.
+ *
+ * RUNNING is passed through unchanged.
+ * Useful for negating conditions (e.g., "if NOT ready, then ...").
+ */
+export class InverterNode extends DecoratorNode {
+    type = 'Inverter';
+    constructor(name, child) {
+        super(name, child);
+    }
+    async tick() {
+        const status = await this.child.tick();
+        if (status === 'SUCCESS')
+            return 'FAILURE';
+        if (status === 'FAILURE')
+            return 'SUCCESS';
+        return 'RUNNING';
+    }
+}
+/**
+ * Repeat decorator - repeats the child node n times.
+ *
+ * - Returns FAILURE immediately if child fails on any iteration
+ * - Returns RUNNING if child returns RUNNING
+ * - Returns SUCCESS after n successful completions
+ */
+export class RepeatNode extends DecoratorNode {
+    type = 'Repeat';
+    count;
+    currentIteration = 0;
+    constructor(name, child, count) {
+        super(name, child);
+        this.count = Math.max(1, Math.floor(count));
+    }
+    async tick() {
+        while (this.currentIteration < this.count) {
+            const status = await this.child.tick();
+            if (status === 'FAILURE') {
+                return 'FAILURE';
+            }
+            if (status === 'RUNNING') {
+                return 'RUNNING';
+            }
+            // SUCCESS - increment and reset child for next iteration
+            this.currentIteration++;
+            if (this.currentIteration < this.count) {
+                this.child.reset();
+            }
+        }
+        return 'SUCCESS';
+    }
+    reset() {
+        this.currentIteration = 0;
+        super.reset();
+    }
+    serialize() {
+        return {
+            type: this.type,
+            name: this.name,
+            children: [this.child.serialize()],
+            config: { count: this.count },
+        };
+    }
+}
+/**
+ * UntilFail decorator - repeats the child until it fails.
+ *
+ * - Returns RUNNING as long as child succeeds (will repeat on next tick)
+ * - Returns SUCCESS when child finally fails
+ * - Passes through RUNNING from child
+ *
+ * Note: When used with a single tick() call, this runs the child
+ * repeatedly in a loop until failure. Safeguard with a Timeout decorator
+ * to prevent infinite loops.
+ */
+export class UntilFailNode extends DecoratorNode {
+    type = 'UntilFail';
+    constructor(name, child) {
+        super(name, child);
+    }
+    async tick() {
+        const status = await this.child.tick();
+        if (status === 'FAILURE') {
+            return 'SUCCESS';
+        }
+        if (status === 'RUNNING') {
+            return 'RUNNING';
+        }
+        // SUCCESS - reset and signal RUNNING so caller ticks again
+        this.child.reset();
+        return 'RUNNING';
+    }
+}
+/**
+ * Timeout decorator - fails if child takes too long.
+ *
+ * - Wraps the child's tick with a timeout
+ * - Returns FAILURE if the timeout is exceeded
+ * - Otherwise passes through the child's result
+ */
+export class TimeoutNode extends DecoratorNode {
+    type = 'Timeout';
+    timeoutMs;
+    constructor(name, child, timeoutMs) {
+        super(name, child);
+        this.timeoutMs = Math.max(1, timeoutMs);
+    }
+    async tick() {
+        const timeoutPromise = new Promise((resolve) => {
+            setTimeout(() => resolve('FAILURE'), this.timeoutMs);
+        });
+        const childPromise = this.child.tick();
+        return Promise.race([childPromise, timeoutPromise]);
+    }
+    serialize() {
+        return {
+            type: this.type,
+            name: this.name,
+            children: [this.child.serialize()],
+            config: { timeoutMs: this.timeoutMs },
+        };
+    }
+}
+/**
+ * Retry decorator - retries the child on failure up to n times.
+ *
+ * - Returns SUCCESS immediately on child success
+ * - Returns RUNNING if child is running
+ * - On FAILURE, retries up to maxRetries times before returning FAILURE
+ */
+export class RetryNode extends DecoratorNode {
+    type = 'Retry';
+    maxRetries;
+    currentRetry = 0;
+    constructor(name, child, maxRetries) {
+        super(name, child);
+        this.maxRetries = Math.max(0, Math.floor(maxRetries));
+    }
+    async tick() {
+        const status = await this.child.tick();
+        if (status === 'SUCCESS') {
+            return 'SUCCESS';
+        }
+        if (status === 'RUNNING') {
+            return 'RUNNING';
+        }
+        // FAILURE - check if we can retry
+        if (this.currentRetry < this.maxRetries) {
+            this.currentRetry++;
+            this.child.reset();
+            return this.tick();
+        }
+        return 'FAILURE';
+    }
+    reset() {
+        this.currentRetry = 0;
+        super.reset();
+    }
+    serialize() {
+        return {
+            type: this.type,
+            name: this.name,
+            children: [this.child.serialize()],
+            config: { maxRetries: this.maxRetries },
+        };
+    }
+}
+// ============================================================================
+// Factory Helpers
+// ============================================================================
+/** Create an Inverter decorator */
+export function inverter(name, child) {
+    return new InverterNode(name, child);
+}
+/** Create a Repeat decorator */
+export function repeat(name, child, count) {
+    return new RepeatNode(name, child, count);
+}
+/** Create an UntilFail decorator */
+export function untilFail(name, child) {
+    return new UntilFailNode(name, child);
+}
+/** Create a Timeout decorator */
+export function timeout(name, child, timeoutMs) {
+    return new TimeoutNode(name, child, timeoutMs);
+}
+/** Create a Retry decorator */
+export function retry(name, child, maxRetries) {
+    return new RetryNode(name, child, maxRetries);
+}
+// ============================================================================
+// Self-Registration for Deserialization
+// ============================================================================
+registerDecoratorFactory('Inverter', (name, child) => {
+    return new InverterNode(name, child);
+});
+registerDecoratorFactory('Repeat', (name, child, config) => {
+    const count = config.count ?? 1;
+    return new RepeatNode(name, child, count);
+});
+registerDecoratorFactory('UntilFail', (name, child) => {
+    return new UntilFailNode(name, child);
+});
+registerDecoratorFactory('Timeout', (name, child, config) => {
+    const timeoutMs = config.timeoutMs ?? 30000;
+    return new TimeoutNode(name, child, timeoutMs);
+});
+registerDecoratorFactory('Retry', (name, child, config) => {
+    const maxRetries = config.maxRetries ?? 1;
+    return new RetryNode(name, child, maxRetries);
+});
+//# sourceMappingURL=decorators.js.map

package/dist/coordination/behavior-tree/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Behavior Tree Orchestration
+ *
+ * Composable behavior trees for agent orchestration.
+ * Provides core nodes, decorators, and pre-built QE workflow trees.
+ */
+export type { NodeStatus, SerializedNode, BehaviorNode, ActionFunction, ConditionPredicate, ParallelConfig, NodeHandlerRegistry, } from './nodes.js';
+export { SequenceNode, SelectorNode, ParallelNode, ActionNode, ConditionNode, deserializeNode, registerDecoratorFactory, sequence, selector, parallel, action, condition, } from './nodes.js';
+export { InverterNode, RepeatNode, UntilFailNode, TimeoutNode, RetryNode, inverter, repeat, untilFail, timeout, retry, } from './decorators.js';
+export type { QETreeHandlers } from './qe-trees.js';
+export { QEActionIds, QEConditionIds, buildTestGenerationPipeline, buildRegressionSuite, buildSecurityAudit, createQEHandlerRegistry, serializeQETree, deserializeQETree, } from './qe-trees.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/coordination/behavior-tree/index.js

@@ -0,0 +1,15 @@
+/**
+ * Behavior Tree Orchestration
+ *
+ * Composable behavior trees for agent orchestration.
+ * Provides core nodes, decorators, and pre-built QE workflow trees.
+ */
+export { SequenceNode, SelectorNode, ParallelNode, ActionNode, ConditionNode, deserializeNode, registerDecoratorFactory, 
+// Factory helpers
+sequence, selector, parallel, action, condition, } from './nodes.js';
+// Decorators
+export { InverterNode, RepeatNode, UntilFailNode, TimeoutNode, RetryNode, 
+// Factory helpers
+inverter, repeat, untilFail, timeout, retry, } from './decorators.js';
+export { QEActionIds, QEConditionIds, buildTestGenerationPipeline, buildRegressionSuite, buildSecurityAudit, createQEHandlerRegistry, serializeQETree, deserializeQETree, } from './qe-trees.js';
+//# sourceMappingURL=index.js.map

package/dist/coordination/behavior-tree/nodes.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Behavior Tree Core Nodes
+ *
+ * Composable behavior tree nodes for agent orchestration.
+ * Each node implements a tick-based evaluation model returning
+ * SUCCESS, FAILURE, or RUNNING.
+ */
+/** Result status of a behavior tree node tick */
+export type NodeStatus = 'SUCCESS' | 'FAILURE' | 'RUNNING';
+/** Serialized representation of a behavior tree node */
+export interface SerializedNode {
+    type: string;
+    name: string;
+    children?: SerializedNode[];
+    config?: Record<string, unknown>;
+}
+/** Base interface for all behavior tree nodes */
+export interface BehaviorNode {
+    /** Node type identifier */
+    readonly type: string;
+    /** Human-readable name */
+    readonly name: string;
+    /** Evaluate this node and return its status */
+    tick(): Promise<NodeStatus>;
+    /** Reset this node (and children) to initial state */
+    reset(): void;
+    /** Serialize this node to a JSON-compatible structure */
+    serialize(): SerializedNode;
+}
+/** Function signature for Action node handlers */
+export type ActionFunction = () => Promise<NodeStatus>;
+/** Function signature for Condition node predicates */
+export type ConditionPredicate = () => Promise<boolean>;
+/** Configuration for Parallel node */
+export interface ParallelConfig {
+    /** Number of children that must succeed for this node to succeed */
+    successThreshold: number;
+    /** Whether to wait for all children or return early */
+    waitForAll?: boolean;
+}
+declare abstract class BaseNode implements BehaviorNode {
+    readonly name: string;
+    abstract readonly type: string;
+    constructor(name: string);
+    abstract tick(): Promise<NodeStatus>;
+    abstract reset(): void;
+    serialize(): SerializedNode;
+}
+declare abstract class CompositeNode extends BaseNode {
+    protected readonly children: BehaviorNode[];
+    constructor(name: string, children: BehaviorNode[]);
+    reset(): void;
+    serialize(): SerializedNode;
+}
+/**
+ * Sequence node - AND logic.
+ *
+ * Runs children in order from left to right:
+ * - Returns FAILURE immediately when any child fails
+ * - Returns RUNNING if a child is still running
+ * - Returns SUCCESS only when all children succeed
+ */
+export declare class SequenceNode extends CompositeNode {
+    readonly type = "Sequence";
+    private currentIndex;
+    constructor(name: string, children: BehaviorNode[]);
+    tick(): Promise<NodeStatus>;
+    reset(): void;
+}
+/**
+ * Selector node - OR logic.
+ *
+ * Runs children in order from left to right:
+ * - Returns SUCCESS immediately when any child succeeds
+ * - Returns RUNNING if a child is still running
+ * - Returns FAILURE only when all children fail
+ */
+export declare class SelectorNode extends CompositeNode {
+    readonly type = "Selector";
+    private currentIndex;
+    constructor(name: string, children: BehaviorNode[]);
+    tick(): Promise<NodeStatus>;
+    reset(): void;
+}
+/**
+ * Parallel node - concurrent execution.
+ *
+ * Runs all children concurrently:
+ * - Returns SUCCESS when successThreshold children succeed
+ * - Returns FAILURE when it becomes impossible to meet the threshold
+ * - Returns RUNNING while children are still executing
+ */
+export declare class ParallelNode extends CompositeNode {
+    readonly type = "Parallel";
+    private readonly config;
+    constructor(name: string, children: BehaviorNode[], config: ParallelConfig);
+    tick(): Promise<NodeStatus>;
+    serialize(): SerializedNode;
+}
+/**
+ * Action node - leaf node that executes a function.
+ *
+ * Wraps an async function that returns a NodeStatus.
+ * Use for side-effectful operations like running tests or generating code.
+ */
+export declare class ActionNode extends BaseNode {
+    readonly type = "Action";
+    private readonly action;
+    private readonly actionId;
+    constructor(name: string, action: ActionFunction, actionId?: string);
+    tick(): Promise<NodeStatus>;
+    reset(): void;
+    serialize(): SerializedNode;
+}
+/**
+ * Condition node - leaf node that checks a predicate.
+ *
+ * Wraps an async predicate that returns boolean.
+ * Returns SUCCESS if predicate is true, FAILURE if false.
+ * Use for checking preconditions or guard clauses.
+ */
+export declare class ConditionNode extends BaseNode {
+    readonly type = "Condition";
+    private readonly predicate;
+    private readonly conditionId;
+    constructor(name: string, predicate: ConditionPredicate, conditionId?: string);
+    tick(): Promise<NodeStatus>;
+    reset(): void;
+    serialize(): SerializedNode;
+}
+/** Registry of action/condition handlers for deserialization */
+export interface NodeHandlerRegistry {
+    actions: Map<string, ActionFunction>;
+    conditions: Map<string, ConditionPredicate>;
+}
+/**
+ * Deserialize a serialized node tree back into executable BehaviorNodes.
+ *
+ * Requires a handler registry to reconstruct Action and Condition nodes
+ * since functions cannot be serialized directly.
+ *
+ * Supports both core nodes (Sequence, Selector, Parallel, Action, Condition)
+ * and decorator nodes (Inverter, Repeat, UntilFail, Timeout, Retry).
+ * Decorator classes must be registered via registerDecoratorTypes() before
+ * deserialization of trees containing decorators.
+ */
+export declare function deserializeNode(data: SerializedNode, registry: NodeHandlerRegistry): BehaviorNode;
+type DecoratorFactory = (name: string, child: BehaviorNode, config: Record<string, unknown>) => BehaviorNode;
+/**
+ * Register decorator type factories for deserialization.
+ * Called automatically when decorators module is imported via the barrel export.
+ */
+export declare function registerDecoratorFactory(type: string, factory: DecoratorFactory): void;
+/** Create a Sequence node */
+export declare function sequence(name: string, children: BehaviorNode[]): SequenceNode;
+/** Create a Selector node */
+export declare function selector(name: string, children: BehaviorNode[]): SelectorNode;
+/** Create a Parallel node */
+export declare function parallel(name: string, children: BehaviorNode[], config: ParallelConfig): ParallelNode;
+/** Create an Action node */
+export declare function action(name: string, fn: ActionFunction, actionId?: string): ActionNode;
+/** Create a Condition node */
+export declare function condition(name: string, predicate: ConditionPredicate, conditionId?: string): ConditionNode;
+export {};
+//# sourceMappingURL=nodes.d.ts.map