@plures/pluresdb 1.4.0

package/scripts/dogfood.ts

@@ -0,0 +1,297 @@
+#!/usr/bin/env -S deno run -A --unstable-kv
+
+import { GunDB } from "../legacy/core/database.ts";
+import { startApiServer } from "../legacy/http/api-server.ts";
+
+declare const Deno: any;
+
+interface StepResult {
+  name: string;
+  ok: boolean;
+  details?: string;
+}
+
+async function main() {
+  const results: StepResult[] = [];
+  const kvDir = await Deno.makeTempDir({ prefix: "pluresdb-dogfood-" });
+  const kvPath = `${kvDir}/kv`;
+  const wsPort = 4600 + Math.floor(Math.random() * 5000);
+  const apiPort = wsPort + 1;
+  const apiUrl = `http://localhost:${apiPort}`;
+
+  const db = new GunDB();
+  await db.ready(kvPath);
+  db.serve({ port: wsPort });
+  const api = startApiServer({ port: apiPort, db });
+
+  const cleanupTasks: Array<() => Promise<void> | void> = [
+    async () => {
+      try {
+        api.close();
+      } catch (_) {
+        /* ignore */
+      }
+    },
+    async () => {
+      try {
+        await db.close();
+      } catch (_) {
+        /* ignore */
+      }
+    },
+    async () => {
+      try {
+        await Deno.remove(kvDir, { recursive: true });
+      } catch (_) {
+        /* ignore */
+      }
+    },
+  ];
+
+  const finalize = async () => {
+    for (const task of cleanupTasks) {
+      await Promise.resolve(task());
+    }
+  };
+
+  const assert = (cond: boolean, message: string) => {
+    if (!cond) {
+      throw new Error(message);
+    }
+  };
+
+  const record = (name: string, ok: boolean, details?: string) => {
+    const entry: StepResult = { name, ok, details };
+    results.push(entry);
+    const icon = ok ? "✅" : "❌";
+    console.log(`${icon} ${name}${details ? ` — ${details}` : ""}`);
+  };
+
+  try {
+    console.log("🚀 Starting PluresDB dogfooding run");
+    console.log(`🗂️  KV path: ${kvPath}`);
+    console.log(`🔌 Mesh port: ${wsPort}`);
+    console.log(`🌐 API port: ${apiPort}`);
+
+    await waitFor(
+      async () => {
+        try {
+          const res = await fetch(`${apiUrl}/api/list`);
+          return res.ok;
+        } catch (_) {
+          return false;
+        }
+      },
+      { timeoutMs: 10_000, intervalMs: 250 },
+    );
+    record("Server readiness", true);
+
+    const nodeId = "dogfood:api";
+    const initialPayload = {
+      type: "DogfoodTest",
+      text: "Hello from the dogfooding script",
+      vector: Array.from({ length: 4 }, (_, i) => i + 1),
+    };
+    const putRes = await fetch(`${apiUrl}/api/put`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ id: nodeId, data: initialPayload }),
+    });
+    assert(putRes.ok, `API put failed (${putRes.status})`);
+    record("API put", true);
+
+    const getRes = await fetch(
+      `${apiUrl}/api/get?id=${encodeURIComponent(nodeId)}`,
+    );
+    assert(getRes.ok, "API get failed");
+    const getJson = await getRes.json();
+    assert(getJson.text === initialPayload.text, "Unexpected API get payload");
+    record("API get", true);
+
+    const listRes = await fetch(`${apiUrl}/api/list`);
+    assert(listRes.ok, "API list failed");
+    const listJson = await listRes.json();
+    assert(
+      Array.isArray(listJson) && listJson.some((n: any) => n.id === nodeId),
+      "Node missing from API list",
+    );
+    record("API list", true);
+
+    const searchRes = await fetch(
+      `${apiUrl}/api/search?q=${encodeURIComponent("dogfood script test")}&k=5`,
+    );
+    assert(searchRes.ok, "API search failed");
+    const searchJson = await searchRes.json();
+    assert(
+      Array.isArray(searchJson) && searchJson.length > 0,
+      "Vector search returned no results",
+    );
+    record("API vector search", true);
+
+    const updatePayload = {
+      type: "DogfoodTest",
+      text: "Hello from the updated dogfooding script",
+    };
+    const putUpdate = await fetch(`${apiUrl}/api/put`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ id: nodeId, data: updatePayload }),
+    });
+    assert(putUpdate.ok, "API put update failed");
+    record("API update", true);
+
+    const historyRes = await fetch(
+      `${apiUrl}/api/history?id=${encodeURIComponent(nodeId)}`,
+    );
+    assert(historyRes.ok, "API history failed");
+    const historyJson = await historyRes.json();
+    assert(
+      Array.isArray(historyJson) && historyJson.length >= 2,
+      "API history missing versions",
+    );
+    record("API history", true, `${historyJson.length} versions`);
+
+    const restoreTimestamp = historyJson.at(-1)?.timestamp ??
+      historyJson[historyJson.length - 1]?.timestamp;
+    assert(
+      typeof restoreTimestamp === "number",
+      "Failed to locate restore timestamp",
+    );
+    const restoreRes = await fetch(
+      `${apiUrl}/api/restore?id=${
+        encodeURIComponent(nodeId)
+      }&timestamp=${restoreTimestamp}`,
+    );
+    assert(restoreRes.ok, "API restore failed");
+    record("API restore", true);
+
+    const restored = await (
+      await fetch(`${apiUrl}/api/get?id=${encodeURIComponent(nodeId)}`)
+    ).json();
+    assert(
+      restored.text === initialPayload.text,
+      "Restore did not revert payload",
+    );
+    record("API post-restore verification", true);
+
+    const instancesRes = await fetch(
+      `${apiUrl}/api/instances?type=${encodeURIComponent("DogfoodTest")}`,
+    );
+    assert(instancesRes.ok, "API instances failed");
+    const instancesJson = await instancesRes.json();
+    assert(
+      Array.isArray(instancesJson) &&
+        instancesJson.some((n: any) => n.id === nodeId),
+      "Instances endpoint missing node",
+    );
+    record("API type instances", true);
+
+    const webRes = await fetch(`${apiUrl}/`);
+    assert(webRes.ok, "Web UI endpoint failed");
+    const webHtml = await webRes.text();
+    record("Web UI fetch", true, `${webHtml.length} chars`);
+
+    const cliId = "dogfood:cli";
+    const cliPut = await runCli([
+      "put",
+      cliId,
+      JSON.stringify({ type: "DogfoodTest", text: "CLI write" }),
+      "--kv",
+      kvPath,
+    ]);
+    assert(cliPut.code === 0, `CLI put failed: ${cliPut.stderr}`);
+    record("CLI put", true);
+
+    const cliGet = await runCli(["get", cliId, "--kv", kvPath]);
+    assert(cliGet.code === 0, `CLI get failed: ${cliGet.stderr}`);
+    const cliGetJson = JSON.parse(cliGet.stdout.trim() || "null");
+    assert(cliGetJson?.text === "CLI write", "CLI get returned wrong payload");
+    record("CLI get", true);
+
+    const cliList = await runCli(["list", "--kv", kvPath]);
+    assert(cliList.code === 0, `CLI list failed: ${cliList.stderr}`);
+    const cliListJson = JSON.parse(cliList.stdout.trim() || "[]");
+    assert(
+      Array.isArray(cliListJson) && cliListJson.length >= 2,
+      "CLI list missing entries",
+    );
+    record("CLI list", true);
+
+    const cliSearch = await runCli([
+      "vsearch",
+      "dogfooding",
+      "5",
+      "--kv",
+      kvPath,
+    ]);
+    assert(cliSearch.code === 0, `CLI vsearch failed: ${cliSearch.stderr}`);
+    const cliSearchJson = JSON.parse(cliSearch.stdout.trim() || "[]");
+    assert(
+      Array.isArray(cliSearchJson) && cliSearchJson.length > 0,
+      "CLI vsearch returned no results",
+    );
+    record("CLI vector search", true);
+
+    console.log("\n🎉 Dogfooding run succeeded!");
+  } catch (error) {
+    record(
+      "Dogfooding run",
+      false,
+      error instanceof Error ? error.message : String(error),
+    );
+    await finalize();
+    console.log("\n❌ Dogfooding run failed");
+    console.log(error);
+    Deno.exit(1);
+  }
+
+  await finalize();
+}
+
+async function runCli(args: string[]) {
+  const command = new Deno.Command("deno", {
+    args: [
+      "run",
+      "-A",
+      "--unstable-kv",
+      "--no-lock",
+      "legacy/main.ts",
+      ...args,
+    ],
+    stdout: "piped",
+    stderr: "piped",
+  });
+  const { code, stdout, stderr } = await command.output();
+  return {
+    code,
+    stdout: new TextDecoder().decode(stdout),
+    stderr: new TextDecoder().decode(stderr),
+  };
+}
+
+async function waitFor(
+  fn: () => Promise<boolean>,
+  opts: { timeoutMs: number; intervalMs: number },
+) {
+  const deadline = Date.now() + opts.timeoutMs;
+  while (Date.now() < deadline) {
+    if (await fn()) return;
+    await sleep(opts.intervalMs);
+  }
+  throw new Error("Timed out waiting for condition");
+}
+
+function sleep(ms: number): Promise<void>;
+function sleep<T>(ms: number, value: T): Promise<T>;
+function sleep(ms: number, value?: unknown) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      clearTimeout(timer);
+      resolve(value);
+    }, ms);
+  });
+}
+
+if ((import.meta as any).main) {
+  await main();
+}

