agentic-qe 3.7.21 → 3.8.0

package/dist/init/init-wizard.js

@@ -6,16 +6,15 @@
  *
  * This is a facade module. Implementation details are extracted to:
  * - init-wizard-hooks.ts     (hook configuration, MCP, CLAUDE.md generation)
- * - init-wizard-migration.ts (V2 detection, migration, config conversion)
- * - init-wizard-steps.ts     (persistence, learning, workers, skills, agents, config)
+ * - init-wizard-steps.ts     (persistence, learning, workers, skills, agents, config, version)
  */
 import { createDefaultConfig } from './types.js';
 import { createProjectAnalyzer } from './project-analyzer.js';
 import { createSelfConfigurator } from './self-configurator.js';
-import { detectV2Installation, runV2Migration, writeVersionToDb, } from './init-wizard-migration.js';
+// Import from extracted modules
 import { configureHooks, configureMCP, generateCLAUDEmd, } from './init-wizard-hooks.js';
 import { toErrorMessage } from '../shared/error-utils.js';
-import { initializePersistenceDatabase, checkCodeIntelligenceIndex, runCodeIntelligenceScan, getKGEntryCount, initializeLearningSystem, startWorkers, installSkills, installAgents, installN8n, saveConfig, } from './init-wizard-steps.js';
+import { initializePersistenceDatabase, checkCodeIntelligenceIndex, runCodeIntelligenceScan, getKGEntryCount, initializeLearningSystem, startWorkers, installSkills, installAgents, installN8n, saveConfig, writeVersionToDb, } from './init-wizard-steps.js';
 // ============================================================================
 // Wizard Step Definitions
 // ============================================================================
