squish-memory 1.0.0 → 1.0.2

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.0";
+const SERVER_VERSION = "1.0.2";
 function parseArgs() {
     const args = process.argv.slice(2);
     let mode = "stdio";
@@ -116,7 +116,9 @@ function createSquishServer() {
     }, async ({ memoryId }) => {
         const db = await getDb();
         const schema = await getSchema();
-        const result = await db.delete(schema.memories).where(eq(schema.memories.id, memoryId));
+        // Cast to any to handle Drizzle ORM union type issue
+        const sqliteDb = db;
+        const result = await sqliteDb.delete(schema.memories).where(eq(schema.memories.id, memoryId));
         return { content: [{ type: "text", text: `Memory deleted: ${memoryId}` }] };
     }))
         toolCount++;
@@ -141,7 +143,9 @@ function createSquishServer() {
         if (Object.keys(updates).length === 0) {
             return { content: [{ type: "text", text: "No updates provided" }], isError: true };
         }
-        await db.update(schema.memories).set(updates).where(eq(schema.memories.id, memoryId));
+        // Cast to any to handle Drizzle ORM union type issue
+        const sqliteDb2 = db;
+        await sqliteDb2.update(schema.memories).set(updates).where(eq(schema.memories.id, memoryId));
         return { content: [{ type: "text", text: `Memory updated: ${memoryId}` }] };
     }))
         toolCount++;

package/dist/config.d.ts

