ruvector 0.1.62 → 0.1.63

package/dist/core/attention-fallbacks.d.ts

@@ -202,13 +202,112 @@ export declare function isAttentionAvailable(): boolean;
  * Get attention module version
  */
 export declare function getAttentionVersion(): string | null;
+/**
+ * Graph attention with Rotary Position Embeddings
+ * Excellent for code AST and dependency graphs
+ */
+export declare class GraphRoPeAttention {
+    private inner;
+    readonly dim: number;
+    readonly numHeads: number;
+    readonly maxSeqLen: number;
+    constructor(dim: number, numHeads?: number, maxSeqLen?: number);
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[], positions?: number[]): AttentionOutput;
+}
+/**
+ * Edge-featured attention for graphs with edge attributes
+ * Useful for weighted dependency graphs
+ */
+export declare class EdgeFeaturedAttention {
+    private inner;
+    readonly dim: number;
+    readonly edgeDim: number;
+    constructor(dim: number, edgeDim?: number);
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[], edgeFeatures?: (number[] | Float32Array)[]): AttentionOutput;
+}
+/**
+ * Dual-space attention (Euclidean + Hyperbolic)
+ * Best of both worlds for hierarchical + semantic similarity
+ */
+export declare class DualSpaceAttention {
+    private inner;
+    readonly dim: number;
+    readonly curvature: number;
+    readonly alpha: number;
+    constructor(dim: number, curvature?: number, alpha?: number);
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+}
+/**
+ * Basic dot-product attention
+ */
+export declare class DotProductAttention {
+    private inner;
+    readonly dim: number;
+    constructor(dim: number);
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+}
+/**
+ * Compute attention in parallel across multiple queries
+ */
+export declare function parallelAttentionCompute(queries: (number[] | Float32Array)[], keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[], attentionType?: 'dot' | 'multi-head' | 'flash' | 'hyperbolic' | 'linear'): Promise<number[][]>;
+/**
+ * Batch attention compute for multiple query-key-value sets
+ */
+export declare function batchAttentionCompute(batches: Array<{
+    query: number[] | Float32Array;
+    keys: (number[] | Float32Array)[];
+    values: (number[] | Float32Array)[];
+}>, attentionType?: 'dot' | 'multi-head' | 'flash' | 'hyperbolic' | 'linear'): Promise<number[][]>;
+/**
+ * Async flash attention with callback
+ */
+export declare function computeFlashAttentionAsync(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): Promise<number[]>;
+/**
+ * Async hyperbolic attention
+ */
+export declare function computeHyperbolicAttentionAsync(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[], curvature?: number): Promise<number[]>;
+/**
+ * Adam optimizer for attention training
+ */
+export declare class AdamOptimizer {
+    private inner;
+    constructor(learningRate?: number, beta1?: number, beta2?: number);
+    step(gradients: number[] | Float32Array, params: number[] | Float32Array): number[];
+}
+/**
+ * InfoNCE contrastive loss
+ */
+export declare function infoNceLoss(anchor: number[] | Float32Array, positive: number[] | Float32Array, negatives: (number[] | Float32Array)[], temperature?: number): number;
+/**
+ * Hard negative mining for contrastive learning
+ */
+export declare function mineHardNegatives(anchor: number[] | Float32Array, candidates: (number[] | Float32Array)[], topK?: number): number[][];
+/**
+ * Benchmark attention implementations
+ */
+export declare function benchmarkAttention(dim: number, seqLen: number, iterations?: number): Promise<Record<string, {
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+}>>;
 declare const _default: {
+    DotProductAttention: typeof DotProductAttention;
     MultiHeadAttention: typeof MultiHeadAttention;
     FlashAttention: typeof FlashAttention;
     HyperbolicAttention: typeof HyperbolicAttention;
     LinearAttention: typeof LinearAttention;
     LocalGlobalAttention: typeof LocalGlobalAttention;
     MoEAttention: typeof MoEAttention;
+    GraphRoPeAttention: typeof GraphRoPeAttention;
+    EdgeFeaturedAttention: typeof EdgeFeaturedAttention;
+    DualSpaceAttention: typeof DualSpaceAttention;
+    parallelAttentionCompute: typeof parallelAttentionCompute;
+    batchAttentionCompute: typeof batchAttentionCompute;
+    computeFlashAttentionAsync: typeof computeFlashAttentionAsync;
+    computeHyperbolicAttentionAsync: typeof computeHyperbolicAttentionAsync;
+    AdamOptimizer: typeof AdamOptimizer;
+    infoNceLoss: typeof infoNceLoss;
+    mineHardNegatives: typeof mineHardNegatives;
     projectToPoincareBall: typeof projectToPoincareBall;
     poincareDistance: typeof poincareDistance;
     mobiusAddition: typeof mobiusAddition;
@@ -216,6 +315,7 @@ declare const _default: {
     logMap: typeof logMap;
     isAttentionAvailable: typeof isAttentionAvailable;
     getAttentionVersion: typeof getAttentionVersion;
+    benchmarkAttention: typeof benchmarkAttention;
 };
 export default _default;
 //# sourceMappingURL=attention-fallbacks.d.ts.map

package/dist/core/attention-fallbacks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attention-fallbacks.d.ts","sourceRoot":"","sources":["../../src/core/attention-fallbacks.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"attention-fallbacks.d.ts","sourceRoot":"","sources":["../../src/core/attention-fallbacks.ts"],"names":[],"mappings":"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"}

package/dist/core/attention-fallbacks.js

