squish-memory 1.0.2 → 1.1.5

package/dist/config.js

@@ -50,16 +50,66 @@ function getConfig(path, envVar, defaultValue) {
     // Priority 3: Default value
     return defaultValue;
 }
-const isTeamMode = !!process.env.DATABASE_URL?.startsWith('postgres');
+// Mode detection: local (default), team (cloud with own db), remote (integrations)
+// Priority: remote > team > local
+const DATABASE_URL = process.env.DATABASE_URL || '';
+const SUPABASE_URL = process.env.SUPABASE_URL || '';
+const NEON_PROJECT_ID = process.env.NEON_PROJECT_ID || '';
+// Determine mode based on environment
+function detectMode() {
+    // Remote mode: user has their own Supabase or Neon
+    if (SUPABASE_URL || NEON_PROJECT_ID) {
+        return 'remote';
+    }
+    // Team mode: PostgreSQL (self-hosted "local cloud")
+    if (DATABASE_URL.startsWith('postgres')) {
+        return 'team';
+    }
+    // Local mode: default SQLite
+    return 'local';
+}
+const detectedMode = detectMode();
+const isTeamMode = detectedMode === 'team';
+const isRemoteMode = detectedMode === 'remote';
+const isLocalMode = detectedMode === 'local';
 const isManagedMode = process.env.SQUISH_MANAGED_MODE === 'true';
+// Team/Remote backend selection
+const teamBackend = (() => {
+    const explicit = getConfig('team.backend', 'SQUISH_TEAM_BACKEND', '').toLowerCase();
+    if (explicit === 'supabase' || explicit === 'neon' || explicit === 'postgres') {
+        return explicit;
+    }
+    // Auto-detect based on env vars
+    if (SUPABASE_URL)
+        return 'supabase';
+    if (NEON_PROJECT_ID)
+        return 'neon';
+    return 'postgres'; // default to PostgreSQL
+})();
+const remoteBackend = (() => {
+    const explicit = getConfig('remote.backend', 'SQUISH_REMOTE_BACKEND', '').toLowerCase();
+    if (explicit === 'supabase' || explicit === 'neon') {
+        return explicit;
+    }
+    // Auto-detect based on env vars
+    if (SUPABASE_URL)
+        return 'supabase';
+    if (NEON_PROJECT_ID)
+        return 'neon';
+    return 'supabase'; // default to Supabase
+})();
+// Neon configuration
+const neonProjectId = process.env.NEON_PROJECT_ID || '';
+const neonServiceKey = process.env.NEON_SERVICE_KEY || '';
 // Embeddings providers:
 // - openai: OpenAI API (requires API key)
-// - ollama: Local Ollama server (requires nomic-embed-text)
+// - ollama: Local Ollama server (any model)
+// - lmstudio: LM Studio local server (any model)
 // - local: TF-IDF offline (no dependencies)
 // - none: Disable embeddings (stub)
 // - google: Google Cloud embeddings
 // - auto: Smart fallback (cloud if available, local fallback)