@@ -105,13 +104,6 @@ export class InitOrchestrator {
     async initialize() {
         const startTime = Date.now();
         try {
-            // Step 0: Check for existing v2 installation
-            const v2Detection = await detectV2Installation(this.projectRoot);
-            if (v2Detection.detected) {
-                const earlyResult = this.handleV2Detection(v2Detection, startTime);
-                if (earlyResult)
-                    return earlyResult;
-            }
             // Step 1: Analyze project
             const analysis = await this.runStep('Project Analysis', async () => {
                 return await this.analyzer.analyze();
@@ -251,64 +243,6 @@ export class InitOrchestrator {
     getWizardSteps() {
         return WIZARD_STEPS;
     }
-    /**
-     * Handle V2 detection - returns early result if migration not auto, null otherwise.
-     */
-    handleV2Detection(v2Detection, startTime) {
-        console.log('\n' + '='.repeat(60));
-        console.log('  EXISTING V2 INSTALLATION DETECTED');
-        console.log('='.repeat(60) + '\n');
-        console.log('Found v2 installation at:');
-        if (v2Detection.hasMemoryDb) {
-            console.log(`  - Memory DB: .agentic-qe/memory.db`);
-        }
-        if (v2Detection.hasConfig) {
-            console.log(`  - Config: .agentic-qe/config/`);
-        }
-        if (v2Detection.hasAgents) {
-            console.log(`  - Agents: .claude/agents/`);
-        }
-        console.log('');
-        if (this.options.autoMigrate) {
-            console.log('Auto-migrate mode enabled. Running migration...\n');
-            // Fire and forget - the caller will await initialize() which runs migration inline
-            runV2Migration(this.projectRoot, v2Detection).catch((e) => { console.warn('[InitWizard] V2 migration failed:', e instanceof Error ? e.message : e); });
-            return null;
-        }
-        // Warn and suggest migration
-        console.log('RECOMMENDED: Run migration before init:\n');
-        console.log('   npx aqe migrate status      # Check what needs migration');
-        console.log('   npx aqe migrate run --dry-run  # Preview changes');
-        console.log('   npx aqe migrate run         # Execute migration\n');
-        console.log('Or continue with:');
-        console.log('   aqe init --auto-migrate     # Auto-migrate during init\n');
-        console.log('='.repeat(60) + '\n');
-        return {
-            success: false,
-            config: createDefaultConfig('unknown', this.projectRoot),
-            steps: [{
-                    step: 'V2 Detection',
-                    status: 'error',
-                    message: 'Existing v2 installation detected. Run migration first.',
-                    durationMs: Date.now() - startTime,
-                }],
-            summary: {
-                projectAnalyzed: false,
-                configGenerated: false,
-                codeIntelligenceIndexed: 0,
-                patternsLoaded: 0,
-                skillsInstalled: 0,
-                agentsInstalled: 0,
-                hooksConfigured: false,
-                mcpConfigured: false,
-                claudeMdGenerated: false,
-                workersStarted: 0,
-            },
-            totalDurationMs: Date.now() - startTime,
-            timestamp: new Date(),
-            v2Detected: true,
-        };
-    }
     /**
      * Run a single initialization step with timing and status tracking
      */

package/dist/init/orchestrator.js

@@ -32,7 +32,6 @@ export class ModularInitOrchestrator {
                 upgrade: options.upgrade,
                 skipPatterns: options.skipPatterns,
                 minimal: options.minimal,
-                autoMigrate: options.autoMigrate,
                 withN8n: options.withN8n,
                 withOpenCode: options.withOpenCode,
                 withKiro: options.withKiro,

package/dist/init/phases/01-detection.js

@@ -27,33 +27,6 @@ export class DetectionPhase extends BasePhase {
         const freshInstall = !v2Detected && !v3Detected;
         // Store v2 detection in context for other phases
         context.v2Detection = v2Detection;
-        if (v2Detected && !context.options.autoMigrate) {
-            context.services.log('');
-            context.services.log('═'.repeat(60));
-            context.services.log('⚠️  EXISTING V2 INSTALLATION DETECTED');
-            context.services.log('═'.repeat(60));
-            context.services.log('');
-            context.services.log('Found v2 installation at:');
-            if (v2Detection.hasMemoryDb) {
-                context.services.log('  • Memory DB: .agentic-qe/memory.db');
-            }
-            if (v2Detection.hasConfig) {
-                context.services.log('  • Config: .agentic-qe/config/');
-            }
-            if (v2Detection.hasAgents) {
-                context.services.log('  • Agents: .claude/agents/');
-            }
-            context.services.log('');
-            context.services.log('📋 RECOMMENDED: Run with --auto-migrate:');
-            context.services.log('   aqe init --auto-migrate');
-            context.services.log('');
-            return {
-                v2Detected: true,
-                v3Detected,
-                freshInstall: false,
-                v2Detection,
-            };
-        }
         return {
             v2Detected,
             v3Detected,

package/dist/init/phases/07-hooks.js

@@ -289,13 +289,14 @@ const { execFileSync } = require('child_process');
 
 function q(bin, args, d) { try { return execFileSync(bin, args, { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] }).trim(); } catch { return d || ''; } }
 
-const dir = process.cwd();
+const dir = path.resolve(__dirname, '..', '..');
 const dbPath = path.join(dir, '.agentic-qe', 'memory.db');
 let patterns = 0;
 try {
   if (fs.existsSync(dbPath)) {
     const Database = require('better-sqlite3');
     const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    db.pragma('busy_timeout = 5000');
     patterns = db.prepare('SELECT COUNT(*) AS c FROM qe_patterns').get()?.c || 0;
     db.close();
   }
@@ -325,7 +326,8 @@ const { execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
-const AQE_DIR = path.join(process.cwd(), '.agentic-qe');
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
+const AQE_DIR = path.join(PROJECT_ROOT, '.agentic-qe');
 const RVF_PATH = path.join(AQE_DIR, 'aqe.rvf');
 const DB_PATH = path.join(AQE_DIR, 'memory.db');
 const MAX_AGE_HOURS = 24;
@@ -496,7 +498,7 @@ if (process.argv.includes('--json')) process.stdout.write(JSON.stringify(result)
                     hooks: [
                         {
                             type: 'command',
-                            command: 'node .claude/helpers/brain-checkpoint.cjs verify --json',
+                            command: 'node "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.claude/helpers/brain-checkpoint.cjs" verify --json',
                             timeout: 5000,
                             continueOnError: true,
                         },
@@ -518,7 +520,7 @@ if (process.argv.includes('--json')) process.stdout.write(JSON.stringify(result)
                     hooks: [
                         {
                             type: 'command',
-                            command: 'node .claude/helpers/brain-checkpoint.cjs export --json',
+                            command: 'node "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.claude/helpers/brain-checkpoint.cjs" export --json',
                             timeout: 60000,
                             continueOnError: true,
                         },

package/dist/init/phases/phase-interface.d.ts

@@ -73,7 +73,6 @@ export interface InitOptions {
     /** Minimal configuration (no skills, patterns, workers) */
     minimal?: boolean;
     /** Automatically migrate from v2 if detected */
-    autoMigrate?: boolean;
     /** Install n8n workflow testing platform */
     withN8n?: boolean;
     /** N8n API configuration */

package/dist/init/settings-merge.js

@@ -97,7 +97,7 @@ export function generateV3SettingsSections(config) {
         },
         statusLine: {
             type: 'command',
-            command: 'node .claude/helpers/statusline-v3.cjs 2>/dev/null || echo "▊ Agentic QE v3"',
+            command: 'node "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.claude/helpers/statusline-v3.cjs" 2>/dev/null || echo "▊ Agentic QE v3"',
             refreshMs: 5000,
             enabled: true,
         },

package/dist/integrations/browser/qe-dashboard/clustering.d.ts

@@ -0,0 +1,48 @@
+/**
+ * K-Means Clustering and Embedding Utilities (Task 4.6)
+ *
+ * Provides K-Means clustering with K-Means++ initialization and
+ * deterministic pseudo-embedding generation for patterns without
+ * pre-computed vectors.
+ *
+ * @module integrations/browser/qe-dashboard/clustering
+ */
+/**
+ * Dimension for auto-generated embeddings.
+ * Kept small (32) for efficiency in browser contexts.
+ */
+export declare const EMBEDDING_DIM = 32;
+/** Minimal pattern shape needed for embedding generation */
+export interface EmbeddablePattern {
+    domain: string;
+    description: string;
+    tags?: string[];
+}
+/**
+ * Generate a deterministic pseudo-embedding from a pattern's text content.
+ *
+ * Uses a simple hash-based approach to produce a stable vector from the
+ * pattern's description and domain. This is a fallback when no real
+ * embedding model is available.
+ *
+ * @param pattern - The pattern to embed
+ * @returns Float32Array embedding of length EMBEDDING_DIM
+ */
+export declare function generateEmbedding(pattern: EmbeddablePattern): Float32Array;
+/**
+ * Generate a query embedding from a text string
+ */
+export declare function generateQueryEmbedding(query: string): Float32Array;
+/**
+ * K-Means clustering for Float32Array vectors.
+ *
+ * Uses K-Means++ initialization for better centroid placement,
+ * then iterates until convergence or maxIter is reached.
+ *
+ * @param vectors - Array of vectors to cluster
+ * @param k - Number of clusters
+ * @param maxIter - Maximum iterations (default: 50)
+ * @returns Array of cluster assignments (index per vector)
+ */
+export declare function kMeansClustering(vectors: Float32Array[], k: number, maxIter?: number): number[];
+//# sourceMappingURL=clustering.d.ts.map

package/dist/integrations/browser/qe-dashboard/clustering.js

@@ -0,0 +1,183 @@
+/**
+ * K-Means Clustering and Embedding Utilities (Task 4.6)
+ *
+ * Provides K-Means clustering with K-Means++ initialization and
+ * deterministic pseudo-embedding generation for patterns without
+ * pre-computed vectors.
+ *
+ * @module integrations/browser/qe-dashboard/clustering
+ */
+import { cosineSimilarity } from './wasm-vector-store.js';
+// ============================================================================
+// Embedding Generation
+// ============================================================================
+/**
+ * Dimension for auto-generated embeddings.
+ * Kept small (32) for efficiency in browser contexts.
+ */
+export const EMBEDDING_DIM = 32;
+/**
+ * Generate a deterministic pseudo-embedding from a pattern's text content.
+ *
+ * Uses a simple hash-based approach to produce a stable vector from the
+ * pattern's description and domain. This is a fallback when no real
+ * embedding model is available.
+ *
+ * @param pattern - The pattern to embed
+ * @returns Float32Array embedding of length EMBEDDING_DIM
+ */
+export function generateEmbedding(pattern) {
+    const text = `${pattern.domain} ${pattern.description} ${(pattern.tags || []).join(' ')}`;
+    const embedding = new Float32Array(EMBEDDING_DIM);
+    // Simple deterministic hash-based embedding
+    for (let i = 0; i < text.length; i++) {
+        const charCode = text.charCodeAt(i);
+        const idx = i % EMBEDDING_DIM;
+        // Mix character codes using a simple multiplicative hash
+        embedding[idx] += Math.sin(charCode * (i + 1) * 0.1) * 0.5;
+    }
+    // Normalize to unit length
+    let norm = 0;
+    for (let i = 0; i < embedding.length; i++) {
+        norm += embedding[i] * embedding[i];
+    }
+    norm = Math.sqrt(norm);
+    if (norm > 0) {
+        for (let i = 0; i < embedding.length; i++) {
+            embedding[i] /= norm;
+        }
+    }
+    return embedding;
+}
+/**
+ * Generate a query embedding from a text string
+ */
+export function generateQueryEmbedding(query) {
+    return generateEmbedding({
+        domain: '',
+        description: query,
+    });
+}
+// ============================================================================
+// K-Means Clustering
+// ============================================================================
+/**
+ * K-Means clustering for Float32Array vectors.
+ *
+ * Uses K-Means++ initialization for better centroid placement,
+ * then iterates until convergence or maxIter is reached.
+ *
+ * @param vectors - Array of vectors to cluster
+ * @param k - Number of clusters
+ * @param maxIter - Maximum iterations (default: 50)
+ * @returns Array of cluster assignments (index per vector)
+ */
+export function kMeansClustering(vectors, k, maxIter = 50) {
+    if (vectors.length === 0 || k <= 0) {
+        return [];
+    }
+    const n = vectors.length;
+    const clampedK = Math.min(k, n);
+    const dim = vectors[0].length;
+    // K-Means++ initialization
+    const centroids = initializeCentroids(vectors, clampedK);
+    const assignments = new Array(n).fill(0);
+    for (let iter = 0; iter < maxIter; iter++) {
+        let changed = false;
+        // Assignment step: assign each vector to the nearest centroid
+        for (let i = 0; i < n; i++) {
+            let bestCluster = 0;
+            let bestSim = -Infinity;
+            for (let c = 0; c < clampedK; c++) {
+                const sim = cosineSimilarity(vectors[i], centroids[c]);
+                if (sim > bestSim) {
+                    bestSim = sim;
+                    bestCluster = c;
+                }
+            }
+            if (assignments[i] !== bestCluster) {
+                assignments[i] = bestCluster;
+                changed = true;
+            }
+        }
+        // Convergence check
+        if (!changed) {
+            break;
+        }
+        // Update step: recompute centroids
+        for (let c = 0; c < clampedK; c++) {
+            const newCentroid = new Float32Array(dim);
+            let count = 0;
+            for (let i = 0; i < n; i++) {
+                if (assignments[i] === c) {
+                    for (let d = 0; d < dim; d++) {
+                        newCentroid[d] += vectors[i][d];
+                    }
+                    count++;
+                }
+            }
+            if (count > 0) {
+                for (let d = 0; d < dim; d++) {
+                    newCentroid[d] /= count;
+                }
+                // Normalize centroid
+                let norm = 0;
+                for (let d = 0; d < dim; d++) {
+                    norm += newCentroid[d] * newCentroid[d];
+                }
+                norm = Math.sqrt(norm);
+                if (norm > 0) {
+                    for (let d = 0; d < dim; d++) {
+                        newCentroid[d] /= norm;
+                    }
+                }
+                centroids[c] = newCentroid;
+            }
+        }
+    }
+    return assignments;
+}
+/**
+ * K-Means++ initialization: select initial centroids with probability
+ * proportional to squared distance from nearest existing centroid.
+ */
+function initializeCentroids(vectors, k) {
+    const n = vectors.length;
+    const centroids = [];
+    // Pick first centroid (deterministic: use first vector)
+    centroids.push(new Float32Array(vectors[0]));
+    for (let c = 1; c < k; c++) {
+        // Compute distances to nearest centroid
+        const distances = new Float64Array(n);
+        let totalDist = 0;
+        for (let i = 0; i < n; i++) {
+            let minDist = Infinity;
+            for (const centroid of centroids) {
+                const sim = cosineSimilarity(vectors[i], centroid);
+                const dist = 1 - sim;
+                if (dist < minDist) {
+                    minDist = dist;
+                }
+            }
+            distances[i] = minDist * minDist; // Squared distance
+            totalDist += distances[i];
+        }
+        if (totalDist === 0) {
+            // All points identical to existing centroids; pick sequentially
+            centroids.push(new Float32Array(vectors[c % n]));
+            continue;
+        }
+        // Deterministic selection: pick the point with maximum distance
+        let maxIdx = 0;
+        let maxDist = -1;
+        for (let i = 0; i < n; i++) {
+            if (distances[i] > maxDist) {
+                maxDist = distances[i];
+                maxIdx = i;
+            }
+        }
+        centroids.push(new Float32Array(vectors[maxIdx]));
+    }
+    return centroids;
+}
+//# sourceMappingURL=clustering.js.map

package/dist/integrations/browser/qe-dashboard/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * QE Dashboard - Browser-based intelligence dashboard (Task 4.6)
+ *
+ * Provides WASM-accelerated vector storage and pattern exploration
+ * for visualizing QE intelligence data in the browser.
+ *
+ * @module integrations/browser/qe-dashboard
+ */
+export { WasmVectorStore, cosineSimilarity, type SearchResult, type StoreStats, } from './wasm-vector-store.js';
+export { kMeansClustering, generateEmbedding, generateQueryEmbedding, EMBEDDING_DIM, type EmbeddablePattern, } from './clustering.js';
+export { PatternExplorer, type Pattern, type PatternCluster, type DomainStats, type DashboardData, } from './pattern-explorer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/integrations/browser/qe-dashboard/index.js

@@ -0,0 +1,15 @@
+/**
+ * QE Dashboard - Browser-based intelligence dashboard (Task 4.6)
+ *
+ * Provides WASM-accelerated vector storage and pattern exploration
+ * for visualizing QE intelligence data in the browser.
+ *
+ * @module integrations/browser/qe-dashboard
+ */
+// Vector Store
+export { WasmVectorStore, cosineSimilarity, } from './wasm-vector-store.js';
+// Clustering
+export { kMeansClustering, generateEmbedding, generateQueryEmbedding, EMBEDDING_DIM, } from './clustering.js';
+// Pattern Explorer
+export { PatternExplorer, } from './pattern-explorer.js';
+//# sourceMappingURL=index.js.map

package/dist/integrations/browser/qe-dashboard/pattern-explorer.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Pattern Explorer for QE Dashboard (Task 4.6)
+ *
+ * Provides pattern exploration, similarity clustering, and visualization
+ * data preparation for the browser-based QE intelligence dashboard.
+ *
+ * Features:
+ * - Load and index patterns into the vector store
+ * - Similarity search across patterns
+ * - K-Means clustering for visualization
+ * - Domain distribution analysis
+ * - Health dashboard data aggregation
+ *
+ * No browser-specific APIs: works in Node.js for testing.
+ *
+ * @module integrations/browser/qe-dashboard/pattern-explorer
+ */
+import { WasmVectorStore } from './wasm-vector-store.js';
+export { kMeansClustering } from './clustering.js';
+/** A QE pattern for exploration */
+export interface Pattern {
+    /** Unique pattern identifier */
+    id: string;
+    /** Domain the pattern belongs to */
+    domain: string;
+    /** Human-readable description */
+    description: string;
+    /** Confidence score (0..1) */
+    confidence: number;
+    /** Embedding vector (optional - will be auto-generated if missing) */
+    embedding?: Float32Array;
+    /** Tags for filtering */
+    tags?: string[];
+    /** Timestamp of pattern creation */
+    createdAt?: number;
+    /** Whether the pattern was successful */
+    success?: boolean;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/** A cluster of similar patterns */
+export interface PatternCluster {
+    /** Cluster index */
+    id: number;
+    /** Centroid vector of the cluster */
+    centroid: Float32Array;
+    /** Patterns assigned to this cluster */
+    patterns: Pattern[];
+    /** Dominant domain in this cluster */
+    dominantDomain: string;
+    /** Average confidence within the cluster */
+    avgConfidence: number;
+    /** Intra-cluster cohesion (average similarity to centroid) */
+    cohesion: number;
+}
+/** Statistics about a domain */
+export interface DomainStats {
+    /** Domain name */
+    domain: string;
+    /** Number of patterns in this domain */
+    patternCount: number;
+    /** Average confidence across patterns */
+    avgConfidence: number;
+    /** Success rate (fraction of successful patterns) */
+    successRate: number;
+    /** Most recent pattern timestamp */
+    latestTimestamp: number;
+    /** Top tags in this domain */
+    topTags: Array<{
+        tag: string;
+        count: number;
+    }>;
+}
+/** Aggregated dashboard data */
+export interface DashboardData {
+    /** Total number of loaded patterns */
+    totalPatterns: number;
+    /** Number of distinct domains */
+    domainCount: number;
+    /** Overall average confidence */
+    avgConfidence: number;
+    /** Overall success rate */
+    successRate: number;
+    /** Per-domain statistics */
+    domainStats: DomainStats[];
+    /** Confidence distribution histogram (10 bins) */
+    confidenceHistogram: number[];
+    /** Recent pattern activity (last 30 days if timestamps present) */
+    recentActivity: number;
+    /** Vector store statistics */
+    storeStats: {
+        totalVectors: number;
+        dimensions: number;
+        wasmActive: boolean;
+        memoryBytes: number;
+    };
+}
+/**
+ * Pattern exploration and visualization data preparation.
+ *
+ * Loads QE patterns into a vector store, provides similarity search,
+ * clustering, domain distribution, and aggregated dashboard data.
+ *
+ * @example
+ * ```typescript
+ * const explorer = new PatternExplorer();
+ * await explorer.initialize();
+ *
+ * explorer.loadPatterns(patterns);
+ *
+ * // Find similar patterns
+ * const similar = explorer.searchSimilar('authentication testing', 5);
+ *
+ * // Cluster for visualization
+ * const clusters = explorer.clusterPatterns(4);
+ *
+ * // Dashboard data
+ * const dashboard = explorer.getHealthDashboardData();
+ * ```
+ */
+export declare class PatternExplorer {
+    private store;
+    private patterns;
+    private embeddings;
+    constructor(store?: WasmVectorStore);
+    /** Initialize the explorer (loads WASM backend if available) */
+    initialize(): Promise<void>;
+    /**
+     * Load patterns into the explorer
+     *
+     * Each pattern is embedded (using provided embedding or auto-generated)
+     * and indexed in the vector store for similarity search.
+     */
+    loadPatterns(patterns: Pattern[]): void;
+    /**
+     * Search for patterns similar to a text query
+     *
+     * @param query - Natural language query string
+     * @param k - Number of results to return
+     * @returns Array of matched patterns ordered by similarity
+     */
+    searchSimilar(query: string, k: number): Pattern[];
+    /**
+     * Cluster patterns into groups using K-Means
+     *
+     * @param numClusters - Number of clusters to create
+     * @returns Array of PatternCluster with centroid, members, and statistics
+     */
+    clusterPatterns(numClusters: number): PatternCluster[];
+    /** Get distribution statistics per domain */
+    getDomainDistribution(): DomainStats[];
+    /** Get aggregated health dashboard data */
+    getHealthDashboardData(): DashboardData;
+    /** Get a pattern by id */
+    getPattern(id: string): Pattern | undefined;
+    /** Get total number of loaded patterns */
+    get patternCount(): number;
+    /** Clear all patterns and reset the explorer */
+    clear(): void;
+    private buildClusters;
+    private computeNormalizedCentroid;
+    private findDominantDomain;
+    private computeDomainStats;
+}
+//# sourceMappingURL=pattern-explorer.d.ts.map