ruvector 0.2.23 → 0.2.25

package/dist/core/diff-embeddings.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Diff Embeddings - Semantic encoding of git diffs
+ *
+ * Generates embeddings for code changes to enable:
+ * - Change classification (feature, bugfix, refactor)
+ * - Similar change detection
+ * - Risk assessment
+ * - Review prioritization
+ */
+export interface DiffHunk {
+    file: string;
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    content: string;
+    additions: string[];
+    deletions: string[];
+}
+export interface DiffAnalysis {
+    file: string;
+    hunks: DiffHunk[];
+    totalAdditions: number;
+    totalDeletions: number;
+    complexity: number;
+    riskScore: number;
+    category: 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'config' | 'unknown';
+    embedding?: number[];
+}
+export interface CommitAnalysis {
+    hash: string;
+    message: string;
+    author: string;
+    date: string;
+    files: DiffAnalysis[];
+    totalAdditions: number;
+    totalDeletions: number;
+    riskScore: number;
+    embedding?: number[];
+}
+/**
+ * Parse a unified diff into hunks
+ */
+export declare function parseDiff(diff: string): DiffHunk[];
+/**
+ * Classify a change based on patterns
+ */
+export declare function classifyChange(diff: string, message?: string): 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'config' | 'unknown';
+/**
+ * Calculate risk score for a diff
+ */
+export declare function calculateRiskScore(analysis: DiffAnalysis): number;
+/**
+ * Analyze a single file diff
+ */
+export declare function analyzeFileDiff(file: string, diff: string, message?: string): Promise<DiffAnalysis>;
+/**
+ * Get diff for a commit
+ */
+export declare function getCommitDiff(commitHash?: string): string;
+/**
+ * Get diff for staged changes
+ */
+export declare function getStagedDiff(): string;
+/**
+ * Get diff for unstaged changes
+ */
+export declare function getUnstagedDiff(): string;
+/**
+ * Analyze a commit
+ */
+export declare function analyzeCommit(commitHash?: string): Promise<CommitAnalysis>;
+/**
+ * Find similar past commits based on diff embeddings
+ */
+export declare function findSimilarCommits(currentDiff: string, recentCommits?: number, topK?: number): Promise<Array<{
+    hash: string;
+    similarity: number;
+    message: string;
+}>>;
+declare const _default: {
+    parseDiff: typeof parseDiff;
+    classifyChange: typeof classifyChange;
+    calculateRiskScore: typeof calculateRiskScore;
+    analyzeFileDiff: typeof analyzeFileDiff;
+    analyzeCommit: typeof analyzeCommit;
+    getCommitDiff: typeof getCommitDiff;
+    getStagedDiff: typeof getStagedDiff;
+    getUnstagedDiff: typeof getUnstagedDiff;
+    findSimilarCommits: typeof findSimilarCommits;
+};
+export default _default;
+//# sourceMappingURL=diff-embeddings.d.ts.map

package/dist/core/diff-embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-embeddings.d.ts","sourceRoot":"","sources":["../../src/core/diff-embeddings.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACrF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAsDlD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAsB7I;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CA2BjE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAsC7G;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,GAAE,MAAe,GAAG,MAAM,CASjE;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAStC;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CASxC;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,UAAU,GAAE,MAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAwDxF;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,EACnB,aAAa,GAAE,MAAW,EAC1B,IAAI,GAAE,MAAU,GACf,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAgCvE;;;;;;;;;;;;AAmBD,wBAUE"}

