squish-memory 1.2.0 → 1.2.1

package/bin/squish-mcp.mjs

@@ -1,46 +1,44 @@
-#!/usr/bin/env node
-
-/**
- * Squish MCP Server Entry Point
- * 
- * Usage:
- *   squish-mcp                    # STDIO mode (default)
- *   squish-mcp --http            # HTTP mode
- *   squish-mcp --port 8765      # Custom port
- *   squish-mcp --health         # Health check mode
- */
-
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { spawn } from 'child_process';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Parse arguments
+#!/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);
-const isHttp = args.includes('--http');
-const isHealth = args.includes('--health');
-const portIndex = args.indexOf('--port');
-const port = portIndex >= 0 ? parseInt(args[portIndex + 1]) : 8765;
-
-// Use bun to run the MCP server
-const bunPath = process.env.BUN?.replace(/\\/g, '/') || 'bun';
-const mcpPath = join(__dirname, '..', 'packages', 'mcp', 'src', 'index.ts');
-
-const mcpArgs = [];
-
-if (isHttp) {
-  mcpArgs.push('--http', '--port', port.toString());
-}
-
-if (isHealth) {
-  mcpArgs.push('--health');
-}
-
-const child = spawn(bunPath, [mcpPath, ...mcpArgs], {
+
+// Spawn bun to run MCP with env vars passed to child
+const proc = spawn('bun', [mcpPath, ...args], {
   stdio: 'inherit',
-  cwd: join(__dirname, '..')
+  env: mcpEnv,
+  cwd: process.cwd(),
 });
 
-child.on('exit', (code) => process.exit(code || 0));
+proc.on('exit', (code) => process.exit(code || 0));

package/core/scheduler/cron-scheduler.ts

@@ -36,6 +36,9 @@ export type JobHandler = (context: JobExecutionContext) => Promise<{ recordsProc
 const jobHandlers = new Map<string, JobHandler>();
 const activeTasks = new Map<string, any>(); // node-cron ScheduledTask type
 
+// Flag to defer logging until explicit init (for MCP silent mode)
+let schedulerInitialized = false;
+
 // Job interval by type (in ms) - used for catch-up detection
 const JOB_INTERVALS: Record<JobType, number> = {
   hourly: 60 * 60 * 1000,           // 1 hour
@@ -46,7 +49,10 @@ const JOB_INTERVALS: Record<JobType, number> = {
 
 export function registerJobHandler(jobName: string, handler: JobHandler): void {
   jobHandlers.set(jobName, handler);
-  logger.info(`[Scheduler] Registered handler for job: ${jobName}`);
+  // Only log after explicit init (not at import time) - enables silent mode for MCP
+  if (schedulerInitialized || process.env.SQUISH_FORCE_LOG === 'true') {
+    logger.info(`[Scheduler] Registered handler for job: ${jobName}`);
+  }
 }
 
 // Register self-iteration job handler
@@ -144,6 +150,9 @@ const autoCleanHandler = async (context: JobExecutionContext) => {
 registerJobHandler('auto_clean', autoCleanHandler);
 
 export async function initializeScheduler(): Promise<void> {
+  // Mark as initialized - enables logging from now on
+  schedulerInitialized = true;
+  
   if (!config.cronEnabled) {
     logger.info('[Scheduler] Cron scheduling disabled, using heartbeat fallback');
     return;

package/core/worker.ts

@@ -10,6 +10,9 @@ import { pruneOldSummaries, getSummarizationStats } from './summarization.js';
 import { runFullConsolidationJob, getDeduplicationStats } from './consolidation.js';
 import { logger } from './logger.js';
 
+// Skip worker initialization in MCP mode
+const MCP_MODE = process.env.SQUISH_MCP_NO_WORKER === 'true' || process.argv.includes('--mcp');
+
 interface WorkerConfig {
   lifecycleInterval: number;
   pruningInterval: number;
@@ -60,7 +63,13 @@ class SquishWorker {
       logger.warn('Worker already running');
       return;
     }
-
+    
+    // Skip in MCP mode for faster startup
+    if (MCP_MODE) {
+      logger.info('Background worker skipped (MCP mode)');
+      return;
+    }
+    
     this.isRunning = true;
     logger.info('Starting background worker');
 

package/package.json

@@ -1,74 +1,74 @@
-{
-  "name": "squish-memory",
-  "version": "1.2.0",
-  "description": "Universal memory for AI agents: QMD fast file search + SQLite/Postgres + Belief System + Persistent Hot Cache. Works out-of-the-box.",
+{
+  "name": "squish-memory",
+  "version": "1.2.1",
+  "description": "Universal memory for AI agents: QMD fast file search + SQLite/Postgres + Belief System + Persistent Hot Cache. Works out-of-the-box.",
   "main": "core/index.ts",
-  "type": "module",
-  "bin": {
-    "squish": "bin/squish.mjs",
-    "squish-mcp": "bin/squish-mcp.mjs"
-  },
-  "scripts": {
-    "clean": "rm -rf dist && rm -f *.log",
-    "build": "echo 'No build needed - runs TypeScript directly with bun. Use bun run start or bun run mcp instead.'",
-    "start": "bun run core/index.ts 2>/dev/null || npx tsx core/index.ts",
-    "mcp": "bun run packages/mcp/src/index.ts 2>/dev/null || npx tsx packages/mcp/src/index.ts",
-    "dev": "bun --hot core/index.ts 2>/dev/null || npx tsx --watch core/index.ts",
-    "dev:mcp": "bun --hot packages/mcp/src/index.ts 2>/dev/null || npx tsx --watch packages/mcp/src/index.ts",
-    "test": "bun test ./tests/ 2>/dev/null || npx vitest",
-    "verify:mcp": "bun run packages/mcp/src/index.ts --health 2>/dev/null || npx tsx packages/mcp/src/index.ts --health",
-    "bench": "bun benchmark/memory.ts 2>/dev/null || npx tsx --cwd . benchmark/memory.ts",
-    "bench:db": "bun benchmark/run.ts 2>/dev/null || npx tsx --cwd . benchmark/run.ts",
-    "bench:locomo": "bun benchmark/locomo-full.ts"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/michielhdoteth/squish.git"
-  },
-  "homepage": "https://github.com/michielhdoteth/squish#readme",
-  "funding": {
-    "type": "github",
-    "url": "https://github.com/sponsors/michielhdoteth"
-  },
-  "bugs": {
-    "url": "https://github.com/michielhdoteth/squish/issues"
-  },
-  "keywords": [
-    "ai-agent",
-    "memory",
-    "persistent-memory",
-    "universal-memory",
-    "mcp-server",
-    "mcp-client",
-    "model-context-protocol",
-    "claude-code",
-    "openclaw",
-    "opencode",
-    "codex",
-    "cursor",
-    "windsurf",
-    "vscode",
-    "plugin",
-    "plugin-architecture",
-    "qmd",
-    "sqlite",
-    "postgres",
-    "hybrid-search",
-    "context-management",
-    "semantic-search",
-    "local-first",
-    "privacy",
-    "agent-framework",
-    "agent-memory",
-    "ai-memory",
-    "agentic",
-    "context-window",
-    "long-term-memory",
-    "rag",
-    "vector-embeddings",
-    "session-persistence"
-  ],
-  "files": [
+  "type": "module",
+  "bin": {
+    "squish": "bin/squish.mjs",
+    "squish-mcp": "bin/squish-mcp.mjs"
+  },
+  "scripts": {
+    "clean": "rm -rf dist && rm -f *.log",
+    "build": "echo 'No build needed - runs TypeScript directly with bun. Use bun run start or bun run mcp instead.'",
+    "start": "bun run core/index.ts 2>/dev/null || npx tsx core/index.ts",
+    "mcp": "bun run packages/mcp/src/index.ts 2>/dev/null || npx tsx packages/mcp/src/index.ts",
+    "dev": "bun --hot core/index.ts 2>/dev/null || npx tsx --watch core/index.ts",
+    "dev:mcp": "bun --hot packages/mcp/src/index.ts 2>/dev/null || npx tsx --watch packages/mcp/src/index.ts",
+    "test": "bun test ./tests/ 2>/dev/null || npx vitest",
+    "verify:mcp": "bun run packages/mcp/src/index.ts --health 2>/dev/null || npx tsx packages/mcp/src/index.ts --health",
+    "bench": "bun benchmark/memory.ts 2>/dev/null || npx tsx --cwd . benchmark/memory.ts",
+    "bench:db": "bun benchmark/run.ts 2>/dev/null || npx tsx --cwd . benchmark/run.ts",
+    "bench:locomo": "bun benchmark/locomo-full.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/michielhdoteth/squish.git"
+  },
+  "homepage": "https://github.com/michielhdoteth/squish#readme",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/michielhdoteth"
+  },
+  "bugs": {
+    "url": "https://github.com/michielhdoteth/squish/issues"
+  },
+  "keywords": [
+    "ai-agent",
+    "memory",
+    "persistent-memory",
+    "universal-memory",
+    "mcp-server",
+    "mcp-client",
+    "model-context-protocol",
+    "claude-code",
+    "openclaw",
+    "opencode",
+    "codex",
+    "cursor",
+    "windsurf",
+    "vscode",
+    "plugin",
+    "plugin-architecture",
+    "qmd",
+    "sqlite",
+    "postgres",
+    "hybrid-search",
+    "context-management",
+    "semantic-search",
+    "local-first",
+    "privacy",
+    "agent-framework",
+    "agent-memory",
+    "ai-memory",
+    "agentic",
+    "context-window",
+    "long-term-memory",
+    "rag",
+    "vector-embeddings",
+    "session-persistence"
+  ],
+  "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "dist/**/*.cjs",
@@ -76,7 +76,7 @@
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts",
     "scripts",
-    "!scripts/init-dirs.ts",
+    "!scripts/init-dirs.ts",
     "skills",
     "config",
     "config.js",
@@ -90,51 +90,51 @@
     "!packages/**/*.test.ts",
     "!packages/**/*.test.js",
     "generated",
-    "mcp.json.example",
-    ".env.example",
-    "LICENSE",
-    "README.md",
-    "CHANGELOG.md"
-  ],
-  "author": "michielhdoteth <michiel@4mlabs.io>",
-  "license": "MIT",
-  "engines": {
-    "node": ">=18.0.0",
-    "bun": ">=1.0.0"
-  },
-  "dependencies": {
-    "@clack/prompts": "^1.2.0",
-    "@huggingface/transformers": "^4.1.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@neondatabase/serverless": "^1.0.2",
-    "better-sqlite3": "12.9.0",
-    "@tobilu/qmd": "^2.1.0",
-    "commander": "^14.0.3",
-    "cors": "2.8.6",
-    "dotenv": "^17.4.2",
-    "drizzle-orm": "^0.45.2",
-    "express": "^5.2.1",
-    "express-rate-limit": "^8.3.2",
-    "node-cron": "^4.2.1",
-    "pg": "^8.20.0",
-    "pgvector": "^0.2.0",
-    "redis": "^5.11.0",
-    "sql.js": "^1.14.1",
-    "zod": "^4.3.6"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/cors": "^2.8.17",
-    "@types/express": "^5.0.0",
-    "@types/node": "^25.6.0",
-    "@types/node-cron": "^3.0.11",
-    "@types/pg": "^8.20.0",
-    "drizzle-kit": "^0.31.10",
-    "esbuild": "^0.28.0",
-    "picocolors": "^1.0.0",
-    "pkg": "^5.8.1",
-    "tsx": "^4.21.0",
-    "typescript": "^6.0.2",
-    "vitest": "^3.0.0"
-  }
-}
+    "mcp.json.example",
+    ".env.example",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "author": "michielhdoteth <michiel@4mlabs.io>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "@huggingface/transformers": "^4.1.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@neondatabase/serverless": "^1.0.2",
+    "better-sqlite3": "12.9.0",
+    "@tobilu/qmd": "^2.1.0",
+    "commander": "^14.0.3",
+    "cors": "2.8.6",
+    "dotenv": "^17.4.2",
+    "drizzle-orm": "^0.45.2",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.3.2",
+    "node-cron": "^4.2.1",
+    "pg": "^8.20.0",
+    "pgvector": "^0.2.0",
+    "redis": "^5.11.0",
+    "sql.js": "^1.14.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/node": "^25.6.0",
+    "@types/node-cron": "^3.0.11",
+    "@types/pg": "^8.20.0",
+    "drizzle-kit": "^0.31.10",
+    "esbuild": "^0.28.0",
+    "picocolors": "^1.0.0",
+    "pkg": "^5.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "vitest": "^3.0.0"
+  }
+}

package/packages/mcp/src/index.ts

@@ -5,6 +5,14 @@
 console.log = console.error;
 console.info = console.error;
 
+// Check for silent mode BEFORE any imports to prevent log spam during module load
+const EARLY_SILENT = process.argv.includes('--silent') || process.env.SQUISH_MCP_SILENT === 'true';
+if (EARLY_SILENT) {
+  // Suppress scheduler spam during module load
+  // We'll restore AFTER imports are done
+  process.env.SQUISH_QUIET = 'true';
+}
+
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -14,7 +22,9 @@ import { config } from "../../../config.js";
 import { getDb } from "../../../db/index.js";
 import { getSchema } from "../../../db/schema.js";
 import { eq } from "drizzle-orm";
-import { startWorker, stopWorker } from "../../../core/worker.js";
+export function startWorker() {
+  throw new Error('[DEBUG] startWorker called - need to find where!');
+}
 import { initializeScheduler } from "../../../core/scheduler/cron-scheduler.js";
 import { parseDate, filterByDateRange } from "../../../core/lib/utils.js";
 import {
@@ -34,9 +44,20 @@ import { logger } from "../../../core/logger.js";
 const SERVER_NAME = "squish-memory";
 const SERVER_VERSION = "1.2.0";
 
-// Create server instance ONCE (not per-session)
-const { server: SQUISH_SERVER, toolCount: SQUISH_TOOL_COUNT } = createSquishServer();
-console.error(`[MCP] Server created with ${SQUISH_TOOL_COUNT} tools`);
+// Create server lazily (only when needed) - avoids init overhead during module load
+let SQUISH_SERVER: McpServer | null = null;
+let SQUISH_TOOL_COUNT = 0;
+
+function getSquishServer(): { server: McpServer; toolCount: number } {
+  if (!SQUISH_SERVER) {
+    const result = createSquishServer();
+    SQUISH_SERVER = result.server;
+    SQUISH_TOOL_COUNT = result.toolCount;
+    const silent = process.env.SQUISH_MCP_SILENT === 'true';
+    if (!silent) console.error(`[MCP] Server created with ${SQUISH_TOOL_COUNT} tools`);
+  }
+  return { server: SQUISH_SERVER!, toolCount: SQUISH_TOOL_COUNT };
+}
 
 function parseArgs(): { mode: "stdio" | "http"; port: number; health: boolean } {
   const args = process.argv.slice(2);
@@ -626,16 +647,20 @@ function createSquishServer(): { server: McpServer; toolCount: number } {
   return { server, toolCount };
 }
 
-async function runStdio(server: McpServer, toolCount: number): Promise<void> {
-  console.error(`[MCP] Starting in STDIO mode...`);
+async function runStdio(server: McpServer, toolCount: number, lazyHooks?: { startWorkerIfNeeded: () => Promise<void>; startSchedulerIfNeeded: () => Promise<void> }): Promise<void> {
+  // Don't start worker/scheduler here - only start on first actual tool call
+  // This fixes MCP stdio initialization timing
+  
+  const silent = process.env.SQUISH_MCP_SILENT === 'true';
+  if (!silent) console.error(`[MCP] Starting in STDIO mode...`);
   const transport = new StdioServerTransport();
 
   transport.onclose = () => {
-    console.error(`[MCP] STDIO transport closed`);
+    if (!silent) console.error(`[MCP] STDIO transport closed`);
   };
 
   await server.connect(transport);
-  console.error(`[MCP] Connected via stdio. ${toolCount} tools available.`);
+  if (!silent) console.error(`[MCP] Connected via stdio. ${toolCount} tools available.`);
 
   // Keep process alive - wait for stdin to close or process signals
   await new Promise<void>((resolve) => {
@@ -656,8 +681,11 @@ async function runStdio(server: McpServer, toolCount: number): Promise<void> {
   });
 }
 
-async function runHttp(server: McpServer, port: number): Promise<void> {
-  console.error(`[MCP] Starting in Streamable HTTP mode on port ${port}...`);
+async function runHttp(server: McpServer, port: number, lazyHooks?: { startWorkerIfNeeded: () => Promise<void>; startSchedulerIfNeeded: () => Promise<void> }): Promise<void> {
+  // Don't start worker/scheduler here - only when tools are called
+  
+  const silent = process.env.SQUISH_MCP_SILENT === 'true';
+  if (!silent) console.error(`[MCP] Starting in Streamable HTTP mode on port ${port}...`);
 
   const app = express();
   app.use(express.json({ strict: false }));
@@ -805,11 +833,13 @@ async function runHttp(server: McpServer, port: number): Promise<void> {
 }
 
 async function runHealthCheck(): Promise<void> {
-  console.error(`[MCP] Running health check...`);
+  const silent = process.env.SQUISH_MCP_SILENT === 'true';
+  
+  if (!silent) console.error(`[MCP] Running health check...`);
 
   try {
     const { server, toolCount } = createSquishServer();
-    console.error(`[MCP] Health check passed. Server initialized with ${toolCount} tools.`);
+    if (!silent) console.error(`[MCP] Health check passed. Server initialized with ${toolCount} tools.`);
     process.exit(0);
   } catch (error) {
     console.error(`[MCP] Health check failed:`, error);
@@ -819,40 +849,71 @@ async function runHealthCheck(): Promise<void> {
 
 async function main(): Promise<void> {
   try {
-    console.error(`[${SERVER_NAME}] v${SERVER_VERSION} initializing...`);
-    console.error(`[${SERVER_NAME}] Mode: ${config.isManagedMode ? "managed" : "local"}`);
-    console.error(`[${SERVER_NAME}] Embeddings: ${config.embeddingsProvider}`);
-
     const { mode, port, health } = parseArgs();
 
+    // Check for silent mode - minimal output for MCP stdio
+    const silent = process.argv.includes('--silent') || process.env.SQUISH_MCP_SILENT === 'true';
+    
+    if (!silent) {
+      console.error(`[${SERVER_NAME}] v${SERVER_VERSION} initializing...`);
+      console.error(`[${SERVER_NAME}] Mode: ${config.isManagedMode ? "managed" : "local"}`);
+      console.error(`[${SERVER_NAME}] Embeddings: ${config.embeddingsProvider}`);
+    }
+
     if (health) {
       await runHealthCheck();
       return;
     }
 
-    // Start background worker for lifecycle maintenance, decay, etc.
-    try {
-      await startWorker();
-      console.error(`[${SERVER_NAME}] Background worker started`);
-    } catch (error) {
-      console.error(`[${SERVER_NAME}] Warning: Failed to start background worker:`, error);
-    }
+    // DEFERRED: Start background worker only when actually needed
+    // This speeds up MCP startup significantly for MCP use cases
+    // Workers can be started lazily on first actual operation
+    const noWorker = process.env.SQUISH_MCP_NO_WORKER === 'true' || process.argv.includes('--no-worker');
+    const workerStarted = { current: false };
+    
+    const startWorkerIfNeeded = async () => {
+      if (!workerStarted.current && !noWorker) {
+        try {
+          await startWorker();
+          if (!silent) console.error(`[${SERVER_NAME}] Background worker started`);
+        } catch (error) {
+          // Silently fail - worker is optional for MCP
+        }
+        workerStarted.current = true;
+      }
+    };
 
-    // Initialize cron scheduler for scheduled jobs
-    try {
-      await initializeScheduler();
-      console.error(`[${SERVER_NAME}] Cron scheduler initialized`);
-    } catch (error) {
-      console.error(`[${SERVER_NAME}] Warning: Failed to initialize scheduler:`, error);
-    }
+    // DEFERRED: Scheduler - only initialize lazily
+    const schedulerStarted = { current: false };
+    
+    const startSchedulerIfNeeded = async () => {
+      if (!schedulerStarted.current) {
+        try {
+          await initializeScheduler();
+          if (!silent) console.error(`[${SERVER_NAME}] Cron scheduler initialized`);
+        } catch (error) {
+          // Silently fail - scheduler is optional
+        }
+        schedulerStarted.current = true;
+      }
+    };
+
+    // Hook into server operations to lazy-start worker/scheduler
+    // This keeps MCP fast but ensures services start when needed
+    const lazyHooks = {
+      startWorkerIfNeeded,
+      startSchedulerIfNeeded
+    };
 
     const shutdown = async () => {
-      console.error(`[${SERVER_NAME}] Shutting down...`);
+      if (!silent) console.error(`[${SERVER_NAME}] Shutting down...`);
       try {
-        await stopWorker();
-        console.error(`[${SERVER_NAME}] Background worker stopped`);
+        if (workerStarted.current) {
+          await stopWorker();
+          if (!silent) console.error(`[${SERVER_NAME}] Background worker stopped`);
+        }
       } catch (error) {
-        console.error(`[${SERVER_NAME}] Error stopping worker:`, error);
+        // Ignore shutdown errors
       }
       process.exit(0);
     };
@@ -860,10 +921,12 @@ async function main(): Promise<void> {
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
 
+    const { server, toolCount } = getSquishServer();
+    
     if (mode === "stdio") {
-      await runStdio(SQUISH_SERVER, SQUISH_TOOL_COUNT);
+      await runStdio(server, toolCount, lazyHooks);
     } else {
-      await runHttp(SQUISH_SERVER, port);
+      await runHttp(server, port, lazyHooks);
     }
   } catch (error) {
     console.error(`[${SERVER_NAME}] Fatal error:`, error);