squish-memory 0.8.2 → 0.9.1

package/scripts/db/fix-schema.mjs

@@ -0,0 +1,38 @@
+import Database from 'better-sqlite3';
+import { getDataDir } from './dist/config.js';
+
+const dbPath = `${getDataDir()}/squish.db`;
+console.log(`Fixing schema for: ${dbPath}`);
+
+const db = new Database(dbPath);
+
+// Check if embedding column exists
+const tableInfo = db.prepare("PRAGMA table_info(memories)").all();
+const hasEmbedding = tableInfo.some(col => col.name === 'embedding');
+
+if (!hasEmbedding) {
+  console.log('Adding missing embedding column...');
+  db.exec(`ALTER TABLE memories ADD COLUMN embedding BLOB;`);
+  console.log('✅ Added embedding column');
+} else {
+  console.log('✅ embedding column already exists');
+}
+
+// Check other tables that might need the embedding column
+const tables = ['observations', 'messages', 'entities'];
+for (const table of tables) {
+  const info = db.prepare(`PRAGMA table_info(${table})`).all();
+  const hasCol = info.some(col => col.name === 'embedding');
+  if (!hasCol) {
+    console.log(`Adding embedding column to ${table}...`);
+    try {
+      db.exec(`ALTER TABLE ${table} ADD COLUMN embedding BLOB;`);
+      console.log(`✅ Added embedding column to ${table}`);
+    } catch (e) {
+      console.log(`⚠️ Could not add to ${table}: ${e.message}`);
+    }
+  }
+}
+
+db.close();
+console.log('✅ Schema fix complete');

package/scripts/db/init-db.mjs

