agentdb 1.0.0

package/dist/cli/index/hnsw.js

@@ -0,0 +1,558 @@
+"use strict";
+/**
+ * HNSW (Hierarchical Navigable Small World) Index Implementation
+ * High-performance approximate nearest neighbor search with O(log n) complexity
+ *
+ * Algorithm: Hierarchical graph structure with multiple layers
+ * - Layer 0: All vectors with dense connections
+ * - Higher layers: Sparse long-range connections for efficient navigation
+ *
+ * Performance targets:
+ * - Search: <10ms for 10K vectors
+ * - Build: <5s for 10K vectors
+ * - Recall: >95% accuracy
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HNSWIndex = exports.DEFAULT_HNSW_CONFIG = void 0;
+/**
+ * Default HNSW configuration optimized for most use cases
+ */
+exports.DEFAULT_HNSW_CONFIG = {
+    M: 16,
+    M0: 32,
+    efConstruction: 200,
+    efSearch: 50,
+    mL: 1 / Math.log(16),
+    minVectorsForIndex: 1000,
+    autoRebuild: false,
+    enabled: true
+};
+/**
+ * HNSW Index implementation
+ */
+var HNSWIndex = /** @class */ (function () {
+    function HNSWIndex(db, config) {
+        if (config === void 0) { config = {}; }
+        this.entryPoint = null;
+        this.maxLevel = 0;
+        this.isBuilt = false;
+        this.db = db;
+        this.config = __assign(__assign({}, exports.DEFAULT_HNSW_CONFIG), config);
+        this.initializeSchema();
+        this.prepareStatements();
+        this.loadMetadata();
+    }
+    /**
+     * Initialize HNSW schema in SQLite
+     */
+    HNSWIndex.prototype.initializeSchema = function () {
+        // Create HNSW nodes table
+        this.db.exec("\n      CREATE TABLE IF NOT EXISTS hnsw_nodes (\n        id TEXT PRIMARY KEY,\n        vector_id TEXT NOT NULL,\n        level INTEGER NOT NULL,\n        embedding BLOB NOT NULL,\n        FOREIGN KEY (vector_id) REFERENCES vectors(id) ON DELETE CASCADE\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_hnsw_nodes_vector ON hnsw_nodes(vector_id);\n      CREATE INDEX IF NOT EXISTS idx_hnsw_nodes_level ON hnsw_nodes(level);\n    ");
+        // Create HNSW edges table
+        this.db.exec("\n      CREATE TABLE IF NOT EXISTS hnsw_edges (\n        from_id TEXT NOT NULL,\n        to_id TEXT NOT NULL,\n        level INTEGER NOT NULL,\n        distance REAL NOT NULL,\n        PRIMARY KEY (from_id, to_id, level),\n        FOREIGN KEY (from_id) REFERENCES hnsw_nodes(id) ON DELETE CASCADE,\n        FOREIGN KEY (to_id) REFERENCES hnsw_nodes(id) ON DELETE CASCADE\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_hnsw_edges_from ON hnsw_edges(from_id, level);\n      CREATE INDEX IF NOT EXISTS idx_hnsw_edges_to ON hnsw_edges(to_id, level);\n      CREATE INDEX IF NOT EXISTS idx_hnsw_edges_level ON hnsw_edges(level);\n    ");
+        // Create metadata table for index state
+        this.db.exec("\n      CREATE TABLE IF NOT EXISTS hnsw_metadata (\n        key TEXT PRIMARY KEY,\n        value TEXT NOT NULL\n      );\n    ");
+    };
+    /**
+     * Prepare frequently used SQL statements
+     */
+    HNSWIndex.prototype.prepareStatements = function () {
+        this.insertNodeStmt = this.db.prepare("\n      INSERT OR REPLACE INTO hnsw_nodes (id, vector_id, level, embedding)\n      VALUES (?, ?, ?, ?)\n    ");
+        this.insertEdgeStmt = this.db.prepare("\n      INSERT OR REPLACE INTO hnsw_edges (from_id, to_id, level, distance)\n      VALUES (?, ?, ?, ?)\n    ");
+        this.getNodeStmt = this.db.prepare("\n      SELECT id, vector_id, level, embedding\n      FROM hnsw_nodes\n      WHERE id = ?\n    ");
+        this.getNeighborsStmt = this.db.prepare("\n      SELECT to_id, distance\n      FROM hnsw_edges\n      WHERE from_id = ? AND level = ?\n      ORDER BY distance ASC\n    ");
+        this.deleteNodeStmt = this.db.prepare("\n      DELETE FROM hnsw_nodes WHERE id = ?\n    ");
+        this.deleteEdgesStmt = this.db.prepare("\n      DELETE FROM hnsw_edges WHERE from_id = ? OR to_id = ?\n    ");
+    };
+    /**
+     * Load metadata from database
+     */
+    HNSWIndex.prototype.loadMetadata = function () {
+        var stmt = this.db.prepare('SELECT value FROM hnsw_metadata WHERE key = ?');
+        var entryPointRow = stmt.get('entry_point');
+        if (entryPointRow) {
+            this.entryPoint = entryPointRow.value;
+        }
+        var maxLevelRow = stmt.get('max_level');
+        if (maxLevelRow) {
+            this.maxLevel = parseInt(maxLevelRow.value, 10);
+        }
+        var isBuiltRow = stmt.get('is_built');
+        if (isBuiltRow) {
+            this.isBuilt = isBuiltRow.value === 'true';
+        }
+    };
+    /**
+     * Save metadata to database
+     */
+    HNSWIndex.prototype.saveMetadata = function () {
+        var stmt = this.db.prepare('INSERT OR REPLACE INTO hnsw_metadata (key, value) VALUES (?, ?)');
+        if (this.entryPoint) {
+            stmt.run('entry_point', this.entryPoint);
+        }
+        stmt.run('max_level', this.maxLevel.toString());
+        stmt.run('is_built', this.isBuilt.toString());
+    };
+    /**
+     * Calculate random level for new node using exponential decay
+     */
+    HNSWIndex.prototype.randomLevel = function () {
+        var level = 0;
+        while (Math.random() < this.config.mL && level < 16) {
+            level++;
+        }
+        return level;
+    };
+    /**
+     * Calculate Euclidean distance between two vectors
+     */
+    HNSWIndex.prototype.calculateDistance = function (a, b) {
+        var sum = 0;
+        for (var i = 0; i < a.length; i++) {
+            var diff = a[i] - b[i];
+            sum += diff * diff;
+        }
+        return Math.sqrt(sum);
+    };
+    /**
+     * Serialize embedding to Buffer
+     */
+    HNSWIndex.prototype.serializeEmbedding = function (embedding) {
+        var buffer = Buffer.allocUnsafe(embedding.length * 4);
+        var view = new Float32Array(buffer.buffer, buffer.byteOffset, embedding.length);
+        view.set(embedding);
+        return buffer;
+    };
+    /**
+     * Deserialize embedding from Buffer
+     */
+    HNSWIndex.prototype.deserializeEmbedding = function (buffer) {
+        var view = new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4);
+        return Array.from(view);
+    };
+    /**
+     * Get node by ID
+     */
+    HNSWIndex.prototype.getNode = function (id) {
+        var row = this.getNodeStmt.get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            vectorId: row.vector_id,
+            level: row.level,
+            embedding: this.deserializeEmbedding(row.embedding)
+        };
+    };
+    /**
+     * Get neighbors of a node at a specific level
+     */
+    HNSWIndex.prototype.getNeighbors = function (nodeId, level) {
+        var rows = this.getNeighborsStmt.all(nodeId, level);
+        return rows.map(function (row) { return ({
+            id: row.to_id,
+            distance: row.distance
+        }); });
+    };
+    /**
+     * Search for k nearest neighbors at a specific layer
+     */
+    HNSWIndex.prototype.searchLayer = function (query, entryPoints, ef, level) {
+        var visited = new Set();
+        var candidates = [];
+        var results = [];
+        // Initialize with entry points
+        for (var _i = 0, entryPoints_1 = entryPoints; _i < entryPoints_1.length; _i++) {
+            var ep = entryPoints_1[_i];
+            var node = this.getNode(ep);
+            if (!node)
+                continue;
+            var distance = this.calculateDistance(query, node.embedding);
+            candidates.push({ id: ep, distance: distance });
+            results.push({ id: ep, distance: distance });
+            visited.add(ep);
+        }
+        // Sort candidates by distance (ascending)
+        candidates.sort(function (a, b) { return a.distance - b.distance; });
+        results.sort(function (a, b) { return a.distance - b.distance; });
+        // Beam search
+        while (candidates.length > 0) {
+            var current = candidates.shift();
+            // If current is farther than worst result, stop
+            if (results.length >= ef && current.distance > results[results.length - 1].distance) {
+                break;
+            }
+            // Explore neighbors
+            var neighbors = this.getNeighbors(current.id, level);
+            for (var _a = 0, neighbors_1 = neighbors; _a < neighbors_1.length; _a++) {
+                var neighbor = neighbors_1[_a];
+                if (visited.has(neighbor.id))
+                    continue;
+                visited.add(neighbor.id);
+                var node = this.getNode(neighbor.id);
+                if (!node)
+                    continue;
+                var distance = this.calculateDistance(query, node.embedding);
+                // Add to candidates if better than worst result
+                if (results.length < ef || distance < results[results.length - 1].distance) {
+                    candidates.push({ id: neighbor.id, distance: distance });
+                    results.push({ id: neighbor.id, distance: distance });
+                    // Keep results sorted and limited to ef
+                    results.sort(function (a, b) { return a.distance - b.distance; });
+                    if (results.length > ef) {
+                        results.pop();
+                    }
+                    // Keep candidates sorted
+                    candidates.sort(function (a, b) { return a.distance - b.distance; });
+                }
+            }
+        }
+        return results;
+    };
+    /**
+     * Select neighbors using heuristic (Alg 4 from HNSW paper)
+     */
+    HNSWIndex.prototype.selectNeighborsHeuristic = function (candidates, M) {
+        // Simple implementation: select M closest neighbors
+        candidates.sort(function (a, b) { return a.distance - b.distance; });
+        return candidates.slice(0, M);
+    };
+    /**
+     * Add bidirectional link between nodes
+     */
+    HNSWIndex.prototype.addEdge = function (fromId, toId, level, distance) {
+        this.insertEdgeStmt.run(fromId, toId, level, distance);
+        this.insertEdgeStmt.run(toId, fromId, level, distance);
+    };
+    /**
+     * Insert a new node into the HNSW index (optimized version)
+     */
+    HNSWIndex.prototype.insert = function (vectorId, embedding) {
+        var nodeId = "hnsw_".concat(vectorId);
+        var level = this.randomLevel();
+        // Insert node
+        this.insertNodeStmt.run(nodeId, vectorId, level, this.serializeEmbedding(embedding));
+        // Update max level
+        if (level > this.maxLevel) {
+            this.maxLevel = level;
+        }
+        // If this is the first node, make it the entry point
+        if (!this.entryPoint) {
+            this.entryPoint = nodeId;
+            // Don't save metadata on every insert (batching will handle it)
+            return;
+        }
+        // Search for nearest neighbors at each layer
+        var entryPoints = [this.entryPoint];
+        // Navigate from top to target level
+        for (var lc = this.maxLevel; lc > level; lc--) {
+            var nearest = this.searchLayer(embedding, entryPoints, 1, lc);
+            if (nearest.length > 0) {
+                entryPoints = [nearest[0].id];
+            }
+        }
+        // Cache for prepared statement reuse
+        var deleteStmtCache = this.db.prepare("\n      DELETE FROM hnsw_edges\n      WHERE (from_id = ? OR to_id = ?) AND level = ?\n    ");
+        // Insert at all levels from level to 0
+        for (var lc = level; lc >= 0; lc--) {
+            var M = lc === 0 ? this.config.M0 : this.config.M;
+            var candidates = this.searchLayer(embedding, entryPoints, this.config.efConstruction, lc);
+            // Select M neighbors
+            var neighbors = this.selectNeighborsHeuristic(candidates, M);
+            // Add bidirectional links
+            for (var _i = 0, neighbors_2 = neighbors; _i < neighbors_2.length; _i++) {
+                var neighbor = neighbors_2[_i];
+                this.addEdge(nodeId, neighbor.id, lc, neighbor.distance);
+            }
+            // Prune neighbors' connections if needed (optimized)
+            for (var _a = 0, neighbors_3 = neighbors; _a < neighbors_3.length; _a++) {
+                var neighbor = neighbors_3[_a];
+                var neighborConnections = this.getNeighbors(neighbor.id, lc);
+                if (neighborConnections.length > M) {
+                    // Need to prune - remove edges and re-add selected ones
+                    deleteStmtCache.run(neighbor.id, neighbor.id, lc);
+                    // Re-select neighbors with minimal node fetching
+                    var node = this.getNode(neighbor.id);
+                    if (node) {
+                        // Batch fetch neighbor nodes for distance calculation
+                        var newCandidates = [];
+                        for (var _b = 0, neighborConnections_1 = neighborConnections; _b < neighborConnections_1.length; _b++) {
+                            var nc = neighborConnections_1[_b];
+                            var n = this.getNode(nc.id);
+                            if (n) {
+                                newCandidates.push({
+                                    id: nc.id,
+                                    distance: this.calculateDistance(node.embedding, n.embedding)
+                                });
+                            }
+                        }
+                        var selected = this.selectNeighborsHeuristic(newCandidates, M);
+                        for (var _c = 0, selected_1 = selected; _c < selected_1.length; _c++) {
+                            var sel = selected_1[_c];
+                            this.addEdge(neighbor.id, sel.id, lc, sel.distance);
+                        }
+                    }
+                }
+            }
+            entryPoints = neighbors.map(function (n) { return n.id; });
+        }
+        this.isBuilt = true;
+        // Don't save metadata on every insert (batching will handle it)
+    };
+    /**
+     * Search for k nearest neighbors using HNSW index
+     */
+    HNSWIndex.prototype.search = function (query, k) {
+        var _this = this;
+        if (!this.entryPoint || !this.isBuilt) {
+            return [];
+        }
+        var entryPoints = [this.entryPoint];
+        // Navigate from top layer to layer 0
+        for (var lc = this.maxLevel; lc > 0; lc--) {
+            var nearest = this.searchLayer(query, entryPoints, 1, lc);
+            if (nearest.length > 0) {
+                entryPoints = [nearest[0].id];
+            }
+        }
+        // Search at layer 0 with efSearch
+        var ef = Math.max(this.config.efSearch, k);
+        var results = this.searchLayer(query, entryPoints, ef, 0);
+        // Convert to final results with full node info
+        return results.slice(0, k).map(function (result) {
+            var node = _this.getNode(result.id);
+            return {
+                id: result.id,
+                vectorId: node.vectorId,
+                distance: result.distance,
+                embedding: node.embedding
+            };
+        });
+    };
+    /**
+     * Build HNSW index from all vectors in database with optimizations
+     */
+    HNSWIndex.prototype.build = function () {
+        var _this = this;
+        // Clear existing index
+        this.clear();
+        // Get all vectors from the main vectors table
+        var stmt = this.db.prepare('SELECT id, embedding FROM vectors ORDER BY id');
+        var rows = stmt.all();
+        if (rows.length === 0) {
+            console.log('No vectors to index');
+            return;
+        }
+        console.log("Building HNSW index for ".concat(rows.length, " vectors..."));
+        var startTime = Date.now();
+        // Batch insert optimization: wrap in transaction
+        var transaction = this.db.transaction(function () {
+            // Insert all vectors into index
+            for (var _i = 0, rows_1 = rows; _i < rows_1.length; _i++) {
+                var row = rows_1[_i];
+                var embedding = _this.deserializeEmbedding(row.embedding);
+                _this.insert(row.id, embedding);
+            }
+        });
+        transaction();
+        var duration = Date.now() - startTime;
+        var perVector = duration / rows.length;
+        console.log("HNSW index built in ".concat(duration, "ms (").concat(perVector.toFixed(2), "ms per vector)"));
+        this.isBuilt = true;
+        this.saveMetadata();
+    };
+    /**
+     * Build index incrementally (non-blocking for large datasets)
+     */
+    HNSWIndex.prototype.buildAsync = function (onProgress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stmt, rows, startTime, BATCH_SIZE, _loop_1, this_1, i, duration, perVector;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Clear existing index
+                        this.clear();
+                        stmt = this.db.prepare('SELECT id, embedding FROM vectors ORDER BY id');
+                        rows = stmt.all();
+                        if (rows.length === 0) {
+                            console.log('No vectors to index');
+                            return [2 /*return*/];
+                        }
+                        console.log("Building HNSW index incrementally for ".concat(rows.length, " vectors..."));
+                        startTime = Date.now();
+                        BATCH_SIZE = 100;
+                        _loop_1 = function (i) {
+                            var batchStartTime, batch, transaction, batchTime;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        batchStartTime = Date.now();
+                                        batch = rows.slice(i, i + BATCH_SIZE);
+                                        transaction = this_1.db.transaction(function () {
+                                            for (var _i = 0, batch_1 = batch; _i < batch_1.length; _i++) {
+                                                var row = batch_1[_i];
+                                                var embedding = _this.deserializeEmbedding(row.embedding);
+                                                _this.insert(row.id, embedding);
+                                            }
+                                        });
+                                        transaction();
+                                        batchTime = Date.now() - batchStartTime;
+                                        // Report progress
+                                        if (onProgress) {
+                                            onProgress(i + batch.length, rows.length, Date.now() - startTime);
+                                        }
+                                        // Yield to event loop every batch
+                                        return [4 /*yield*/, new Promise(function (resolve) { return setImmediate(resolve); })];
+                                    case 1:
+                                        // Yield to event loop every batch
+                                        _b.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < rows.length)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1(i)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        i += BATCH_SIZE;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        duration = Date.now() - startTime;
+                        perVector = duration / rows.length;
+                        console.log("HNSW index built incrementally in ".concat(duration, "ms (").concat(perVector.toFixed(2), "ms per vector)"));
+                        this.isBuilt = true;
+                        this.saveMetadata();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Clear the entire index
+     */
+    HNSWIndex.prototype.clear = function () {
+        this.db.exec('DELETE FROM hnsw_edges');
+        this.db.exec('DELETE FROM hnsw_nodes');
+        this.db.exec('DELETE FROM hnsw_metadata');
+        this.entryPoint = null;
+        this.maxLevel = 0;
+        this.isBuilt = false;
+    };
+    /**
+     * Delete a node from the index
+     */
+    HNSWIndex.prototype.delete = function (vectorId) {
+        var nodeId = "hnsw_".concat(vectorId);
+        // Check if node exists
+        var node = this.getNode(nodeId);
+        if (!node)
+            return;
+        // If this is the entry point, find a new one
+        if (this.entryPoint === nodeId) {
+            var stmt = this.db.prepare('SELECT id FROM hnsw_nodes WHERE id != ? LIMIT 1');
+            var row = stmt.get(nodeId);
+            this.entryPoint = row ? row.id : null;
+        }
+        // Delete edges
+        this.deleteEdgesStmt.run(nodeId, nodeId);
+        // Delete node
+        this.deleteNodeStmt.run(nodeId);
+        // Update metadata
+        if (!this.entryPoint) {
+            this.isBuilt = false;
+            this.maxLevel = 0;
+        }
+        this.saveMetadata();
+    };
+    /**
+     * Get index statistics
+     */
+    HNSWIndex.prototype.getStats = function () {
+        var nodeCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM hnsw_nodes');
+        var edgeCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM hnsw_edges');
+        var nodeCount = nodeCountStmt.get().count;
+        var edgeCount = edgeCountStmt.get().count;
+        var avgDegree = nodeCount > 0 ? edgeCount / nodeCount : 0;
+        return {
+            nodeCount: nodeCount,
+            edgeCount: edgeCount,
+            maxLevel: this.maxLevel,
+            isBuilt: this.isBuilt,
+            avgDegree: avgDegree
+        };
+    };
+    /**
+     * Check if index is ready to use
+     */
+    HNSWIndex.prototype.isReady = function () {
+        return this.isBuilt && this.entryPoint !== null;
+    };
+    /**
+     * Get configuration
+     */
+    HNSWIndex.prototype.getConfig = function () {
+        return __assign({}, this.config);
+    };
+    /**
+     * Update configuration (requires rebuild)
+     */
+    HNSWIndex.prototype.updateConfig = function (config) {
+        this.config = __assign(__assign({}, this.config), config);
+    };
+    return HNSWIndex;
+}());
+exports.HNSWIndex = HNSWIndex;

package/dist/cli/plugin-cli.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * SQLite Vector Learning Plugin CLI
+ * Interactive wizard for creating custom learning methodologies
+ */
+export {};
+//# sourceMappingURL=plugin-cli.d.ts.map

package/dist/cli/plugin-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-cli.d.ts","sourceRoot":"","sources":["../../src/cli/plugin-cli.ts"],"names":[],"mappings":";AACA;;;GAGG"}