-const VALID_PROVIDERS = new Set(['openai', 'ollama', 'local', 'none', 'google', 'auto']);
+const VALID_PROVIDERS = new Set(['openai', 'ollama', 'lmstudio', 'local', 'none', 'google', 'auto']);
 const embeddingsProvider = (() => {
     const explicit = getConfig('embeddings.provider', 'SQUISH_EMBEDDINGS_PROVIDER', 'local').toLowerCase();
     if (VALID_PROVIDERS.has(explicit)) {
@@ -67,25 +117,6 @@ const embeddingsProvider = (() => {
     }
     return 'local';
 })();
-// QMD Integration
-const qmdEnabled = process.env.SQUISH_QMD_ENABLED === 'true';
-const qmdCollectionsPath = process.env.SQUISH_QMD_COLLECTIONS ||
-    getDataDir().replace('.squish', 'qmd-collections');
-const VALID_FALLBACK_MODES = new Set(['qmd-only', 'cloud-first', 'hybrid', 'local-only']);
-const qmdFallbackMode = (() => {
-    const mode = process.env.SQUISH_QMD_FALLBACK || 'hybrid';
-    return VALID_FALLBACK_MODES.has(mode) ? mode : 'hybrid';
-})();
-const defaultCollectionMapping = {
-    observation: 'squish-observations',
-    fact: 'squish-facts',
-    decision: 'squish-decisions',
-    context: 'squish-context',
-    preference: 'squish-preferences'
-};
-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');
@@ -97,14 +128,24 @@ const googleCloudLocation = process.env.GOOGLE_CLOUD_LOCATION || process.env.SQU
 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');
+const ollamaEmbeddingModel = getConfig('embeddings.models.ollama.model', 'SQUISH_OLLAMA_EMBEDDING_MODEL', '');
+// LM Studio Configuration (OpenAI-compatible local server)
+const lmStudioUrl = getConfig('api.lmstudio.url', 'SQUISH_LM_STUDIO_URL', 'http://localhost:1234');
+const lmStudioEmbeddingModel = getConfig('embeddings.models.lmstudio.model', 'SQUISH_LM_STUDIO_EMBEDDING_MODEL', '');
 export const config = {
+    // Mode detection
+    mode: detectedMode,
+    isLocalMode,
     isTeamMode,
+    isRemoteMode,
+    // Backend selection
+    teamBackend: teamBackend,
+    remoteBackend: remoteBackend,
+    // Legacy support
     isManagedMode,
     redisEnabled: !!process.env.REDIS_URL,
     dataDir: getDataDir(),
     mcpServerPort: parseInt(getConfig('mcp.serverPort', 'SQUISH_MCP_PORT', '8767')),
-    mcpServerEnabled: getConfig('mcp.serverEnabled', 'SQUISH_MCP_SERVER_ENABLED', true) !== false,
     embeddingsProvider: embeddingsProvider,
     // OpenAI
     openAiApiKey,
@@ -118,9 +159,22 @@ export const config = {
     // Ollama
     ollamaUrl,
     ollamaEmbeddingModel,
+    // LM Studio (OpenAI-compatible local)
+    lmStudioUrl,
+    lmStudioEmbeddingModel,
+    // Supabase configuration
+    supabaseUrl: getConfig('supabase.url', 'SUPABASE_URL', ''),
+    supabaseKey: getConfig('supabase.key', 'SUPABASE_SERVICE_KEY', ''),
+    // Neon configuration
+    neonProjectId: process.env.NEON_PROJECT_ID || '',
+    neonServiceKey: process.env.NEON_SERVICE_KEY || '',
+    // Encryption configuration
+    clientEncryptionEnabled: getConfig('security.encryptionEnabled', null, false) !== false,
+    encryptionPassphrase: process.env.SQUISH_ENCRYPTION_PASSPHRASE || '',
     // Lifecycle Management
     lifecycleEnabled: getConfig('features.lifecycleEnabled', 'SQUISH_LIFECYCLE_ENABLED', true) !== false,
     lifecycleInterval: parseInt(process.env.SQUISH_LIFECYCLE_INTERVAL || '3600000'),
+    decayThreshold: parseFloat(process.env.SQUISH_DECAY_THRESHOLD || '0.1'),
     // Session Summarization
     summarizationEnabled: getConfig('features.summarizationEnabled', 'SQUISH_SUMMARIZATION_ENABLED', true) !== false,
     incrementalThreshold: parseInt(process.env.SQUISH_INCREMENTAL_THRESHOLD || '10'),
@@ -133,11 +187,17 @@ export const config = {
     // Memory Consolidation
     consolidationEnabled: process.env.SQUISH_CONSOLIDATION_ENABLED === 'true',
     consolidationSimilarityThreshold: parseFloat(process.env.SQUISH_CONSOLIDATION_THRESHOLD || '0.8'),
-    // QMD Integration
-    qmdEnabled,
-    qmdCollectionsPath,
-    qmdFallbackMode: qmdFallbackMode,
-    qmdCollectionMapping,
+    // Obsidian Integration (NEW)
+    obsidianEnabled: process.env.SQUISH_OBSIDIAN_ENABLED === 'true',
+    obsidianVaultPath: process.env.SQUISH_OBSIDIAN_VAULT_PATH || '',
+    // External Folder Memory (QMD Wrapper)
+    externalMemoryEnabled: process.env.SQUISH_EXTERNAL_MEMORY_ENABLED === 'true',
+    externalMemoryPath: process.env.SQUISH_EXTERNAL_MEMORY_PATH || '',
+    // DEPRECATED: QMD (kept for backward compat during transition)
+    qmdEnabled: false, // DEPRECATED - use Obsidian integration instead
+    qmdCollectionsPath: '', // DEPRECATED
+    qmdFallbackMode: 'local-only', // DEPRECATED
+    qmdCollectionMapping: {}, // DEPRECATED
     // Managed Mode
     managedMode: process.env.SQUISH_MANAGED_MODE === 'true',
     managedApiUrl: process.env.SQUISH_MANAGED_API_URL || 'https://api.squish.dev',
@@ -154,6 +214,14 @@ export const config = {
     feedbackTrackingEnabled: process.env.SQUISH_FEEDBACK_TRACKING !== 'false',
     feedbackEchoBonus: parseInt(process.env.SQUISH_FEEDBACK_ECHO_BONUS || '10'),
     feedbackFizzlePenalty: parseInt(process.env.SQUISH_FEEDBACK_FIZZLE_PENALTY || '5'),
+    // Scoring Weights (override defaults)
+    scoringWeights: {
+        recency: parseFloat(process.env.SQUISH_WEIGHT_RECENCY || '0.5'),
+        relevance: parseFloat(process.env.SQUISH_WEIGHT_RELEVANCE || '3'),
+        importance: parseFloat(process.env.SQUISH_WEIGHT_IMPORTANCE || '2'),
+        vectorSim: parseFloat(process.env.SQUISH_WEIGHT_VECTOR_SIM || '3'),
+        graphBoost: parseFloat(process.env.SQUISH_WEIGHT_GRAPH_BOOST || '1.5'),
+    },
     // Scheduler
     schedulerMode: (process.env.SQUISH_SCHEDULER_MODE || 'cron'),
     cronEnabled: process.env.SQUISH_CRON_ENABLED !== 'false',

package/dist/core/adapters/config/claude-code.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Claude Code Adapter Configuration
+ *
+ * Native Claude Code configuration for integrating Squish as MCP server.
+ * Usage: Add to ~/.claude.json or project .claude.json
+ */
+import { AgentConfig } from '../types.js';
+declare const ADAPTER_CONFIG: AgentConfig;
+/**
+ * Register Claude Code adapter
+ */
+export declare function registerClaudeCodeAdapter(): void;
+/** Native config for .claude.json */
+export declare const CLAUDE_CODE_CONFIG: {
+    mcpServers: {
+        squish: {
+            command: string;
+            args: string[];
+            env: {
+                NODE_ENV: string;
+            };
+        };
+    };
+    hooks: {};
+};
+/** Claude Code settings.json snippet */
+export declare const CLAUDE_CODE_SETTINGS: {
+    mcpServers: {
+        squish: {
+            command: string;
+            args: string[];
+            env: {
+                NODE_ENV: string;
+            };
+        };
+    };
+    experimental: {
+        squish: {
+            autoCapture: boolean;
+            contextLimit: number;
+        };
+    };
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=claude-code.d.ts.map

package/dist/core/adapters/config/claude-code.js

@@ -0,0 +1,113 @@
+/**
+ * Claude Code Adapter Configuration
+ *
+ * Native Claude Code configuration for integrating Squish as MCP server.
+ * Usage: Add to ~/.claude.json or project .claude.json
+ */
+const ADAPTER_CONFIG = {
+    agentId: 'claude-code',
+    name: 'Claude Code',
+    type: 'claude-code',
+    mcp: {
+        command: 'node',
+        args: ['dist/core/commands/mcp-server.js'],
+        env: { NODE_ENV: 'production' }
+    },
+    hooks: {
+    // Claude Code hooks configuration - stored as JSON string in settings
+    },
+    settings: {
+        // Squish integration settings
+        squish: {
+            autoCapture: true,
+            captureTools: ['Read', 'Write', 'Edit', 'Bash'],
+            contextLimit: 5,
+        }
+    }
+};
+/**
+ * Register Claude Code adapter
+ */
+export function registerClaudeCodeAdapter() {
+    const { registerAdapter } = require('../index.js');
+    const adapter = {
+        id: 'claude-code',
+        type: 'claude-code',
+        name: 'Claude Code',
+        version: 'latest',
+        getSessionContext: async (input) => {
+            const { getRecent, search } = await import('../../memory/memories.js');
+            const recent = await getRecent(input.project, input.mode === 'compact' ? 3 : 5);
+            const memories = recent.map((m, i) => `${i + 1}. [${m.type}] ${m.content?.substring(0, 100)}`).join('\n');
+            return {
+                mode: input.mode,
+                project: input.project,
+                memories,
+                count: recent.length,
+            };
+        },
+        recordObservation: async (input) => {
+            const { createLearning } = await import('../../ingestion/learnings.js');
+            // Extract simple string target, not object
+            const targetVal = input.toolInput?.filePath || input.toolInput?.command;
+            const targetStr = typeof targetVal === 'string' ? targetVal :
+                typeof targetVal === 'object' ? JSON.stringify(targetVal).substring(0, 50) :
+                    'unknown';
+            const memory = await createLearning({
+                type: 'insight', // Tool usage is an insight
+                content: `[${input.toolName}] ${JSON.stringify(input.toolInput).substring(0, 200)}`,
+                action: input.toolName,
+                target: targetStr,
+                project: input.project,
+                autoLink: false,
+            });
+            return {
+                memoryId: memory.id,
+                category: 'other',
+                content: `Recorded: ${input.toolName}`,
+            };
+        },
+        getTimeline: async (query, depth, limit) => {
+            const { getTimeline } = await require('../timeline.js');
+            return getTimeline(query, depth, limit);
+        },
+        shouldCaptureTool: (toolName) => {
+            const captureTools = ['Read', 'Write', 'Edit', 'Bash', 'grep', 'Glob', 'Task'];
+            return captureTools.includes(toolName);
+        },
+        getNativeConfig: () => ADAPTER_CONFIG,
+    };
+    registerAdapter(adapter);
+    console.error('[Adapters] Registered Claude Code adapter');
+}
+/** Native config for .claude.json */
+export const CLAUDE_CODE_CONFIG = {
+    mcpServers: {
+        squish: {
+            command: 'node',
+            args: ['dist/core/commands/mcp-server.js'],
+            env: { NODE_ENV: 'production' }
+        }
+    },
+    hooks: {
+    // Hooks can be configured in settings.json
+    }
+};
+/** Claude Code settings.json snippet */
+export const CLAUDE_CODE_SETTINGS = {
+    "mcpServers": {
+        "squish": {
+            "command": "node",
+            "args": ["dist/core/commands/mcp-server.js"],
+            "env": { "NODE_ENV": "production" }
+        }
+    },
+    "experimental": {
+        "squish": {
+            "autoCapture": true,
+            "contextLimit": 5
+        }
+    }
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=claude-code.js.map

package/dist/core/adapters/config/cursor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cursor Adapter Configuration
+ *
+ * Native Cursor configuration for integrating Squish as MCP server.
+ * Cursor uses .cursor/mcp.json or cursor.config.yaml format.
+ */
+import { AgentConfig } from '../types.js';
+declare const ADAPTER_CONFIG: AgentConfig;
+/**
+ * Register Cursor adapter
+ */
+export declare function registerCursorAdapter(): void;
+/** Cursor mcp.json format */
+export declare const CURSOR_MCP_CONFIG: {
+    mcpServers: {
+        squish: {
+            command: string;
+            args: string[];
+            env: {
+                NODE_ENV: string;
+            };
+        };
+    };
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=cursor.d.ts.map

package/dist/core/adapters/config/cursor.js

@@ -0,0 +1,74 @@
+/**
+ * Cursor Adapter Configuration
+ *
+ * Native Cursor configuration for integrating Squish as MCP server.
+ * Cursor uses .cursor/mcp.json or cursor.config.yaml format.
+ */
+const ADAPTER_CONFIG = {
+    agentId: 'cursor',
+    name: 'Cursor',
+    type: 'cursor',
+    mcp: {
+        command: 'node',
+        args: ['dist/core/commands/mcp-server.js'],
+        env: { NODE_ENV: 'production' }
+    },
+    hooks: {},
+    settings: {
+        squish: {
+            autoCapture: true,
+            captureTools: ['Read', 'Write', 'Edit', 'Bash'],
+            contextLimit: 5,
+        }
+    }
+};
+/**
+ * Register Cursor adapter
+ */
+export function registerCursorAdapter() {
+    const { registerAdapter } = require('../index.js');
+    const adapter = {
+        id: 'cursor',
+        type: 'cursor',
+        name: 'Cursor',
+        version: 'latest',
+        getSessionContext: async (input) => {
+            const { getRecent } = await import('../../memory/memories.js');
+            const recent = await getRecent(input.project, 5);
+            const memories = recent.map((m, i) => `${i + 1}. [${m.type}] ${m.content?.substring(0, 100)}`).join('\n');
+            return { mode: input.mode, project: input.project, memories, count: recent.length };
+        },
+        recordObservation: async (input) => {
+            const { createLearning } = await import('../../ingestion/learnings.js');
+            const memory = await createLearning({
+                type: 'insight',
+                content: `[${input.toolName}] ${JSON.stringify(input.toolInput).substring(0, 200)}`,
+                action: input.toolName,
+                project: input.project,
+                autoLink: false,
+            });
+            return { memoryId: memory.id, category: 'other', content: `Recorded: ${input.toolName}` };
+        },
+        getTimeline: async (query, depth, limit) => {
+            const { getTimeline } = await require('../timeline.js');
+            return getTimeline(query, depth, limit);
+        },
+        shouldCaptureTool: (toolName) => {
+            return ['Read', 'Write', 'Edit', 'Bash', 'grep', 'Glob', 'Task'].includes(toolName);
+        },
+        getNativeConfig: () => ADAPTER_CONFIG,
+    };
+    registerAdapter(adapter);
+}
+/** Cursor mcp.json format */
+export const CURSOR_MCP_CONFIG = {
+    "mcpServers": {
+        "squish": {
+            "command": "node",
+            "args": ["dist/core/commands/mcp-server.js"],
+            "env": { "NODE_ENV": "production" }
+        }
+    }
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=cursor.js.map

package/dist/core/adapters/config/opencode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OpenCode Adapter Configuration
+ *
+ * Native OpenCode configuration for integrating Squish as MCP server.
+ * OpenCode uses similar MCP configuration to Claude Code.
+ */
+import { AgentConfig } from '../types.js';
+declare const ADAPTER_CONFIG: AgentConfig;
+/**
+ * Register OpenCode adapter
+ */
+export declare function registerOpenCodeAdapter(): void;
+/** OpenCode settings.json format */
+export declare const OPENCODE_SETTINGS: {
+    mcpServers: {
+        squish: {
+            command: string;
+            args: string[];
+        };
+    };
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=opencode.d.ts.map

package/dist/core/adapters/config/opencode.js

@@ -0,0 +1,73 @@
+/**
+ * OpenCode Adapter Configuration
+ *
+ * Native OpenCode configuration for integrating Squish as MCP server.
+ * OpenCode uses similar MCP configuration to Claude Code.
+ */
+const ADAPTER_CONFIG = {
+    agentId: 'opencode',
+    name: 'OpenCode',
+    type: 'opencode',
+    mcp: {
+        command: 'node',
+        args: ['dist/core/commands/mcp-server.js'],
+        env: { NODE_ENV: 'production' }
+    },
+    hooks: {},
+    settings: {
+        squish: {
+            autoCapture: true,
+            captureTools: ['Read', 'Write', 'Edit', 'Bash'],
+            contextLimit: 5,
+        }
+    }
+};
+/**
+ * Register OpenCode adapter
+ */
+export function registerOpenCodeAdapter() {
+    const { registerAdapter } = require('../index.js');
+    const adapter = {
+        id: 'opencode',
+        type: 'opencode',
+        name: 'OpenCode',
+        version: 'latest',
+        getSessionContext: async (input) => {
+            const { getRecent } = await import('../../memory/memories.js');
+            const recent = await getRecent(input.project, 5);
+            const memories = recent.map((m, i) => `${i + 1}. [${m.type}] ${m.content?.substring(0, 100)}`).join('\n');
+            return { mode: input.mode, project: input.project, memories, count: recent.length };
+        },
+        recordObservation: async (input) => {
+            const { createLearning } = await import('../../ingestion/learnings.js');
+            const memory = await createLearning({
+                type: 'insight',
+                content: `[${input.toolName}] ${JSON.stringify(input.toolInput).substring(0, 200)}`,
+                action: input.toolName,
+                project: input.project,
+                autoLink: false,
+            });
+            return { memoryId: memory.id, category: 'other', content: `Recorded: ${input.toolName}` };
+        },
+        getTimeline: async (query, depth, limit) => {
+            const { getTimeline } = await require('../timeline.js');
+            return getTimeline(query, depth, limit);
+        },
+        shouldCaptureTool: (toolName) => {
+            return ['Read', 'Write', 'Edit', 'Bash', 'grep', 'Glob', 'Task'].includes(toolName);
+        },
+        getNativeConfig: () => ADAPTER_CONFIG,
+    };
+    registerAdapter(adapter);
+}
+/** OpenCode settings.json format */
+export const OPENCODE_SETTINGS = {
+    "mcpServers": {
+        "squish": {
+            "command": "node",
+            "args": ["dist/core/commands/mcp-server.js"]
+        }
+    }
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=opencode.js.map

package/dist/core/adapters/config/windsurf.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Windsurf Adapter Configuration
+ *
+ * Native Windsurf configuration for integrating Squish as MCP server.
+ * Windsurf uses .windsurf/config.json format.
+ */
+import { AgentConfig } from '../types.js';
+declare const ADAPTER_CONFIG: AgentConfig;
+/**
+ * Register Windsurf adapter
+ */
+export declare function registerWindsurfAdapter(): void;
+/** Windsurf config.json format */
+export declare const WINDSURF_CONFIG: {
+    mcpServers: {
+        squish: {
+            command: string;
+            args: string[];
+            env: {
+                NODE_ENV: string;
+            };
+        };
+    };
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=windsurf.d.ts.map

package/dist/core/adapters/config/windsurf.js

@@ -0,0 +1,74 @@
+/**
+ * Windsurf Adapter Configuration
+ *
+ * Native Windsurf configuration for integrating Squish as MCP server.
+ * Windsurf uses .windsurf/config.json format.
+ */
+const ADAPTER_CONFIG = {
+    agentId: 'windsurf',
+    name: 'Windsurf',
+    type: 'windsurf',
+    mcp: {
+        command: 'node',
+        args: ['dist/core/commands/mcp-server.js'],
+        env: { NODE_ENV: 'production' }
+    },
+    hooks: {},
+    settings: {
+        squish: {
+            autoCapture: true,
+            captureTools: ['Read', 'Write', 'Edit', 'Bash'],
+            contextLimit: 5,
+        }
+    }
+};
+/**
+ * Register Windsurf adapter
+ */
+export function registerWindsurfAdapter() {
+    const { registerAdapter } = require('../index.js');
+    const adapter = {
+        id: 'windsurf',
+        type: 'windsurf',
+        name: 'Windsurf',
+        version: 'latest',
+        getSessionContext: async (input) => {
+            const { getRecent } = await import('../../memory/memories.js');
+            const recent = await getRecent(input.project, 5);
+            const memories = recent.map((m, i) => `${i + 1}. [${m.type}] ${m.content?.substring(0, 100)}`).join('\n');
+            return { mode: input.mode, project: input.project, memories, count: recent.length };
+        },
+        recordObservation: async (input) => {
+            const { createLearning } = await import('../../ingestion/learnings.js');
+            const memory = await createLearning({
+                type: 'insight',
+                content: `[${input.toolName}] ${JSON.stringify(input.toolInput).substring(0, 200)}`,
+                action: input.toolName,
+                project: input.project,
+                autoLink: false,
+            });
+            return { memoryId: memory.id, category: 'other', content: `Recorded: ${input.toolName}` };
+        },
+        getTimeline: async (query, depth, limit) => {
+            const { getTimeline } = await require('../timeline.js');
+            return getTimeline(query, depth, limit);
+        },
+        shouldCaptureTool: (toolName) => {
+            return ['Read', 'Write', 'Edit', 'Bash', 'grep', 'Glob', 'Task'].includes(toolName);
+        },
+        getNativeConfig: () => ADAPTER_CONFIG,
+    };
+    registerAdapter(adapter);
+}
+/** Windsurf config.json format */
+export const WINDSURF_CONFIG = {
+    "mcpServers": {
+        "squish": {
+            "command": "node",
+            "args": ["dist/core/commands/mcp-server.js"],
+            "env": { "NODE_ENV": "production" }
+        }
+    }
+};
+export default ADAPTER_CONFIG;
+//# sourceMappingURL=windsurf.js.map