squish-memory 0.9.2 → 1.0.0

package/scripts/dependency-manager.mjs

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const root = process.cwd();
+
+// Load manifest to get pinned versions
+function loadManifest() {
+  const manifestPath = path.join(root, "config", "plugin-manifest.json");
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`Plugin manifest not found: ${manifestPath}`);
+  }
+  return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+}
+
+function which(binaryName) {
+  const isWindows = process.platform === "win32";
+  const extensions = isWindows ? [".exe", ".cmd", ".bat"] : [""];
+  
+  const envPath = process.env.PATH || "";
+  const paths = envPath.split(path.delimiter);
+  
+  for (const dir of paths) {
+    for (const ext of extensions) {
+      const fullPath = path.join(dir, binaryName + ext);
+      try {
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+          return fullPath;
+        }
+      } catch {
+        // ignore
+      }
+    }
+  }
+  return null;
+}
+
+function checkBinary(binaryName) {
+  const path = which(binaryName);
+  if (!path) return { available: false, path: null };
+  
+  const result = spawnSync(binaryName, ["--version"], { 
+    encoding: "utf8", 
+    timeout: 5000 
+  });
+  const version = result.stdout.trim().split("\n")[0] || result.stderr.trim().split("\n")[0];
+  return { available: true, path, version: version || "unknown" };
+}
+
+function installPackage(packageName, version, packageManager = "npm") {
+  console.log(`[DEP] Installing ${packageName}@${version} via ${packageManager}...`);
+  const result = spawnSync(
+    packageManager,
+    ["install", "-g", `${packageName}@${version}`],
+    { 
+      encoding: "utf8",
+      stdio: "inherit",
+      timeout: 120000 
+    }
+  );
+  return result.status === 0;
+}
+
+function verifyInstallation(binaryName, expectedVersion) {
+  const check = checkBinary(binaryName);
+  if (!check.available) {
+    return { ok: false, error: `${binaryName} not found on PATH` };
+  }
+  
+  // Version verification: just check it's present, exact match not required
+  // since binary might report different format
+  console.log(`[DEP] ✓ ${binaryName} available at ${check.path} (${check.version})`);
+  return { ok: true, path: check.path, version: check.version };
+}
+
+function getBinaryName(packageName) {
+  // For scoped packages like @tobilu/qmd, the binary is just "qmd"
+  if (packageName.startsWith("@")) {
+    return packageName.split("/").pop();
+  }
+  return packageName;
+}
+
+function installDependency(name, depConfig) {
+  const { version, autoInstall, optional } = depConfig;
+  const binaryName = getBinaryName(name);
+  
+  console.log(`\n[DEP] Checking dependency: ${name}@${version} (binary: ${binaryName})`);
+  
+  const check = checkBinary(binaryName);
+  
+  if (check.available) {
+    console.log(`[DEP] ✓ ${name} already installed`);
+    return { status: "ok", installed: true, path: check.path };
+  }
+  
+  if (!autoInstall) {
+    const msg = optional 
+      ? `[DEP] ⚠ ${name} is optional but not installed`
+      : `[DEP] ✗ ${name} is required but not installed`;
+    console.log(msg);
+    return { 
+      status: optional ? "warning" : "error", 
+      error: `${name} not found and autoInstall disabled` 
+    };
+  }
+  
+  console.log(`[DEP] Auto-installing ${name}@${version}...`);
+  
+  const packageManagers = ["npm", "bun"];
+  let success = false;
+  
+  for (const pm of packageManagers) {
+    success = installPackage(name, version, pm);
+    if (success) break;
+    console.log(`[DEP] ${pm} install failed, trying next...`);
+  }
+  
+  if (!success) {
+    return { 
+      status: "error", 
+      error: `Failed to install ${name}@${version}` 
+    };
+  }
+  
+  const verify = verifyInstallation(name, version);
+  if (!verify.ok) {
+    return { status: "error", error: verify.error };
+  }
+  
+  console.log(`[DEP] ✓ Successfully installed ${name}`);
+  return { status: "ok", installed: true, path: verify.path };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+  const strict = args.includes("--strict");
+  const showVersions = args.includes("--versions");
+  
+  try {
+    const manifest = loadManifest();
+    const dependencies = manifest.dependencies || {};
+    
+    console.log(`[DEP] Squish Dependency Manager v${manifest.version}`);
+    console.log(`[DEP] Mode: ${dryRun ? "DRY_RUN" : "LIVE"}`);
+    
+    if (dryRun) {
+      console.log("[DEP] DRY RUN - no installations will be performed");
+    }
+    
+    const results = {};
+    let hasErrors = false;
+    
+    for (const [name, config] of Object.entries(dependencies)) {
+      const binaryName = getBinaryName(name);
+      const check = checkBinary(binaryName);
+      
+      if (showVersions) {
+        console.log(`[VER] ${name}: ${check.available ? check.version : "NOT INSTALLED"}`);
+        continue;
+      }
+      
+      if (check.available) {
+        console.log(`[DEP] ✓ ${name} ${check.version} (already installed)`);
+        results[name] = { status: "ok", installed: true, path: check.path, version: check.version };
+        continue;
+      }
+      
+      if (!config.autoInstall) {
+        console.log(`[DEP] ${name}: required but not installed (autoInstall=false)`);
+        if (strict) {
+          hasErrors = true;
+          results[name] = { status: "error", error: "required but not installed" };
+        } else {
+          results[name] = { status: "warning", error: "required but not installed" };
+        }
+        continue;
+      }
+      
+      if (dryRun) {
+        console.log(`[DEP] [DRY_RUN] Would install ${name}@${config.version}`);
+        results[name] = { status: "ok", wouldInstall: true, version: config.version };
+        continue;
+      }
+      
+      const result = installDependency(name, config);
+      results[name] = result;
+      if (result.status === "error") {
+        hasErrors = true;
+      }
+    }
+    
+    console.log("\n[DEP] Dependency check complete");
+    
+    const summary = Object.entries(results)
+      .map(([name, res]) => `  ${name}: ${res.status}${res.path ? ` (${res.path})` : ''}`)
+      .join("\n");
+    console.log(`Results:\n${summary}`);
+    
+    if (hasErrors) {
+      console.error("[DEP] Some dependencies failed to install");
+      process.exit(1);
+    }
+    
+    process.exit(0);
+    
+  } catch (error) {
+    console.error("[DEP] Fatal error:", error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/detect-clients.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// Client default directories
+const CLIENT_DIRS = {
+  "claude-code": path.join(os.homedir(), ".claude"),
+  opencode: path.join(os.homedir(), ".config", "opencode"),
+  codex: path.join(os.homedir(), ".codex"),
+  cursor: path.join(os.homedir(), ".cursor"),
+  vscode: path.join(os.homedir(), ".vscode", "mcp"),
+  windsurf: path.join(os.homedir(), ".windsurf"),
+  openclaw: path.join(os.homedir(), ".openclaw")
+};
+
+function detectClient(client) {
+  const dir = CLIENT_DIRS[client];
+  if (!dir) return false;
+  
+  try {
+    return fs.existsSync(dir);
+  } catch {
+    return false;
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const all = args.includes("--all");
+  const json = args.includes("--json");
+  
+  const results = {};
+  
+  if (all) {
+    for (const client of Object.keys(CLIENT_DIRS)) {
+      results[client] = detectClient(client);
+    }
+  } else {
+    const clientsToCheck = args.length > 0 ? args : Object.keys(CLIENT_DIRS);
+    for (const client of clientsToCheck) {
+      if (CLIENT_DIRS[client]) {
+        results[client] = detectClient(client);
+      } else {
+        results[client] = false;
+      }
+    }
+  }
+  
+  if (json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    console.log("\nClient Detection Results:");
+    console.log("========================\n");
+    
+    const detected = Object.entries(results).filter(([_, present]) => present);
+    const notDetected = Object.entries(results).filter(([_, present]) => !present);
+    
+    if (detected.length > 0) {
+      console.log("Detected clients:");
+      for (const [client] of detected) {
+        console.log(`  ✓ ${client} (${CLIENT_DIRS[client]})`);
+      }
+    }
+    
+    if (notDetected.length > 0) {
+      console.log("\nNot detected:");
+      for (const [client] of notDetected) {
+        console.log(`  ✗ ${client} (expected at ${CLIENT_DIRS[client]})`);
+      }
+    }
+    
+    console.log("\nSummary:", detected.length, "detected,", notDetected.length, "missing");
+  }
+}
+
+main();

package/scripts/github-release.sh

@@ -3,49 +3,65 @@
 # Squish GitHub Release Script
 # Run after npm publish to create GitHub release
 
-VERSION="0.3.0"
+# Auto-detect version from package.json
+VERSION=$(node -p "require('./package.json').version")
 REPO="michielhdoteth/squish"
 
-echo "🏷️ Creating GitHub release v$VERSION..."
+echo "Creating GitHub release v$VERSION..."
 
 # Build binaries for different platforms
-echo "🔨 Building binaries..."
+echo "Building binaries..."
+
+# Create temporary directory for release assets
+mkdir -p release-assets
+cd release-assets
 
 # Linux x64
 echo "Building linux-x64..."
-npx pkg dist/index.js --targets node18-linux-x64 --output bin/squish-linux-x64
-tar -czf squish-v${VERSION}-linux-x64.tar.gz bin/ dist/ plugin.json README.md LICENSE
+npx pkg ../dist/index.js --targets node18-linux-x64 --output squish-linux-x64
+tar -czf "../squish-v${VERSION}-linux-x64.tar.gz" squish-linux-x64 ../dist/ ../plugin.json ../README.md ../LICENSE
 
 # Linux ARM64
 echo "Building linux-arm64..."
-npx pkg dist/index.js --targets node18-linux-arm64 --output bin/squish-linux-arm64
-tar -czf squish-v${VERSION}-linux-arm64.tar.gz bin/ dist/ plugin.json README.md LICENSE
+npx pkg ../dist/index.js --targets node18-linux-arm64 --output squish-linux-arm64
+tar -czf "../squish-v${VERSION}-linux-arm64.tar.gz" squish-linux-arm64 ../dist/ ../plugin.json ../README.md ../LICENSE
 
 # macOS ARM64 (Apple Silicon)
 echo "Building macos-arm64..."
-npx pkg dist/index.js --targets node18-macos-arm64 --output bin/squish-macos-arm64
-tar -czf squish-v${VERSION}-macos-arm64.tar.gz bin/ dist/ plugin.json README.md LICENSE
+npx pkg ../dist/index.js --targets node18-macos-arm64 --output squish-macos-arm64
+tar -czf "../squish-v${VERSION}-macos-arm64.tar.gz" squish-macos-arm64 ../dist/ ../plugin.json ../README.md ../LICENSE
 
 # Windows x64
 echo "Building windows-x64..."
-npx pkg dist/index.js --targets node18-win-x64 --output bin/squish-windows-x64.exe
-zip squish-v${VERSION}-windows-x64.zip bin/ dist/ plugin.json README.md LICENSE
+npx pkg ../dist/index.js --targets node18-win-x64 --output squish-windows-x64.exe
+zip "../squish-v${VERSION}-windows-x64.zip" squish-windows-x64.exe ../dist/ ../plugin.json ../README.md ../LICENSE
+
+cd ..
+rm -rf release-assets
+
+echo "Binaries created!"
 
-echo "📦 Binaries created!"
+# Check if gh CLI is available and user is authenticated
+if ! command -v gh &> /dev/null; then
+    echo "❌ GitHub CLI (gh) not installed. Skipping release creation."
+    echo "   Install gh CLI and run this script again to create GitHub release."
+    echo "   Alternatively, create release manually at: https://github.com/$REPO/releases/new?tag=v$VERSION"
+    exit 1
+fi
 
-# Create GitHub release (requires gh CLI)
-echo "🚀 Creating GitHub release..."
+# Create GitHub release
+echo "Creating GitHub release..."
 gh release create "v${VERSION}" \
-  --title "Squish v${VERSION} - Memory Plugin for Claude Code" \
-  --notes "Local-first persistent memory for Claude Code with code quality improvements and better maintainability.
+  --title "Squish v${VERSION} - Universal Memory for AI Agents" \
+  --notes "## What's New in v${VERSION}
 
-## What's New in v0.3.0
+Squish provides universal persistent memory for AI agents with support for MCP, CLI, and HTTP API.
 
-### Code Quality Improvements
-- Reduced complexity in core modules (summarization, temporal-facts, requirements)
-- Split long files into focused submodules for better organization
-- Eliminated ~200+ lines of duplicated code
-- Created 9 shared utility modules in core/utils/
+### Key Features
+- Two-tier memory architecture (QMD search + SQLite/PostgreSQL storage)
+- Trigger detection, contradiction resolution, and temporal facts
+- Universal API compatible with any AI agent framework
+- MCP server integration for Claude Code, OpenClaw, and other MCP clients
 
 ### Installation
 \`\`\`bash
@@ -53,9 +69,9 @@ npx squish-install
 \`\`\`
 
 Or visit: https://github.com/michielhdoteth/squish" \
-  squish-v${VERSION}-linux-x64.tar.gz \
-  squish-v${VERSION}-linux-arm64.tar.gz \
-  squish-v${VERSION}-macos-arm64.tar.gz \
-  squish-v${VERSION}-windows-x64.zip
+  "squish-v${VERSION}-linux-x64.tar.gz" \
+  "squish-v${VERSION}-linux-arm64.tar.gz" \
+  "squish-v${VERSION}-macos-arm64.tar.gz" \
+  "squish-v${VERSION}-windows-x64.zip"
 
-echo "🎉 Release v${VERSION} published!"
+echo "Release v${VERSION} published!"