@@ -9,7 +9,7 @@
  * This wrapper handles the conversion automatically.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoEAttention = exports.LocalGlobalAttention = exports.LinearAttention = exports.HyperbolicAttention = exports.FlashAttention = exports.MultiHeadAttention = void 0;
+exports.AdamOptimizer = exports.DotProductAttention = exports.DualSpaceAttention = exports.EdgeFeaturedAttention = exports.GraphRoPeAttention = exports.MoEAttention = exports.LocalGlobalAttention = exports.LinearAttention = exports.HyperbolicAttention = exports.FlashAttention = exports.MultiHeadAttention = void 0;
 exports.projectToPoincareBall = projectToPoincareBall;
 exports.poincareDistance = poincareDistance;
 exports.mobiusAddition = mobiusAddition;
@@ -17,6 +17,13 @@ exports.expMap = expMap;
 exports.logMap = logMap;
 exports.isAttentionAvailable = isAttentionAvailable;
 exports.getAttentionVersion = getAttentionVersion;
+exports.parallelAttentionCompute = parallelAttentionCompute;
+exports.batchAttentionCompute = batchAttentionCompute;
+exports.computeFlashAttentionAsync = computeFlashAttentionAsync;
+exports.computeHyperbolicAttentionAsync = computeHyperbolicAttentionAsync;
+exports.infoNceLoss = infoNceLoss;
+exports.mineHardNegatives = mineHardNegatives;
+exports.benchmarkAttention = benchmarkAttention;
 // Lazy load to avoid import errors if not installed
 let attentionModule = null;
 let loadError = null;
@@ -344,18 +351,202 @@ function getAttentionVersion() {
         return null;
     }
 }
+// ============================================================================
+// Graph-based Attention (for code structure)
+// ============================================================================
+/**
+ * Graph attention with Rotary Position Embeddings
+ * Excellent for code AST and dependency graphs
+ */
+class GraphRoPeAttention {
+    constructor(dim, numHeads = 4, maxSeqLen = 4096) {
+        const attention = getAttentionModule();
+        this.inner = new attention.GraphRoPeAttention(dim, numHeads, maxSeqLen);
+        this.dim = dim;
+        this.numHeads = numHeads;
+        this.maxSeqLen = maxSeqLen;
+    }
+    compute(query, keys, values, positions) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), positions ? new Int32Array(positions) : undefined);
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.GraphRoPeAttention = GraphRoPeAttention;
+/**
+ * Edge-featured attention for graphs with edge attributes
+ * Useful for weighted dependency graphs
+ */
+class EdgeFeaturedAttention {
+    constructor(dim, edgeDim = 16) {
+        const attention = getAttentionModule();
+        this.inner = new attention.EdgeFeaturedAttention(dim, edgeDim);
+        this.dim = dim;
+        this.edgeDim = edgeDim;
+    }
+    compute(query, keys, values, edgeFeatures) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), edgeFeatures ? toFloat32Arrays(edgeFeatures) : undefined);
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.EdgeFeaturedAttention = EdgeFeaturedAttention;
+/**
+ * Dual-space attention (Euclidean + Hyperbolic)
+ * Best of both worlds for hierarchical + semantic similarity
+ */
+class DualSpaceAttention {
+    constructor(dim, curvature = 1.0, alpha = 0.5) {
+        const attention = getAttentionModule();
+        this.inner = new attention.DualSpaceAttention(dim, curvature, alpha);
+        this.dim = dim;
+        this.curvature = curvature;
+        this.alpha = alpha;
+    }
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.DualSpaceAttention = DualSpaceAttention;
+/**
+ * Basic dot-product attention
+ */
+class DotProductAttention {
+    constructor(dim) {
+        const attention = getAttentionModule();
+        this.inner = new attention.DotProductAttention(dim);
+        this.dim = dim;
+    }
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.DotProductAttention = DotProductAttention;
+// ============================================================================
+// Parallel/Batch Attention Compute
+// ============================================================================
+/**
+ * Compute attention in parallel across multiple queries
+ */
+async function parallelAttentionCompute(queries, keys, values, attentionType = 'multi-head') {
+    const attention = getAttentionModule();
+    const results = await attention.parallelAttentionCompute(toFloat32Arrays(queries), toFloat32Arrays(keys), toFloat32Arrays(values), attentionType);
+    return results.map((r) => fromFloat32Array(r));
+}
+/**
+ * Batch attention compute for multiple query-key-value sets
+ */
+async function batchAttentionCompute(batches, attentionType = 'multi-head') {
+    const attention = getAttentionModule();
+    const nativeBatches = batches.map(b => ({
+        query: toFloat32Array(b.query),
+        keys: toFloat32Arrays(b.keys),
+        values: toFloat32Arrays(b.values),
+    }));
+    const results = await attention.batchAttentionCompute(nativeBatches, attentionType);
+    return results.map((r) => fromFloat32Array(r));
+}
+/**
+ * Async flash attention with callback
+ */
+function computeFlashAttentionAsync(query, keys, values) {
+    const attention = getAttentionModule();
+    return new Promise((resolve, reject) => {
+        attention.computeFlashAttentionAsync(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(fromFloat32Array(result));
+        });
+    });
+}
+/**
+ * Async hyperbolic attention
+ */
+function computeHyperbolicAttentionAsync(query, keys, values, curvature = 1.0) {
+    const attention = getAttentionModule();
+    return new Promise((resolve, reject) => {
+        attention.computeHyperbolicAttentionAsync(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), curvature, (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(fromFloat32Array(result));
+        });
+    });
+}
+// ============================================================================
+// Training Utilities (for SONA integration)
+// ============================================================================
+/**
+ * Adam optimizer for attention training
+ */
+class AdamOptimizer {
+    constructor(learningRate = 0.001, beta1 = 0.9, beta2 = 0.999) {
+        const attention = getAttentionModule();
+        this.inner = new attention.AdamOptimizer(learningRate, beta1, beta2);
+    }
+    step(gradients, params) {
+        const result = this.inner.step(toFloat32Array(gradients), toFloat32Array(params));
+        return fromFloat32Array(result);
+    }
+}
+exports.AdamOptimizer = AdamOptimizer;
+/**
+ * InfoNCE contrastive loss
+ */
+function infoNceLoss(anchor, positive, negatives, temperature = 0.07) {
+    const attention = getAttentionModule();
+    return attention.InfoNceLoss.compute(toFloat32Array(anchor), toFloat32Array(positive), toFloat32Arrays(negatives), temperature);
+}
+/**
+ * Hard negative mining for contrastive learning
+ */
+function mineHardNegatives(anchor, candidates, topK = 5) {
+    const attention = getAttentionModule();
+    const miner = new attention.HardNegativeMiner(topK);
+    const results = miner.mine(toFloat32Array(anchor), toFloat32Arrays(candidates));
+    return results.map((r) => fromFloat32Array(r));
+}
+// ============================================================================
+// Benchmarking
+// ============================================================================
+/**
+ * Benchmark attention implementations
+ */
+async function benchmarkAttention(dim, seqLen, iterations = 100) {
+    const attention = getAttentionModule();
+    return attention.benchmarkAttention(dim, seqLen, iterations);
+}
 exports.default = {
+    // Core attention types
+    DotProductAttention,
     MultiHeadAttention,
     FlashAttention,
     HyperbolicAttention,
     LinearAttention,
     LocalGlobalAttention,
     MoEAttention,
+    // Graph attention types
+    GraphRoPeAttention,
+    EdgeFeaturedAttention,
+    DualSpaceAttention,
+    // Parallel/batch compute
+    parallelAttentionCompute,
+    batchAttentionCompute,
+    computeFlashAttentionAsync,
+    computeHyperbolicAttentionAsync,
+    // Training utilities
+    AdamOptimizer,
+    infoNceLoss,
+    mineHardNegatives,
+    // Hyperbolic math
     projectToPoincareBall,
     poincareDistance,
     mobiusAddition,
     expMap,
     logMap,
+    // Utilities
     isAttentionAvailable,
     getAttentionVersion,
+    benchmarkAttention,
 };