package/scripts/postinstall.js

@@ -0,0 +1,156 @@
+/**
+ * Post-install script for PluresDB npm package
+ * This script ensures Deno is available and sets up the environment
+ */
+
+const { spawn, exec } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const DENO_VERSION = "1.40.0";
+
+function log(message) {
+  console.log(`[pluresdb] ${message}`);
+}
+
+function logError(message) {
+  console.error(`[pluresdb] ERROR: ${message}`);
+}
+
+function isDenoInstalled() {
+  return new Promise((resolve) => {
+    exec("deno --version", (error) => {
+      resolve(!error);
+    });
+  });
+}
+
+function installDeno() {
+  return new Promise((resolve, reject) => {
+    const platform = os.platform();
+    const arch = os.arch();
+
+    log("Installing Deno...");
+
+    let installCommand;
+
+    if (platform === "win32") {
+      // Windows - use PowerShell
+      installCommand =
+        `powershell -c "iwr https://deno.land/install.ps1 -useb | iex"`;
+    } else if (platform === "darwin") {
+      // macOS - use Homebrew or curl
+      installCommand = "curl -fsSL https://deno.land/install.sh | sh";
+    } else {
+      // Linux - use curl
+      installCommand = "curl -fsSL https://deno.land/install.sh | sh";
+    }
+
+    exec(installCommand, (error, stdout, stderr) => {
+      if (error) {
+        logError(`Failed to install Deno: ${error.message}`);
+        logError("Please install Deno manually from https://deno.land/");
+        reject(error);
+      } else {
+        log("Deno installed successfully");
+        resolve();
+      }
+    });
+  });
+}
+
+function createStartScript() {
+  const scriptContent = `#!/bin/bash
+# PluresDB start script
+export DENO_INSTALL="$HOME/.deno"
+export PATH="$DENO_INSTALL/bin:$PATH"
+
+# Start PluresDB
+deno run -A "${path.join(__dirname, "../src/main.ts")}" serve "$@"
+`;
+
+  const scriptPath = path.join(__dirname, "../bin/pluresdb.sh");
+  const scriptDir = path.dirname(scriptPath);
+
+  if (!fs.existsSync(scriptDir)) {
+    fs.mkdirSync(scriptDir, { recursive: true });
+  }
+
+  fs.writeFileSync(scriptPath, scriptContent);
+  fs.chmodSync(scriptPath, "755");
+
+  log("Created start script");
+}
+
+function createWindowsStartScript() {
+  const scriptContent = `@echo off
+REM PluresDB start script for Windows
+set DENO_INSTALL=%USERPROFILE%\\.deno
+set PATH=%DENO_INSTALL%\\bin;%PATH%
+
+REM Start PluresDB
+deno run -A "${path.join(__dirname, "../src/main.ts")}" serve %*
+`;
+
+  const scriptPath = path.join(__dirname, "../bin/pluresdb.bat");
+  const scriptDir = path.dirname(scriptPath);
+
+  if (!fs.existsSync(scriptDir)) {
+    fs.mkdirSync(scriptDir, { recursive: true });
+  }
+
+  fs.writeFileSync(scriptPath, scriptContent);
+
+  log("Created Windows start script");
+}
+
+async function main() {
+  try {
+    log("Setting up PluresDB...");
+
+    // Check if Deno is installed
+    const denoInstalled = await isDenoInstalled();
+
+    if (!denoInstalled) {
+      log("Deno not found, attempting to install...");
+      try {
+        await installDeno();
+      } catch {
+        logError("Failed to install Deno automatically");
+        logError("Please install Deno manually:");
+        logError("  Windows: iwr https://deno.land/install.ps1 -useb | iex");
+        logError("  macOS/Linux: curl -fsSL https://deno.land/install.sh | sh");
+        logError("  Or visit: https://deno.land/");
+        return;
+      }
+    } else {
+      log("Deno is already installed");
+    }
+
+    // Create start scripts
+    createStartScript();
+    if (os.platform() === "win32") {
+      createWindowsStartScript();
+    }
+
+    // Create data directory
+    const dataDir = path.join(os.homedir(), ".pluresdb");
+    if (!fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
+      log(`Created data directory: ${dataDir}`);
+    }
+
+    log("Setup complete!");
+    log("Usage:");
+    log("  npx pluresdb serve");
+    log("  or");
+    log("  node node_modules/pluresdb/dist/cli.js serve");
+  } catch (error) {
+    logError(`Setup failed: ${error.message}`);
+    Deno.exit(1);
+  }
+}
+
+// Run the setup
+main();