@@ -6,12 +6,16 @@ export declare const config: {
     dataDir: string;
     mcpServerPort: number;
     mcpServerEnabled: boolean;
-    embeddingsProvider: "openai" | "ollama" | "local" | "none" | "qmd" | "hybrid" | "google-multimodal" | "auto";
+    embeddingsProvider: "local" | "openai" | "ollama" | "google" | "none" | "auto";
     openAiApiKey: string;
-    openAiApiUrl: string;
-    openAiEmbeddingModel: string;
-    ollamaUrl: string;
-    ollamaEmbeddingModel: string;
+    openAiApiUrl: any;
+    openAiEmbeddingModel: any;
+    googleCloudApiKey: string;
+    googleCloudProject: string;
+    googleCloudLocation: string;
+    googleEmbeddingModel: any;
+    ollamaUrl: any;
+    ollamaEmbeddingModel: any;
     lifecycleEnabled: boolean;
     lifecycleInterval: number;
     summarizationEnabled: boolean;
@@ -26,10 +30,6 @@ export declare const config: {
     qmdCollectionsPath: string;
     qmdFallbackMode: "qmd-only" | "cloud-first" | "hybrid" | "local-only";
     qmdCollectionMapping: any;
-    googleCloudApiKey: string;
-    googleCloudProject: string;
-    googleCloudLocation: string;
-    multimodalEmbeddingsEnabled: boolean;
     managedMode: boolean;
     managedApiUrl: string;
     managedApiKey: string;
@@ -53,7 +53,7 @@ export declare const config: {
     embeddingsRetryDelayMs: number;
     openAiTimeoutMs: number;
     ollamaTimeoutMs: number;
-    googleMultimodalTimeoutMs: number;
+    googleTimeoutMs: number;
 };
 export default config;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,5 +1,9 @@
 import { join } from 'path';
-import { mkdirSync, existsSync } from 'fs';
+import { mkdirSync, existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 export function getDataDir() {
     const projectRoot = process.env.CLAUDE_WORKING_DIRECTORY || process.cwd();
     const dir = process.env.SQUISH_DATA_DIR || join(projectRoot, '.squish');
@@ -7,21 +11,58 @@ export function getDataDir() {
         mkdirSync(dir, { recursive: true });
     return dir;
 }
+// Load settings from config/settings.json
+function loadSettings() {
+    const settingsPath = join(__dirname, 'config', 'settings.json');
+    try {
+        if (existsSync(settingsPath)) {
+            const content = readFileSync(settingsPath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch (error) {
+        console.warn('Failed to load settings.json, using defaults');
+    }
+    return {};
+}
+const settings = loadSettings();
+// Helper to get env var or settings value
+function getConfig(path, envVar, defaultValue) {
+    // Priority 1: Environment variable
+    if (envVar && process.env[envVar]) {
+        return process.env[envVar];
+    }
+    // Priority 2: Settings file
+    const keys = path.split('.');
+    let value = settings;
+    for (const key of keys) {
+        if (value && typeof value === 'object' && key in value) {
+            value = value[key];
+        }
+        else {
+            value = undefined;
+            break;
+        }
+    }
+    if (value !== undefined) {
+        return value;
+    }
+    // Priority 3: Default value
+    return defaultValue;
+}
 const isTeamMode = !!process.env.DATABASE_URL?.startsWith('postgres');
 const isManagedMode = process.env.SQUISH_MANAGED_MODE === 'true';
-const openAiApiKey = process.env.SQUISH_OPENAI_API_KEY || process.env.OPENAI_API_KEY || '';
 // Embeddings providers:
 // - openai: OpenAI API (requires API key)
 // - ollama: Local Ollama server (requires nomic-embed-text)
 // - local: TF-IDF offline (no dependencies)
 // - none: Disable embeddings (stub)
-// - qmd: QMD (requires qmd CLI installed)
-// - hybrid: Try multiple providers with fallbacks
-// - google-multimodal: Google Cloud multimodal embeddings
-const VALID_PROVIDERS = new Set(['openai', 'ollama', 'local', 'none', 'qmd', 'hybrid', 'google-multimodal', 'auto']);
+// - google: Google Cloud embeddings
+// - auto: Smart fallback (cloud if available, local fallback)
+const VALID_PROVIDERS = new Set(['openai', 'ollama', 'local', 'none', 'google', 'auto']);
 const embeddingsProvider = (() => {
-    const explicit = process.env.SQUISH_EMBEDDINGS_PROVIDER?.toLowerCase();
-    if (explicit && VALID_PROVIDERS.has(explicit)) {
+    const explicit = getConfig('embeddings.provider', 'SQUISH_EMBEDDINGS_PROVIDER', 'local').toLowerCase();
+    if (VALID_PROVIDERS.has(explicit)) {
         return explicit;
     }
     return 'local';
@@ -45,28 +86,47 @@ const defaultCollectionMapping = {
 const qmdCollectionMapping = process.env.SQUISH_QMD_COLLECTION_MAPPING
     ? JSON.parse(process.env.SQUISH_QMD_COLLECTION_MAPPING)
     : defaultCollectionMapping;
+// OpenAI Configuration
+const openAiApiKey = process.env.SQUISH_OPENAI_API_KEY || process.env.OPENAI_API_KEY || '';
+const openAiApiUrl = getConfig('api.openai.apiUrl', 'SQUISH_OPENAI_API_URL', 'https://api.openai.com/v1/embeddings');
+const openAiEmbeddingModel = getConfig('embeddings.models.openai.model', 'SQUISH_OPENAI_EMBEDDING_MODEL', 'text-embedding-3-small');
+// Google Configuration  
+const googleCloudApiKey = process.env.GOOGLE_CLOUD_API_KEY || process.env.SQUISH_GOOGLE_CLOUD_API_KEY || '';
+const googleCloudProject = process.env.GOOGLE_CLOUD_PROJECT || process.env.SQUISH_GOOGLE_CLOUD_PROJECT || '';
+const googleCloudLocation = process.env.GOOGLE_CLOUD_LOCATION || process.env.SQUISH_GOOGLE_CLOUD_LOCATION || 'us-central1';
+const googleEmbeddingModel = getConfig('embeddings.models.google.model', 'SQUISH_GOOGLE_EMBEDDING_MODEL', 'gemini-embedding-001');
+// Ollama Configuration
+const ollamaUrl = getConfig('api.ollama.url', 'SQUISH_OLLAMA_URL', 'http://localhost:11434');
+const ollamaEmbeddingModel = getConfig('embeddings.models.ollama.model', 'SQUISH_OLLAMA_EMBEDDING_MODEL', 'nomic-embed-text:v1.5');
 export const config = {
     isTeamMode,
     isManagedMode,
     redisEnabled: !!process.env.REDIS_URL,
     dataDir: getDataDir(),
-    mcpServerPort: parseInt(process.env.SQUISH_MCP_PORT || '8767'),
-    mcpServerEnabled: process.env.SQUISH_MCP_SERVER_ENABLED !== 'false',
+    mcpServerPort: parseInt(getConfig('mcp.serverPort', 'SQUISH_MCP_PORT', '8767')),
+    mcpServerEnabled: getConfig('mcp.serverEnabled', 'SQUISH_MCP_SERVER_ENABLED', true) !== false,
     embeddingsProvider: embeddingsProvider,
+    // OpenAI
     openAiApiKey,
-    openAiApiUrl: process.env.SQUISH_OPENAI_API_URL || 'https://api.openai.com/v1/embeddings',
-    openAiEmbeddingModel: process.env.SQUISH_OPENAI_EMBEDDING_MODEL || 'text-embedding-3-small',
-    ollamaUrl: process.env.SQUISH_OLLAMA_URL || 'http://localhost:11434',
-    ollamaEmbeddingModel: process.env.SQUISH_OLLAMA_EMBEDDING_MODEL || 'nomic-embed-text:v1.5',
+    openAiApiUrl,
+    openAiEmbeddingModel,
+    // Google
+    googleCloudApiKey,
+    googleCloudProject,
+    googleCloudLocation,
+    googleEmbeddingModel,
+    // Ollama
+    ollamaUrl,
+    ollamaEmbeddingModel,
     // Lifecycle Management
-    lifecycleEnabled: process.env.SQUISH_LIFECYCLE_ENABLED !== 'false',
+    lifecycleEnabled: getConfig('features.lifecycleEnabled', 'SQUISH_LIFECYCLE_ENABLED', true) !== false,
     lifecycleInterval: parseInt(process.env.SQUISH_LIFECYCLE_INTERVAL || '3600000'),
     // Session Summarization
-    summarizationEnabled: process.env.SQUISH_SUMMARIZATION_ENABLED !== 'false',
+    summarizationEnabled: getConfig('features.summarizationEnabled', 'SQUISH_SUMMARIZATION_ENABLED', true) !== false,
     incrementalThreshold: parseInt(process.env.SQUISH_INCREMENTAL_THRESHOLD || '10'),
     rollingWindowSize: parseInt(process.env.SQUISH_ROLLING_WINDOW_SIZE || '50'),
     // Agent-Aware Memory
-    agentIsolationEnabled: process.env.SQUISH_AGENT_ISOLATION_ENABLED !== 'false',
+    agentIsolationEnabled: getConfig('features.agentIsolation', 'SQUISH_AGENT_ISOLATION_ENABLED', true) !== false,
     defaultVisibilityScope: (process.env.SQUISH_DEFAULT_VISIBILITY || 'private'),
     // Memory Governance
     governanceEnabled: process.env.SQUISH_GOVERNANCE_ENABLED !== 'false',
@@ -78,11 +138,6 @@ export const config = {
     qmdCollectionsPath,
     qmdFallbackMode: qmdFallbackMode,
     qmdCollectionMapping,
-    // Google Cloud Multimodal Embeddings
-    googleCloudApiKey: process.env.GOOGLE_CLOUD_API_KEY || process.env.SQUISH_GOOGLE_CLOUD_API_KEY || '',
-    googleCloudProject: process.env.GOOGLE_CLOUD_PROJECT || process.env.SQUISH_GOOGLE_CLOUD_PROJECT || '',
-    googleCloudLocation: process.env.GOOGLE_CLOUD_LOCATION || process.env.SQUISH_GOOGLE_CLOUD_LOCATION || 'us-central1',
-    multimodalEmbeddingsEnabled: process.env.SQUISH_MULTIMODAL_EMBEDDINGS_ENABLED === 'true',
     // Managed Mode
     managedMode: process.env.SQUISH_MANAGED_MODE === 'true',
     managedApiUrl: process.env.SQUISH_MANAGED_API_URL || 'https://api.squish.dev',
@@ -113,7 +168,7 @@ export const config = {
     embeddingsRetryDelayMs: parseInt(process.env.SQUISH_EMBEDDINGS_RETRY_DELAY_MS || '1000'),
     openAiTimeoutMs: parseInt(process.env.SQUISH_OPENAI_TIMEOUT_MS || process.env.SQUISH_EMBEDDINGS_TIMEOUT_MS || '30000'),
     ollamaTimeoutMs: parseInt(process.env.SQUISH_OLLAMA_TIMEOUT_MS || process.env.SQUISH_EMBEDDINGS_TIMEOUT_MS || '30000'),
-    googleMultimodalTimeoutMs: parseInt(process.env.SQUISH_GOOGLE_MULTIMODAL_TIMEOUT_MS || process.env.SQUISH_EMBEDDINGS_TIMEOUT_MS || '30000'),
+    googleTimeoutMs: parseInt(process.env.SQUISH_GOOGLE_TIMEOUT_MS || process.env.SQUISH_EMBEDDINGS_TIMEOUT_MS || '30000'),
 };
 export default config;
 //# sourceMappingURL=config.js.map

package/dist/core/embeddings.d.ts

@@ -1,5 +1,5 @@
 import { MultimodalInput } from './embeddings/google-multimodal.js';
-export type EmbeddingProvider = 'openai' | 'ollama' | 'local' | 'none' | 'auto' | 'qmd' | 'hybrid' | 'google-multimodal';
+export type EmbeddingProvider = 'local' | 'openai' | 'ollama' | 'google' | 'none' | 'auto';
 export declare function getEmbedding(input: string | MultimodalInput): Promise<number[] | null>;
 /**
  * Get embeddings for multiple inputs in parallel batches

package/dist/core/embeddings.js

@@ -1,5 +1,4 @@
 import { config } from '../config.js';
-import { getQMDClient } from './embeddings/qmd-client.js';
 import { getGoogleMultimodalEmbedding, isMultimodalInput } from './embeddings/google-multimodal.js';
 import { logger } from './logger.js';
 // Retry utility with exponential backoff
@@ -104,7 +103,7 @@ export async function getEmbedding(input) {
     }
     let result = null;
     // Handle multimodal input
-    if (isMultimodalInput(input) && (provider === 'google-multimodal' || provider === 'hybrid')) {
+    if (isMultimodalInput(input) && provider === 'google') {
         const multimodalResult = await getGoogleMultimodalEmbedding(input);
         if (multimodalResult) {
             result = multimodalResult.embedding;
@@ -116,35 +115,10 @@ export async function getEmbedding(input) {
         if (provider === 'none') {
             result = null;
         }
-        else if (provider === 'google-multimodal') {
+        else if (provider === 'google') {
             const multimodalResult = await getGoogleMultimodalEmbedding({ text: textInput });
             result = multimodalResult?.embedding || null;
         }
-        else if (provider === 'qmd') {
-            result = await getQMDEmbedding(textInput);
-            // Fallback if QMD fails (unless qmd-only mode)
-            if (!result && config.qmdFallbackMode !== 'qmd-only') {
-                result = getLocalEmbedding(textInput);
-            }
-        }
-        else if (provider === 'hybrid') {
-            // Hybrid mode: Try cloud providers first (best quality), then local fallback
-            // Order: Google Multimodal → OpenAI → Ollama → Local TF-IDF
-            // Note: QMD is not used for embedding generation (search only)
-            if (config.multimodalEmbeddingsEnabled) {
-                const multimodalResult = await getGoogleMultimodalEmbedding({ text: textInput });
-                result = multimodalResult?.embedding || null;
-            }
-            if (!result && config.openAiApiKey) {
-                result = await getOpenAiEmbedding(textInput);
-            }
-            if (!result && config.ollamaUrl) {
-                result = await getOllamaEmbedding(textInput);
-            }
-            if (!result) {
-                result = getLocalEmbedding(textInput);
-            }
-        }
         else if (provider === 'openai') {
             result = await getOpenAiEmbedding(textInput);
         }
@@ -155,8 +129,7 @@ export async function getEmbedding(input) {
             result = getLocalEmbedding(textInput);
         }
         else {
-            // Auto mode: use local TF-IDF by default (fast, no API needed)
-            // Only try external providers if explicitly configured
+            // Auto mode: try cloud providers first if configured, then fall back to local
             if (config.openAiApiKey) {
                 result = await getOpenAiEmbedding(textInput);
             }
@@ -288,34 +261,6 @@ function getLocalEmbedding(input) {
     }
     return vector;
 }
-/**
- * Get embedding via QMD
- * Note: QMD doesn't expose direct embedding generation via MCP.
- * This function returns null to trigger fallback to other providers.
- * The main QMD integration value is through hybrid search (qmd_query).
- */
-async function getQMDEmbedding(input) {
-    if (!config.qmdEnabled) {
-        return null;
-    }
-    try {
-        const client = await getQMDClient();
-        const available = await client.isAvailable();
-        if (!available) {
-            return null;
-        }
-        // QMD doesn't expose direct embedding generation via MCP
-        // The search tools use embeddings internally but don't return them
-        //
-        // For embedding generation, we rely on fallback providers
-        // QMD's main value is through the qmd_search, qmd_vsearch, qmd_query tools
-        return null;
-    }
-    catch (error) {
-        logger.debug('QMD embedding unavailable (expected if QMD server not running)');
-        return null;
-    }
-}
 /**
  * DJB2 hash function - fast, good distribution
  */
@@ -384,7 +329,7 @@ async function getOllamaEmbedding(input) {
  */
 export async function checkEmbeddingProviderHealth() {
     const results = new Map();
-    const providers = ['local', 'openai', 'ollama', 'google-multimodal', 'qmd'];
+    const providers = ['local', 'openai', 'ollama', 'google', 'none', 'auto'];
     // Test local provider (always available)
     results.set('local', { available: true, latencyMs: 0 });
     // Test OpenAI if configured
@@ -431,29 +376,27 @@ export async function checkEmbeddingProviderHealth() {
     else {
         results.set('ollama', { available: false, error: 'Not configured' });
     }
-    // Test Google Multimodal if configured
-    if (config.multimodalEmbeddingsEnabled && (config.googleCloudApiKey || config.googleCloudProject)) {
+    // Test Google if configured
+    if (config.googleCloudApiKey || config.googleCloudProject) {
         const start = Date.now();
         try {
-            const result = await withRetry(() => withTimeout(getGoogleMultimodalEmbedding({ text: 'health check' }), config.googleMultimodalTimeoutMs), config.embeddingsMaxRetries, config.embeddingsRetryDelayMs);
+            const result = await withRetry(() => withTimeout(getGoogleMultimodalEmbedding({ text: 'health check' }), config.googleTimeoutMs), config.embeddingsMaxRetries, config.embeddingsRetryDelayMs);
             const latency = Date.now() - start;
-            results.set('google-multimodal', {
+            results.set('google', {
                 available: result !== null && result.embedding.length > 0,
                 latencyMs: latency
             });
         }
         catch (error) {
-            results.set('google-multimodal', {
+            results.set('google', {
                 available: false,
                 error: error.message
             });
         }
     }
     else {
-        results.set('google-multimodal', { available: false, error: 'Not configured' });
+        results.set('google', { available: false, error: 'Not configured' });
     }
-    // QMD is not used for embedding generation (search only)
-    results.set('qmd', { available: false, error: 'QMD not used for embeddings (search only)' });
     return results;
 }
 //# sourceMappingURL=embeddings.js.map

package/dist/core/local-embeddings.d.ts

@@ -1,14 +1,6 @@
 /**
- * Local Vector Embeddings Service
- * Provides local embedding generation without external APIs
+ * Utility functions for local embeddings
+ * Note: Actual embedding generation is in core/embeddings.ts
  */
-export type Embedding = number[];
-export declare const EMBEDDING_DIMENSIONS = 1536;
-export interface EmbeddingProvider {
-    embed(text: string): Promise<Embedding>;
-    isAvailable(): Promise<boolean>;
-    getDimensions(): number;
-}
-export declare function initializeEmbeddingProvider(): Promise<void>;
-export declare function cosineSimilarity(a: Embedding, b: Embedding): number;
+export declare function cosineSimilarity(a: number[], b: number[]): number;
 //# sourceMappingURL=local-embeddings.d.ts.map

package/dist/core/local-embeddings.js

@@ -1,81 +1,7 @@
 /**
- * Local Vector Embeddings Service
- * Provides local embedding generation without external APIs
+ * Utility functions for local embeddings
+ * Note: Actual embedding generation is in core/embeddings.ts
  */
-import { config } from '../config.js';
-import { logger } from './logger.js';
-export const EMBEDDING_DIMENSIONS = 1536;
-class StubEmbeddingProvider {
-    async embed(_text) {
-        return Array(EMBEDDING_DIMENSIONS).fill(0);
-    }
-    async isAvailable() {
-        return true;
-    }
-    getDimensions() {
-        return EMBEDDING_DIMENSIONS;
-    }
-}
-class LocalTfidfEmbeddingProvider {
-    idf = new Map();
-    async embed(text) {
-        const words = this.tokenize(text);
-        const embedding = Array(EMBEDDING_DIMENSIONS).fill(0);
-        const wordFreq = new Map();
-        for (const word of words) {
-            wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
-        }
-        for (const [word, freq] of wordFreq.entries()) {
-            const hash = this.hash(word) % EMBEDDING_DIMENSIONS;
-            const idf = this.idf.get(word) || 1;
-            embedding[hash] += freq * idf;
-        }
-        const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
-        if (norm > 0) {
-            for (let i = 0; i < embedding.length; i++) {
-                embedding[i] /= norm;
-            }
-        }
-        return embedding;
-    }
-    async isAvailable() {
-        return true;
-    }
-    getDimensions() {
-        return EMBEDDING_DIMENSIONS;
-    }
-    tokenize(text) {
-        return text.toLowerCase().split(/\s+/).filter(w => w.length > 2).slice(0, 100);
-    }
-    hash(str) {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            hash = ((hash << 5) - hash) + str.charCodeAt(i);
-            hash = hash & hash;
-        }
-        return Math.abs(hash);
-    }
-}
-let currentProvider = null;
-export async function initializeEmbeddingProvider() {
-    if (config.embeddingsProvider === 'openai' && config.openAiApiKey) {
-        logger.info('Using OpenAI embeddings (team mode - requires API key)');
-        currentProvider = new StubEmbeddingProvider();
-    }
-    else if (config.embeddingsProvider === 'ollama') {
-        logger.info('Using Ollama embeddings (team mode - local LLM)');
-        currentProvider = new StubEmbeddingProvider();
-    }
-    else if (config.embeddingsProvider === 'local') {
-        logger.info('Using local TF-IDF embeddings (SQLite mode - offline, no API key)');
-        currentProvider = new LocalTfidfEmbeddingProvider();
-    }
-    else {
-        // 'none' mode
-        logger.info('Embeddings disabled (stub provider)');
-        currentProvider = new StubEmbeddingProvider();
-    }
-}
 export function cosineSimilarity(a, b) {
     if (a.length !== b.length) {
         throw new Error('Embeddings must have same dimensions');

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/context-collector.js

@@ -10,7 +10,8 @@ export async function collectRecentContext(sessionId, count = 5) {
         return [];
     }
     try {
-        const [conversation] = await db
+        const sqliteDb = db;
+        const [conversation] = await sqliteDb
             .select()
             .from(conversations)
             .where(eq(conversations.sessionId, sessionId))
@@ -20,7 +21,7 @@ export async function collectRecentContext(sessionId, count = 5) {
             logger.debug(`[ContextCollector] No conversation found for session ${sessionId}`);
             return [];
         }
-        const recentMessages = await db
+        const recentMessages = await sqliteDb
             .select()
             .from(messages)
             .where(eq(messages.conversationId, conversation.id))

package/dist/core/memory/feedback-tracker.js

@@ -19,8 +19,9 @@ export async function recordInjection(sessionId, memoryIds, memoryContent) {
         return;
     try {
         const now = new Date();
+        const sqliteDb = db;
         for (const memoryId of memoryIds) {
-            await db.insert(memoryFeedback).values({
+            await sqliteDb.insert(memoryFeedback).values({
                 memoryId,
                 sessionId,
                 wasInjected: true,
@@ -55,16 +56,17 @@ export async function analyzeAndRecordFeedback(sessionId, responseText) {
         return;
     try {
         const now = new Date();
+        const sqliteDb = db;
         for (const memoryId of injection.memoryIds) {
             const wasReferenced = analysis.referencedMemoryIds.includes(memoryId);
             const delta = wasReferenced ? config.feedbackEchoBonus : -config.feedbackFizzlePenalty;
-            const existing = await db
+            const existing = await sqliteDb
                 .select()
                 .from(memoryFeedback)
                 .where(and(eq(memoryFeedback.memoryId, memoryId), eq(memoryFeedback.sessionId, sessionId)))
                 .limit(1);
             if (existing.length > 0) {
-                await db
+                await sqliteDb
                     .update(memoryFeedback)
                     .set({
                     wasReferenced,
@@ -99,7 +101,8 @@ export async function updateRetrievalPriority(memoryId, delta) {
     if (!db)
         return;
     try {
-        const [memory] = await db
+        const sqliteDb = db;
+        const [memory] = await sqliteDb
             .select({ retrievalPriority: memories.retrievalPriority })
             .from(memories)
             .where(eq(memories.id, memoryId))
@@ -108,7 +111,7 @@ export async function updateRetrievalPriority(memoryId, delta) {
             return;
         const currentPriority = memory.retrievalPriority ?? 50;
         const newPriority = Math.max(0, Math.min(100, currentPriority + delta));
-        await db
+        await sqliteDb
             .update(memories)
             .set({ retrievalPriority: newPriority })
             .where(eq(memories.id, memoryId));
@@ -124,7 +127,8 @@ export async function getMemoryFeedbackStats(memoryId) {
         return { totalInjections: 0, totalReferences: 0, echoRate: 0, averagePriorityDelta: 0 };
     }
     try {
-        const records = await db
+        const sqliteDb = db;
+        const records = await sqliteDb
             .select()
             .from(memoryFeedback)
             .where(eq(memoryFeedback.memoryId, memoryId));