pluresdb 1.0.1 → 1.3.1

package/examples/vscode-extension-integration.js

@@ -3,44 +3,45 @@
  * VSCode Extension Integration Example
  * This shows how to integrate PluresDB into a VSCode extension
  */
-var __createBinding =
-  (this && this.__createBinding) ||
+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);
+      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) ||
+      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 });
-      }
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }
     : function (o, v) {
-        o["default"] = v;
-      });
-var __importStar =
-  (this && this.__importStar) ||
+      o["default"] = v;
+    });
+var __importStar = (this && this.__importStar) ||
   (function () {
     var ownKeys = function (o) {
-      ownKeys =
-        Object.getOwnPropertyNames ||
+      ownKeys = Object.getOwnPropertyNames ||
         function (o) {
           var ar = [];
-          for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          for (var k in o) {
+            if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          }
           return ar;
         };
       return ownKeys(o);
@@ -48,9 +49,11 @@ var __importStar =
     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 (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;
     };
@@ -114,7 +117,9 @@ class PluresExtension {
       await this.setupDatabase();
       vscode.window.showInformationMessage("PluresDB extension activated");
     } catch (error) {
-      vscode.window.showErrorMessage(`Failed to activate PluresDB: ${error.message}`);
+      vscode.window.showErrorMessage(
+        `Failed to activate PluresDB: ${error.message}`,
+      );
     }
   }
   async deactivate() {
@@ -127,95 +132,124 @@ class PluresExtension {
   }
   registerCommands() {
     // Command to open PluresDB web UI
-    const openWebUI = vscode.commands.registerCommand("pluresdb.openWebUI", () => {
-      const webUrl = this.plures.getWebUrl();
-      vscode.env.openExternal(vscode.Uri.parse(webUrl));
-    });
+    const openWebUI = vscode.commands.registerCommand(
+      "pluresdb.openWebUI",
+      () => {
+        const webUrl = this.plures.getWebUrl();
+        vscode.env.openExternal(vscode.Uri.parse(webUrl));
+      },
+    );
     // Command to execute SQL query
-    const executeQuery = vscode.commands.registerCommand("pluresdb.executeQuery", async () => {
-      const sql = await vscode.window.showInputBox({
-        prompt: "Enter SQL query",
-        placeHolder: "SELECT * FROM users",
-      });
-      if (sql) {
-        try {
-          const result = await this.sqliteAPI.all(sql);
-          const doc = await vscode.workspace.openTextDocument({
-            content: JSON.stringify(result, null, 2),
-            language: "json",
-          });
-          await vscode.window.showTextDocument(doc);
-        } catch (error) {
-          vscode.window.showErrorMessage(`Query failed: ${error.message}`);
-        }
-      }
-    });
-    // Command to perform vector search
-    const vectorSearch = vscode.commands.registerCommand("pluresdb.vectorSearch", async () => {
-      const query = await vscode.window.showInputBox({
-        prompt: "Enter search query",
-        placeHolder: "machine learning",
-      });
-      if (query) {
-        try {
-          const results = await this.sqliteAPI.vectorSearch(query, 10);
-          const doc = await vscode.workspace.openTextDocument({
-            content: JSON.stringify(results, null, 2),
-            language: "json",
-          });
-          await vscode.window.showTextDocument(doc);
-        } catch (error) {
-          vscode.window.showErrorMessage(`Vector search failed: ${error.message}`);
-        }
-      }
-    });
-    // Command to store data
-    const storeData = vscode.commands.registerCommand("pluresdb.storeData", async () => {
-      const key = await vscode.window.showInputBox({
-        prompt: "Enter key",
-        placeHolder: "user:123",
-      });
-      if (key) {
-        const value = await vscode.window.showInputBox({
-          prompt: "Enter value (JSON)",
-          placeHolder: '{"name": "John", "email": "john@example.com"}',
+    const executeQuery = vscode.commands.registerCommand(
+      "pluresdb.executeQuery",
+      async () => {
+        const sql = await vscode.window.showInputBox({
+          prompt: "Enter SQL query",
+          placeHolder: "SELECT * FROM users",
         });
-        if (value) {
+        if (sql) {
           try {
-            const parsedValue = JSON.parse(value);
-            await this.sqliteAPI.put(key, parsedValue);
-            vscode.window.showInformationMessage(`Stored data for key: ${key}`);
+            const result = await this.sqliteAPI.all(sql);
+            const doc = await vscode.workspace.openTextDocument({
+              content: JSON.stringify(result, null, 2),
+              language: "json",
+            });
+            await vscode.window.showTextDocument(doc);
           } catch (error) {
-            vscode.window.showErrorMessage(`Failed to store data: ${error.message}`);
+            vscode.window.showErrorMessage(`Query failed: ${error.message}`);
           }
         }
-      }
-    });
-    // Command to retrieve data
-    const retrieveData = vscode.commands.registerCommand("pluresdb.retrieveData", async () => {
-      const key = await vscode.window.showInputBox({
-        prompt: "Enter key to retrieve",
-        placeHolder: "user:123",
-      });
-      if (key) {
-        try {
-          const value = await this.sqliteAPI.getValue(key);
-          if (value) {
+      },
+    );
+    // Command to perform vector search
+    const vectorSearch = vscode.commands.registerCommand(
+      "pluresdb.vectorSearch",
+      async () => {
+        const query = await vscode.window.showInputBox({
+          prompt: "Enter search query",
+          placeHolder: "machine learning",
+        });
+        if (query) {
+          try {
+            const results = await this.sqliteAPI.vectorSearch(query, 10);
             const doc = await vscode.workspace.openTextDocument({
-              content: JSON.stringify(value, null, 2),
+              content: JSON.stringify(results, null, 2),
               language: "json",
             });
             await vscode.window.showTextDocument(doc);
-          } else {
-            vscode.window.showInformationMessage("Key not found");
+          } catch (error) {
+            vscode.window.showErrorMessage(
+              `Vector search failed: ${error.message}`,
+            );
           }
-        } catch (error) {
-          vscode.window.showErrorMessage(`Failed to retrieve data: ${error.message}`);
         }
-      }
-    });
+      },
+    );
+    // Command to store data
+    const storeData = vscode.commands.registerCommand(
+      "pluresdb.storeData",
+      async () => {
+        const key = await vscode.window.showInputBox({
+          prompt: "Enter key",
+          placeHolder: "user:123",
+        });
+        if (key) {
+          const value = await vscode.window.showInputBox({
+            prompt: "Enter value (JSON)",
+            placeHolder: '{"name": "John", "email": "john@example.com"}',
+          });
+          if (value) {
+            try {
+              const parsedValue = JSON.parse(value);
+              await this.sqliteAPI.put(key, parsedValue);
+              vscode.window.showInformationMessage(
+                `Stored data for key: ${key}`,
+              );
+            } catch (error) {
+              vscode.window.showErrorMessage(
+                `Failed to store data: ${error.message}`,
+              );
+            }
+          }
+        }
+      },
+    );
+    // Command to retrieve data
+    const retrieveData = vscode.commands.registerCommand(
+      "pluresdb.retrieveData",
+      async () => {
+        const key = await vscode.window.showInputBox({
+          prompt: "Enter key to retrieve",
+          placeHolder: "user:123",
+        });
+        if (key) {
+          try {
+            const value = await this.sqliteAPI.getValue(key);
+            if (value) {
+              const doc = await vscode.workspace.openTextDocument({
+                content: JSON.stringify(value, null, 2),
+                language: "json",
+              });
+              await vscode.window.showTextDocument(doc);
+            } else {
+              vscode.window.showInformationMessage("Key not found");
+            }
+          } catch (error) {
+            vscode.window.showErrorMessage(
+              `Failed to retrieve data: ${error.message}`,
+            );
+          }
+        }
+      },
+    );
     // Register all commands
-    this.context.subscriptions.push(openWebUI, executeQuery, vectorSearch, storeData, retrieveData);
+    this.context.subscriptions.push(
+      openWebUI,
+      executeQuery,
+      vectorSearch,
+      storeData,
+      retrieveData,
+    );
   }
   async setupDatabase() {
     // Create tables for common VSCode extension use cases

package/examples/vscode-extension-integration.ts

@@ -6,8 +6,8 @@
 import * as vscode from "vscode";
 import {
   createPluresExtension,
-  PluresVSCodeExtension,
   ExtensionContextLike,
+  PluresVSCodeExtension,
   VSCodeAPI,
 } from "../src/vscode/extension.ts";
 

package/{src → legacy}/benchmarks/memory-benchmarks.ts

@@ -54,9 +54,13 @@ class MemoryBenchmark {
 
     this.results.push(metrics);
 
-    console.log(`  Initial Memory: ${(initialMemory / 1024 / 1024).toFixed(2)}MB`);
+    console.log(
+      `  Initial Memory: ${(initialMemory / 1024 / 1024).toFixed(2)}MB`,
+    );
     console.log(`  Final Memory: ${(finalMemory / 1024 / 1024).toFixed(2)}MB`);
-    console.log(`  Memory Increase: ${(memoryIncrease / 1024 / 1024).toFixed(2)}MB`);
+    console.log(
+      `  Memory Increase: ${(memoryIncrease / 1024 / 1024).toFixed(2)}MB`,
+    );
     console.log(`  Memory per Record: ${memoryPerRecord.toFixed(2)} bytes`);
     console.log();
 
@@ -71,8 +75,14 @@ class MemoryBenchmark {
     this.results.forEach((result) => {
       console.log(`${result.operation}:`);
       console.log(`  Records: ${result.recordCount.toLocaleString()}`);
-      console.log(`  Memory Increase: ${(result.memoryIncrease / 1024 / 1024).toFixed(2)}MB`);
-      console.log(`  Memory per Record: ${result.memoryPerRecord.toFixed(2)} bytes`);
+      console.log(
+        `  Memory Increase: ${
+          (result.memoryIncrease / 1024 / 1024).toFixed(2)
+        }MB`,
+      );
+      console.log(
+        `  Memory per Record: ${result.memoryPerRecord.toFixed(2)} bytes`,
+      );
       console.log();
     });
   }
@@ -92,53 +102,69 @@ async function runMemoryBenchmarks() {
     console.log("Starting Memory Benchmarks...\n");
 
     // Benchmark 1: Small Records
-    await benchmark.measureMemoryUsage("Small Records (100 bytes)", 1000, async () => {
-      for (let i = 0; i < 1000; i++) {
-        await db.put(`small:${i}`, {
-          id: i,
-          data: "x".repeat(100),
-          timestamp: Date.now(),
-        });
-      }
-    });
+    await benchmark.measureMemoryUsage(
+      "Small Records (100 bytes)",
+      1000,
+      async () => {
+        for (let i = 0; i < 1000; i++) {
+          await db.put(`small:${i}`, {
+            id: i,
+            data: "x".repeat(100),
+            timestamp: Date.now(),
+          });
+        }
+      },
+    );
 
     // Benchmark 2: Medium Records
-    await benchmark.measureMemoryUsage("Medium Records (1KB)", 1000, async () => {
-      for (let i = 0; i < 1000; i++) {
-        await db.put(`medium:${i}`, {
-          id: i,
-          data: "x".repeat(1024),
-          timestamp: Date.now(),
-          metadata: { size: "medium", type: "test" },
-        });
-      }
-    });
+    await benchmark.measureMemoryUsage(
+      "Medium Records (1KB)",
+      1000,
+      async () => {
+        for (let i = 0; i < 1000; i++) {
+          await db.put(`medium:${i}`, {
+            id: i,
+            data: "x".repeat(1024),
+            timestamp: Date.now(),
+            metadata: { size: "medium", type: "test" },
+          });
+        }
+      },
+    );
 
     // Benchmark 3: Large Records
-    await benchmark.measureMemoryUsage("Large Records (10KB)", 100, async () => {
-      for (let i = 0; i < 100; i++) {
-        await db.put(`large:${i}`, {
-          id: i,
-          data: "x".repeat(10 * 1024),
-          timestamp: Date.now(),
-          metadata: { size: "large", type: "test" },
-          additional: "y".repeat(1024),
-        });
-      }
-    });
+    await benchmark.measureMemoryUsage(
+      "Large Records (10KB)",
+      100,
+      async () => {
+        for (let i = 0; i < 100; i++) {
+          await db.put(`large:${i}`, {
+            id: i,
+            data: "x".repeat(10 * 1024),
+            timestamp: Date.now(),
+            metadata: { size: "large", type: "test" },
+            additional: "y".repeat(1024),
+          });
+        }
+      },
+    );
 
     // Benchmark 4: Vector Data
-    await benchmark.measureMemoryUsage("Vector Data (100 dimensions)", 500, async () => {
-      for (let i = 0; i < 500; i++) {
-        const vector = Array.from({ length: 100 }, () => Math.random());
-        await db.put(`vector:${i}`, {
-          id: i,
-          text: `Document ${i} with vector data`,
-          vector: vector,
-          timestamp: Date.now(),
-        });
-      }
-    });
+    await benchmark.measureMemoryUsage(
+      "Vector Data (100 dimensions)",
+      500,
+      async () => {
+        for (let i = 0; i < 500; i++) {
+          const vector = Array.from({ length: 100 }, () => Math.random());
+          await db.put(`vector:${i}`, {
+            id: i,
+            text: `Document ${i} with vector data`,
+            vector: vector,
+            timestamp: Date.now(),
+          });
+        }
+      },
+    );
 
     // Benchmark 5: Nested Objects
     await benchmark.measureMemoryUsage("Nested Objects", 500, async () => {
@@ -181,9 +207,9 @@ async function runMemoryBenchmarks() {
 
     // Clean up subscriptions
     if ((globalThis as any).subscriptions) {
-      ((globalThis as any).subscriptions as Array<() => void>).forEach((unsubscribe) =>
-        unsubscribe(),
-      );
+      ((globalThis as any).subscriptions as Array<() => void>).forEach((
+        unsubscribe,
+      ) => unsubscribe());
       delete (globalThis as any).subscriptions;
     }
 
@@ -251,7 +277,9 @@ async function runMemoryLeakTests() {
     const memoryIncrease = finalMemory - initialMemory;
 
     console.log(
-      `Memory increase after subscription cycles: ${(memoryIncrease / 1024).toFixed(2)}KB`,
+      `Memory increase after subscription cycles: ${
+        (memoryIncrease / 1024).toFixed(2)
+      }KB`,
     );
 
     if (memoryIncrease > 1024 * 1024) {
@@ -269,7 +297,9 @@ async function runMemoryLeakTests() {
     // Perform many CRUD operations
     for (let cycle = 0; cycle < 100; cycle++) {
       for (let i = 0; i < 100; i++) {
-        await db.put(`leak:${cycle}:${i}`, { data: `Cycle ${cycle} Item ${i}` });
+        await db.put(`leak:${cycle}:${i}`, {
+          data: `Cycle ${cycle} Item ${i}`,
+        });
         await db.get(`leak:${cycle}:${i}`);
         await db.delete(`leak:${cycle}:${i}`);
       }
@@ -283,7 +313,11 @@ async function runMemoryLeakTests() {
     const crudFinalMemory = (performance as any).memory?.usedJSHeapSize || 0;
     const crudMemoryIncrease = crudFinalMemory - crudInitialMemory;
 
-    console.log(`Memory increase after CRUD cycles: ${(crudMemoryIncrease / 1024).toFixed(2)}KB`);
+    console.log(
+      `Memory increase after CRUD cycles: ${
+        (crudMemoryIncrease / 1024).toFixed(2)
+      }KB`,
+    );
 
     if (crudMemoryIncrease > 1024 * 1024) {
       // More than 1MB

package/{src → legacy}/benchmarks/run-benchmarks.ts

@@ -46,7 +46,11 @@ class BenchmarkRunner {
     };
 
     this.results.push(result);
-    console.log(`  ✓ ${operationsPerSecond.toFixed(2)} ops/sec (${averageTime.toFixed(2)}ms avg)`);
+    console.log(
+      `  ✓ ${operationsPerSecond.toFixed(2)} ops/sec (${
+        averageTime.toFixed(2)
+      }ms avg)`,
+    );
 
     return result;
   }
@@ -63,7 +67,9 @@ class BenchmarkRunner {
       console.log(`  Average Time: ${result.averageTime.toFixed(2)}ms`);
       console.log(`  Operations/sec: ${result.operationsPerSecond.toFixed(2)}`);
       if (result.memoryUsage) {
-        console.log(`  Memory Usage: ${(result.memoryUsage / 1024 / 1024).toFixed(2)}MB`);
+        console.log(
+          `  Memory Usage: ${(result.memoryUsage / 1024 / 1024).toFixed(2)}MB`,
+        );
       }
       console.log();
     });
@@ -117,8 +123,10 @@ async function runCoreBenchmarks() {
     // First populate with documents
     for (let i = 0; i < 100; i++) {
       await db.put(`doc:${i}`, {
-        text: `Document ${i} about machine learning and artificial intelligence`,
-        content: `This is document number ${i} containing information about AI and ML algorithms`,
+        text:
+          `Document ${i} about machine learning and artificial intelligence`,
+        content:
+          `This is document number ${i} containing information about AI and ML algorithms`,
       });
     }
 
@@ -244,8 +252,14 @@ async function runMemoryBenchmarks() {
     const finalMemory = (performance as any).memory?.usedJSHeapSize || 0;
     const memoryIncrease = finalMemory - initialMemory;
 
-    console.log(`Memory Usage: ${(memoryIncrease / 1024 / 1024).toFixed(2)}MB for 1000 records`);
-    console.log(`Memory per record: ${(memoryIncrease / 1000).toFixed(2)} bytes`);
+    console.log(
+      `Memory Usage: ${
+        (memoryIncrease / 1024 / 1024).toFixed(2)
+      }MB for 1000 records`,
+    );
+    console.log(
+      `Memory per record: ${(memoryIncrease / 1000).toFixed(2)} bytes`,
+    );
 
     // Benchmark 2: Subscription Memory Usage
     const subscriptionMemory = (performance as any).memory?.usedJSHeapSize || 0;
@@ -257,13 +271,21 @@ async function runMemoryBenchmarks() {
       subscriptions.push(unsubscribe);
     });
 
-    const afterSubscriptionMemory = (performance as any).memory?.usedJSHeapSize || 0;
-    const subscriptionMemoryIncrease = afterSubscriptionMemory - subscriptionMemory;
+    const afterSubscriptionMemory =
+      (performance as any).memory?.usedJSHeapSize || 0;
+    const subscriptionMemoryIncrease = afterSubscriptionMemory -
+      subscriptionMemory;
 
     console.log(
-      `Subscription Memory: ${(subscriptionMemoryIncrease / 1024).toFixed(2)}KB for 1000 subscriptions`,
+      `Subscription Memory: ${
+        (subscriptionMemoryIncrease / 1024).toFixed(2)
+      }KB for 1000 subscriptions`,
+    );
+    console.log(
+      `Memory per subscription: ${
+        (subscriptionMemoryIncrease / 1000).toFixed(2)
+      } bytes`,
     );
-    console.log(`Memory per subscription: ${(subscriptionMemoryIncrease / 1000).toFixed(2)} bytes`);
 
     // Clean up subscriptions
     subscriptions.forEach((unsubscribe) => unsubscribe());