VSCode Extension: Bring Persistent Memory to GitHub Copilot

[thedotmack]

Summary

We're building a VSCode extension to bring claude-mem's persistent memory capabilities to GitHub Copilot. This will enable Copilot to remember past conversations, decisions, and context across sessions - just like it currently works with Claude Code.

📚 Developer Cheat Sheet

👉 VSCode Extension Developer Cheat Sheet

This comprehensive guide provides everything you need to contribute without access to the claude-mem knowledge base:

• Quick start setup (get running in 5 minutes)
• Complete Worker Service API reference
• All TypeScript type definitions with examples
• Step-by-step lifecycle flow diagrams
• VSCode API integration guide
• Copy-pasteable code examples (WorkerClient, Chat Participant, Tools)
• Error handling patterns
• Testing strategy
• Development workflow

Current Status

Branch: feature/vscode-extension

Architecture Document: docs/context/vscode-extension-architecture.md

Phase: Ready to start Phase 1 (Foundation)

We have a complete architecture document that defines:

• How the extension will integrate with VSCode's Chat Participant API and Language Model Tools API
• How it will reuse the existing worker service (shared with Claude Code plugin)
• Complete event mapping from Claude Code hooks to VSCode equivalents
• Design decisions with rationale
• 15-phase implementation plan

What We're Building

The extension will have two main components:

1. Language Model Tools (Explicit Capabilities)

Tools that Copilot can invoke to search memory:

• mem_search - Semantic search across past work
• mem_get_recent - Get recent session summaries
• mem_timeline - Chronological timeline of observations
• mem_find_file - Find observations related to specific files

2. Chat Participant (Automatic Lifecycle)

Invisible to Copilot, handles:

• Creating sessions on conversation start
• Logging user prompts automatically
• Capturing Copilot's tool invocations as observations
• Injecting relevant context at conversation start
• Generating summaries on conversation end

Architecture Highlights

VSCode Extension (lightweight HTTP client)
          ↓
Worker Service (existing, shared with Claude Code)
          ↓
SQLite + ChromaDB (persistent memory store)

The extension is just VSCode API bindings + HTTP client. All the heavy lifting (AI processing, vector search, storage) is handled by the existing worker service.

How to Contribute

Getting Started

1. Checkout the branch:

   git checkout feature/vscode-extension

2. Read the cheat sheet:
   Developer Cheat Sheet

3. Read the architecture doc:
   docs/context/vscode-extension-architecture.md

4. Understand the existing codebase:

   • src/hooks/ - Claude Code lifecycle hooks (we're mirroring this behavior)
   • src/services/worker-service.ts - Worker service (we'll reuse this via HTTP)
   • plugin/skills/mem-search/SKILL.md - Search functionality reference

What Help We Need

Phase 1: Foundation Work (First Milestone)

• Create src/shared/worker-client.ts - Shared TypeScript HTTP client for worker service
• Add unit tests for worker client
• Create VSCode extension scaffold in src/vscode/
• Set up build pipeline for extension
• Verify worker client can communicate with existing worker service

Phase 2-3: Language Model Tools

• Implement mem_search tool
• Implement mem_get_recent tool
• Implement mem_timeline tool
• Implement mem_find_file tool
• Test tools with GitHub Copilot

Phase 4-6: Chat Participant

• Implement session lifecycle management
• Implement observation capture
• Implement context injection
• Test end-to-end with real Copilot conversations

Skills Needed

• TypeScript - Extension is written in TypeScript
• VSCode Extension API - Specifically Chat Participant API and Language Model Tools API
• HTTP/REST - Worker client communicates via HTTP
• Testing - Unit and integration tests

Resources

• Developer Cheat Sheet
• VSCode Chat Extension Guide
• VSCode Language Model API
• Claude-Mem Worker Service API (lines 1-200 show the API endpoints)

Why This Matters

For VSCode/Copilot Users:

• Copilot will remember your past work, decisions, and context
• No more repeating yourself across sessions
• Copilot can search your project history to give better answers

For Claude-Mem:

• Expands reach beyond Claude Code
• Demonstrates architecture flexibility
• Brings persistent memory to millions of Copilot users

Questions?

Comment below or check the Developer Cheat Sheet!

Looking forward to building this together! 🚀

[thedotmack]

📚 Developer Cheat Sheet Available

I've created a comprehensive developer cheat sheet to help community contributors who don't have access to the claude-mem knowledge base:

👉 VSCode Extension Developer Cheat Sheet

What's Included

The cheat sheet provides everything you need to build the extension without prior context:

✅ Quick Start Setup - How to install, run, and verify the worker service locally
✅ Worker Service API Reference - Complete API documentation with request/response examples
✅ Data Models & Type Definitions - All TypeScript interfaces with real examples
✅ Lifecycle Flow Examples - Step-by-step diagrams of the entire conversation flow
✅ VSCode API Integration Guide - How to use Chat Participant and Language Model Tools APIs
✅ Search API Reference - All search endpoints with query examples
✅ Error Handling Patterns - Retry logic, graceful degradation, custom error classes
✅ Development Workflow - Project structure, build config, debug setup, local dev loop
✅ Testing Strategy - Unit tests, integration tests, manual testing checklist
✅ Code Examples - Complete, copy-pasteable implementations:

• WorkerClient (shared HTTP client)
• Chat Participant (minimal implementation)
• Language Model Tool (mem_search example)

Key Sections for Getting Started

1. Quick Start Setup - Get the worker running in 5 minutes
2. Worker Service API Reference - API endpoints you'll be calling
3. Code Examples - Copy-paste starting points

How This Was Built

I used deep thinking (sequential-thinking MCP tool) to work through 15 different knowledge barriers that community developers would face:

1. Worker Service API understanding
2. Data models & types
3. Lifecycle flow in practice
4. VSCode API integration specifics
5. Environment setup
6. Search/context retrieval behavior
7. Error handling & edge cases
8. Observation structure & capture
9. Testing without full integration
10. Context injection formatting
11. Build & packaging
12. Project structure & patterns
13. VSCode extension gotchas
14. Sessions vs conversations
15. Quick reference examples

Each section addresses one of these gaps with concrete information, real code examples, and clear explanations.

Questions?

If something's unclear or missing from the cheat sheet, comment here and I'll update it!

[naroslife]

Now with VSCode Copilot supporting Claude agent types, should this be reevaluated?