package/dist/core/index.d.ts

@@ -11,6 +11,7 @@ export * from './sona-wrapper';
 export * from './intelligence-engine';
 export * from './onnx-embedder';
 export * from './parallel-intelligence';
+export * from './parallel-workers';
 export { default as gnnWrapper } from './gnn-wrapper';
 export { default as attentionFallbacks } from './attention-fallbacks';
 export { default as agentdbFast } from './agentdb-fast';
@@ -18,4 +19,5 @@ export { default as Sona } from './sona-wrapper';
 export { default as IntelligenceEngine } from './intelligence-engine';
 export { default as OnnxEmbedder } from './onnx-embedder';
 export { default as ParallelIntelligence } from './parallel-intelligence';
+export { default as ExtendedWorkerPool } from './parallel-workers';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AAGxC,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AAGnC,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/core/index.js

@@ -23,7 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParallelIntelligence = exports.OnnxEmbedder = exports.IntelligenceEngine = exports.Sona = exports.agentdbFast = exports.attentionFallbacks = exports.gnnWrapper = void 0;
+exports.ExtendedWorkerPool = exports.ParallelIntelligence = exports.OnnxEmbedder = exports.IntelligenceEngine = exports.Sona = exports.agentdbFast = exports.attentionFallbacks = exports.gnnWrapper = void 0;
 __exportStar(require("./gnn-wrapper"), exports);
 __exportStar(require("./attention-fallbacks"), exports);
 __exportStar(require("./agentdb-fast"), exports);
@@ -31,6 +31,7 @@ __exportStar(require("./sona-wrapper"), exports);
 __exportStar(require("./intelligence-engine"), exports);
 __exportStar(require("./onnx-embedder"), exports);
 __exportStar(require("./parallel-intelligence"), exports);
+__exportStar(require("./parallel-workers"), exports);
 // Re-export default objects for convenience
 var gnn_wrapper_1 = require("./gnn-wrapper");
 Object.defineProperty(exports, "gnnWrapper", { enumerable: true, get: function () { return __importDefault(gnn_wrapper_1).default; } });
@@ -46,3 +47,5 @@ var onnx_embedder_1 = require("./onnx-embedder");
 Object.defineProperty(exports, "OnnxEmbedder", { enumerable: true, get: function () { return __importDefault(onnx_embedder_1).default; } });
 var parallel_intelligence_1 = require("./parallel-intelligence");
 Object.defineProperty(exports, "ParallelIntelligence", { enumerable: true, get: function () { return __importDefault(parallel_intelligence_1).default; } });
+var parallel_workers_1 = require("./parallel-workers");
+Object.defineProperty(exports, "ExtendedWorkerPool", { enumerable: true, get: function () { return __importDefault(parallel_workers_1).default; } });