package/scripts/release-check.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-release validation checks
+ * Ensures the repository is ready for a release
+ * 
+ * Usage: node scripts/release-check.js
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function run(cmd, ignoreError = false) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: 'pipe' }).trim();
+  } catch (e) {
+    if (ignoreError) return null;
+    throw e;
+  }
+}
+
+function checkGitStatus() {
+  console.log('🔍 Checking git status...');
+  const status = run('git status --porcelain', true);
+  
+  if (status && status.length > 0) {
+    console.warn('⚠️  Warning: Working directory has uncommitted changes');
+    console.log(status);
+  } else {
+    console.log('✅ Working directory is clean');
+  }
+}
+
+function checkPackageVersions() {
+  console.log('\n🔍 Checking package versions...');
+  
+  const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  const cargoToml = fs.readFileSync('Cargo.toml', 'utf8');
+  
+  const packageVersion = packageJson.version;
+  const cargoMatch = cargoToml.match(/^version\s*=\s*"([^"]+)"/m);
+  const cargoVersion = cargoMatch ? cargoMatch[1] : null;
+  
+  console.log(`  package.json: ${packageVersion}`);
+  console.log(`  Cargo.toml:   ${cargoVersion || 'not found'}`);
+  
+  if (cargoVersion && packageVersion !== cargoVersion) {
+    console.error('❌ Version mismatch between package.json and Cargo.toml');
+    return false;
+  }
+  
+  console.log('✅ Package versions are consistent');
+  return true;
+}
+
+function checkChangelog() {
+  console.log('\n🔍 Checking CHANGELOG.md...');
+  
+  if (!fs.existsSync('CHANGELOG.md')) {
+    console.error('❌ CHANGELOG.md not found');
+    return false;
+  }
+  
+  const changelog = fs.readFileSync('CHANGELOG.md', 'utf8');
+  const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  const currentVersion = packageJson.version;
+  
+  if (!changelog.includes(`## [${currentVersion}]`)) {
+    console.warn(`⚠️  Warning: Current version ${currentVersion} not found in CHANGELOG.md`);
+  } else {
+    console.log(`✅ CHANGELOG.md includes current version ${currentVersion}`);
+  }
+  
+  return true;
+}
+
+function checkCommitMessages() {
+  console.log('\n🔍 Checking recent commit messages...');
+  
+  const lastTag = run('git describe --tags --abbrev=0 2>/dev/null', true);
+  const range = lastTag ? `${lastTag}..HEAD` : '--all';
+  
+  const commits = run(`git log --format="%s" ${range}`, true);
+  
+  if (!commits) {
+    console.log('ℹ️  No commits to check');
+    return true;
+  }
+  
+  const commitLines = commits.split('\n').filter(Boolean);
+  const conventionalTypes = ['feat', 'fix', 'docs', 'style', 'refactor', 'perf', 'test', 'chore', 'ci', 'build', 'revert'];
+  
+  let conventionalCount = 0;
+  commitLines.forEach(commit => {
+    const match = commit.match(/^(\w+)(\(.+\))?:/);
+    if (match && conventionalTypes.includes(match[1])) {
+      conventionalCount++;
+    }
+  });
+  
+  const percentage = (conventionalCount / commitLines.length * 100).toFixed(0);
+  console.log(`  ${conventionalCount}/${commitLines.length} commits follow conventional format (${percentage}%)`);
+  
+  if (conventionalCount === 0) {
+    console.warn('⚠️  Warning: No conventional commits found');
+  } else {
+    console.log('✅ Found conventional commits');
+  }
+  
+  return true;
+}
+
+function checkBuildStatus() {
+  console.log('\n🔍 Checking if project builds...');
+  
+  try {
+    // Check if npm build works
+    console.log('  Running npm run build:lib...');
+    run('npm run build:lib');
+    console.log('✅ Build successful');
+    return true;
+  } catch (e) {
+    console.error('❌ Build failed');
+    console.error(e.message);
+    return false;
+  }
+}
+
+function checkTests() {
+  console.log('\n🔍 Checking tests...');
+  
+  try {
+    console.log('  Running tests...');
+    run('npm test');
+    console.log('✅ Tests passed');
+    return true;
+  } catch (e) {
+    console.error('❌ Tests failed');
+    console.error(e.message);
+    return false;
+  }
+}
+
+function main() {
+  console.log('🚀 Running pre-release checks for pluresdb\n');
+  
+  let allPassed = true;
+  
+  try {
+    checkGitStatus();
+    
+    if (!checkPackageVersions()) {
+      allPassed = false;
+    }
+    
+    if (!checkChangelog()) {
+      allPassed = false;
+    }
+    
+    checkCommitMessages();
+    
+    // Skip build and test checks in CI for now
+    if (process.env.CI !== 'true') {
+      if (!checkBuildStatus()) {
+        allPassed = false;
+      }
+      
+      if (!checkTests()) {
+        allPassed = false;
+      }
+    } else {
+      console.log('\nℹ️  Skipping build and test checks in CI');
+    }
+    
+    console.log('\n' + '='.repeat(50));
+    if (allPassed) {
+      console.log('✅ All pre-release checks passed!');
+      process.exit(0);
+    } else {
+      console.log('❌ Some pre-release checks failed');
+      process.exit(1);
+    }
+  } catch (e) {
+    console.error('\n❌ Pre-release check error:', e.message);
+    process.exit(1);
+  }
+}
+
+main();