package/dist/core/diff-embeddings.js

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * Diff Embeddings - Semantic encoding of git diffs
+ *
+ * Generates embeddings for code changes to enable:
+ * - Change classification (feature, bugfix, refactor)
+ * - Similar change detection
+ * - Risk assessment
+ * - Review prioritization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDiff = parseDiff;
+exports.classifyChange = classifyChange;
+exports.calculateRiskScore = calculateRiskScore;
+exports.analyzeFileDiff = analyzeFileDiff;
+exports.getCommitDiff = getCommitDiff;
+exports.getStagedDiff = getStagedDiff;
+exports.getUnstagedDiff = getUnstagedDiff;
+exports.analyzeCommit = analyzeCommit;
+exports.findSimilarCommits = findSimilarCommits;
+const child_process_1 = require("child_process");
+const onnx_embedder_1 = require("./onnx-embedder");
+/**
+ * Parse a unified diff into hunks
+ */
+function parseDiff(diff) {
+    const hunks = [];
+    const lines = diff.split('\n');
+    let currentFile = '';
+    let currentHunk = null;
+    for (const line of lines) {
+        // File header
+        if (line.startsWith('diff --git')) {
+            const match = line.match(/diff --git a\/(.+) b\/(.+)/);
+            if (match) {
+                currentFile = match[2];
+            }
+        }
+        // Hunk header
+        if (line.startsWith('@@')) {
+            if (currentHunk) {
+                hunks.push(currentHunk);
+            }
+            const match = line.match(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@/);
+            if (match) {
+                currentHunk = {
+                    file: currentFile,
+                    oldStart: parseInt(match[1]),
+                    oldLines: parseInt(match[2] || '1'),
+                    newStart: parseInt(match[3]),
+                    newLines: parseInt(match[4] || '1'),
+                    content: '',
+                    additions: [],
+                    deletions: [],
+                };
+            }
+        }
+        else if (currentHunk) {
+            // Content lines
+            if (line.startsWith('+') && !line.startsWith('+++')) {
+                currentHunk.additions.push(line.substring(1));
+                currentHunk.content += line + '\n';
+            }
+            else if (line.startsWith('-') && !line.startsWith('---')) {
+                currentHunk.deletions.push(line.substring(1));
+                currentHunk.content += line + '\n';
+            }
+            else if (line.startsWith(' ')) {
+                currentHunk.content += line + '\n';
+            }
+        }
+    }
+    if (currentHunk) {
+        hunks.push(currentHunk);
+    }
+    return hunks;
+}
+/**
+ * Classify a change based on patterns
+ */
+function classifyChange(diff, message = '') {
+    const lowerMessage = message.toLowerCase();
+    const lowerDiff = diff.toLowerCase();
+    // Check message patterns
+    if (/\b(fix|bug|issue|error|crash|patch)\b/.test(lowerMessage))
+        return 'bugfix';
+    if (/\b(feat|feature|add|new|implement)\b/.test(lowerMessage))
+        return 'feature';
+    if (/\b(refactor|clean|improve|optimize)\b/.test(lowerMessage))
+        return 'refactor';
+    if (/\b(doc|readme|comment|jsdoc)\b/.test(lowerMessage))
+        return 'docs';
+    if (/\b(test|spec|coverage)\b/.test(lowerMessage))
+        return 'test';
+    if (/\b(config|ci|cd|build|deps)\b/.test(lowerMessage))
+        return 'config';
+    // Check diff patterns
+    if (/\.(md|txt|rst)$/.test(diff))
+        return 'docs';
+    if (/\.(test|spec)\.[jt]sx?/.test(diff))
+        return 'test';
+    if (/\.(json|ya?ml|toml|ini)$/.test(diff))
+        return 'config';
+    // Check content patterns
+    if (/\bcatch\b|\btry\b|\berror\b/.test(lowerDiff) && /\bfix\b/.test(lowerDiff))
+        return 'bugfix';
+    if (/\bfunction\b|\bclass\b|\bexport\b/.test(lowerDiff))
+        return 'feature';
+    return 'unknown';
+}
+/**
+ * Calculate risk score for a diff
+ */
+function calculateRiskScore(analysis) {
+    let risk = 0;
+    // Size risk
+    const totalChanges = analysis.totalAdditions + analysis.totalDeletions;
+    if (totalChanges > 500)
+        risk += 0.3;
+    else if (totalChanges > 200)
+        risk += 0.2;
+    else if (totalChanges > 50)
+        risk += 0.1;
+    // Complexity risk
+    if (analysis.complexity > 20)
+        risk += 0.2;
+    else if (analysis.complexity > 10)
+        risk += 0.1;
+    // File type risk
+    if (analysis.file.includes('auth') || analysis.file.includes('security'))
+        risk += 0.2;
+    if (analysis.file.includes('database') || analysis.file.includes('migration'))
+        risk += 0.15;
+    if (analysis.file.includes('api') || analysis.file.includes('endpoint'))
+        risk += 0.1;
+    // Pattern risk (deletions of error handling, etc.)
+    for (const hunk of analysis.hunks) {
+        for (const del of hunk.deletions) {
+            if (/\bcatch\b|\berror\b|\bvalidat/.test(del))
+                risk += 0.1;
+            if (/\bif\b.*\bnull\b|\bundefined\b/.test(del))
+                risk += 0.05;
+        }
+    }
+    return Math.min(1, risk);
+}
+/**
+ * Analyze a single file diff
+ */
+async function analyzeFileDiff(file, diff, message = '') {
+    const hunks = parseDiff(diff).filter(h => h.file === file || h.file === '');
+    const totalAdditions = hunks.reduce((sum, h) => sum + h.additions.length, 0);
+    const totalDeletions = hunks.reduce((sum, h) => sum + h.deletions.length, 0);
+    // Calculate complexity (branch keywords in additions)
+    let complexity = 0;
+    for (const hunk of hunks) {
+        for (const add of hunk.additions) {
+            if (/\bif\b|\belse\b|\bfor\b|\bwhile\b|\bswitch\b|\bcatch\b|\?/.test(add)) {
+                complexity++;
+            }
+        }
+    }
+    const category = classifyChange(diff, message);
+    const analysis = {
+        file,
+        hunks,
+        totalAdditions,
+        totalDeletions,
+        complexity,
+        riskScore: 0,
+        category,
+    };
+    analysis.riskScore = calculateRiskScore(analysis);
+    // Generate embedding for the diff
+    if ((0, onnx_embedder_1.isReady)()) {
+        const diffText = hunks.map(h => h.content).join('\n');
+        const result = await (0, onnx_embedder_1.embed)(`${category} change in ${file}: ${diffText.substring(0, 500)}`);
+        analysis.embedding = result.embedding;
+    }
+    return analysis;
+}
+/**
+ * Get diff for a commit
+ */
+function getCommitDiff(commitHash = 'HEAD') {
+    try {
+        return (0, child_process_1.execSync)(`git show ${commitHash} --format="" 2>/dev/null`, {
+            encoding: 'utf8',
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Get diff for staged changes
+ */
+function getStagedDiff() {
+    try {
+        return (0, child_process_1.execSync)('git diff --cached 2>/dev/null', {
+            encoding: 'utf8',
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Get diff for unstaged changes
+ */
+function getUnstagedDiff() {
+    try {
+        return (0, child_process_1.execSync)('git diff 2>/dev/null', {
+            encoding: 'utf8',
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Analyze a commit
+ */
+async function analyzeCommit(commitHash = 'HEAD') {
+    const diff = getCommitDiff(commitHash);
+    // Get commit metadata
+    let message = '', author = '', date = '';
+    try {
+        const info = (0, child_process_1.execSync)(`git log -1 --format="%s|%an|%aI" ${commitHash} 2>/dev/null`, {
+            encoding: 'utf8',
+        }).trim();
+        [message, author, date] = info.split('|');
+    }
+    catch { }
+    // Parse hunks and group by file
+    const hunks = parseDiff(diff);
+    const fileHunks = new Map();
+    for (const hunk of hunks) {
+        if (!fileHunks.has(hunk.file)) {
+            fileHunks.set(hunk.file, []);
+        }
+        fileHunks.get(hunk.file).push(hunk);
+    }
+    // Analyze each file
+    const files = [];
+    for (const [file, fileHunkList] of fileHunks) {
+        const fileDiff = fileHunkList.map(h => h.content).join('\n');
+        const analysis = await analyzeFileDiff(file, diff, message);
+        files.push(analysis);
+    }
+    const totalAdditions = files.reduce((sum, f) => sum + f.totalAdditions, 0);
+    const totalDeletions = files.reduce((sum, f) => sum + f.totalDeletions, 0);
+    const riskScore = files.length > 0
+        ? files.reduce((sum, f) => sum + f.riskScore, 0) / files.length
+        : 0;
+    // Generate commit embedding
+    let embedding;
+    if ((0, onnx_embedder_1.isReady)()) {
+        const commitText = `${message}\n\nFiles changed: ${files.map(f => f.file).join(', ')}\n+${totalAdditions} -${totalDeletions}`;
+        const result = await (0, onnx_embedder_1.embed)(commitText);
+        embedding = result.embedding;
+    }
+    return {
+        hash: commitHash,
+        message,
+        author,
+        date,
+        files,
+        totalAdditions,
+        totalDeletions,
+        riskScore,
+        embedding,
+    };
+}
+/**
+ * Find similar past commits based on diff embeddings
+ */
+async function findSimilarCommits(currentDiff, recentCommits = 50, topK = 5) {
+    if (!(0, onnx_embedder_1.isReady)()) {
+        await (0, onnx_embedder_1.initOnnxEmbedder)();
+    }
+    // Get current diff embedding
+    const currentEmbedding = (await (0, onnx_embedder_1.embed)(currentDiff.substring(0, 1000))).embedding;
+    // Get recent commits
+    let commits = [];
+    try {
+        commits = (0, child_process_1.execSync)(`git log -${recentCommits} --format="%H" 2>/dev/null`, {
+            encoding: 'utf8',
+        }).trim().split('\n');
+    }
+    catch {
+        return [];
+    }
+    // Analyze and compare
+    const results = [];
+    for (const hash of commits.slice(0, Math.min(commits.length, recentCommits))) {
+        const analysis = await analyzeCommit(hash);
+        if (analysis.embedding) {
+            const similarity = cosineSimilarity(currentEmbedding, analysis.embedding);
+            results.push({ hash, similarity, message: analysis.message });
+        }
+    }
+    return results
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, topK);
+}
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dotProduct / magnitude;
+}
+exports.default = {
+    parseDiff,
+    classifyChange,
+    calculateRiskScore,
+    analyzeFileDiff,
+    analyzeCommit,
+    getCommitDiff,
+    getStagedDiff,
+    getUnstagedDiff,
+    findSimilarCommits,
+};

package/dist/core/diskann-wrapper.d.ts

@@ -0,0 +1,53 @@
+/**
+ * DiskANN Wrapper — Vamana graph ANN for billion-scale vector search
+ *
+ * Wraps @ruvector/diskann for SSD-friendly approximate nearest neighbor search.
+ * Provides the same lazy-load pattern as other native wrappers.
+ */
+export declare function isDiskAnnAvailable(): boolean;
+export interface DiskAnnConfig {
+    dim: number;
+    maxDegree?: number;
+    buildBeam?: number;
+    searchBeam?: number;
+    alpha?: number;
+    pqSubspaces?: number;
+    pqIterations?: number;
+    storagePath?: string;
+}
+export interface DiskAnnSearchResult {
+    id: string;
+    distance: number;
+}
+/**
+ * DiskANN index for large-scale approximate nearest neighbor search.
+ *
+ * Uses the Vamana graph algorithm with optional Product Quantization.
+ * Build after all inserts, then search.
+ */
+export declare class DiskAnnIndex {
+    private inner;
+    constructor(config: DiskAnnConfig);
+    /** Insert a vector with a string ID */
+    insert(id: string, vector: Float32Array | number[]): void;
+    /** Insert a batch of vectors (flat Float32Array: N * dim) */
+    insertBatch(ids: string[], vectors: Float32Array, dim: number): void;
+    /** Build the Vamana graph index (required before search) */
+    build(): void;
+    /** Build index asynchronously */
+    buildAsync(): Promise<void>;
+    /** Search for k nearest neighbors */
+    search(query: Float32Array | number[], k?: number): DiskAnnSearchResult[];
+    /** Search asynchronously */
+    searchAsync(query: Float32Array | number[], k?: number): Promise<DiskAnnSearchResult[]>;
+    /** Delete a vector by ID */
+    delete(id: string): boolean;
+    /** Get the number of vectors */
+    count(): number;
+    /** Save index to directory */
+    save(dir: string): void;
+    /** Load index from directory */
+    static load(dir: string): DiskAnnIndex;
+}
+export default DiskAnnIndex;
+//# sourceMappingURL=diskann-wrapper.d.ts.map

package/dist/core/diskann-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diskann-wrapper.d.ts","sourceRoot":"","sources":["../../src/core/diskann-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAqBH,wBAAgB,kBAAkB,IAAI,OAAO,CAO5C;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAM;gBAEP,MAAM,EAAE,aAAa;IAcjC,uCAAuC;IACvC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,EAAE,GAAG,IAAI;IAKzD,6DAA6D;IAC7D,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAIpE,4DAA4D;IAC5D,KAAK,IAAI,IAAI;IAIb,iCAAiC;IAC3B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,qCAAqC;IACrC,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,EAAE,EAAE,CAAC,GAAE,MAAW,GAAG,mBAAmB,EAAE;IAK7E,4BAA4B;IACtB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,EAAE,EAAE,CAAC,GAAE,MAAW,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAKjG,4BAA4B;IAC5B,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI3B,gCAAgC;IAChC,KAAK,IAAI,MAAM;IAIf,8BAA8B;IAC9B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIvB,gCAAgC;IAChC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;CAMvC;AAED,eAAe,YAAY,CAAC"}

package/dist/core/diskann-wrapper.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * DiskANN Wrapper — Vamana graph ANN for billion-scale vector search
+ *
+ * Wraps @ruvector/diskann for SSD-friendly approximate nearest neighbor search.
+ * Provides the same lazy-load pattern as other native wrappers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskAnnIndex = void 0;
+exports.isDiskAnnAvailable = isDiskAnnAvailable;
+let diskannModule = null;
+let loadError = null;
+function getDiskAnnModule() {
+    if (diskannModule)
+        return diskannModule;
+    if (loadError)
+        throw loadError;
+    try {
+        diskannModule = require('@ruvector/diskann');
+        return diskannModule;
+    }
+    catch (e) {
+        loadError = new Error(`@ruvector/diskann not installed: ${e.message}\n` +
+            `Install with: npm install @ruvector/diskann`);
+        throw loadError;
+    }
+}
+function isDiskAnnAvailable() {
+    try {
+        getDiskAnnModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * DiskANN index for large-scale approximate nearest neighbor search.
+ *
+ * Uses the Vamana graph algorithm with optional Product Quantization.
+ * Build after all inserts, then search.
+ */
+class DiskAnnIndex {
+    constructor(config) {
+        const mod = getDiskAnnModule();
+        this.inner = new mod.DiskAnn({
+            dim: config.dim,
+            maxDegree: config.maxDegree ?? 64,
+            buildBeam: config.buildBeam ?? 128,
+            searchBeam: config.searchBeam ?? 64,
+            alpha: config.alpha ?? 1.2,
+            pqSubspaces: config.pqSubspaces ?? 0,
+            pqIterations: config.pqIterations ?? 10,
+            storagePath: config.storagePath,
+        });
+    }
+    /** Insert a vector with a string ID */
+    insert(id, vector) {
+        const v = vector instanceof Float32Array ? vector : new Float32Array(vector);
+        this.inner.insert(id, v);
+    }
+    /** Insert a batch of vectors (flat Float32Array: N * dim) */
+    insertBatch(ids, vectors, dim) {
+        this.inner.insertBatch(ids, vectors, dim);
+    }
+    /** Build the Vamana graph index (required before search) */
+    build() {
+        this.inner.build();
+    }
+    /** Build index asynchronously */
+    async buildAsync() {
+        return this.inner.buildAsync();
+    }
+    /** Search for k nearest neighbors */
+    search(query, k = 10) {
+        const q = query instanceof Float32Array ? query : new Float32Array(query);
+        return this.inner.search(q, k);
+    }
+    /** Search asynchronously */
+    async searchAsync(query, k = 10) {
+        const q = query instanceof Float32Array ? query : new Float32Array(query);
+        return this.inner.searchAsync(q, k);
+    }
+    /** Delete a vector by ID */
+    delete(id) {
+        return this.inner.delete(id);
+    }
+    /** Get the number of vectors */
+    count() {
+        return this.inner.count();
+    }
+    /** Save index to directory */
+    save(dir) {
+        this.inner.save(dir);
+    }
+    /** Load index from directory */
+    static load(dir) {
+        const mod = getDiskAnnModule();
+        const instance = new DiskAnnIndex({ dim: 1 }); // placeholder
+        instance.inner = mod.DiskAnn.load(dir);
+        return instance;
+    }
+}
+exports.DiskAnnIndex = DiskAnnIndex;
+exports.default = DiskAnnIndex;