squish-memory 0.9.2 → 1.0.0

package/packages/plugin-openclaw/openclaw.plugin.json

@@ -0,0 +1,94 @@
+{
+  "id": "squish-memory-openclaw",
+  "name": "Squish Memory for OpenClaw",
+  "description": "Connect OpenClaw to Squish memory system via MCP",
+  "version": "1.0.0",
+  "pluginApiVersion": "1.0.0",
+  "author": "michielhdoteth",
+  "license": "MIT",
+  "homepage": "https://github.com/michielhdoteth/squish",
+  "slot": "memory",
+  "tools": [
+    {
+      "name": "memory_search",
+      "description": "Search memories using Squish hybrid search",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "query": {
+            "type": "string",
+            "description": "Search query"
+          },
+          "maxResults": {
+            "type": "number",
+            "description": "Maximum results to return",
+            "default": 6
+          },
+          "project": {
+            "type": "string",
+            "description": "Project path to scope search"
+          }
+        },
+        "required": ["query"]
+      }
+    },
+    {
+      "name": "memory_get",
+      "description": "Get memory content by URI or ID",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "Memory URI (e.g., squish://memory/<id>) or file path"
+          },
+          "lineRange": {
+            "type": "array",
+            "items": { "type": "number" },
+            "minItems": 2,
+            "maxItems": 2,
+            "description": "Line range [start, end]"
+          },
+          "overview": {
+            "type": "boolean",
+            "description": "Get overview instead of full content",
+            "default": false
+          }
+        },
+        "required": ["uri"]
+      }
+    }
+  ],
+  "config": {
+    "baseUrl": {
+      "type": "string",
+      "default": "http://127.0.0.1:8767",
+      "description": "Squish MCP server URL"
+    },
+    "autoStart": {
+      "type": "boolean",
+      "default": false,
+      "description": "Auto-start Squish MCP server if not running"
+    },
+    "sync": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "default": true
+        },
+        "interval": {
+          "type": "string",
+          "default": "5m",
+          "description": "Sync interval (e.g., 5m, 1h)"
+        },
+        "extraPaths": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["notes", "docs/memory"],
+          "description": "Extra directories to sync"
+        }
+      }
+    }
+  }
+}

