squish-memory 1.0.1 → 1.0.2

package/.env.mcp.example

@@ -2,6 +2,10 @@
 SQUISH_MCP_PORT=8767
 SQUISH_MCP_SERVER_ENABLED=true
 
+# CORS Configuration (comma-separated origins, * wildcard for port)
+# Default: localhost and 127.0.0.1 on any port
+# SQUISH_CORS_ORIGINS=http://localhost:3000,http://127.0.0.1:8080
+
 # Embeddings Provider: local | openai | ollama | google | none | auto
 # Default: local (TF-IDF, no API needed)
 SQUISH_EMBEDDINGS_PROVIDER=local

package/README.md

@@ -1,11 +1,18 @@
 # Squish - Universal Two-Tier Memory for AI Agents
 
+[![npm version](https://img.shields.io/npm/v/squish-memory)](https://www.npmjs.com/package/squish-memory)
+[![npm downloads](https://img.shields.io/npm/dm/squish-memory)](https://www.npmjs.com/package/squish-memory)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue.svg)](https://www.typescriptlang.org/)
+
 **Squish gives any AI agent persistent, intelligent memory through a two-tier architecture.** Without memory, agents forget everything between sessions. With Squish, they learn, adapt, and get smarter over time - regardless of which agent framework you use.
 
 ```bash
 npm install squish-memory
 ```
 
+**Works out-of-the-box.** No database setup required - local TF-IDF embeddings work instantly. Upgrade to vector search with OpenAI/Ollama when ready.
+
 ## Why Agents Need Memory
 
 | Without Squish | With Squish |
@@ -18,8 +25,8 @@ npm install squish-memory
 ## How It Works
 
 Squish uses a two-tier memory architecture for optimal performance:
-- **Fast Search Tier**: QMD (Quick Markdown Search) provides lightning-fast hybrid BM25 + vector search
-- **Persistent Storage Tier**: SQLite (local) or PostgreSQL (team) ensures durable, reliable memory storage
+- **Short-term Memory (QMD)**: Lightning-fast file-based search using QMD (BM25 + vector). Instant recall, optimized for recent/active context.
+- **Long-term Memory (Database)**: SQLite (local) or PostgreSQL (team) for durable, searchable storage of important memories.
 
 ```
 Agent Action -----> [Squish Memory Layer]
@@ -35,19 +42,18 @@ Agent Action -----> [Squish Memory Layer]
                      │  Write Gate  │ <-- Validate, sanitize, score
                      └──────────────┘
                             |
-                            v
-          ┌─────────────────────┐
-          │  Dual Storage Write │
-          │  ──→ QMD Index      │  (fast search)
-          │  ──→ SQLite/Postgres│  (durable storage)
-          └─────────────────────┘
-                            |
-                            v
-          ┌─────────────────────┐
-          │  Hybrid Retrieval   │
-          │  QMD Search +       │
-          │  Vector Ranking     │
-          └─────────────────────┘
+            ┌───────────────┴───────────────┐
+            v                               v
+     ┌──────────────┐              ┌──────────────┐
+     │ Short-term   │              │ Long-term    │
+     │ QMD (Files)  │              │ SQLite/PG    │
+     │ Fast recall  │              │ Persistent   │
+     └──────────────┘              └──────────────┘
+            |                               |
+            v                               v
+     ┌──────────────────────────────────────────┐
+     │  Hybrid Retrieval: QMD + Vector Ranking  │
+     └──────────────────────────────────────────┘
                             |
                             v
                      Agent Context
@@ -73,6 +79,18 @@ Agent Action -----> [Squish Memory Layer]
 
 ## Quick Start
 
+### Simple Example
+```bash
+# Store a memory
+squish remember "User prefers TypeScript"
+
+# Search memories
+squish search "preferences"
+
+# Check health
+squish health
+```
+
 ### Universal Plugin Installer (Recommended)
 ```bash
 # Install for your AI assistant(s)
@@ -288,8 +306,8 @@ DATABASE_URL=postgresql://user:pass@host/db
 
 ### Two-Tier Memory System
 Squish employs a two-tier architecture for optimal performance and reliability:
-- **Fast Search Tier**: QMD (Quick Markdown Search) provides hybrid BM25 + vector search with sub-second response times
-- **Persistent Storage Tier**: SQLite (local mode) or PostgreSQL (team mode) ensures durable, ACID-compliant memory storage
+- **Short-term (QMD)**: File-based search using QMD (BM25 + vectors). Ultra-fast for recent context and active memories.
+- **Long-term (Database)**: SQLite (local) or PostgreSQL (team). Durable ACID-compliant storage for important memories that need persistence.
 
 ### Universal Interfaces
 - **MCP Server**: Native integration for Claude Code, OpenClaw, and any MCP-compatible agent

package/config/plugin-manifest.json

@@ -1,7 +1,7 @@
 {
   "id": "squish-memory",
   "name": "Squish Memory",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Universal two-tier memory system for AI agents with hybrid search, core memory, and MCP-first architecture",
   "capabilities": ["mcp", "cli", "web"],
   "targets": {

package/dist/api/web/web.js

@@ -1,5 +1,6 @@
 import express from 'express';
 import cors from 'cors';
+import rateLimit from 'express-rate-limit';
 import { logger } from '../../core/logger.js';
 import { getRecentMemories } from '../../core/memory/memories.js';
 import { getObservationsForProject } from '../../core/observations.js';
@@ -7,7 +8,32 @@ import { getAllProjects, getProjectByPath } from '../../core/projects.js';
 import { getDb } from '../../db/index.js';
 const app = express();
 const PORT = process.env.SQUISH_WEB_PORT || 37777;
-app.use(cors());
+const allowedOrigins = process.env.SQUISH_CORS_ORIGINS?.split(',').map(s => s.trim()) || ['http://localhost:*', 'http://127.0.0.1:*'];
+const appCors = cors({
+    origin: (origin, callback) => {
+        if (!origin || allowedOrigins.some(allowed => {
+            if (allowed.endsWith(':*')) {
+                const prefix = allowed.slice(0, -1);
+                return origin.startsWith(prefix);
+            }
+            return origin === allowed;
+        })) {
+            callback(null, true);
+        }
+        else {
+            callback(new Error('Not allowed by CORS'));
+        }
+    }
+});
+const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000,
+    max: 100,
+    message: { error: 'Too many requests, please try again later.' },
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+app.use(appCors);
+app.use(limiter);
 app.use(express.json());
 // Health check endpoint
 app.get('/api/health', async (req, res) => {

package/dist/commands/mcp-server.js

@@ -21,7 +21,7 @@ import { getDb } from "../db/index.js";
 import { getSchema } from "../db/schema.js";
 import { eq } from "drizzle-orm";
 const SERVER_NAME = "squish-memory";
-const SERVER_VERSION = "1.0.1";
+const SERVER_VERSION = "1.0.2";
 function parseArgs() {
     const args = process.argv.slice(2);
     let mode = "stdio";

package/dist/core/mcp/server.js

@@ -1,5 +1,6 @@
 import express from 'express';
 import cors from 'cors';
+import rateLimit from 'express-rate-limit';
 import { logger } from '../logger.js';
 export class MCPServer {
     app = express();
@@ -16,7 +17,32 @@ export class MCPServer {
         this.setupRoutes();
     }
     setupMiddleware() {
-        this.app.use(cors());
+        const allowedOrigins = process.env.SQUISH_CORS_ORIGINS?.split(',').map(s => s.trim()) || ['http://localhost:*', 'http://127.0.0.1:*'];
+        const appCors = cors({
+            origin: (origin, callback) => {
+                if (!origin || allowedOrigins.some(allowed => {
+                    if (allowed.endsWith(':*')) {
+                        const prefix = allowed.slice(0, -1);
+                        return origin.startsWith(prefix);
+                    }
+                    return origin === allowed;
+                })) {
+                    callback(null, true);
+                }
+                else {
+                    callback(new Error('Not allowed by CORS'));
+                }
+            }
+        });
+        const limiter = rateLimit({
+            windowMs: 15 * 60 * 1000,
+            max: 100,
+            message: { error: 'Too many requests, please try again later.' },
+            standardHeaders: true,
+            legacyHeaders: false,
+        });
+        this.app.use(appCors);
+        this.app.use(limiter);
         this.app.use(express.json());
     }
     setupRoutes() {

package/dist/core/mcp/types.d.ts

@@ -30,29 +30,29 @@ export declare const MCPToolResultSchema: z.ZodObject<{
         mimeType: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         type: "text" | "image" | "resource";
-        data?: string | undefined;
         text?: string | undefined;
+        data?: string | undefined;
         mimeType?: string | undefined;
     }, {
         type: "text" | "image" | "resource";
-        data?: string | undefined;
         text?: string | undefined;
+        data?: string | undefined;
         mimeType?: string | undefined;
     }>, "many">;
     isError: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     content: {
         type: "text" | "image" | "resource";
-        data?: string | undefined;
         text?: string | undefined;
+        data?: string | undefined;
         mimeType?: string | undefined;
     }[];
     isError?: boolean | undefined;
 }, {
     content: {
         type: "text" | "image" | "resource";
-        data?: string | undefined;
         text?: string | undefined;
+        data?: string | undefined;
         mimeType?: string | undefined;
     }[];
     isError?: boolean | undefined;

package/dist/core/memory/memories.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'crypto';
-import { desc, eq } from 'drizzle-orm';
+import { eq } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
 import { config } from '../../config.js';
@@ -143,14 +143,17 @@ export async function getMemoryById(id, incrementAccess = true) {
 export async function getRecentMemories(projectPath, limit) {
     try {
         const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
+        const sqlite = db.$client;
         const project = await getProjectByPath(projectPath);
         if (!project)
             return [];
-        const rows = await db.select().from(schema.memories)
-            .where(eq(schema.memories.projectId, project.id))
-            .orderBy(desc(schema.memories.createdAt))
-            .limit(limit);
+        // Use raw SQL to avoid drizzle column name issues
+        const rows = sqlite.prepare(`
+      SELECT * FROM memories 
+      WHERE project_id = ? 
+      ORDER BY created_at DESC 
+      LIMIT ?
+    `).all(project.id, limit);
         return rows.map((row) => normalizeMemory(row));
     }
     catch (error) {

package/dist/core/scheduler/cron-scheduler.js

@@ -65,18 +65,61 @@ async function ensureDefaultJobs(db) {
         },
     ];
     for (const job of defaultJobs) {
-        const existing = await db
-            .select()
-            .from(maintenanceJobs)
-            .where(eq(maintenanceJobs.jobName, job.jobName))
-            .limit(1);
+        let existing;
+        try {
+            existing = await db
+                .select()
+                .from(maintenanceJobs)
+                .where(eq(maintenanceJobs.jobName, job.jobName))
+                .limit(1);
+        }
+        catch (queryError) {
+            logger.error(`[Scheduler] Query failed for job ${job.jobName}:`, queryError.message);
+            // Try raw SQL fallback
+            try {
+                const rawDb = db.$client;
+                if (rawDb && typeof rawDb.prepare === 'function') {
+                    existing = rawDb.prepare('SELECT * FROM maintenance_jobs WHERE job_name = ?').all(job.jobName);
+                }
+            }
+            catch (fallbackError) {
+                logger.error(`[Scheduler] Fallback query also failed:`, fallbackError.message);
+                throw queryError;
+            }
+        }
         if (existing.length === 0) {
-            await db.insert(maintenanceJobs).values({
-                ...job,
-                totalRuns: 0,
-                successCount: 0,
-                failureCount: 0,
-            });
+            try {
+                await db.insert(maintenanceJobs).values({
+                    jobName: job.jobName,
+                    jobType: job.jobType,
+                    cronExpression: job.cronExpression,
+                    enabled: job.enabled,
+                    jobConfig: job.jobConfig,
+                    totalRuns: 0,
+                    successCount: 0,
+                    failureCount: 0,
+                    lastRunAt: null,
+                    nextRunAt: null,
+                    lastRunDuration: null,
+                    lastRunStatus: null,
+                    lastRunError: null,
+                });
+            }
+            catch (insertError) {
+                // Fallback to raw SQL if drizzle insert fails
+                logger.warn(`[Scheduler] Drizzle insert failed, using raw SQL: ${insertError.message}`);
+                const rawDb = db.$client;
+                if (rawDb && typeof rawDb.prepare === 'function') {
+                    const stmt = rawDb.prepare(`
+            INSERT INTO maintenance_jobs 
+            (id, job_name, job_type, cron_expression, enabled, job_config, 
+             total_runs, success_count, failure_count, last_run_at, next_run_at, 
+             last_run_duration, last_run_status, last_run_error)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `);
+                    stmt.run(crypto.randomUUID(), job.jobName, job.jobType, job.cronExpression, job.enabled ? 1 : 0, JSON.stringify(job.jobConfig), 0, 0, 0, null, null, null, null, null);
+                }
+            }
             logger.info(`[Scheduler] Created default job: ${job.jobName}`);
             // Register self-iteration handler
             if (job.jobName === 'self_iteration') {
@@ -115,7 +158,7 @@ export async function scheduleJob(job) {
             .set({ nextRunAt: nextRun })
             .where(eq(maintenanceJobs.id, job.id));
     }
-    logger.info(`[Scheduler] Scheduled ${job.jobName} with cron: ${job.cronExpression}, next run: ${nextRun?.toISOString()}`);
+    logger.info(`[Scheduler] Scheduled ${job.jobName} with cron: ${job.cronExpression}${nextRun ? `, next run: ${nextRun.toISOString()}` : ''}`);
 }
 export async function executeJob(job) {
     const db = await getDb();
@@ -183,13 +226,23 @@ function getNextRunTime(cronExpression) {
     try {
         const now = new Date();
         const parts = cronExpression.split(' ');
-        if (parts[2] === '*' && parts[3] === '*' && parts[4] === '*') {
+        // Daily jobs: MM HH * * *
+        if (parts[2] === '*' && parts[3] === '*' && parts[4] === '*' && parts[1] !== '*') {
             const next = new Date(now);
             next.setHours(parseInt(parts[1]), parseInt(parts[0]), 0, 0);
             if (next <= now)
                 next.setDate(next.getDate() + 1);
             return next;
         }
+        // Hourly jobs: MM * * * *
+        if (parts[1] === '*' && parts[2] === '*' && parts[3] === '*' && parts[4] === '*') {
+            const next = new Date(now);
+            next.setMinutes(parseInt(parts[0]), 0, 0);
+            if (next <= now)
+                next.setHours(next.getHours() + 1);
+            return next;
+        }
+        // Weekly jobs: MM HH * * D
         if (parts[4] !== '*') {
             const dayOfWeek = parseInt(parts[4]);
             const next = new Date(now);

package/dist/db/adapter.js

@@ -1,6 +1,19 @@
 import { config, getDataDir } from '../config.js';
 import { ensurePostgresSchema, ensureSqliteSchema } from './bootstrap.js';
 import { logger } from '../core/logger.js';
+async function createBunSqliteDb(dbPath) {
+    // @ts-ignore - bun:sqlite module not found in types but works at runtime
+    const { drizzle } = await import('drizzle-orm/bun-sqlite');
+    const schemaModule = await import('../drizzle/schema-sqlite.js');
+    // Bun SQLite doesn't need file path for in-memory, but we'll use file path for persistence
+    // @ts-ignore - bun:sqlite module not found in types but works at runtime
+    const sqlite = new (await import('bun:sqlite')).default(dbPath);
+    // Enable foreign keys
+    sqlite.exec('PRAGMA foreign_keys = ON');
+    await ensureSqliteSchema(sqlite);
+    logger.info('SQLite initialized with bun:sqlite');
+    return drizzle(sqlite, { schema: schemaModule });
+}
 export async function createDb() {
     if (config.isTeamMode) {
         return createPostgresDb();
@@ -22,31 +35,41 @@ async function createPostgresDb() {
 }
 async function createSqliteDb() {
     const dbPath = `${getDataDir()}/squish.db`;
-    // Try better-sqlite3 first (best performance)
+    // Try bun:sqlite first (Bun's built-in SQLite)
     try {
-        return await createBetterSqliteDb(dbPath);
+        return await createBunSqliteDb(dbPath);
     }
-    catch (betterSqliteError) {
-        logger.warn('better-sqlite3 failed, trying sql.js fallback', {
-            error: betterSqliteError.message
+    catch (bunSqliteError) {
+        logger.warn('bun:sqlite failed, trying better-sqlite3', {
+            error: bunSqliteError.message
         });
-        // Fallback to sql.js (pure JavaScript, no native module)
+        // Try better-sqlite3 second (best performance)
         try {
-            return await createSqlJsDb(dbPath);
+            return await createBetterSqliteDb(dbPath);
         }
-        catch (sqlJsError) {
-            // Both failed - this is critical, Squish cannot work without DB
-            logger.error('CRITICAL: SQLite database initialization failed', {
-                betterSqliteError: betterSqliteError.message,
-                sqlJsError: sqlJsError.message
+        catch (betterSqliteError) {
+            logger.warn('better-sqlite3 failed, trying sql.js fallback', {
+                error: betterSqliteError.message
             });
-            throw new Error(`Squish requires SQLite to function. Database initialization failed.\n` +
-                `Primary error (better-sqlite3): ${betterSqliteError.message}\n` +
-                `Fallback error (sql.js): ${sqlJsError.message}\n\n` +
-                `Solutions:\n` +
-                `1. Rebuild native module: npm rebuild better-sqlite3\n` +
-                `2. Install build tools: npm install -g windows-build-tools (Windows)\n` +
-                `3. Or use PostgreSQL instead by setting DATABASE_URL environment variable`);
+            // Fallback to sql.js (pure JavaScript, no native module)
+            try {
+                return await createSqlJsDb(dbPath);
+            }
+            catch (sqlJsError) {
+                // All failed - this is critical, Squish cannot work without DB
+                logger.error('CRITICAL: SQLite database initialization failed', {
+                    bunSqliteError: bunSqliteError.message,
+                    betterSqliteError: betterSqliteError.message,
+                    sqlJsError: sqlJsError.message
+                });
+                throw new Error(`Squish requires SQLite to function. Database initialization failed.\n` +
+                    `Primary error (bun:sqlite): ${bunSqliteError.message}\n` +
+                    `Secondary error (better-sqlite3): ${betterSqliteError.message}\n` +
+                    `Fallback error (sql.js): ${sqlJsError.message}\n\n` +
+                    `Solutions:\n` +
+                    `1. Install build tools: npm install -g windows-build-tools (Windows)\n` +
+                    `2. Or use PostgreSQL instead by setting DATABASE_URL environment variable`);
+            }
         }
     }
 }
@@ -77,7 +100,7 @@ async function createSqlJsDb(dbPath) {
     }
     const sqlite = new SQL.Database(data);
     // Enable foreign keys
-    sqlite.run('PRAGMA foreign_keys = ON');
+    sqlite.exec('PRAGMA foreign_keys = ON');
     // Schema bootstrap
     await ensureSqliteSchema(sqlite);
     // Persist database on changes (sql.js is in-memory by default)
@@ -89,6 +112,51 @@ async function createSqlJsDb(dbPath) {
         fs.writeFileSync(dbPath, Buffer.from(data));
         return result;
     };
+    // Add prepare method for compatibility with drizzle-orm/sql-js
+    sqlite.prepare = (query) => {
+        const stmt = sqlite.prepare(query);
+        const preparedStatement = {};
+        preparedStatement.bind = (bindParams) => {
+            bindParams.forEach((param, index) => {
+                stmt.bind(param, index + 1);
+            });
+            return preparedStatement;
+        };
+        preparedStatement.step = () => {
+            return stmt.step();
+        };
+        preparedStatement.getAsObject = () => {
+            return stmt.getAsObject();
+        };
+        preparedStatement.free = () => {
+            stmt.free();
+        };
+        preparedStatement.run = () => {
+            const result = stmt.step() ? { changes: sqlite.changes() } : { changes: 0 };
+            stmt.reset();
+            return result;
+        };
+        preparedStatement.get = (bindParams = []) => {
+            if (bindParams.length > 0) {
+                preparedStatement.bind(bindParams);
+            }
+            const row = stmt.step() ? stmt.getAsObject() : undefined;
+            stmt.reset();
+            return row;
+        };
+        preparedStatement.all = (bindParams = []) => {
+            if (bindParams.length > 0) {
+                preparedStatement.bind(bindParams);
+            }
+            const rows = [];
+            while (stmt.step()) {
+                rows.push(stmt.getAsObject());
+            }
+            stmt.reset();
+            return rows;
+        };
+        return preparedStatement;
+    };
     logger.info('SQLite initialized with sql.js (pure JavaScript fallback)');
     return drizzle(sqlite, { schema: schemaModule });
 }