squish-memory 1.1.5 → 1.2.1

package/bin/install-interactive.mjs

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+/**
+ * Squish MCP Installer (using add-mcp)
+ * Installs Squish MCP configuration for various AI clients
+ * Supports: Claude Code, OpenCode, Codex, Cursor, VS Code, Windsurf, and more via add-mcp
+ * 
+ * Usage:
+ *   bun run install              # Interactive wizard
+ *   bun run install --all        # Auto-install for all detected clients
+ *   bun run install --clients=claude-code,opencode  # Specific clients
+ *   bun run install --global      # Install globally (user-level)
+ *   bun run install --dry-run    # Preview without installing
+ */
+
+import { intro, outro, confirm, multiselect, isCancel, spinner, note } from '@clack/prompts';
+import picocolors from 'picocolors';
+import { spawn } from 'child_process';
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const root = process.cwd();
+const packageJsonPath = path.join(root, "package.json");
+
+const c = picocolors;
+
+const icons = {
+  squish: "🐙",
+  check: "✓",
+  cross: "✗",
+  arrow: "→",
+  mcp: "🔌"
+};
+
+// add-mcp supported agents (for reference - add-mcp auto-detects)
+const ADD_MCP_AGENTS = [
+  'claude-code',
+  'opencode', 
+  'codex',
+  'cursor',
+  'vscode',
+  'claude-desktop',
+  'gemini-cli',
+  'goose',
+  'zed'
+];
+
+// CLI argument parsing
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    all: false,
+    global: false,
+    clients: [],
+    dryRun: false,
+    help: false
+  };
+
+  for (const arg of args) {
+    if (arg === '--all') options.all = true;
+    else if (arg === '--global' || arg === '-g') options.global = true;
+    else if (arg === '--dry-run') options.dryRun = true;
+    else if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg.startsWith('--clients=')) {
+      options.clients = arg.slice(10).split(',').map(c => c.trim());
+    }
+  }
+
+  return options;
+}
+
+function printHelp() {
+  printLogo();
+  console.log(c.white("Usage:"));
+  console.log(`  ${c.cyan("bun run install")}              # Interactive wizard`);
+  console.log(`  ${c.cyan("bun run install --all")}         # Auto-install for all detected clients`);
+  console.log(`  ${c.cyan("bun run install --global")}      # Install globally (user-level)`);
+  console.log(`  ${c.cyan("bun run install --clients=claude-code,opencode")}  # Specific clients`);
+  console.log(`  ${c.cyan("bun run install --dry-run")}    # Preview without installing\n`);
+  console.log(c.white("Options:"));
+  console.log(`  ${c.cyan("--all")}         Install for all supported clients`);
+  console.log(`  ${c.cyan("--global")}      Install globally (user-level instead of project)`);
+  console.log(`  ${c.cyan("--clients=")}    Comma-separated list of clients`);
+  console.log(`  ${c.cyan("--dry-run")}    Preview changes without installing`);
+  console.log(`  ${c.cyan("--help")}       Show this help message\n`);
+  console.log(c.white("Supported clients:"));
+  console.log(`  claude-code, opencode, codex, cursor, vscode, windsurf, and more`);
+  console.log(c.white("\nAlso works directly:"));
+  console.log(`  ${c.cyan("npx add-mcp squish-memory")}    # Install via add-mcp directly`);
+}
+
+function printLogo() {
+  console.log(c.cyan(`
+██████╗ ██████╗ ██╗   ██╗██╗███████╗██╗  ██╗
+██╔════╝██╔═══██╗██║   ██║██║██╔════╝██║  ██║
+██████╗██║   ██║██║   ██║██║███████╗███████║
+╚════██║██║   ██║██║   ██║██║╚════██║██╔══██║
+██████║╚██████╔╝╚██████╔╝██║███████║██║  ██║
+╚═════╝ ╚═════╝  ╚═════╝ ╚═╝╚══════╝╚═╝  ╚═╝
+  `));
+  console.log(c.gray("   Universal Memory System for AI Agents\n"));
+}
+
+// Detect which add-mcp agents are available on this system
+function detectAvailableAgents() {
+  const agents = [];
+  
+  // Check common client directories
+  const checks = [
+    { dir: path.join(os.homedir(), '.claude'), agent: 'claude-code' },
+    { dir: path.join(os.homedir(), '.config', 'opencode'), agent: 'opencode' },
+    { dir: path.join(os.homedir(), '.codex'), agent: 'codex' },
+    { dir: path.join(os.homedir(), '.cursor'), agent: 'cursor' },
+    { dir: path.join(os.homedir(), '.vscode'), agent: 'vscode' },
+    { dir: path.join(os.homedir(), '.windsurf'), agent: 'windsurf' },
+    { dir: path.join(os.homedir(), '.zed'), agent: 'zed' },
+    { dir: path.join(os.homedir(), '.gemini'), agent: 'gemini-cli' },
+  ];
+
+  for (const check of checks) {
+    if (fs.existsSync(check.dir)) {
+      agents.push(check.agent);
+    }
+  }
+
+  return agents;
+}
+
+// Get client display name
+function getClientName(agent) {
+  const names = {
+    'claude-code': 'Claude Code',
+    'opencode': 'OpenCode',
+    'codex': 'Codex',
+    'cursor': 'Cursor',
+    'vscode': 'VS Code',
+    'windsurf': 'Windsurf',
+    'zed': 'Zed',
+    'gemini-cli': 'Gemini CLI',
+    'claude-desktop': 'Claude Desktop',
+    'goose': 'Goose'
+  };
+  return names[agent] || agent;
+}
+
+// Check if squish-memory package exists locally
+function checkPackageExists() {
+  // Check if package.json exists in root
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+  
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    // Check if squish-memory is in dependencies or devDependencies
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return !!deps['squish-memory'];
+  } catch {
+    return false;
+  }
+}
+
+// Run add-mcp command
+function runAddMcp(clients, options) {
+  return new Promise((resolve, reject) => {
+    // Try squish-memory first (published name), fallback to @squish/memory
+    // add-mcp will find the correct package
+    const packageName = 'squish-memory';
+    const args = ['add-mcp', packageName, '-y'];
+    
+    // Add specific agents
+    if (clients && clients.length > 0) {
+      for (const client of clients) {
+        args.push('-a', client);
+      }
+    }
+    
+    // Add global flag if requested
+    if (options.global) {
+      args.push('--global');
+    }
+    
+    console.log(c.cyan(`Running: npx ${args.join(' ')}\n`));
+    
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      cwd: root,
+      shell: true
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve(code);
+      } else {
+        reject(new Error(`add-mcp exited with code ${code}`));
+      }
+    });
+
+    child.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+// Interactive client selection
+async function selectClients(availableAgents) {
+  const options = availableAgents.map(agent => ({
+    value: agent,
+    label: getClientName(agent),
+    hint: 'Detected on system'
+  }));
+
+  if (options.length === 0) {
+    console.log(c.yellow("No AI clients detected. Installing globally...\n"));
+    return null;
+  }
+
+  const selected = await multiselect({
+    message: 'Which AI agents do you want to install Squish MCP for?',
+    options,
+    required: false
+  });
+
+  return selected;
+}
+
+async function main() {
+  const opts = parseArgs();
+
+  if (opts.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  // Dry run mode - check first before any other logic
+  if (opts.dryRun) {
+    console.log(c.yellow("\n--- DRY RUN MODE ---\n"));
+    console.log(`Would run: npx add-mcp squish-memory -y`);
+    if (opts.global) {
+      console.log("  (--global) Install globally");
+    }
+    if (opts.clients && opts.clients.length > 0) {
+      console.log(`  (--agents) ${opts.clients.join(', ')}`);
+    } else {
+      console.log("  (auto-detect) Let add-mcp detect installed agents");
+    }
+    console.log("");
+    process.exit(0);
+  }
+
+  printLogo();
+  console.log(c.gray("Using add-mcp for universal MCP installation\n"));
+
+  // Detect available agents
+  const availableAgents = detectAvailableAgents();
+  
+  let clients;
+  
+  // Non-interactive mode
+  if (opts.all) {
+    // Install for all available agents (or all known if none detected)
+    clients = availableAgents.length > 0 ? availableAgents : ADD_MCP_AGENTS;
+    console.log(c.cyan(`Auto-installing for ${clients.length} clients...\n`));
+  } else if (opts.clients.length > 0) {
+    // Install for specific clients
+    clients = opts.clients;
+    console.log(c.cyan(`Installing for: ${clients.join(', ')}\n`));
+  } else if (process.stdin.isTTY) {
+    // Interactive mode
+    intro(c.cyan(`${icons.squish} Squish MCP Installer`));
+    
+    clients = await selectClients(availableAgents);
+    
+    if (isCancel(clients) || !clients || clients.length === 0) {
+      console.log(c.yellow("No clients selected. Using add-mcp auto-detection...\n"));
+      clients = null; // Let add-mcp auto-detect
+    }
+  } else {
+    // Non-interactive without flags - show help
+    printHelp();
+    process.exit(0);
+  }
+
+  // Install
+  const s = spinner();
+  s.start('Installing Squish MCP via add-mcp...');
+
+  try {
+    await runAddMcp(clients, opts);
+    s.stop(c.green(`${icons.check} Installation Complete!`));
+  } catch (error) {
+    s.stop(c.red(`${icons.cross} Installation failed`));
+    console.log(c.red(`Error: ${error.message}`));
+    console.log(c.gray("\nTrying alternative: npx add-mcp squish-memory -y"));
+    
+    // Fallback: try without specific agents (let add-mcp auto-detect)
+    try {
+      await runAddMcp(null, opts);
+      s.stop(c.green(`${icons.check} Installation complete (fallback)!`));
+    } catch (fallbackError) {
+      console.log(c.red(`Fallback also failed: ${fallbackError.message}`));
+      process.exit(1);
+    }
+  }
+
+  // Next steps
+  console.log();
+  console.log(c.white("What's next?"));
+  console.log(`  ${c.cyan(icons.arrow)} Restart your AI assistant(s)`);
+  console.log(`  ${c.cyan(icons.arrow)} Try: squish remember "Your first memory"`);
+  console.log(`  ${c.cyan(icons.arrow)} Or use: npx add-mcp squish-memory --help`);
+  console.log();
+
+  outro(c.green(`${icons.check} Squish MCP installed!`));
+}
+
+main().catch((err) => {
+  console.log(c.red(`Fatal error: ${err.message}`));
+  process.exit(1);
+});

package/bin/squish-mcp.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+
+/**
+ * Squish MCP Server Entry Point
+ * 
+ * Uses spawn to run MCP - passes env vars to child process for MCP mode
+ * This fixes initialization timing issue in OpenCode/Claude Code
+ * 
+ * Usage:
+ *   squish-mcp                    # STDIO mode (default)
+ *   squish-mcp --http            # HTTP mode
+ *   squish-mcp --port 8765      # Custom port
+ *   squish-mcp --health         # Health check mode
+ */
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = join(__dirname, '..');
+
+// Set MCP mode - pass to child process to skip heavy background jobs at startup
+const mcpEnv = {
+  ...process.env,
+  SQUISH_MCP_NO_WORKER: 'true',  // Skip worker startup for fast init
+  SQUISH_QUIET: 'true',          // Suppress logs for clean JSON-RPC
+};
+
+// MCP TypeScript file path
+const mcpPath = join(packageRoot, 'packages/mcp/src/index.ts');
+
+// Pass through any command line arguments
+const args = process.argv.slice(2);
+
+// Spawn bun to run MCP with env vars passed to child
+const proc = spawn('bun', [mcpPath, ...args], {
+  stdio: 'inherit',
+  env: mcpEnv,
+  cwd: process.cwd(),
+});
+
+proc.on('exit', (code) => process.exit(code || 0));

package/bin/squish.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+/**
+ * Squish CLI - Main Entry Point
+ * Universal Memory for AI Agents
+ * 
+ * Usage:
+ *   squish remember "Store this memory"
+ *   squish recall "query"
+ *   squish inspect <memory-id>
+ *   squish context --list-projects
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Use bun to run the CLI directly with ts support
+const { spawn } = await import('child_process');
+const bunPath = process.env.BUN?.replace(/\\/g, '/') || 'bun';
+const cliPath = join(__dirname, '..', 'packages', 'cli', 'src', 'index.ts');
+
+const args = process.argv.slice(2);
+const child = spawn(bunPath, [cliPath, ...args], {
+  stdio: 'inherit',
+  cwd: join(__dirname, '..')
+});
+
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});

package/config/mcp-migration-map.json

@@ -13,10 +13,5 @@
   "outputChange": {
     "from": "generated/mcp/{profile}/",
     "to": "generated/mcp/"
-  },
-  "notes": [
-    "Universal generation removes per-profile directories.",
-    "Client-specific behavior moves to installer/bootstrap scripts.",
-    "Legacy profile references should emit migration warnings during upgrade windows."
-  ]
+  }
 }

package/config/mcp-mode-semantics.json

@@ -1,23 +1,19 @@
-{
-  "canonicalModes": [
-    "local",
-    "team",
-    "remote"
-  ],
-  "defaultMode": "local",
-  "legacyAliases": {
-    "team": "team"
-  },
-  "teamBackends": {
-    "supported": ["postgres", "supabase", "neon"],
-    "default": "postgres"
-  },
-  "remoteBackends": {
-    "supported": ["supabase", "neon"],
-    "default": "supabase"
-  },
-  "remoteAuth": {
-    "supported": ["oauth", "token"],
-    "defaultForCli": "token"
-  }
-}
+{
+  "canonicalModes": ["local", "team", "remote"],
+  "defaultMode": "local",
+  "legacyAliases": {
+    "team": "team"
+  },
+  "teamBackends": {
+    "supported": ["postgres", "supabase", "neon"],
+    "default": "postgres"
+  },
+  "remoteBackends": {
+    "supported": ["supabase", "neon"],
+    "default": "supabase"
+  },
+  "remoteAuth": {
+    "supported": ["oauth", "token"],
+    "defaultForCli": "token"
+  }
+}

package/config/mcp-remote-auth.json

@@ -1,36 +1,13 @@
 {
-  "methods": [
-    "oauth",
-    "token"
-  ],
+  "methods": ["oauth", "token"],
   "defaultMethod": "token",
-  "precedence": [
-    "token",
-    "oauth"
-  ],
+  "precedence": ["token", "oauth"],
   "token": {
-    "requiredEnv": [
-      "SQUISH_REMOTE_TOKEN"
-    ],
-    "header": "Authorization",
-    "scheme": "Bearer"
-  },
-  "oauth": {
-    "pkce": true,
-    "deviceCode": true,
-    "authorizationUrlEnv": "SQUISH_OAUTH_AUTH_URL",
-    "tokenUrlEnv": "SQUISH_OAUTH_TOKEN_URL",
-    "clientIdEnv": "SQUISH_OAUTH_CLIENT_ID"
+    "requiredEnv": ["SQUISH_REMOTE_TOKEN"]
   },
   "cli": {
     "openclaw": {
       "default": "token"
-    },
-    "claude-code": {
-      "default": "token"
-    },
-    "opencode": {
-      "default": "token"
     }
   }
 }

package/config/mcp-universal.schema.json

@@ -2,47 +2,17 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "title": "Squish MCP Universal Config",
   "type": "object",
-  "additionalProperties": false,
   "required": ["version", "defaults", "servers"],
   "properties": {
     "version": {
-      "type": "integer",
-      "minimum": 1
+      "type": "integer"
     },
     "defaults": {
-      "type": "object",
-      "additionalProperties": true
+      "type": "object"
     },
     "servers": {
-      "type": "object",
-      "minProperties": 1,
-      "additionalProperties": {
-        "type": "object",
-        "additionalProperties": true,
-        "required": ["transport", "command", "args", "env"],
-        "properties": {
-          "transport": {
-            "type": "string",
-            "enum": ["stdio", "http", "sse"]
-          },
-          "command": {
-            "type": "string",
-            "minLength": 1
-          },
-          "args": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "env": {
-            "type": "object",
-            "additionalProperties": {
-              "type": "string"
-            }
-          }
-        }
-      }
+      "type": "object"
     }
-  }
+  },
+  "additionalProperties": true
 }