squish-memory 1.1.5 → 1.2.0

package/core/adapters/config/opencode.ts

@@ -0,0 +1,89 @@
+/**
+ * OpenCode Adapter Configuration
+ * 
+ * Native OpenCode configuration for integrating Squish as MCP server.
+ * OpenCode uses similar MCP configuration to Claude Code.
+ */
+
+import { AgentAdapter, AgentType, AgentConfig } from '../types.js';
+
+const ADAPTER_CONFIG: AgentConfig = {
+  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(): void {
+  const { registerAdapter } = require('../index.js');
+  
+  const adapter: AgentAdapter = {
+    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;

package/core/adapters/config/windsurf.ts

@@ -0,0 +1,90 @@
+/**
+ * Windsurf Adapter Configuration
+ * 
+ * Native Windsurf configuration for integrating Squish as MCP server.
+ * Windsurf uses .windsurf/config.json format.
+ */
+
+import { AgentAdapter, AgentType, AgentConfig } from '../types.js';
+
+const ADAPTER_CONFIG: AgentConfig = {
+  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(): void {
+  const { registerAdapter } = require('../index.js');
+  
+  const adapter: AgentAdapter = {
+    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;

package/core/adapters/index.ts

@@ -0,0 +1,102 @@
+/**
+ * UAM Adapter Registry
+ * 
+ * Manages agent adapters for Universal Agent Memory.
+ * Provides functions to register, retrieve, and list adapters.
+ */
+
+import { AgentAdapter, AgentType, AgentConfig } from './types.js';
+import { logger } from '../logger.js';
+
+/** In-memory adapter registry */
+const adapters = new Map<AgentType, AgentAdapter>();
+
+/** Config directory for agent configs */
+let configDir: string | null = null;
+
+/**
+ * Register an adapter
+ */
+export function registerAdapter(adapter: AgentAdapter): void {
+  if (adapters.has(adapter.type)) {
+    logger.warn(`[Adapters] Overriding existing adapter for type: ${adapter.type}`);
+  }
+  adapters.set(adapter.type, adapter);
+  logger.info(`[Adapters] Registered adapter: ${adapter.name} (${adapter.type})`);
+}
+
+/**
+ * Get adapter by type
+ */
+export function getAdapter(type: AgentType): AgentAdapter | undefined {
+  return adapters.get(type);
+}
+
+/**
+ * List all registered adapters
+ */
+export function listAdapters(): AgentAdapter[] {
+  return Array.from(adapters.values());
+}
+
+/**
+ * Load all adapters from config directory
+ */
+export async function loadAllAdapters(dir: string): Promise<void> {
+  configDir = dir;
+  logger.info(`[Adapters] Loading adapters from: ${dir}`);
+  
+  // Dynamic import and register adapters
+  try {
+    const { registerClaudeCodeAdapter } = await import('./config/claude-code.js');
+    const { registerOpenCodeAdapter } = await import('./config/opencode.js');
+    const { registerCursorAdapter } = await import('./config/cursor.js');
+    const { registerWindsurfAdapter } = await import('./config/windsurf.js');
+    
+    registerClaudeCodeAdapter();
+    registerOpenCodeAdapter();
+    registerCursorAdapter();
+    registerWindsurfAdapter();
+    
+    logger.info(`[Adapters] Loaded ${listAdapters().length} adapters`);
+  } catch (error) {
+    logger.error(`[Adapters] Failed to load adapters:`, error);
+  }
+}
+
+/**
+ * Get adapter config by type (for native integration)
+ */
+export function getAdapterConfig(type: AgentType): AgentConfig | undefined {
+  const adapter = adapters.get(type);
+  return adapter?.getNativeConfig();
+}
+
+/**
+ * List all adapter configs (for MCP tool)
+ */
+export function listAdapterConfigs(): AgentConfig[] {
+  return listAdapters().map(a => a.getNativeConfig());
+}
+
+/**
+ * Check if an adapter is registered
+ */
+export function hasAdapter(type: AgentType): boolean {
+  return adapters.has(type);
+}
+
+/**
+ * Clear all adapters (mainly for testing)
+ */
+export function clearAdapters(): void {
+  adapters.clear();
+  logger.info('[Adapters] Cleared all adapters');
+}
+
+// Re-export types
+export * from './types.js';
+export type { AgentAdapter, AgentType, AgentConfig };
+export type { SessionContextInput, SessionContextOutput } from './types.js';
+export type { ToolObservationInput, ToolObservationOutput } from './types.js';
+export type { TimelineDepth } from './types.js';

package/core/adapters/timeline.ts

@@ -0,0 +1,116 @@
+/**
+ * Timeline Implementation - 3-Layer Progressive Disclosure
+ * 
+ * Provides timeline functionality for MCP tool with depth parameter.
+ * Layer 1 (index): ~50 tokens - memory titles only
+ * Layer 2 (timeline): ~200 tokens - titles + timestamps + tags
+ * Layer 3 (detail): ~2000 tokens - full content
+ */
+
+import { search as searchMemories, getMemory } from '../memory/memories.js';
+import { TimelineDepth } from './types.js';
+
+/** Token estimates per layer */
+const LAYER_TOKENS = {
+  index: 50,
+  timeline: 200,
+  detail: 2000,
+};
+
+/**
+ * Get timeline with progressive disclosure
+ */
+export async function getTimeline(
+  query: string,
+  depth: TimelineDepth = 'index',
+  limit: number = 10,
+  project?: string
+): Promise<{
+  results: unknown[];
+  layer: TimelineDepth;
+  tokenEstimate: number;
+  query: string;
+}> {
+  // First get search results
+  const memories = await searchMemories({
+    query,
+    project,
+    limit,
+  });
+  
+  // Format based on depth
+  let results: unknown[];
+  let tokenEstimate = 0;
+  
+  switch (depth) {
+    case 'index':
+      results = memories.map(m => ({
+        id: m.id,
+        title: `${m.type}: ${m.content?.substring(0, 60)}...`,
+      }));
+      tokenEstimate = results.length * (LAYER_TOKENS.index / Math.max(results.length, 1));
+      break;
+      
+    case 'timeline':
+      results = memories.map(m => ({
+        id: m.id,
+        type: m.type,
+        content: m.content?.substring(0, 100),
+        tags: m.tags,
+        createdAt: m.createdAt,
+      }));
+      tokenEstimate = results.length * (LAYER_TOKENS.timeline / Math.max(results.length, 1));
+      break;
+      
+    case 'detail':
+      results = await Promise.all(
+        memories.map(async (m) => {
+          const full = await getMemory(m.id);
+          return full || { id: m.id, error: 'Not found' };
+        })
+      );
+      tokenEstimate = LAYER_TOKENS.detail;
+      break;
+  }
+  
+  return {
+    results,
+    layer: depth,
+    tokenEstimate,
+    query,
+  };
+}
+
+/**
+ * Get memory by ID with optional depth
+ */
+export async function getMemoryTimeline(
+  memoryId: string,
+  depth: TimelineDepth = 'detail'
+): Promise<unknown> {
+  const memory = await getMemory(memoryId);
+  
+  if (!memory) {
+    return { error: 'Memory not found', id: memoryId };
+  }
+  
+  if (depth === 'index') {
+    return {
+      id: memory.id,
+      title: `${memory.type}: ${memory.content?.substring(0, 60)}...`,
+    };
+  }
+  
+  if (depth === 'timeline') {
+    return {
+      id: memory.id,
+      type: memory.type,
+      content: memory.content?.substring(0, 100),
+      tags: memory.tags,
+      createdAt: memory.createdAt,
+    };
+  }
+  
+  // detail
+  return memory;
+}

package/core/adapters/types.ts

@@ -0,0 +1,166 @@
+/**
+ * UAM Adapter Types
+ * 
+ * Universal Agent Memory - Adapter interfaces for different AI coding agents.
+ * Each agent (Claude Code, OpenCode, Cursor, Windsurf, etc.) has its own adapter
+ * that defines how to integrate with Squish.
+ * 
+ * Key concepts:
+ * - Agent adapters use native config formats where possible
+ * - Hooks are explicit (calls squish_learn) not hidden
+ * - Uses existing MCP tools (squish_context, squish_learn)
+ */
+
+import { z } from 'zod';
+
+/** Agent types supported by UAM */
+export type AgentType = 'claude-code' | 'opencode' | 'cursor' | 'windsurf' | 'codex' | 'generic';
+
+/** Hook event types */
+export type HookEvent = 
+  | 'onSessionStart'
+  | 'onSessionEnd'
+  | 'onToolCall'
+  | 'onPreCompact'
+  | 'onPostCompact';
+
+/** 3-Layer depth for progressive disclosure */
+export type TimelineDepth = 'index' | 'timeline' | 'detail';
+
+/** Memory context for session start */
+export interface SessionContextInput {
+  project: string;
+  mode: 'startup' | 'resume' | 'compact';
+  sessionId?: string;
+}
+
+export interface SessionContextOutput {
+  mode: string;
+  project: string;
+  memories: string;
+  count: number;
+  snapshot?: { id: string; content: string } | null;
+}
+
+/** Tool call observation */
+export interface ToolObservationInput {
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  toolResult: unknown;
+  project: string;
+  sessionId?: string;
+}
+
+export interface ToolObservationOutput {
+  memoryId: string;
+  category: 'reading' | 'modification' | 'commit' | 'testing' | 'command' | 'search' | 'planning' | 'other';
+  content: string;
+}
+
+/** Agent configuration */
+export interface AgentConfig {
+  /** Unique agent identifier */
+  agentId: string;
+  /** Human-readable name */
+  name: string;
+  /** Agent type */
+  type: AgentType;
+  /** MCP server configuration */
+  mcp: {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+  };
+  /** Hook patterns (native format for each agent) */
+  hooks?: {
+    sessionStart?: unknown;
+    sessionEnd?: unknown;
+    preCompact?: unknown;
+    postToolUse?: unknown;
+  };
+  /** Custom settings */
+  settings?: Record<string, unknown>;
+}
+
+/** Agent adapter interface */
+export interface AgentAdapter {
+  /** Unique adapter ID */
+  id: string;
+  /** Agent type */
+  type: AgentType;
+  /** Human-readable name */
+  name: string;
+  /** Agent version (if known) */
+  version?: string;
+  
+  /** Get session context for injection */
+  getSessionContext(input: SessionContextInput): Promise<SessionContextOutput>;
+  
+  /** Record a tool observation */
+  recordObservation(input: ToolObservationInput): Promise<ToolObservationOutput>;
+  
+  /** Get timeline (3-layer progressive disclosure) */
+  getTimeline(query: string, depth: TimelineDepth, limit: number): Promise<unknown[]>;
+  
+  /** Check if this agent should capture this tool */
+  shouldCaptureTool(toolName: string): boolean;
+  
+  /** Get raw config for native integration */
+  getNativeConfig(): AgentConfig;
+}
+
+/** Registry for managing adapters */
+export interface AdapterRegistry {
+  /** Register a new adapter */
+  register(adapter: AgentAdapter): void;
+  
+  /** Get adapter by type */
+  get(type: AgentType): AgentAdapter | undefined;
+  
+  /** List all registered adapters */
+  list(): AgentAdapter[];
+  
+  /** Load all adapters from config directory */
+  loadAll(configDir: string): Promise<void>;
+}
+
+/** Zod schemas for validation */
+export const SessionContextInputSchema = z.object({
+  project: z.string(),
+  mode: z.enum(['startup', 'resume', 'compact']).default('startup'),
+  sessionId: z.string().optional(),
+});
+
+export const ToolObservationInputSchema = z.object({
+  toolName: z.string(),
+  toolInput: z.record(z.string(), z.unknown()),
+  toolResult: z.unknown(),
+  project: z.string(),
+  sessionId: z.string().optional(),
+});
+
+export const TimelineInputSchema = z.object({
+  query: z.string(),
+  depth: z.enum(['index', 'timeline', 'detail']).default('index'),
+  limit: z.number().min(1).max(100).default(10),
+});
+
+/** Tool category mapping */
+export const TOOL_CATEGORIES: Record<string, ToolObservationOutput['category']> = {
+  'Read': 'reading',
+  'Write': 'modification',
+  'Edit': 'modification',
+  'Bash': 'command',
+  'grep': 'search',
+  'Glob': 'search',
+  'TodoWrite': 'planning',
+  'TodoRead': 'planning',
+  'Task': 'planning',
+};
+
+/**
+ * Categorize a tool call
+ */
+export function categorizeTool(toolName: string): ToolObservationOutput['category'] {
+  return TOOL_CATEGORIES[toolName] || 'other';
+}

package/core/agent-preferences.ts

@@ -0,0 +1,140 @@
+/**
+ * Agent Preferences - Accumulate and retrieve agent preferences from learnings
+ * Enables agents to learn and evolve over time
+ */
+
+import { getDb } from '../db/index.js';
+import { eq, and } from 'drizzle-orm';
+import { logger } from './logger.js';
+
+/**
+ * Extract preference from learning content
+ * E.g., "Prefer bun over npm" -> key: "prefer_bun", value: "bun"
+ */
+function extractPreference(content: string): { key: string; value: string } | null {
+  const patterns = [
+    // "Prefer X over Y"
+    /prefer\s+(\w+)\s+over\s+(\w+)/i,
+    // "Always use X"
+    /always\s+use\s+(\w+)/i,
+    // "Use X instead of Y"
+    /use\s+(\w+)\s+instead\s+of\s+(\w+)/i,
+    // "X is better than Y"
+    /(\w+)\s+is\s+better\s+than\s+(\w+)/i,
+    // "Don't use X"
+    /(?:don't|do not|never)\s+use\s+(\w+)/i,
+  ];
+  
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      const key = `prefer_${match[1].toLowerCase()}`;
+      const value = match[2]?.toLowerCase() || 'true';
+      return { key, value };
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Update agent preference from a learning
+ */
+export async function updateAgentPreference(
+  projectId: string,
+  content: string,
+  sourceMemoryId?: string
+): Promise<void> {
+  const preference = extractPreference(content);
+  if (!preference) return;
+  
+  try {
+    const db = getDb();
+    
+    // Check if preference exists
+    const existing = await db.query.agentPreferences?.findFirst(
+      and(
+        eq(db.schema.agentPreferences.projectId, projectId),
+        eq(db.schema.agentPreferences.key, preference.key)
+      )
+    ).catch(() => null);
+    
+    if (existing) {
+      // Update existing preference
+      await db.update(db.schema.agentPreferences)
+        .set({
+          value: preference.value,
+          sourceMemoryId: sourceMemoryId,
+          usageCount: (existing.usageCount ?? 0) + 1,
+          lastUpdated: Math.floor(Date.now() / 1000)
+        })
+        .where(eq(db.schema.agentPreferences.id, existing.id))
+        .catch(() => {
+          // Fallback for SQLite which uses different table name
+          const sqlite = (db as any)._?.sqlite || (db as any);
+          if (sqlite) {
+            sqlite.prepare(`
+              UPDATE agent_preferences 
+              SET value = ?, source_memory_id = ?, usage_count = usage_count + 1, last_updated = ?
+              WHERE project_id = ? AND key = ?
+            `).run(preference.value, sourceMemoryId, Math.floor(Date.now() / 1000), projectId, preference.key);
+          }
+        });
+      logger.info(`[AgentPrefs] Updated preference: ${preference.key} = ${preference.value}`);
+    } else {
+      // Insert new preference
+      const id = `pref_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      await db.insert(db.schema.agentPreferences)
+        .values({
+          id,
+          projectId,
+          key: preference.key,
+          value: preference.value,
+          sourceMemoryId: sourceMemoryId ?? null,
+          confidence: 0.5,
+          usageCount: 1
+        })
+        .catch(() => {
+          // Fallback for SQLite
+          const sqlite = (db as any)._?.sqlite || (db as any);
+          if (sqlite) {
+            sqlite.prepare(`
+              INSERT INTO agent_preferences (id, project_id, key, value, source_memory_id, confidence, usage_count)
+              VALUES (?, ?, ?, ?, ?, 0.5, 1)
+            `).run(id, projectId, preference.key, preference.value, sourceMemoryId ?? null);
+          }
+        });
+      logger.info(`[AgentPrefs] Created preference: ${preference.key} = ${preference.value}`);
+    }
+  } catch (error) {
+    logger.warn(`[AgentPrefs] Failed to update preference:`, error);
+  }
+}
+
+/**
+ * Get all agent preferences for a project
+ */
+export async function getAgentPreferences(projectId: string): Promise<Array<{key: string; value: string}>> {
+  try {
+    const db = getDb();
+    const results = await db.query.agentPreferences?.findMany({
+      where: eq(db.schema.agentPreferences.projectId, projectId)
+    }).catch(() => []);
+    
+    if (results && results.length > 0) {
+      return results.map(p => ({ key: p.key, value: p.value }));
+    }
+    
+    // Fallback for SQLite
+    const sqlite = (db as any)._?.sqlite || (db as any);
+    if (sqlite) {
+      const rows = sqlite.prepare('SELECT key, value FROM agent_preferences WHERE project_id = ?').all(projectId) as Array<{key: string; value: string}>;
+      return rows.map(r => ({ key: r.key, value: r.value }));
+    }
+    
+    return [];
+  } catch (error) {
+    logger.warn(`[AgentPrefs] Failed to get preferences:`, error);
+    return [];
+  }
+}