squish-memory 0.8.2 → 0.9.2

package/scripts/install.mjs

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+
+/**
+ * Squish Memory v0.9.0 - OpenClaw Self-Install Script
+ *
+ * Usage: npx squish-memory install
+ *        node install.mjs
+ *        squish install
+ *
+ * This script:
+ * 1. Detects OpenClaw directory
+ * 2. Installs Squish CLI globally if needed
+ * 3. Configures MCP via mcporter
+ * 4. Creates .squish data directory
+ * 5. Runs health check
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const SQUISH_VERSION = "0.9.0";
+const OPENCLAW_DEFAULT_DIR = path.join(os.homedir(), ".openclaw");
+const SQUISH_DATA_DIR = path.join(os.homedir(), ".squish");
+
+const colors = {
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  reset: "\x1b[0m"
+};
+
+function log(color, message) {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function detectOpenClawDir() {
+  if (process.env.OPENCLAW_HOME) {
+    return process.env.OPENCLAW_HOME;
+  }
+  return OPENCLAW_DEFAULT_DIR;
+}
+
+function checkCommandAvailable(cmd) {
+  const result = spawnSync(cmd, ["--version"], {
+    encoding: "utf8",
+    shell: process.platform === "win32"
+  });
+  return result.status === 0;
+}
+
+function getSquishBinary() {
+  if (checkCommandAvailable("squish")) {
+    return "squish";
+  }
+
+  const candidates = [
+    path.join(os.homedir(), ".local", "bin", "squish"),
+    path.join(os.homedir(), "node_modules", ".bin", "squish"),
+    "/usr/local/bin/squish",
+    "/usr/bin/squish"
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function installSquishGlobally() {
+  log("blue", "Installing squish-memory globally...");
+
+  let result = spawnSync("bun", ["add", "-g", "squish-memory"], {
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    stdio: "inherit"
+  });
+
+  if (result.status !== 0) {
+    log("yellow", "bun not available, trying npm...");
+    result = spawnSync("npm", ["install", "-g", "squish-memory"], {
+      encoding: "utf8",
+      shell: process.platform === "win32",
+      stdio: "inherit"
+    });
+  }
+
+  return result.status === 0;
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+    log("green", `Created directory: ${dirPath}`);
+  }
+}
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+function backupIfExists(filePath) {
+  if (fs.existsSync(filePath)) {
+    const backupPath = `${filePath}.bak.${Date.now()}`;
+    fs.copyFileSync(filePath, backupPath);
+    log("yellow", `Backed up: ${backupPath}`);
+    return backupPath;
+  }
+  return null;
+}
+
+function configureMcporter(openclawDir) {
+  const mcporterPath = path.join(openclawDir, "mcporter.json");
+
+  const squishConfig = {
+    command: "squish",
+    args: [],
+    env: {
+      SQUISH_MODE: "local",
+      SQUISH_EMBEDDINGS_PROVIDER: "local"
+    },
+    transport: "stdio"
+  };
+
+  let config = readJson(mcporterPath) || { mcpServers: {} };
+
+  if (config.mcpServers?.squish) {
+    log("cyan", "Squish already configured in mcporter.json");
+    return true;
+  }
+
+  backupIfExists(mcporterPath);
+
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  config.mcpServers.squish = squishConfig;
+
+  writeJson(mcporterPath, config);
+  log("green", `Configured mcporter: ${mcporterPath}`);
+
+  return true;
+}
+
+function runHealthCheck() {
+  const squishBin = getSquishBinary();
+  if (!squishBin) {
+    log("yellow", "Squish binary not found, skipping health check");
+    return false;
+  }
+
+  log("blue", "Running health check...");
+  const result = spawnSync(squishBin, ["health"], {
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    stdio: "inherit"
+  });
+
+  return result.status === 0;
+}
+
+function printSuccess(openclawDir) {
+  console.log("");
+  log("green", "===========================================");
+  log("green", `  Squish Memory v${SQUISH_VERSION} Installed!`);
+  log("green", "===========================================");
+  console.log("");
+  log("cyan", "Configuration:");
+  console.log(`  OpenClaw dir: ${openclawDir}`);
+  console.log(`  Data dir:     ${SQUISH_DATA_DIR}`);
+  console.log(`  MCP config:   ${path.join(openclawDir, "mcporter.json")}`);
+  console.log("");
+  log("cyan", "CLI Commands:");
+  console.log("  squish health              - Check service health");
+  console.log("  squish remember \"text\"    - Store a memory");
+  console.log("  squish search \"query\"     - Search memories");
+  console.log("  squish stats               - View statistics");
+  console.log("");
+  log("cyan", "MCP Tools (via mcporter):");
+  console.log("  remember, search, recall, observe");
+  console.log("  context, health, core_memory, forget");
+  console.log("");
+  log("blue", "Documentation: https://github.com/michielhdoteth/squish");
+  console.log("");
+}
+
+function printDryRun(openclawDir) {
+  log("cyan", "=== DRY RUN MODE ===");
+  console.log("");
+  console.log("Would perform:");
+  console.log(`  1. Ensure OpenClaw dir: ${openclawDir}`);
+  console.log(`  2. Ensure data dir: ${SQUISH_DATA_DIR}`);
+  console.log(`  3. Configure mcporter: ${path.join(openclawDir, "mcporter.json")}`);
+  console.log(`  4. Run health check`);
+  console.log("");
+}
+
+function parseArgs(argv) {
+  const args = {
+    dryRun: false,
+    openclawDir: null,
+    skipInstall: false
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--dry-run" || token === "-n") {
+      args.dryRun = true;
+      continue;
+    }
+    if (token === "--openclaw-dir" || token === "-o") {
+      args.openclawDir = path.resolve(argv[i + 1]);
+      i++;
+      continue;
+    }
+    if (token === "--skip-install") {
+      args.skipInstall = true;
+      continue;
+    }
+    if (token === "--help" || token === "-h") {
+      console.log(`
+Squish Memory v${SQUISH_VERSION} - OpenClaw Self-Install
+
+Usage: npx squish-memory install [options]
+
+Options:
+  --dry-run, -n          Show what would be done without making changes
+  --openclaw-dir, -o     Specify OpenClaw directory (default: ~/.openclaw)
+  --skip-install         Skip global npm install step
+  --help, -h             Show this help message
+`);
+      process.exit(0);
+    }
+  }
+
+  return args;
+}
+
+/**
+ * Run the installer programmatically (for CLI command)
+ */
+export async function runInstall(options = {}) {
+  const {
+    dryRun = false,
+    openclawDir: customOpenclawDir = null,
+    skipInstall = false
+  } = options;
+
+  log("blue", `Squish Memory v${SQUISH_VERSION} - OpenClaw Installer`);
+  log("blue", "===================================================");
+  console.log("");
+
+  const openclawDir = customOpenclawDir || detectOpenClawDir();
+
+  if (dryRun) {
+    printDryRun(openclawDir);
+    return { success: true, dryRun: true };
+  }
+
+  // Step 1: Check/install Squish globally
+  let squishBin = getSquishBinary();
+  if (!squishBin && !skipInstall) {
+    const installed = installSquishGlobally();
+    if (!installed) {
+      log("red", "Failed to install squish-memory globally");
+      log("yellow", "Please install manually: npm install -g squish-memory");
+      return { success: false, error: "Failed to install globally" };
+    }
+    squishBin = getSquishBinary();
+  }
+
+  if (!squishBin) {
+    log("red", "Squish binary not found after installation");
+    return { success: false, error: "Squish binary not found" };
+  }
+
+  log("green", `Squish binary: ${squishBin}`);
+
+  // Step 2: Ensure OpenClaw directory exists
+  ensureDir(openclawDir);
+
+  // Step 3: Ensure .squish data directory exists
+  ensureDir(SQUISH_DATA_DIR);
+
+  // Step 4: Configure mcporter
+  configureMcporter(openclawDir);
+
+  // Step 5: Run health check
+  const healthOk = runHealthCheck();
+
+  if (!healthOk) {
+    log("yellow", "Health check failed, but installation completed");
+    log("yellow", "You may need to restart your shell or add squish to PATH");
+  }
+
+  // Print success message
+  printSuccess(openclawDir);
+
+  return { success: true };
+}
+
+/**
+ * Main entry point when run directly
+ */
+async function main() {
+  const args = parseArgs(process.argv);
+  const result = await runInstall({
+    dryRun: args.dryRun,
+    openclawDir: args.openclawDir,
+    skipInstall: args.skipInstall
+  });
+
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+
+// Run main if executed directly
+main().catch((err) => {
+  log("red", `Installation failed: ${err.message}`);
+  console.error(err);
+  process.exit(1);
+});

package/scripts/openclaw-bootstrap.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const root = process.cwd();
+const defaultSourceDir = path.join(root, "generated", "mcp");
+const defaultTargetDir = path.join(os.homedir(), ".openclaw");
+
+function parseArgs(argv) {
+  const args = {
+    sourceDir: defaultSourceDir,
+    targetDir: defaultTargetDir,
+    dryRun: false,
+    skipToolCheck: false
+  };
+
+  for (let i = 2; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--dry-run") {
+      args.dryRun = true;
+      continue;
+    }
+    if (token === "--skip-tool-check") {
+      args.skipToolCheck = true;
+      continue;
+    }
+    if (token === "--source") {
+      args.sourceDir = path.resolve(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (token === "--target") {
+      args.targetDir = path.resolve(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${token}`);
+  }
+
+  return args;
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function checkBinaryAvailable(binaryName) {
+  const run = spawnSync(binaryName, ["--version"], { encoding: "utf8" });
+  return run.status === 0;
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+function deepMerge(base, overlay) {
+  if (Array.isArray(base) || Array.isArray(overlay)) {
+    return overlay;
+  }
+  if (base && typeof base === "object" && overlay && typeof overlay === "object") {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(overlay)) {
+      out[key] = key in out ? deepMerge(out[key], value) : value;
+    }
+    return out;
+  }
+  return overlay;
+}
+
+function backupIfExists(filePath) {
+  if (fs.existsSync(filePath)) {
+    fs.copyFileSync(filePath, `${filePath}.bak`);
+  }
+}
+
+function requireSource(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Required source artifact not found: ${filePath}`);
+  }
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+
+  if (!args.skipToolCheck) {
+    if (!checkBinaryAvailable("mcporter")) {
+      throw new Error("mcporter is not available on PATH");
+    }
+    if (!checkBinaryAvailable("qmd")) {
+      throw new Error("qmd is not available on PATH");
+    }
+  }
+
+  const mcporterSource = path.join(args.sourceDir, "mcporter.json");
+  const openclawSnippetSource = path.join(args.sourceDir, "openclaw-memory-qmd.json");
+  requireSource(mcporterSource);
+  requireSource(openclawSnippetSource);
+
+  ensureDir(args.targetDir);
+
+  const mcporterTarget = path.join(args.targetDir, "mcporter.json");
+  const memoryTarget = path.join(args.targetDir, "openclaw-memory.json");
+
+  if (!args.dryRun) {
+    backupIfExists(mcporterTarget);
+    fs.copyFileSync(mcporterSource, mcporterTarget);
+
+    const base = fs.existsSync(memoryTarget) ? readJson(memoryTarget) : {};
+    const snippet = readJson(openclawSnippetSource);
+    const merged = deepMerge(base, snippet);
+    backupIfExists(memoryTarget);
+    writeJson(memoryTarget, merged);
+  }
+
+  const prefix = args.dryRun ? "DRY_RUN" : "BOOTSTRAPPED";
+  console.log(`${prefix} mcporter config -> ${mcporterTarget}`);
+  console.log(`${prefix} memory config merge -> ${memoryTarget}`);
+}
+
+main();

package/scripts/package-release.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+
+# Squish Release Packaging Script
+# Creates platform-specific packages for distribution
+
+set -e
+
+VERSION=$(node -p "require('./package.json').version")
+echo "Building Squish v$VERSION release packages..."
+
+# Clean previous builds
+rm -rf dist/ *.tar.gz *.zip
+
+# Build production version
+npm run build:prod
+
+# Create platform-specific packages
+create_package() {
+    local platform=$1
+    local arch=$2
+    local output_name="squish-${VERSION}-${platform}-${arch}"
+
+    echo "Creating $output_name..."
+
+    # Create package directory
+    mkdir -p "package/$output_name"
+    mkdir -p "package/$output_name/bin"
+
+    # Copy files
+    cp -r dist/prod/* "package/$output_name/"
+    cp install.sh "package/$output_name/"
+    cp README.md "package/$output_name/"
+    cp LICENSE "package/$output_name/"
+
+    # Create executable wrapper
+    cat > "package/$output_name/bin/squish" << 'EOF'
+#!/bin/bash
+# Squish wrapper script
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+exec node "$DIR/src/index.js" "$@"
+EOF
+    chmod +x "package/$output_name/bin/squish"
+
+    # Create archive
+    cd package
+    if [[ "$platform" == "windows" ]]; then
+        zip -r "../${output_name}.zip" "$output_name"
+    else
+        tar -czf "../${output_name}.tar.gz" "$output_name"
+    fi
+    cd ..
+
+    echo "✓ Created ${output_name}.tar.gz"
+}
+
+# Build for multiple platforms
+create_package "linux" "x64"
+create_package "linux" "arm64"
+create_package "macos" "x64"
+create_package "macos" "arm64"
+create_package "windows" "x64"
+
+# Clean up
+rm -rf package/
+
+echo ""
+echo "🎉 Release packages created:"
+ls -la *.tar.gz *.zip 2>/dev/null || true
+echo ""
+echo "Upload these to GitHub releases at:"
+echo "https://github.com/michielhdoteth/squish/releases/tag/v$VERSION"

package/scripts/remote-preflight.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+
+const root = process.cwd();
+const policyPath = path.join(root, "config", "remote-memory-policy.json");
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+function warn(message) {
+  process.stderr.write(`[warn] ${message}\n`);
+}
+
+function readPolicy() {
+  if (!fs.existsSync(policyPath)) {
+    fail(`Missing policy file: ${policyPath}`);
+  }
+  try {
+    return JSON.parse(fs.readFileSync(policyPath, "utf8"));
+  } catch (error) {
+    fail(`Invalid policy JSON: ${String(error)}`);
+  }
+}
+
+function main() {
+  const policy = readPolicy();
+  const required = Array.isArray(policy.requiredEnv) ? policy.requiredEnv : [];
+
+  const missing = required.filter((key) => {
+    const value = process.env[key];
+    return !value || value.trim().length === 0;
+  });
+
+  if (missing.length > 0) {
+    fail(`Remote preflight failed: missing required env vars: ${missing.join(", ")}`);
+  }
+
+  const provider = process.env.SQUISH_EMBEDDINGS_PROVIDER || "local";
+  if (!["local", "openai", "ollama", "none", "hybrid", "qmd"].includes(provider)) {
+    fail(`Remote preflight failed: invalid SQUISH_EMBEDDINGS_PROVIDER='${provider}'`);
+  }
+
+  if (provider === "openai" && !process.env.SQUISH_OPENAI_API_KEY) {
+    warn("SQUISH_EMBEDDINGS_PROVIDER=openai but SQUISH_OPENAI_API_KEY is missing");
+  }
+
+  process.stdout.write(
+    `${JSON.stringify({
+      success: true,
+      mode: "remote",
+      requiredEnvChecked: required,
+      embeddingsProvider: provider,
+      memoryPolicyVersion: policy.version
+    })}\n`
+  );
+}
+
+main();