pluresdb 1.0.1 → 1.3.1

package/scripts/run-tests.ts

@@ -95,7 +95,9 @@ class TestRunner {
     console.log("\nDetailed Results:");
     this.results.forEach((result) => {
       const status = result.passed ? "✅" : "❌";
-      console.log(`  ${status} ${result.suite} (${result.duration.toFixed(2)}ms)`);
+      console.log(
+        `  ${status} ${result.suite} (${result.duration.toFixed(2)}ms)`,
+      );
     });
 
     if (passed < total) {
@@ -118,7 +120,8 @@ async function main() {
     {
       name: "Unit Tests",
       command: "test -A --unstable-kv --parallel src/tests/unit/",
-      description: "Core functionality tests (CRUD, subscriptions, vector search)",
+      description:
+        "Core functionality tests (CRUD, subscriptions, vector search)",
       timeout: 30000,
     },
     {

package/scripts/update-changelog.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+/**
+ * Updates CHANGELOG.md with commits since the last tag
+ * This script is meant to be run during CI before version bumping
+ * 
+ * Usage: node scripts/update-changelog.js <version>
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function run(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: 'pipe' }).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+function getCommitsSinceLastTag() {
+  const lastTag = run('git describe --tags --abbrev=0 2>/dev/null');
+  if (!lastTag) {
+    console.log('No previous tags found, analyzing all commits');
+    const commits = run('git log --format="%s"');
+    return commits ? commits.split('\n').filter(Boolean) : [];
+  }
+
+  const range = `${lastTag}..HEAD`;
+  const commits = run(`git log --format="%s" ${range}`);
+  if (!commits) {
+    console.log('No commits since last tag');
+    return [];
+  }
+
+  return commits.split('\n').filter(Boolean);
+}
+
+function categorizeCommits(commits) {
+  const categories = {
+    feat: [],
+    fix: [],
+    docs: [],
+    style: [],
+    refactor: [],
+    test: [],
+    chore: [],
+    perf: [],
+    ci: [],
+    build: [],
+    other: [],
+  };
+
+  commits.forEach((commit) => {
+    // Skip release commits
+    if (commit.match(/^chore\(release\):/)) {
+      return;
+    }
+
+    const match = commit.match(/^(\w+)(\(.+\))?: (.+)/);
+    if (match) {
+      const [, type, , description] = match;
+      if (categories[type]) {
+        categories[type].push(description);
+      } else {
+        categories.other.push(commit);
+      }
+    } else {
+      categories.other.push(commit);
+    }
+  });
+
+  return categories;
+}
+
+function generateChangelogEntry(version, categories) {
+  const today = new Date().toISOString().split('T')[0];
+  let entry = `## [${version}] - ${today}\n\n`;
+  let hasContent = false;
+
+  if (categories.feat.length > 0) {
+    entry += '### Added\n\n';
+    categories.feat.forEach((item) => {
+      entry += `- ${item}\n`;
+    });
+    entry += '\n';
+    hasContent = true;
+  }
+
+  if (categories.fix.length > 0) {
+    entry += '### Fixed\n\n';
+    categories.fix.forEach((item) => {
+      entry += `- ${item}\n`;
+    });
+    entry += '\n';
+    hasContent = true;
+  }
+
+  if (categories.refactor.length > 0 || categories.style.length > 0 || categories.perf.length > 0) {
+    entry += '### Changed\n\n';
+    [...categories.refactor, ...categories.style, ...categories.perf].forEach((item) => {
+      entry += `- ${item}\n`;
+    });
+    entry += '\n';
+    hasContent = true;
+  }
+
+  if (categories.docs.length > 0) {
+    entry += '### Documentation\n\n';
+    categories.docs.forEach((item) => {
+      entry += `- ${item}\n`;
+    });
+    entry += '\n';
+    hasContent = true;
+  }
+
+  if (categories.test.length > 0 || categories.chore.length > 0 || categories.ci.length > 0 || categories.build.length > 0) {
+    entry += '### Developer Experience\n\n';
+    [...categories.test, ...categories.chore, ...categories.ci, ...categories.build].forEach((item) => {
+      entry += `- ${item}\n`;
+    });
+    entry += '\n';
+    hasContent = true;
+  }
+
+  if (categories.other.length > 0) {
+    entry += '### Other\n\n';
+    categories.other.forEach((item) => {
+      entry += `- ${item}\n`;
+    });
+    entry += '\n';
+    hasContent = true;
+  }
+
+  if (!hasContent) {
+    entry += '- Maintenance and improvements\n\n';
+  }
+
+  return entry;
+}
+
+function updateChangelog(newEntry) {
+  const changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
+  
+  if (!fs.existsSync(changelogPath)) {
+    console.log('CHANGELOG.md not found, creating new one');
+    const content = `# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n${newEntry}`;
+    fs.writeFileSync(changelogPath, content);
+    console.log('Created CHANGELOG.md');
+    return;
+  }
+
+  const content = fs.readFileSync(changelogPath, 'utf8');
+  const lines = content.split('\n');
+  let insertIndex = -1;
+
+  // Find the position after the header and before the first version entry
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith('## [') && !lines[i].includes('[Unreleased]')) {
+      insertIndex = i;
+      break;
+    }
+  }
+
+  if (insertIndex === -1) {
+    // No previous releases found, insert after any "Unreleased" section
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith('## [Unreleased]')) {
+        // Skip the unreleased section
+        let j = i + 1;
+        while (j < lines.length && !lines[j].startsWith('##')) {
+          j++;
+        }
+        insertIndex = j;
+        break;
+      } else if (lines[i].startsWith('# ')) {
+        // Found the main header, insert after it
+        insertIndex = i + 2;
+        break;
+      }
+    }
+  }
+
+  if (insertIndex === -1) {
+    // Last resort: append at the end
+    lines.push('', newEntry);
+  } else {
+    // Insert the new entry
+    lines.splice(insertIndex, 0, newEntry);
+  }
+
+  fs.writeFileSync(changelogPath, lines.join('\n'));
+  console.log('✅ Updated CHANGELOG.md');
+}
+
+function main() {
+  const version = process.argv[2];
+  if (!version) {
+    console.error('Usage: node scripts/update-changelog.js <version>');
+    process.exit(1);
+  }
+
+  const commits = getCommitsSinceLastTag();
+  if (commits.length === 0) {
+    console.log('No commits to add to changelog, creating minimal entry');
+  }
+
+  const categories = categorizeCommits(commits);
+  const entry = generateChangelogEntry(version, categories);
+  updateChangelog(entry);
+}
+
+main();

package/web/svelte/package.json

@@ -15,17 +15,17 @@
     "@codemirror/state": "^6.4.0",
     "@codemirror/theme-one-dark": "^6.1.2",
     "@codemirror/view": "^6.28.1",
-    "@sveltejs/vite-plugin-svelte": "^3.1.1",
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
     "ajv": "^8.12.0",
-    "svelte": "^4.2.18",
-    "vite": "^5.3.3"
+    "svelte": "^5.17.3",
+    "vite": "^7.2.2"
   },
   "dependencies": {
     "@monaco-editor/loader": "^1.5.0",
-    "cytoscape": "^3.28.1",
+    "cytoscape": "^3.29.3",
     "cytoscape-cola": "^2.5.1",
     "cytoscape-cose-bilkent": "^4.1.0",
     "cytoscape-dagre": "^2.5.0",
-    "monaco-editor": "^0.53.0"
+    "monaco-editor": "^0.49.0"
   }
 }

package/src/node-index.ts

@@ -1,385 +0,0 @@
-/**
- * Node.js Entry Point for PluresDB
- * This provides a clean API for VSCode extensions and other Node.js applications
- */
-
-import { EventEmitter } from "node:events";
-import { spawn, ChildProcess } from "node:child_process";
-import * as path from "node:path";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import process from "node:process";
-import { PluresDBConfig, PluresDBOptions } from "./types/node-types";
-
-const packageRoot =
-  typeof __dirname !== "undefined" ? path.resolve(__dirname, "..") : process.cwd();
-
-export class PluresNode extends EventEmitter {
-  private process: ChildProcess | null = null;
-  private config: PluresDBConfig;
-  private denoPath: string;
-  private isRunning = false;
-  private apiUrl: string = "";
-
-  constructor(options: PluresDBOptions = {}) {
-    super();
-
-    this.config = {
-      port: 34567,
-      host: "localhost",
-      dataDir: path.join(os.homedir(), ".pluresdb"),
-      webPort: 34568,
-      logLevel: "info",
-      ...options.config,
-    };
-
-    this.denoPath = options.denoPath || this.findDenoPath();
-
-    if (options.autoStart !== false) {
-      this.start();
-    }
-  }
-
-  private findDenoPath(): string {
-    // Try to find Deno in common locations
-    const possiblePaths = [
-      "deno", // In PATH
-      path.join(os.homedir(), ".deno", "bin", "deno"),
-      path.join(os.homedir(), ".local", "bin", "deno"),
-      "/usr/local/bin/deno",
-      "/opt/homebrew/bin/deno",
-      "C:\\Users\\" + os.userInfo().username + "\\.deno\\bin\\deno.exe",
-      "C:\\Program Files\\deno\\deno.exe",
-    ];
-
-    for (const denoPath of possiblePaths) {
-      try {
-        if (fs.existsSync(denoPath) || this.isCommandAvailable(denoPath)) {
-          return denoPath;
-        }
-      } catch (error) {
-        // Continue to next path
-      }
-    }
-
-    throw new Error("Deno not found. Please install Deno from https://deno.land/");
-  }
-
-  private isCommandAvailable(command: string): boolean {
-    try {
-      require("child_process").execSync(`"${command}" --version`, { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async start(): Promise<void> {
-    if (this.isRunning) {
-      return;
-    }
-
-    return new Promise((resolve, reject) => {
-      try {
-        // Ensure data directory exists
-        if (!fs.existsSync(this.config.dataDir!)) {
-          fs.mkdirSync(this.config.dataDir!, { recursive: true });
-        }
-
-        const kvPath = path.join(this.config.dataDir!, "pluresdb.kv");
-
-        // Find the main.ts file
-        const mainTsPath = path.join(packageRoot, "src", "main.ts");
-        if (!fs.existsSync(mainTsPath)) {
-          throw new Error(
-            "PluresDB main.ts not found. Please ensure the package is properly installed.",
-          );
-        }
-
-        // Start the Deno process
-        const args = [
-          "run",
-          "-A",
-          "--unstable-kv",
-          "--no-lock",
-          mainTsPath,
-          "serve",
-          "--port",
-          this.config.port!.toString(),
-          "--host",
-          this.config.host!,
-          "--kv",
-          kvPath,
-        ];
-
-        this.process = spawn(this.denoPath, args, {
-          stdio: ["pipe", "pipe", "pipe"],
-          cwd: packageRoot,
-        });
-
-        this.apiUrl = `http://${this.config.host}:${this.config.port}`;
-
-        // Handle process events
-        this.process.on("error", (error) => {
-          this.emit("error", error);
-          reject(error);
-        });
-
-        this.process.on("exit", (code) => {
-          this.isRunning = false;
-          this.emit("exit", code);
-        });
-
-        // Wait for server to start
-        this.waitForServer()
-          .then(() => {
-            this.isRunning = true;
-            this.emit("started");
-            resolve();
-          })
-          .catch(reject);
-
-        // Handle stdout/stderr
-        this.process.stdout?.on("data", (data) => {
-          const output = data.toString();
-          this.emit("stdout", output);
-        });
-
-        this.process.stderr?.on("data", (data) => {
-          const output = data.toString();
-          this.emit("stderr", output);
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-
-  private async waitForServer(timeout = 20000): Promise<void> {
-    const startTime = Date.now();
-
-    while (Date.now() - startTime < timeout) {
-      try {
-        const response = await fetch(`${this.apiUrl}/api/config`);
-        if (response.ok) {
-          return;
-        }
-      } catch (error) {
-        // Server not ready yet
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-
-    throw new Error("Server failed to start within timeout");
-  }
-
-  async stop(): Promise<void> {
-    if (!this.isRunning || !this.process) {
-      return;
-    }
-
-    return new Promise((resolve) => {
-      this.process!.kill("SIGTERM");
-
-      this.process!.on("exit", () => {
-        this.isRunning = false;
-        this.emit("stopped");
-        resolve();
-      });
-
-      // Force kill after 5 seconds
-      setTimeout(() => {
-        if (this.process && this.isRunning) {
-          this.process.kill("SIGKILL");
-        }
-        resolve();
-      }, 5000);
-    });
-  }
-
-  getApiUrl(): string {
-    return this.apiUrl;
-  }
-
-  getWebUrl(): string {
-    return `http://${this.config.host}:${this.config.webPort}`;
-  }
-
-  isServerRunning(): boolean {
-    return this.isRunning;
-  }
-
-  // SQLite-compatible API methods
-  async query(sql: string, params: any[] = []): Promise<any> {
-    const response = await fetch(`${this.apiUrl}/api/query`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ sql, params }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Query failed: ${response.statusText}`);
-    }
-
-    return response.json();
-  }
-
-  async put(key: string, value: any): Promise<void> {
-    const response = await fetch(`${this.apiUrl}/api/data`, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ key, value }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Put failed: ${response.statusText}`);
-    }
-  }
-
-  async get(key: string): Promise<any> {
-    const response = await fetch(`${this.apiUrl}/api/data/${encodeURIComponent(key)}`);
-
-    if (!response.ok) {
-      if (response.status === 404) {
-        return null;
-      }
-      throw new Error(`Get failed: ${response.statusText}`);
-    }
-
-    return response.json();
-  }
-
-  async delete(key: string): Promise<void> {
-    const response = await fetch(`${this.apiUrl}/api/data/${encodeURIComponent(key)}`, {
-      method: "DELETE",
-    });
-
-    if (!response.ok) {
-      throw new Error(`Delete failed: ${response.statusText}`);
-    }
-  }
-
-  async vectorSearch(query: string, limit = 10): Promise<any[]> {
-    const response = await fetch(`${this.apiUrl}/api/vsearch`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ query, limit }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Vector search failed: ${response.statusText}`);
-    }
-
-    return response.json() as Promise<any[]>;
-  }
-
-  async list(prefix?: string): Promise<string[]> {
-    const url = prefix
-      ? `${this.apiUrl}/api/list?prefix=${encodeURIComponent(prefix)}`
-      : `${this.apiUrl}/api/list`;
-    const response = await fetch(url);
-
-    if (!response.ok) {
-      throw new Error(`List failed: ${response.statusText}`);
-    }
-
-    return response.json() as Promise<string[]>;
-  }
-
-  async getConfig(): Promise<any> {
-    const response = await fetch(`${this.apiUrl}/api/config`);
-
-    if (!response.ok) {
-      throw new Error(`Get config failed: ${response.statusText}`);
-    }
-
-    return response.json();
-  }
-
-  async setConfig(config: any): Promise<void> {
-    const response = await fetch(`${this.apiUrl}/api/config`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(config),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Set config failed: ${response.statusText}`);
-    }
-  }
-}
-
-// SQLite-compatible API for easy migration
-export class SQLiteCompatibleAPI {
-  private plures: PluresNode;
-
-  constructor(options?: PluresDBOptions) {
-    this.plures = new PluresNode(options);
-  }
-
-  async start() {
-    await this.plures.start();
-  }
-
-  async stop() {
-    await this.plures.stop();
-  }
-
-  // SQLite-compatible methods
-  async run(sql: string, params: any[] = []) {
-    return this.plures.query(sql, params);
-  }
-
-  async get(sql: string, params: any[] = []) {
-    const result = await this.plures.query(sql, params);
-    return result.rows?.[0] || null;
-  }
-
-  async all(sql: string, params: any[] = []) {
-    const result = await this.plures.query(sql, params);
-    return result.rows || [];
-  }
-
-  async exec(sql: string) {
-    return this.plures.query(sql);
-  }
-
-  // Additional PluresDB specific methods
-  async put(key: string, value: any) {
-    return this.plures.put(key, value);
-  }
-
-  async getValue(key: string) {
-    return this.plures.get(key);
-  }
-
-  async delete(key: string) {
-    return this.plures.delete(key);
-  }
-
-  async vectorSearch(query: string, limit = 10) {
-    return this.plures.vectorSearch(query, limit);
-  }
-
-  async list(prefix?: string) {
-    return this.plures.list(prefix);
-  }
-
-  getApiUrl() {
-    return this.plures.getApiUrl();
-  }
-
-  getWebUrl() {
-    return this.plures.getWebUrl();
-  }
-
-  isRunning() {
-    return this.plures.isServerRunning();
-  }
-}
-
-// Export the main class and types
-export { PluresNode as default };
-export * from "./types/node-types";
-export { PluresVSCodeExtension, createPluresExtension } from "./vscode/extension";