@@ -0,0 +1,13 @@
+import { createDb } from './dist/db/adapter.js';
+
+async function main() {
+  try {
+    await createDb();
+    console.log('✅ Database initialized successfully');
+  } catch (error) {
+    console.error('❌ Failed to initialize database:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/db/recreate-db.mjs

@@ -0,0 +1,14 @@
+import { createDb } from './dist/db/adapter.js';
+
+async function main() {
+  try {
+    console.log('Creating database with proper schema...');
+    await createDb();
+    console.log('✅ Database recreated successfully');
+  } catch (error) {
+    console.error('❌ Failed:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/generate-mcp.mjs

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+
+const root = process.cwd();
+const defaultSourcePath = path.join(root, "config", "mcp.json");
+const defaultOutDir = path.join(root, "generated", "mcp");
+const defaultImports = [
+  "cursor",
+  "claude-code",
+  "claude-desktop",
+  "codex",
+  "windsurf",
+  "opencode",
+  "vscode"
+];
+
+function parseArgs(argv) {
+  const args = {
+    configPath: defaultSourcePath,
+    outDir: defaultOutDir,
+    strictEnv: false
+  };
+
+  for (let i = 2; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--strict-env") {
+      args.strictEnv = true;
+      continue;
+    }
+    if (token === "--config") {
+      args.configPath = path.resolve(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (token === "--out") {
+      args.outDir = path.resolve(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${token}`);
+  }
+
+  return args;
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+function sha256File(filePath) {
+  const hash = crypto.createHash("sha256");
+  hash.update(fs.readFileSync(filePath));
+  return hash.digest("hex");
+}
+
+function sortObjectKeys(input) {
+  if (Array.isArray(input)) {
+    return input.map(sortObjectKeys);
+  }
+  if (input && typeof input === "object") {
+    const sorted = {};
+    for (const key of Object.keys(input).sort()) {
+      sorted[key] = sortObjectKeys(input[key]);
+    }
+    return sorted;
+  }
+  return input;
+}
+
+function extractEnvPlaceholders(servers) {
+  const placeholders = [];
+  for (const [serverName, server] of Object.entries(servers)) {
+    const env = server?.env || {};
+    for (const [envKey, value] of Object.entries(env)) {
+      if (typeof value !== "string") continue;
+      const match = value.match(/^\$\{([A-Z0-9_]+)\}$/);
+      if (match) {
+        placeholders.push({ serverName, envKey, variable: match[1] });
+      }
+    }
+  }
+  return placeholders;
+}
+
+function validateConfig(config, strictEnv) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Invalid config: expected object");
+  }
+
+  if (!config.defaults || typeof config.defaults !== "object") {
+    throw new Error("Invalid config: defaults must be an object");
+  }
+
+  if (!config.servers || typeof config.servers !== "object") {
+    throw new Error("Invalid config: servers must be an object");
+  }
+
+  const serverNames = Object.keys(config.servers);
+  if (serverNames.length === 0) {
+    throw new Error("Invalid config: at least one server is required");
+  }
+
+  for (const [serverName, server] of Object.entries(config.servers)) {
+    if (!server || typeof server !== "object") {
+      throw new Error(`Invalid server ${serverName}: expected object`);
+    }
+    if (!server.command || typeof server.command !== "string") {
+      throw new Error(`Invalid server ${serverName}: command is required`);
+    }
+    if (!Array.isArray(server.args)) {
+      throw new Error(`Invalid server ${serverName}: args must be an array`);
+    }
+    if (!server.transport || typeof server.transport !== "string") {
+      throw new Error(`Invalid server ${serverName}: transport is required`);
+    }
+    if (!server.env || typeof server.env !== "object") {
+      throw new Error(`Invalid server ${serverName}: env must be an object`);
+    }
+  }
+
+  const includeServers = config.includeServers || [];
+  if (includeServers.length > 0) {
+    const unique = new Set(includeServers);
+    if (unique.size !== includeServers.length) {
+      throw new Error("Invalid config: includeServers contains duplicates");
+    }
+    for (const name of includeServers) {
+      if (!config.servers[name]) {
+        throw new Error(`Invalid config: includeServers references unknown server ${name}`);
+      }
+    }
+  }
+
+  if (strictEnv) {
+    const unresolved = extractEnvPlaceholders(config.servers)
+      .filter((entry) => !process.env[entry.variable]);
+    if (unresolved.length > 0) {
+      const first = unresolved[0];
+      throw new Error(
+        `Missing required env for strict mode: ${first.variable} (server=${first.serverName}, key=${first.envKey})`
+      );
+    }
+  }
+}
+
+function selectServers(config) {
+  const include = config.includeServers || [];
+  if (include.length === 0) {
+    return config.servers;
+  }
+  const selected = {};
+  for (const serverName of include) {
+    selected[serverName] = config.servers[serverName];
+  }
+  return selected;
+}
+
+function toOpenClawMemoryConfig(runtime) {
+  return {
+    memory: {
+      backend: "qmd",
+      qmd: {
+        mcporter: {
+          enabled: true,
+          serverName: "qmd",
+          startDaemon: true
+        },
+        limits: {
+          timeoutMs: runtime.requestTimeoutMs,
+          maxSnippetChars: runtime.resultMaxChars,
+          maxResults: 12
+        }
+      }
+    }
+  };
+}
+
+function toMcporterConfig(servers) {
+  return {
+    mcpServers: servers,
+    imports: defaultImports
+  };
+}
+
+function removeLegacyProfileDirectories(outDir) {
+  const removed = [];
+  if (!fs.existsSync(outDir)) return;
+  const entries = fs.readdirSync(outDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      fs.rmSync(path.join(outDir, entry.name), { recursive: true, force: true });
+      removed.push(entry.name);
+    }
+  }
+  return removed;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const config = readJson(args.configPath);
+
+  validateConfig(config, args.strictEnv);
+
+  ensureDir(args.outDir);
+  const removedLegacyDirs = removeLegacyProfileDirectories(args.outDir) || [];
+
+  if (config.profiles && typeof config.profiles === "object") {
+    console.warn(
+      "[mcp-migration] legacy profiles detected in config/mcp.json and ignored by universal generator"
+    );
+  }
+  if (removedLegacyDirs.length > 0) {
+    console.warn(
+      `[mcp-migration] removed legacy profile output directories: ${removedLegacyDirs.join(", ")}`
+    );
+  }
+
+  const runtime = sortObjectKeys(config.defaults);
+  const selectedServers = sortObjectKeys(selectServers(config));
+
+  const fileMap = {
+    "runtime.json": runtime,
+    "mcp-servers.json": { mcpServers: selectedServers },
+    "mcporter.json": toMcporterConfig(selectedServers),
+    "openclaw-memory-qmd.json": toOpenClawMemoryConfig(runtime)
+  };
+
+  for (const [fileName, json] of Object.entries(fileMap)) {
+    writeJson(path.join(args.outDir, fileName), json);
+  }
+
+  const manifestFiles = Object.keys(fileMap)
+    .sort()
+    .map((fileName) => {
+      const filePath = path.join(args.outDir, fileName);
+      return {
+        file: fileName,
+        sha256: sha256File(filePath)
+      };
+    });
+
+  const manifest = {
+    mode: "universal",
+    generatedAt: new Date().toISOString(),
+    source: path.relative(root, args.configPath).replace(/\\/g, "/"),
+    files: manifestFiles
+  };
+
+  writeJson(path.join(args.outDir, "manifest.json"), manifest);
+  console.log(`Generated universal MCP artifacts in ${args.outDir}`);
+}
+
+main();

package/scripts/github-release.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+# Squish GitHub Release Script
+# Run after npm publish to create GitHub release
+
+VERSION="0.3.0"
+REPO="michielhdoteth/squish"
+
+echo "🏷️ Creating GitHub release v$VERSION..."
+
+# Build binaries for different platforms
+echo "🔨 Building binaries..."
+
+# 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
+
+# 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
+
+# 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
+
+# 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
+
+echo "📦 Binaries created!"
+
+# Create GitHub release (requires gh CLI)
+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.
+
+## What's New in v0.3.0
+
+### 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/
+
+### Installation
+\`\`\`bash
+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
+
+echo "🎉 Release v${VERSION} published!"

package/scripts/init-dirs.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const defaultDir = join(homedir(), '.squish');
+
+if (!existsSync(defaultDir)) {
+  mkdirSync(defaultDir, { recursive: true });
+}
+
+console.log(`Squish data directory: ${defaultDir}`);

package/scripts/init-dirs.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Squish Directory Initialization
+ * Creates default data directories for npm-installed Squish
+ */
+import { mkdirSync, existsSync } from 'fs';
+import { join, homedir } from 'path';
+
+// Create ~/.squish (default global data directory)
+const defaultDir = join(homedir(), '.squish');
+if (!existsSync(defaultDir)) {
+  mkdirSync(defaultDir, { recursive: true });
+}
+
+console.log(`Squish data directory: ${defaultDir}`);

package/scripts/install-mcp.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const root = process.cwd();
+const defaultSourceDir = path.join(root, "generated", "mcp");
+
+const clientDefaultDirs = {
+  "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 parseArgs(argv) {
+  const args = {
+    client: "",
+    sourceDir: defaultSourceDir,
+    targetDir: "",
+    dryRun: false,
+    backup: true
+  };
+
+  for (let i = 2; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--dry-run") {
+      args.dryRun = true;
+      continue;
+    }
+    if (token === "--no-backup") {
+      args.backup = false;
+      continue;
+    }
+    if (token === "--client") {
+      args.client = argv[i + 1];
+      i += 1;
+      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}`);
+  }
+
+  if (!args.client) {
+    throw new Error("Missing required argument: --client");
+  }
+  if (!clientDefaultDirs[args.client]) {
+    throw new Error(`Unsupported client: ${args.client}`);
+  }
+  if (!args.targetDir) {
+    args.targetDir = clientDefaultDirs[args.client];
+  }
+
+  return args;
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function backupFile(targetPath) {
+  if (!fs.existsSync(targetPath)) return;
+  fs.copyFileSync(targetPath, `${targetPath}.bak`);
+}
+
+function copyFile(sourcePath, targetPath, options) {
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(`Missing source file: ${sourcePath}`);
+  }
+  if (options.backup) {
+    backupFile(targetPath);
+  }
+  if (!options.dryRun) {
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+}
+
+function filePlanForClient(client) {
+  if (client === "openclaw") {
+    return [
+      { from: "mcporter.json", to: "mcporter.json" },
+      { from: "openclaw-memory-qmd.json", to: "openclaw-memory-qmd.json" }
+    ];
+  }
+  return [{ from: "mcp-servers.json", to: "mcp-servers.json" }];
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const plan = filePlanForClient(args.client);
+
+  ensureDir(args.targetDir);
+
+  for (const item of plan) {
+    const sourcePath = path.join(args.sourceDir, item.from);
+    const targetPath = path.join(args.targetDir, item.to);
+    copyFile(sourcePath, targetPath, args);
+    const modeTag = args.dryRun ? "DRY_RUN" : "INSTALLED";
+    console.log(`${modeTag} ${item.from} -> ${targetPath}`);
+  }
+}
+
+main();

package/scripts/install-web.sh

@@ -0,0 +1,120 @@
+#!/bin/bash
+
+# Simple web server to host Squish install script
+# This would be deployed to make https://get.squish.dev work
+
+echo "Content-Type: application/x-shellscript"
+echo ""
+cat << 'EOF'
+#!/bin/bash
+
+# Squish v0.2.6 - One-line installer for Claude Code Plugin
+# Usage: curl -fsSL https://get.squish.dev | bash
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}🐙 Installing Squish Memory v0.2.6...${NC}"
+
+# Detect platform and architecture
+detect_platform() {
+    case "$(uname -s)" in
+        Linux*)     PLATFORM="linux" ;;
+        Darwin*)    PLATFORM="macos" ;;
+        CYGWIN*|MINGW*|MSYS*) PLATFORM="windows" ;;
+        *)          echo -e "${RED}Unsupported platform: $(uname -s)${NC}"; exit 1 ;;
+    esac
+
+    case "$(uname -m)" in
+        x86_64|amd64) ARCH="x64" ;;
+        arm64|aarch64) ARCH="arm64" ;;
+        *)          echo -e "${RED}Unsupported architecture: $(uname -m)${NC}"; exit 1 ;;
+    esac
+}
+
+# Download and extract Squish
+install_squish() {
+    echo -e "${BLUE}Downloading Squish for ${PLATFORM}-${ARCH}...${NC}"
+
+    TMP_DIR=$(mktemp -d)
+    cd "$TMP_DIR"
+
+    DOWNLOAD_URL="https://github.com/michielhdoteth/squish-memory/releases/download/v0.2.6"
+
+    if [ "$PLATFORM" = "windows" ]; then
+        FILENAME="squish-v0.2.6-windows-${ARCH}.zip"
+        curl -L -o "$FILENAME" "${DOWNLOAD_URL}/${FILENAME}"
+        unzip -q "$FILENAME"
+    else
+        FILENAME="squish-v0.2.6-${PLATFORM}-${ARCH}.tar.gz"
+        curl -L -o "$FILENAME" "${DOWNLOAD_URL}/${FILENAME}"
+        tar -xzf "$FILENAME"
+    fi
+
+    # Install to ~/.squish
+    INSTALL_DIR="$HOME/.squish"
+    mkdir -p "$INSTALL_DIR"
+    cp -r squish/* "$INSTALL_DIR/"
+    chmod +x "$INSTALL_DIR/bin/squish"
+
+    cd - > /dev/null
+    rm -rf "$TMP_DIR"
+
+    echo -e "${GREEN}✓ Installed to: ${INSTALL_DIR}${NC}"
+}
+
+# Setup Claude Code configuration
+setup_claude() {
+    echo -e "${BLUE}Configuring Claude Code...${NC}"
+
+    CLAUDE_CONFIG="$HOME/.claude/settings.json"
+    mkdir -p "$HOME/.claude"
+
+    # Backup existing config
+    if [ -f "$CLAUDE_CONFIG" ]; then
+        cp "$CLAUDE_CONFIG" "${CLAUDE_CONFIG}.backup.$(date +%s)"
+    fi
+
+    # Create or update config
+    if [ -f "$CLAUDE_CONFIG" ] && command -v jq &> /dev/null; then
+        jq --arg bin_path "$HOME/.squish/bin/squish" '.mcpServers.squish = {"command": "node", "args": [$bin_path]}' "$CLAUDE_CONFIG" > "${CLAUDE_CONFIG}.tmp" && mv "${CLAUDE_CONFIG}.tmp" "$CLAUDE_CONFIG"
+    else
+        cat > "$CLAUDE_CONFIG" << EOF
+{
+  "mcpServers": {
+    "squish": {
+      "command": "node",
+      "args": ["$HOME/.squish/bin/squish"]
+    }
+  }
+}
+EOF
+    fi
+
+    echo -e "${GREEN}✓ Claude Code configured${NC}"
+}
+
+# Main installation
+main() {
+    detect_platform
+    install_squish
+    setup_claude
+
+    echo ""
+    echo -e "${GREEN}🎉 Squish v0.2.6 installed successfully!${NC}"
+    echo ""
+    echo -e "${BLUE}Next steps:${NC}"
+    echo -e "  1. Restart Claude Code"
+    echo -e "  2. Visit http://localhost:37777 for web UI"
+    echo ""
+    echo -e "${BLUE}Documentation: https://github.com/michielhdoteth/squish-memory${NC}"
+}
+
+main "$@"
+EOF