package/dist/core/parallel-workers.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Parallel Workers - Extended worker capabilities for RuVector hooks
+ *
+ * Provides parallel processing for advanced operations:
+ *
+ * 1. SPECULATIVE PRE-COMPUTATION
+ *    - Pre-embed likely next files based on co-edit patterns
+ *    - Warm model cache before operations
+ *    - Predictive route caching
+ *
+ * 2. REAL-TIME CODE ANALYSIS
+ *    - Multi-file AST parsing with tree-sitter
+ *    - Cross-file type inference
+ *    - Live complexity metrics
+ *    - Dependency graph updates
+ *
+ * 3. ADVANCED LEARNING
+ *    - Distributed trajectory replay
+ *    - Parallel SONA micro-LoRA updates
+ *    - Background EWC consolidation
+ *    - Online pattern clustering
+ *
+ * 4. INTELLIGENT RETRIEVAL
+ *    - Parallel RAG chunking and retrieval
+ *    - Sharded similarity search
+ *    - Context relevance ranking
+ *    - Semantic deduplication
+ *
+ * 5. SECURITY & QUALITY
+ *    - Parallel SAST scanning
+ *    - Multi-rule linting
+ *    - Vulnerability detection
+ *    - Code smell analysis
+ *
+ * 6. GIT INTELLIGENCE
+ *    - Parallel blame analysis
+ *    - Branch comparison
+ *    - Merge conflict prediction
+ *    - Code churn metrics
+ */
+export interface WorkerPoolConfig {
+    numWorkers?: number;
+    enabled?: boolean;
+    taskTimeout?: number;
+    maxQueueSize?: number;
+}
+export interface SpeculativeEmbedding {
+    file: string;
+    embedding: number[];
+    confidence: number;
+    timestamp: number;
+}
+export interface ASTAnalysis {
+    file: string;
+    language: string;
+    complexity: number;
+    functions: string[];
+    imports: string[];
+    exports: string[];
+    dependencies: string[];
+}
+export interface SecurityFinding {
+    file: string;
+    line: number;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    rule: string;
+    message: string;
+    suggestion?: string;
+}
+export interface ContextChunk {
+    content: string;
+    source: string;
+    relevance: number;
+    embedding?: number[];
+}
+export interface GitBlame {
+    file: string;
+    lines: Array<{
+        line: number;
+        author: string;
+        date: string;
+        commit: string;
+    }>;
+}
+export interface CodeChurn {
+    file: string;
+    additions: number;
+    deletions: number;
+    commits: number;
+    authors: string[];
+    lastModified: string;
+}
+export declare class ExtendedWorkerPool {
+    private workers;
+    private taskQueue;
+    private busyWorkers;
+    private config;
+    private initialized;
+    private speculativeCache;
+    private astCache;
+    constructor(config?: WorkerPoolConfig);
+    init(): Promise<void>;
+    private getWorkerCode;
+    private getWorkerHandlers;
+    private handleWorkerResult;
+    private processQueue;
+    private execute;
+    /**
+     * Pre-embed files likely to be edited next based on co-edit patterns
+     * Hook: session-start, post-edit
+     */
+    speculativeEmbed(currentFile: string, coEditGraph: Map<string, string[]>): Promise<SpeculativeEmbedding[]>;
+    /**
+     * Analyze AST of multiple files in parallel
+     * Hook: pre-edit, route
+     */
+    analyzeAST(files: string[]): Promise<ASTAnalysis[]>;
+    /**
+     * Analyze code complexity for multiple files
+     * Hook: post-edit, session-end
+     */
+    analyzeComplexity(files: string[]): Promise<Array<{
+        file: string;
+        lines: number;
+        nonEmptyLines: number;
+        cyclomaticComplexity: number;
+        functions: number;
+        avgFunctionSize: number;
+    }>>;
+    /**
+     * Build dependency graph from entry points
+     * Hook: session-start
+     */
+    buildDependencyGraph(entryPoints: string[]): Promise<Record<string, string[]>>;
+    /**
+     * Scan files for security vulnerabilities
+     * Hook: pre-command (before commit), post-edit
+     */
+    securityScan(files: string[], rules?: string[]): Promise<SecurityFinding[]>;
+    /**
+     * Retrieve relevant context chunks in parallel
+     * Hook: suggest-context, recall
+     */
+    ragRetrieve(query: string, chunks: ContextChunk[], topK?: number): Promise<ContextChunk[]>;
+    /**
+     * Rank context items by relevance to query
+     * Hook: suggest-context
+     */
+    rankContext(context: string[], query: string): Promise<Array<{
+        index: number;
+        content: string;
+        relevance: number;
+    }>>;
+    /**
+     * Deduplicate similar items
+     * Hook: remember, suggest-context
+     */
+    deduplicate(items: string[], threshold?: number): Promise<string[]>;
+    /**
+     * Get blame information for files in parallel
+     * Hook: pre-edit (for context), coedit
+     */
+    gitBlame(files: string[]): Promise<GitBlame[]>;
+    /**
+     * Analyze code churn for files
+     * Hook: session-start, route
+     */
+    gitChurn(files: string[], since?: string): Promise<CodeChurn[]>;
+    getStats(): {
+        enabled: boolean;
+        workers: number;
+        busy: number;
+        queued: number;
+        speculativeCacheSize: number;
+        astCacheSize: number;
+    };
+    clearCaches(): void;
+    shutdown(): Promise<void>;
+}
+export declare function getExtendedWorkerPool(config?: WorkerPoolConfig): ExtendedWorkerPool;
+export declare function initExtendedWorkerPool(config?: WorkerPoolConfig): Promise<ExtendedWorkerPool>;
+export default ExtendedWorkerPool;
+//# sourceMappingURL=parallel-workers.d.ts.map

package/dist/core/parallel-workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-workers.d.ts","sourceRoot":"","sources":["../../src/core/parallel-workers.ts"],"names":[],"mappings":"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"}

