feat: initial conversation memory system implementation

- Add comprehensive memory service architecture mirroring CodeIndexManager pattern
- Implement temporal intelligence with fact categorization (infrastructure, architecture, debugging, pattern)
- Add memory_search tool for retrieving relevant conversation context
- Create service factory, orchestrator, and search service stubs
- Add configuration management for memory system settings
- Implement cache manager for persistent memory storage
- Define interfaces for fact extraction, conflict resolution, and temporal management

Based on detailed planning documents:
- Temporal intelligence for managing fact lifecycle
- Battle-tested patterns from mem0, Graphiti, and Potpie
- Workspace isolation for project-specific memories
- Non-invasive integration with minimal codebase changes

This is an initial implementation that provides the foundation for the conversation memory feature as described in issue #7537.

Author: roomote

packages/types/src/tool.ts

@@ -33,6 +33,7 @@ export const toolNames = [
 	"new_task",
 	"fetch_instructions",
 	"codebase_search",
+	"memory_search",
 	"update_todo_list",
 	"generate_image",
 ] as const

src/core/prompts/tools/index.ts

@@ -26,7 +26,9 @@ import { getNewTaskDescription } from "./new-task"
 import { getCodebaseSearchDescription } from "./codebase-search"
 import { getUpdateTodoListDescription } from "./update-todo-list"
 import { getGenerateImageDescription } from "./generate-image"
+import { getMemorySearchDescription } from "./memory-search"
 import { CodeIndexManager } from "../../../services/code-index/manager"