package/packages/plugin-openclaw/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@squish/memory-openclaw",
+  "version": "1.0.0",
+  "description": "OpenClaw memory plugin for Squish - provides memory_search and memory_get tools via Squish MCP",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "bun --hot src/index.ts",
+    "prepublishOnly": "npm run clean && npm run build",
+    "prepare": "npm run build",
+    "clean": "rm -rf dist"
+  },
+  "keywords": ["openclaw", "plugin", "memory", "mcp", "squish"],
+  "author": "michielhdoteth",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.17"
+  },
+  "peerDependencies": {
+    "squish-memory": ">=1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/packages/plugin-opencode/install.mjs

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+/**
+ * OpenCode Plugin Installer for Squish
+ * Auto-installs CLI + configures OpenCode to use Squish as MCP server
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawnSync } from "node:child_process";
+
+const CONFIG_DIR = path.join(os.homedir(), ".config", "opencode");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+
+const OPENCODE_SCHEMA = "https://opencode.ai/config.json";
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function getSquishMcpConfig() {
+  return {
+    type: "local",
+    command: ["squish-mcp"],
+    enabled: true,
+    environment: {}
+  };
+}
+
+function loadOpenCodeConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return null;
+  }
+  
+  try {
+    const content = fs.readFileSync(CONFIG_PATH, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`[ERROR] Failed to parse OpenCode config: ${error.message}`);
+    return null;
+  }
+}
+
+function saveOpenCodeConfig(config) {
+  ensureDir(CONFIG_DIR);
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+function createNewConfig() {
+  return {
+    $schema: OPENCODE_SCHEMA,
+    mcp: {
+      squish: getSquishMcpConfig()
+    }
+  };
+}
+
+function installForOpenCode(options = {}) {
+  console.log("[INSTALL] Installing Squish for OpenCode...");
+  
+  let config = loadOpenCodeConfig();
+  let created = false;
+  
+  if (!config) {
+    if (options.dryRun) {
+      console.log("[DRY-RUN] Would create new OpenCode config at:", CONFIG_PATH);
+      return true;
+    }
+    
+    config = createNewConfig();
+    created = true;
+    console.log("[INSTALL] Created new OpenCode config");
+  } else {
+    if (options.dryRun) {
+      console.log("[DRY-RUN] Would update existing OpenCode config at:", CONFIG_PATH);
+      return true;
+    }
+    
+    // Ensure mcp section exists
+    if (!config.mcp) {
+      config.mcp = {};
+    }
+    
+    // Add or update squish MCP config
+    config.mcp.squish = getSquishMcpConfig();
+    console.log("[INSTALL] Updated existing OpenCode config");
+  }
+  
+  saveOpenCodeConfig(config);
+  console.log(`[INSTALL] ${created ? 'Created' : 'Updated'}: ${CONFIG_PATH}`);
+  
+  return true;
+}
+
+function uninstallForOpenCode(options = {}) {
+  console.log("[UNINSTALL] Removing Squish from OpenCode...");
+  
+  const config = loadOpenCodeConfig();
+  if (!config) {
+    console.log("[UNINSTALL] No OpenCode config found");
+    return true;
+  }
+  
+  if (!config.mcp || !config.mcp.squish) {
+    console.log("[UNINSTALL] Squish not found in OpenCode config");
+    return true;
+  }
+  
+  if (options.dryRun) {
+    console.log("[DRY-RUN] Would remove Squish from OpenCode config");
+    return true;
+  }
+  
+  delete config.mcp.squish;
+  
+  // Clean up empty mcp section
+  if (Object.keys(config.mcp).length === 0) {
+    delete config.mcp;
+  }
+  
+  saveOpenCodeConfig(config);
+  console.log("[UNINSTALL] Removed Squish from OpenCode config");
+  
+  return true;
+}
+
+function verifyOpenCodeInstallation() {
+  console.log("[VERIFY] Checking OpenCode installation...");
+  
+  const config = loadOpenCodeConfig();
+  if (!config) {
+    return { ok: false, error: "OpenCode config not found" };
+  }
+  
+  if (!config.mcp || !config.mcp.squish) {
+    return { ok: false, error: "Squish MCP not configured" };
+  }
+  
+  const squishConfig = config.mcp.squish;
+  
+  if (squishConfig.type !== "local") {
+    return { ok: false, error: `Expected type 'local', got '${squishConfig.type}'` };
+  }
+  
+  if (!squishConfig.enabled) {
+    return { ok: false, error: "Squish MCP is disabled" };
+  }
+  
+  // Check if squish-mcp command is available
+  const result = spawnSync("which", ["squish-mcp"], { encoding: "utf8", shell: true });
+  if (result.status !== 0) {
+    return { ok: false, error: "squish-mcp command not found in PATH" };
+  }
+  
+  console.log("[VERIFY] OpenCode config:", CONFIG_PATH);
+  console.log("[VERIFY] Squish MCP configured:", squishConfig.command.join(" "));
+  console.log("[VERIFY] Status: enabled");
+  
+  return { ok: true, message: "OpenCode installation verified" };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const options = {
+    dryRun: args.includes("--dry-run") || args.includes("-d"),
+    uninstall: args.includes("--uninstall") || args.includes("-u"),
+    verify: args.includes("--verify") || args.includes("-v")
+  };
+  
+  console.log("[OpenCode Plugin for Squish]");
+  console.log();
+  
+  try {
+    if (options.verify) {
+      const result = verifyOpenCodeInstallation();
+      if (result.ok) {
+        console.log("\n[VERIFY] " + result.message);
+        process.exit(0);
+      } else {
+        console.error("\n[VERIFY] Failed:", result.error);
+        process.exit(1);
+      }
+    }
+    
+    if (options.uninstall) {
+      const success = uninstallForOpenCode(options);
+      process.exit(success ? 0 : 1);
+    }
+    
+    const success = installForOpenCode(options);
+    
+    if (success && !options.dryRun) {
+      const verify = verifyOpenCodeInstallation();
+      if (verify.ok) {
+        console.log("\n[SUCCESS] OpenCode plugin installed successfully!");
+        console.log("\nTo use Squish in OpenCode:");
+        console.log("  1. Restart OpenCode if it's running");
+        console.log("  2. Start a conversation and ask about memories");
+        console.log("  3. Or explicitly: 'use the squish tool to search for...'");
+      } else {
+        console.error("\n[WARNING] Installation succeeded but verification failed:");
+        console.error("  ", verify.error);
+      }
+    }
+    
+    process.exit(success ? 0 : 1);
+    
+  } catch (error) {
+    console.error("[ERROR]", error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/packages/plugin-opencode/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@squish/plugin-opencode",
+  "version": "1.0.0",
+  "description": "OpenCode plugin for Squish - auto-installs CLI and configures OpenCode to use Squish as MCP server",
+  "main": "install.mjs",
+  "type": "module",
+  "scripts": {
+    "install": "node install.mjs",
+    "verify": "node install.mjs --verify",
+    "uninstall": "node install.mjs --uninstall"
+  },
+  "keywords": ["opencode", "plugin", "memory", "mcp", "squish"],
+  "author": "michielhdoteth",
+  "license": "MIT",
+  "peerDependencies": {
+    "squish-memory": ">=1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/build-release.sh

@@ -5,29 +5,32 @@
 
 set -e
 
-echo "🔨 Building Squish v0.3.0..."
+# Auto-detect version from package.json
+VERSION=$(node -p "require('./package.json').version")
+echo "Building Squish v$VERSION..."
 
 # Clean previous builds
 npm run clean
 
-# Build the project (core only, merge system disabled)
-echo "Building core functionality..."
-npx tsc index.ts --outDir dist --skipLibCheck --esModuleInterop --module commonjs
-npx tsc features/web/web.ts --outDir dist/features/web --skipLibCheck --esModuleInterop --module commonjs
-npx tsc features/web/web-server.ts --outDir dist/features/web --skipLibCheck --esModuleInterop --module commonjs
+# Build the project using standard build script
+echo "Building project..."
+npm run build
 
-# Rename to .js extension for CommonJS
-mv dist/features/web/web-server.js dist/features/web/web-server.cjs 2>/dev/null || true
+# Verify MCP artifacts are generated
+echo "🔨 Generating MCP artifacts..."
+node scripts/generate-mcp.mjs
 
-echo "✅ Build complete!"
+# Verify MCP artifacts
+echo "🧪 Verifying MCP artifacts..."
+node scripts/verify-mcp.mjs
 
-# Test the build
-echo "🧪 Testing build..."
-timeout 5 node dist/index.js &
-sleep 2
-curl -s http://localhost:37777/api/health | grep -q "ok" && echo "✅ API working" || echo "❌ API failed"
+echo "Build complete!"
 
-# Kill test server
-pkill -f "node dist/index.js" || true
+# Optional: Test the build (uncomment if needed)
+# echo "🧪 Testing build..."
+# timeout 5 node dist/index.js &
+# sleep 2
+# curl -s http://localhost:37777/api/health | grep -q "ok" && echo "✅ API working" || echo "❌ API failed"
+# pkill -f "node dist/index.js" || true
 
-echo "🎉 Ready for release!"
+echo "Ready for release!"

package/scripts/check-secrets.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+/**
+ * Secret Scanner - Checks for accidentally committed secrets
+ * Run this before committing or use the pre-commit hook
+ * 
+ * Usage: node scripts/check-secrets.js
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+
+// Common secret patterns
+const SECRET_PATTERNS = [
+  // API Keys
+  { pattern: /(sk|sg)-[0-9a-zA-Z]{24,}/gi, name: 'Stripe/General API Key' },
+  { pattern: /AIza[0-9A-Za-z\\-_]{35}/gi, name: 'Google API Key' },
+  { pattern: /xox[baprs]-[0-9a-zA-Z-]{10,}/gi, name: 'Slack Token' },
+  { pattern: /xox[baprs]-[0-9a-zA-Z-]{10,}/gi, name: 'Slack Token' },
+  { pattern: /ghp_[0-9a-zA-Z]{36}/gi, name: 'GitHub Personal Access Token' },
+  { pattern: /github_pat_[0-9a-zA-Z]{22}_[0-9a-zA-Z]{59}/gi, name: 'GitHub Fine-grained Token' },
+  { pattern: /Bearer\s+[A-Za-z0-9\-_]+/gi, name: 'Bearer Token' },
+  { pattern: /Authorization:\s*Bearer\s+[A-Za-z0-9\-_]+/gi, name: 'Authorization Header' },
+  { pattern: /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/gi, name: 'JWT Token' },
+  
+  // AWS
+  { pattern: /(?:A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}/gi, name: 'AWS Access Key' },
+  { pattern: /(?:\")?aws_access_key_id(?:\\s*:\\s*\")([A-Z0-9]{20})(?:\"|$)/gi, name: 'AWS Access Key ID' },
+  { pattern: /(?:\")?aws_secret_access_key(?:\\s*:\\s*\")([A-Za-z0-9/+=]{40})(?:\"|$)/gi, name: 'AWS Secret Access Key' },
+  
+  // Database
+  { pattern: /(?:mongodb|mysql|postgres|postgresql|redis):\/\/[^\s]+:[^\s]+@/gi, name: 'Database Connection String' },
+  { pattern: /(?:password|passwd|pwd)\s*[=:]\s*['"]?[^'"]{8,}['"]?/gi, name: 'Password in config' },
+  
+  // .env specific
+  { pattern: /^[A-Z_]+=sk-|^[A-Z_]+=AIza/gi, name: 'API Key in .env format' },
+];
+
+// File extensions to check
+const TEXT_EXTENSIONS = [
+  '.ts', '.js', '.json', '.md', '.txt', '.yml', '.yaml', '.toml',
+  '.sh', '.bash', '.zsh', '.ini', '.cfg', '.conf', '.env', '.env.local'
+];
+
+function isTextFile(filePath) {
+  return TEXT_EXTENSIONS.some(ext => filePath.endsWith(ext)) || filePath.includes('.env');
+}
+
+function getStagedFiles() {
+  try {
+    const output = execSync('git diff --cached --name-only', { encoding: 'utf-8' });
+    return output.split('\n').filter(f => f.trim());
+  } catch (error) {
+    console.error('Failed to get staged files:', error.message);
+    return [];
+  }
+}
+
+function readFileContent(filePath) {
+  try {
+    return readFileSync(filePath, 'utf-8');
+  } catch (error) {
+    // File may have been removed or unreadable
+    return '';
+  }
+}
+
+function scanContent(content, filePath) {
+  const findings = [];
+  
+  for (const { pattern, name } of SECRET_PATTERNS) {
+    let match;
+    const regex = new RegExp(pattern);
+    while ((match = regex.exec(content)) !== null) {
+      const lineNumber = content.substring(0, match.index).split('\n').length;
+      findings.push({
+        file: filePath,
+        line: lineNumber,
+        type: name,
+        value: maskSecret(match[0]),
+      });
+    }
+  }
+  
+  return findings;
+}
+
+function maskSecret(secret) {
+  if (secret.length <= 8) return '***';
+  return secret.substring(0, 6) + '...' + secret.substring(secret.length - 4);
+}
+
+function main() {
+  console.log('🔍 Scanning for secrets...\n');
+  
+  const stagedFiles = getStagedFiles();
+  const textFiles = stagedFiles.filter(isTextFile);
+  
+  if (textFiles.length === 0) {
+    console.log('No text files to scan.');
+    process.exit(0);
+  }
+  
+  let totalFindings = 0;
+  
+  for (const file of textFiles) {
+    const content = readFileContent(file);
+    if (!content) continue;
+    
+    const findings = scanContent(content, file);
+    if (findings.length > 0) {
+      console.log(`❌ ${file}:`);
+      for (const finding of findings) {
+        console.log(`   Line ${finding.line}: ${finding.type} - ${finding.value}`);
+        totalFindings++;
+      }
+      console.log('');
+    }
+  }
+  
+  if (totalFindings > 0) {
+    console.log(`\n🚨 Found ${totalFindings} potential secret(s).`);
+    console.log('   Please remove these before committing!');
+    console.log('   Use environment variables or a secret manager instead.\n');
+    process.exit(1);
+  } else {
+    console.log('✅ No secrets detected.\n');
+    process.exit(0);
+  }
+}
+
+main();