package/dist/core/parallel-workers.js

@@ -0,0 +1,671 @@
+"use strict";
+/**
+ * Parallel Workers - Extended worker capabilities for RuVector hooks
+ *
+ * Provides parallel processing for advanced operations:
+ *
+ * 1. SPECULATIVE PRE-COMPUTATION
+ *    - Pre-embed likely next files based on co-edit patterns
+ *    - Warm model cache before operations
+ *    - Predictive route caching
+ *
+ * 2. REAL-TIME CODE ANALYSIS
+ *    - Multi-file AST parsing with tree-sitter
+ *    - Cross-file type inference
+ *    - Live complexity metrics
+ *    - Dependency graph updates
+ *
+ * 3. ADVANCED LEARNING
+ *    - Distributed trajectory replay
+ *    - Parallel SONA micro-LoRA updates
+ *    - Background EWC consolidation
+ *    - Online pattern clustering
+ *
+ * 4. INTELLIGENT RETRIEVAL
+ *    - Parallel RAG chunking and retrieval
+ *    - Sharded similarity search
+ *    - Context relevance ranking
+ *    - Semantic deduplication
+ *
+ * 5. SECURITY & QUALITY
+ *    - Parallel SAST scanning
+ *    - Multi-rule linting
+ *    - Vulnerability detection
+ *    - Code smell analysis
+ *
+ * 6. GIT INTELLIGENCE
+ *    - Parallel blame analysis
+ *    - Branch comparison
+ *    - Merge conflict prediction
+ *    - Code churn metrics
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendedWorkerPool = void 0;
+exports.getExtendedWorkerPool = getExtendedWorkerPool;
+exports.initExtendedWorkerPool = initExtendedWorkerPool;
+const worker_threads_1 = require("worker_threads");
+const os = __importStar(require("os"));
+// ============================================================================
+// Extended Worker Pool
+// ============================================================================
+class ExtendedWorkerPool {
+    constructor(config = {}) {
+        this.workers = [];
+        this.taskQueue = [];
+        this.busyWorkers = new Map();
+        this.initialized = false;
+        this.speculativeCache = new Map();
+        this.astCache = new Map();
+        const isCLI = process.env.RUVECTOR_CLI === '1';
+        const isMCP = process.env.MCP_SERVER === '1';
+        this.config = {
+            numWorkers: config.numWorkers ?? Math.max(1, os.cpus().length - 1),
+            enabled: config.enabled ?? (isMCP || process.env.RUVECTOR_PARALLEL === '1'),
+            taskTimeout: config.taskTimeout ?? 30000,
+            maxQueueSize: config.maxQueueSize ?? 1000,
+        };
+    }
+    async init() {
+        if (this.initialized || !this.config.enabled)
+            return;
+        const workerCode = this.getWorkerCode();
+        const workerBlob = new Blob([workerCode], { type: 'application/javascript' });
+        for (let i = 0; i < this.config.numWorkers; i++) {
+            // Create worker from inline code
+            const worker = new worker_threads_1.Worker(`
+        const { parentPort, workerData } = require('worker_threads');
+        ${this.getWorkerHandlers()}
+        `, { eval: true, workerData: { workerId: i } });
+            worker.on('message', (result) => {
+                this.handleWorkerResult(worker, result);
+            });
+            worker.on('error', (err) => {
+                console.error(`Worker ${i} error:`, err);
+                this.busyWorkers.delete(worker);
+                this.processQueue();
+            });
+            this.workers.push(worker);
+        }
+        this.initialized = true;
+    }
+    getWorkerCode() {
+        return `
+      const { parentPort, workerData } = require('worker_threads');
+      ${this.getWorkerHandlers()}
+    `;
+    }
+    getWorkerHandlers() {
+        return `
+      parentPort.on('message', async (task) => {
+        try {
+          let result;
+          switch (task.type) {
+            case 'speculative-embed':
+              result = await speculativeEmbed(task.files, task.coEditGraph);
+              break;
+            case 'ast-analyze':
+              result = await astAnalyze(task.files);
+              break;
+            case 'security-scan':
+              result = await securityScan(task.files, task.rules);
+              break;
+            case 'rag-retrieve':
+              result = await ragRetrieve(task.query, task.chunks, task.topK);
+              break;
+            case 'context-rank':
+              result = await contextRank(task.context, task.query);
+              break;
+            case 'git-blame':
+              result = await gitBlame(task.files);
+              break;
+            case 'git-churn':
+              result = await gitChurn(task.files, task.since);
+              break;
+            case 'complexity-analyze':
+              result = await complexityAnalyze(task.files);
+              break;
+            case 'dependency-graph':
+              result = await dependencyGraph(task.entryPoints);
+              break;
+            case 'deduplicate':
+              result = await deduplicate(task.items, task.threshold);
+              break;
+            default:
+              throw new Error('Unknown task type: ' + task.type);
+          }
+          parentPort.postMessage({ success: true, data: result, taskId: task.taskId });
+        } catch (error) {
+          parentPort.postMessage({ success: false, error: error.message, taskId: task.taskId });
+        }
+      });
+
+      // Worker implementations
+      async function speculativeEmbed(files, coEditGraph) {
+        // Pre-compute embeddings for likely next files
+        return files.map(f => ({ file: f, embedding: [], confidence: 0.5 }));
+      }
+
+      async function astAnalyze(files) {
+        const fs = require('fs');
+        return files.map(file => {
+          try {
+            const content = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+            const lines = content.split('\\n');
+            return {
+              file,
+              language: file.split('.').pop() || 'unknown',
+              complexity: Math.min(lines.length / 10, 100),
+              functions: extractFunctions(content),
+              imports: extractImports(content),
+              exports: extractExports(content),
+              dependencies: [],
+            };
+          } catch {
+            return { file, language: 'unknown', complexity: 0, functions: [], imports: [], exports: [], dependencies: [] };
+          }
+        });
+      }
+
+      function extractFunctions(content) {
+        const patterns = [
+          /function\\s+(\\w+)/g,
+          /const\\s+(\\w+)\\s*=\\s*(?:async\\s*)?\\([^)]*\\)\\s*=>/g,
+          /(?:async\\s+)?(?:public|private|protected)?\\s*(\\w+)\\s*\\([^)]*\\)\\s*{/g,
+        ];
+        const funcs = new Set();
+        for (const pattern of patterns) {
+          let match;
+          while ((match = pattern.exec(content)) !== null) {
+            if (match[1] && !['if', 'for', 'while', 'switch', 'catch'].includes(match[1])) {
+              funcs.add(match[1]);
+            }
+          }
+        }
+        return Array.from(funcs);
+      }
+
+      function extractImports(content) {
+        const imports = [];
+        const patterns = [
+          /import\\s+.*?from\\s+['"]([^'"]+)['"]/g,
+          /require\\s*\\(['"]([^'"]+)['"]\\)/g,
+        ];
+        for (const pattern of patterns) {
+          let match;
+          while ((match = pattern.exec(content)) !== null) {
+            imports.push(match[1]);
+          }
+        }
+        return imports;
+      }
+
+      function extractExports(content) {
+        const exports = [];
+        const patterns = [
+          /export\\s+(?:default\\s+)?(?:class|function|const|let|var)\\s+(\\w+)/g,
+          /module\\.exports\\s*=\\s*(\\w+)/g,
+        ];
+        for (const pattern of patterns) {
+          let match;
+          while ((match = pattern.exec(content)) !== null) {
+            exports.push(match[1]);
+          }
+        }
+        return exports;
+      }
+
+      async function securityScan(files, rules) {
+        const fs = require('fs');
+        const findings = [];
+        const securityPatterns = [
+          { pattern: /eval\\s*\\(/g, rule: 'no-eval', severity: 'high', message: 'Avoid eval()' },
+          { pattern: /innerHTML\\s*=/g, rule: 'no-inner-html', severity: 'medium', message: 'Avoid innerHTML, use textContent' },
+          { pattern: /password\\s*=\\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-secrets', severity: 'critical', message: 'Hardcoded password detected' },
+          { pattern: /api[_-]?key\\s*=\\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-secrets', severity: 'critical', message: 'Hardcoded API key detected' },
+          { pattern: /exec\\s*\\(/g, rule: 'no-exec', severity: 'high', message: 'Avoid exec(), use execFile or spawn' },
+          { pattern: /\\$\\{.*\\}/g, rule: 'template-injection', severity: 'medium', message: 'Potential template injection' },
+        ];
+
+        for (const file of files) {
+          try {
+            if (!fs.existsSync(file)) continue;
+            const content = fs.readFileSync(file, 'utf8');
+            const lines = content.split('\\n');
+
+            for (const { pattern, rule, severity, message } of securityPatterns) {
+              let match;
+              const regex = new RegExp(pattern.source, pattern.flags);
+              while ((match = regex.exec(content)) !== null) {
+                const lineNum = content.substring(0, match.index).split('\\n').length;
+                findings.push({ file, line: lineNum, severity, rule, message });
+              }
+            }
+          } catch {}
+        }
+        return findings;
+      }
+
+      async function ragRetrieve(query, chunks, topK) {
+        // Simple keyword-based retrieval (would use embeddings in production)
+        const queryTerms = query.toLowerCase().split(/\\s+/);
+        return chunks
+          .map(chunk => {
+            const content = chunk.content.toLowerCase();
+            const matches = queryTerms.filter(term => content.includes(term)).length;
+            return { ...chunk, relevance: matches / queryTerms.length };
+          })
+          .sort((a, b) => b.relevance - a.relevance)
+          .slice(0, topK);
+      }
+
+      async function contextRank(context, query) {
+        const queryTerms = query.toLowerCase().split(/\\s+/);
+        return context
+          .map((ctx, i) => {
+            const content = ctx.toLowerCase();
+            const matches = queryTerms.filter(term => content.includes(term)).length;
+            return { index: i, content: ctx, relevance: matches / queryTerms.length };
+          })
+          .sort((a, b) => b.relevance - a.relevance);
+      }
+
+      async function gitBlame(files) {
+        const { execSync } = require('child_process');
+        const results = [];
+        for (const file of files) {
+          try {
+            const output = execSync(\`git blame --line-porcelain "\${file}" 2>/dev/null\`, { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
+            const lines = [];
+            let currentLine = {};
+            for (const line of output.split('\\n')) {
+              if (line.startsWith('author ')) currentLine.author = line.slice(7);
+              else if (line.startsWith('author-time ')) currentLine.date = new Date(parseInt(line.slice(12)) * 1000).toISOString();
+              else if (line.match(/^[a-f0-9]{40}/)) currentLine.commit = line.slice(0, 40);
+              else if (line.startsWith('\\t')) {
+                lines.push({ ...currentLine, line: lines.length + 1 });
+                currentLine = {};
+              }
+            }
+            results.push({ file, lines });
+          } catch {
+            results.push({ file, lines: [] });
+          }
+        }
+        return results;
+      }
+
+      async function gitChurn(files, since) {
+        const { execSync } = require('child_process');
+        const results = [];
+        const sinceArg = since ? \`--since="\${since}"\` : '--since="30 days ago"';
+
+        for (const file of files) {
+          try {
+            const log = execSync(\`git log \${sinceArg} --format="%H|%an|%aI" --numstat -- "\${file}" 2>/dev/null\`, { encoding: 'utf8' });
+            let additions = 0, deletions = 0, commits = 0;
+            const authors = new Set();
+            let lastModified = '';
+
+            for (const line of log.split('\\n')) {
+              if (line.includes('|')) {
+                const [commit, author, date] = line.split('|');
+                authors.add(author);
+                commits++;
+                if (!lastModified) lastModified = date;
+              } else if (line.match(/^\\d+\\s+\\d+/)) {
+                const [add, del] = line.split('\\t');
+                additions += parseInt(add) || 0;
+                deletions += parseInt(del) || 0;
+              }
+            }
+
+            results.push({ file, additions, deletions, commits, authors: Array.from(authors), lastModified });
+          } catch {
+            results.push({ file, additions: 0, deletions: 0, commits: 0, authors: [], lastModified: '' });
+          }
+        }
+        return results;
+      }
+
+      async function complexityAnalyze(files) {
+        const fs = require('fs');
+        return files.map(file => {
+          try {
+            const content = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+            const lines = content.split('\\n');
+            const nonEmpty = lines.filter(l => l.trim()).length;
+            const branches = (content.match(/\\b(if|else|switch|case|for|while|catch|\\?|&&|\\|\\|)\\b/g) || []).length;
+            const functions = (content.match(/function|=>|\\bdef\\b|\\bfn\\b/g) || []).length;
+
+            return {
+              file,
+              lines: lines.length,
+              nonEmptyLines: nonEmpty,
+              cyclomaticComplexity: branches + 1,
+              functions,
+              avgFunctionSize: functions > 0 ? Math.round(nonEmpty / functions) : nonEmpty,
+            };
+          } catch {
+            return { file, lines: 0, nonEmptyLines: 0, cyclomaticComplexity: 1, functions: 0, avgFunctionSize: 0 };
+          }
+        });
+      }
+
+      async function dependencyGraph(entryPoints) {
+        const fs = require('fs');
+        const path = require('path');
+        const graph = new Map();
+
+        function analyze(file, visited = new Set()) {
+          if (visited.has(file)) return;
+          visited.add(file);
+
+          try {
+            if (!fs.existsSync(file)) return;
+            const content = fs.readFileSync(file, 'utf8');
+            const deps = [];
+
+            // Extract imports
+            const importRegex = /(?:import|require)\\s*\\(?['"]([^'"]+)['"]/g;
+            let match;
+            while ((match = importRegex.exec(content)) !== null) {
+              const dep = match[1];
+              if (dep.startsWith('.')) {
+                const resolved = path.resolve(path.dirname(file), dep);
+                deps.push(resolved);
+                analyze(resolved, visited);
+              } else {
+                deps.push(dep);
+              }
+            }
+
+            graph.set(file, deps);
+          } catch {}
+        }
+
+        for (const entry of entryPoints) {
+          analyze(entry);
+        }
+
+        return Object.fromEntries(graph);
+      }
+
+      async function deduplicate(items, threshold) {
+        // Simple Jaccard similarity deduplication
+        const unique = [];
+        const seen = new Set();
+
+        for (const item of items) {
+          const tokens = new Set(item.toLowerCase().split(/\\s+/));
+          let isDup = false;
+
+          for (const existing of unique) {
+            const existingTokens = new Set(existing.toLowerCase().split(/\\s+/));
+            const intersection = [...tokens].filter(t => existingTokens.has(t)).length;
+            const union = new Set([...tokens, ...existingTokens]).size;
+            const similarity = intersection / union;
+
+            if (similarity >= threshold) {
+              isDup = true;
+              break;
+            }
+          }
+
+          if (!isDup) unique.push(item);
+        }
+
+        return unique;
+      }
+    `;
+    }
+    handleWorkerResult(worker, result) {
+        this.busyWorkers.delete(worker);
+        // Find and resolve the corresponding task
+        const taskIndex = this.taskQueue.findIndex(t => t.task.taskId === result.taskId);
+        if (taskIndex >= 0) {
+            const task = this.taskQueue.splice(taskIndex, 1)[0];
+            clearTimeout(task.timeout);
+            if (result.success) {
+                task.resolve(result.data);
+            }
+            else {
+                task.reject(new Error(result.error));
+            }
+        }
+        this.processQueue();
+    }
+    processQueue() {
+        while (this.taskQueue.length > 0) {
+            const availableWorker = this.workers.find(w => !this.busyWorkers.has(w));
+            if (!availableWorker)
+                break;
+            const task = this.taskQueue[0];
+            this.busyWorkers.set(availableWorker, task.task.type);
+            availableWorker.postMessage(task.task);
+        }
+    }
+    async execute(task) {
+        if (!this.initialized || !this.config.enabled) {
+            throw new Error('Worker pool not initialized');
+        }
+        const taskId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const taskWithId = { ...task, taskId };
+        return new Promise((resolve, reject) => {
+            if (this.taskQueue.length >= this.config.maxQueueSize) {
+                reject(new Error('Task queue full'));
+                return;
+            }
+            const timeout = setTimeout(() => {
+                const idx = this.taskQueue.findIndex(t => t.task.taskId === taskId);
+                if (idx >= 0) {
+                    this.taskQueue.splice(idx, 1);
+                    reject(new Error('Task timeout'));
+                }
+            }, this.config.taskTimeout);
+            const availableWorker = this.workers.find(w => !this.busyWorkers.has(w));
+            if (availableWorker) {
+                this.busyWorkers.set(availableWorker, task.type);
+                this.taskQueue.push({ task: taskWithId, resolve, reject, timeout });
+                availableWorker.postMessage(taskWithId);
+            }
+            else {
+                this.taskQueue.push({ task: taskWithId, resolve, reject, timeout });
+            }
+        });
+    }
+    // =========================================================================
+    // Public API - Speculative Pre-computation
+    // =========================================================================
+    /**
+     * Pre-embed files likely to be edited next based on co-edit patterns
+     * Hook: session-start, post-edit
+     */
+    async speculativeEmbed(currentFile, coEditGraph) {
+        const likelyFiles = coEditGraph.get(currentFile) || [];
+        if (likelyFiles.length === 0)
+            return [];
+        // Check cache first
+        const uncached = likelyFiles.filter(f => !this.speculativeCache.has(f));
+        if (uncached.length === 0) {
+            return likelyFiles.map(f => this.speculativeCache.get(f));
+        }
+        const results = await this.execute({
+            type: 'speculative-embed',
+            files: uncached,
+            coEditGraph,
+        });
+        // Update cache
+        for (const result of results) {
+            this.speculativeCache.set(result.file, result);
+        }
+        return likelyFiles.map(f => this.speculativeCache.get(f)).filter(Boolean);
+    }
+    // =========================================================================
+    // Public API - Code Analysis
+    // =========================================================================
+    /**
+     * Analyze AST of multiple files in parallel
+     * Hook: pre-edit, route
+     */
+    async analyzeAST(files) {
+        // Check cache
+        const uncached = files.filter(f => !this.astCache.has(f));
+        if (uncached.length === 0) {
+            return files.map(f => this.astCache.get(f));
+        }
+        const results = await this.execute({
+            type: 'ast-analyze',
+            files: uncached,
+        });
+        // Update cache
+        for (const result of results) {
+            this.astCache.set(result.file, result);
+        }
+        return files.map(f => this.astCache.get(f)).filter(Boolean);
+    }
+    /**
+     * Analyze code complexity for multiple files
+     * Hook: post-edit, session-end
+     */
+    async analyzeComplexity(files) {
+        return this.execute({ type: 'complexity-analyze', files });
+    }
+    /**
+     * Build dependency graph from entry points
+     * Hook: session-start
+     */
+    async buildDependencyGraph(entryPoints) {
+        return this.execute({ type: 'dependency-graph', entryPoints });
+    }
+    // =========================================================================
+    // Public API - Security
+    // =========================================================================
+    /**
+     * Scan files for security vulnerabilities
+     * Hook: pre-command (before commit), post-edit
+     */
+    async securityScan(files, rules) {
+        return this.execute({ type: 'security-scan', files, rules });
+    }
+    // =========================================================================
+    // Public API - RAG & Context
+    // =========================================================================
+    /**
+     * Retrieve relevant context chunks in parallel
+     * Hook: suggest-context, recall
+     */
+    async ragRetrieve(query, chunks, topK = 5) {
+        return this.execute({ type: 'rag-retrieve', query, chunks, topK });
+    }
+    /**
+     * Rank context items by relevance to query
+     * Hook: suggest-context
+     */
+    async rankContext(context, query) {
+        return this.execute({ type: 'context-rank', context, query });
+    }
+    /**
+     * Deduplicate similar items
+     * Hook: remember, suggest-context
+     */
+    async deduplicate(items, threshold = 0.8) {
+        return this.execute({ type: 'deduplicate', items, threshold });
+    }
+    // =========================================================================
+    // Public API - Git Intelligence
+    // =========================================================================
+    /**
+     * Get blame information for files in parallel
+     * Hook: pre-edit (for context), coedit
+     */
+    async gitBlame(files) {
+        return this.execute({ type: 'git-blame', files });
+    }
+    /**
+     * Analyze code churn for files
+     * Hook: session-start, route
+     */
+    async gitChurn(files, since) {
+        return this.execute({ type: 'git-churn', files, since });
+    }
+    // =========================================================================
+    // Stats & Lifecycle
+    // =========================================================================
+    getStats() {
+        return {
+            enabled: this.config.enabled,
+            workers: this.workers.length,
+            busy: this.busyWorkers.size,
+            queued: this.taskQueue.length,
+            speculativeCacheSize: this.speculativeCache.size,
+            astCacheSize: this.astCache.size,
+        };
+    }
+    clearCaches() {
+        this.speculativeCache.clear();
+        this.astCache.clear();
+    }
+    async shutdown() {
+        // Clear pending tasks
+        for (const task of this.taskQueue) {
+            clearTimeout(task.timeout);
+            task.reject(new Error('Worker pool shutting down'));
+        }
+        this.taskQueue = [];
+        // Terminate workers
+        await Promise.all(this.workers.map(w => w.terminate()));
+        this.workers = [];
+        this.busyWorkers.clear();
+        this.initialized = false;
+    }
+}
+exports.ExtendedWorkerPool = ExtendedWorkerPool;
+// ============================================================================
+// Singleton
+// ============================================================================
+let instance = null;
+function getExtendedWorkerPool(config) {
+    if (!instance) {
+        instance = new ExtendedWorkerPool(config);
+    }
+    return instance;
+}
+async function initExtendedWorkerPool(config) {
+    const pool = getExtendedWorkerPool(config);
+    await pool.init();
+    return pool;
+}
+exports.default = ExtendedWorkerPool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.1.62",
+  "version": "0.1.63",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",