+import { ConversationMemoryManager } from "../../../services/conversation-memory/manager"
 
 // Map of tool names to their description functions
 const toolDescriptionMap: Record<string, (args: ToolArgs) => string | undefined> = {
@@ -50,6 +52,7 @@ const toolDescriptionMap: Record<string, (args: ToolArgs) => string | undefined>
 	use_mcp_tool: (args) => getUseMcpToolDescription(args),
 	access_mcp_resource: (args) => getAccessMcpResourceDescription(args),
 	codebase_search: (args) => getCodebaseSearchDescription(args),
+	memory_search: (args) => getMemorySearchDescription(args),
 	switch_mode: () => getSwitchModeDescription(),
 	new_task: (args) => getNewTaskDescription(args),
 	insert_content: (args) => getInsertContentDescription(args),
@@ -126,6 +129,12 @@ export function getToolDescriptionsForMode(
 		tools.delete("codebase_search")
 	}
 
+	// Conditionally exclude memory_search if feature is disabled or not configured
+	const memoryManager = ConversationMemoryManager.getCurrentWorkspaceManager()
+	if (!memoryManager || !memoryManager.isFeatureEnabled || !memoryManager.isInitialized) {
+		tools.delete("memory_search")
+	}
+
 	// Conditionally exclude update_todo_list if disabled in settings
 	if (settings?.todoListEnabled === false) {
 		tools.delete("update_todo_list")
@@ -171,5 +180,6 @@ export {
 	getInsertContentDescription,
 	getSearchAndReplaceDescription,
 	getCodebaseSearchDescription,
+	getMemorySearchDescription,
 	getGenerateImageDescription,
 }

src/core/prompts/tools/memory-search.ts

@@ -0,0 +1,44 @@
+import { ToolArgs } from "./types"
+
+export function getMemorySearchDescription(args: ToolArgs): string {
+	return `## memory_search
+Description: Search conversation memory for past technical decisions, patterns, and project context. Retrieves relevant memories about infrastructure, architecture, debugging issues, and learned patterns for the current workspace.
+
+Parameters:
+- query: (required) Natural language search query. Use the user's exact wording when possible.
+- category: (optional) Filter by category: infrastructure, architecture, pattern, or debugging
+- tags: (optional) Comma-separated tags to filter results (e.g., "auth,cookies")
+- limit: (optional) Maximum number of results to return (default: 10)
+
+Usage:
+<memory_search>
+<query>Your natural language query here</query>
+<category>architecture</category>
+<tags>auth,cookies</tags>
+<limit>6</limit>
+</memory_search>
+
+Examples:
+
+1. Search for authentication decisions:
+<memory_search>
+<query>authentication approach</query>
+<category>architecture</category>
+</memory_search>
+
+2. Find debugging patterns:
+<memory_search>
+<query>CORS error fixes</query>
+<category>pattern</category>
+</memory_search>
+
+3. General project context search:
+<memory_search>
+<query>database configuration</query>
+</memory_search>
+
+Output format:
+ARCHITECTURE: Database access via dependency injection (replaces singleton) (2025-07-08)
+PATTERN: Avoid N+1 queries in SQLAlchemy using selectinload (derived from incident) (2025-05-21)
+`
+}

src/services/conversation-memory/cache-manager.ts

@@ -0,0 +1,167 @@
+import * as vscode from "vscode"
+import * as path from "path"
+import * as fs from "fs/promises"
+import { ConversationFact } from "./interfaces"
+
+export interface MemoryCacheData {
+	version: string
+	lastUpdated: string
+	facts: ConversationFact[]
+	metadata: {
+		workspacePath: string
+		totalFacts: number
+		categories: Record<string, number>
+	}
+}
+
+export class ConversationMemoryCacheManager {
+	private readonly cacheFileName = "conversation-memory-cache.json"
+	private readonly cacheVersion = "1.0.0"
+	private cacheFilePath: string
+	private memoryCache: Map<string, ConversationFact> = new Map()
+
+	constructor(
+		private readonly context: vscode.ExtensionContext,
+		private readonly workspacePath: string,
+	) {
+		// Store cache in VS Code's global storage
+		const storageUri = context.globalStorageUri
+		this.cacheFilePath = path.join(storageUri.fsPath, this.getCacheFileName())
+	}
+
+	private getCacheFileName(): string {
+		// Create unique cache file name per workspace
+		const workspaceHash = Buffer.from(this.workspacePath).toString("base64").replace(/[/+=]/g, "_")
+		return `${workspaceHash}-${this.cacheFileName}`
+	}
+
+	public async initialize(): Promise<void> {
+		// Ensure storage directory exists
+		const storageDir = path.dirname(this.cacheFilePath)
+		await fs.mkdir(storageDir, { recursive: true })
+
+		// Load existing cache if available
+		await this.loadCache()
+	}
+
+	public async loadCache(): Promise<void> {
+		try {
+			const cacheContent = await fs.readFile(this.cacheFilePath, "utf8")
+			const cacheData: MemoryCacheData = JSON.parse(cacheContent)
+
+			// Validate cache version
+			if (cacheData.version !== this.cacheVersion) {
+				console.log(
+					`Cache version mismatch. Expected ${this.cacheVersion}, got ${cacheData.version}. Clearing cache.`,
+				)
+				await this.clearCacheFile()
+				return
+			}
+
+			// Load facts into memory
+			this.memoryCache.clear()
+			for (const fact of cacheData.facts) {
+				// Convert date strings back to Date objects
+				fact.reference_time = new Date(fact.reference_time)
+				fact.ingestion_time = new Date(fact.ingestion_time)
+				if (fact.superseded_at) fact.superseded_at = new Date(fact.superseded_at)
+				if (fact.resolved_at) fact.resolved_at = new Date(fact.resolved_at)
+				if (fact.last_confirmed) fact.last_confirmed = new Date(fact.last_confirmed)
+
+				this.memoryCache.set(fact.id, fact)
+			}
+
+			console.log(`Loaded ${this.memoryCache.size} facts from cache`)
+		} catch (error) {
+			// Cache doesn't exist or is corrupted - start fresh
+			console.log("No valid cache found, starting with empty memory")
+			this.memoryCache.clear()
+		}
+	}
+
+	public async saveCache(): Promise<void> {
+		try {
+			const facts = Array.from(this.memoryCache.values())
+
+			// Calculate category statistics
+			const categories: Record<string, number> = {}
+			for (const fact of facts) {
+				categories[fact.category] = (categories[fact.category] || 0) + 1
+			}
+
+			const cacheData: MemoryCacheData = {
+				version: this.cacheVersion,
+				lastUpdated: new Date().toISOString(),
+				facts,
+				metadata: {
+					workspacePath: this.workspacePath,
+					totalFacts: facts.length,
+					categories,
+				},
+			}
+
+			await fs.writeFile(this.cacheFilePath, JSON.stringify(cacheData, null, 2), "utf8")
+			console.log(`Saved ${facts.length} facts to cache`)
+		} catch (error) {
+			console.error("Failed to save memory cache:", error)
+		}
+	}
+
+	public async clearCacheFile(): Promise<void> {
+		try {
+			await fs.unlink(this.cacheFilePath)
+			this.memoryCache.clear()
+			console.log("Memory cache cleared")
+		} catch (error) {
+			// File might not exist, which is fine
+			if ((error as any).code !== "ENOENT") {
+				console.error("Failed to clear memory cache:", error)
+			}
+		}
+	}
+
+	// Cache operations
+	public getFact(id: string): ConversationFact | undefined {
+		return this.memoryCache.get(id)
+	}
+
+	public setFact(fact: ConversationFact): void {
+		this.memoryCache.set(fact.id, fact)
+	}
+
+	public deleteFact(id: string): boolean {
+		return this.memoryCache.delete(id)
+	}
+
+	public getAllFacts(): ConversationFact[] {
+		return Array.from(this.memoryCache.values())
+	}
+
+	public getFactsByCategory(category: string): ConversationFact[] {
+		return Array.from(this.memoryCache.values()).filter((fact) => fact.category === category)
+	}
+
+	public getFactCount(): number {
+		return this.memoryCache.size
+	}
+
+	// Periodic save
+	private saveTimer: NodeJS.Timeout | undefined
+
+	public scheduleSave(delayMs: number = 5000): void {
+		if (this.saveTimer) {
+			clearTimeout(this.saveTimer)
+		}
+
+		this.saveTimer = setTimeout(() => {
+			this.saveCache()
+		}, delayMs)
+	}
+
+	public async dispose(): Promise<void> {
+		if (this.saveTimer) {
+			clearTimeout(this.saveTimer)
+		}
+		await this.saveCache()
+	}
+}