v1.1.0: generic multi-tool session support, remove Claude Code coupling

- Remove all Claude Code-specific naming: claudeDir→dataDir, projectsDir→sessionsDir
- New env vars: KNOWLEDGE_DATA_DIR, KNOWLEDGE_ANTHROPIC_API_KEY (no legacy fallbacks)
- Default memory dir: ~/agent-knowledge (was ~/claude-memory)
- Rename ClaudeEmbeddingProvider→AnthropicEmbeddingProvider (claude.ts→anthropic.ts)
- Add session adapter system with auto-detection for 6 AI coding tools:
  Claude Code (JSONL), Cursor (JSONL), OpenCode (SQLite),
  Cline (JSON), Continue.dev (JSON), Aider (Markdown/JSONL)
- Native Cursor session format support (role field, content arrays)
- Auto-create vector DB parent directory on startup
- Update all documentation for generic multi-tool identity

Author: keshrath

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 1.1.0 (2026-03-27)
+
+### Multi-Source Session Adapters
+
+agent-knowledge now auto-discovers and reads sessions from all major AI coding assistants. If a tool is installed, its sessions appear automatically in the dashboard and search results -- no configuration required.
+
+- **New adapters**: OpenCode (SQLite), Cline (JSON), Continue.dev (JSON), Aider (Markdown/JSONL)
+- **Auto-detection**: Cursor sessions discovered from `~/.cursor/projects/*/agent-transcripts/`; OpenCode from `~/.local/share/opencode/opencode.db`; Cline from VS Code globalStorage; Continue.dev from `~/.continue/sessions/`; Aider from `.aider.chat.history.md` / `.aider.llm.history` in project dirs
+- **Adapter interface**: pluggable `SessionAdapter` with `isAvailable()`, `discoverProjects()`, `listSessions()`, `parseSession()` -- add new tools by implementing one file
+- **`EXTRA_SESSION_ROOTS` env var**: comma-separated paths for additional session directories
+- **`OPENCODE_DATA_DIR` env var**: override OpenCode data location (default `~/.local/share/opencode`)
+
+### Generic Naming Refactor
+
+Removed Claude Code-specific language throughout. agent-knowledge is now fully client-agnostic.
+
+- **Config fields renamed**: `claudeDir` -> `dataDir`, `projectsDir` -> `sessionsDir`
+- **Env vars renamed**:
+  - `KNOWLEDGE_DATA_DIR` (was `CLAUDE_DIR`)
+  - `KNOWLEDGE_ANTHROPIC_API_KEY` (was `KNOWLEDGE_CLAUDE_API_KEY`)
+- **Default memory directory**: `~/agent-knowledge`
+- **Embedding class renamed**: `ClaudeEmbeddingProvider` -> `AnthropicEmbeddingProvider`
+- **Documentation**: all references updated to use generic "agent sessions" language, architecture diagrams show "Session Data Dir" instead of `~/.claude/projects`
+
 ## 1.0.0 (2026-03-26)
 
 Initial release.
@@ -30,7 +54,7 @@ Initial release.
 
 ### Knowledge Base
 
-- Git-synced markdown vault at `~/claude-memory/`
+- Git-synced markdown vault at `~/agent-knowledge/` (previously `~/claude-memory/`)
 - 5 categories: projects, people, decisions, workflows, notes
 - YAML frontmatter for metadata (title, tags, updated)
 - Auto git commit + push on writes, pull on reads

CLAUDE.md

@@ -9,7 +9,7 @@ src/
   server.ts             MCP server, 12 tool definitions, request routing
   dashboard.ts          HTTP + WebSocket server, REST API, file watcher
   index.ts              Entry point (MCP stdio + dashboard auto-start)
-  types.ts              KnowledgeConfig, getConfig(), persisted config
+  types.ts              KnowledgeConfig (dataDir, sessionsDir, extraSessionRoots), getConfig(), persisted config
   validate.ts           ValidationError class, input validation
   version.ts            Runtime version from package.json
   knowledge/
@@ -18,11 +18,17 @@ src/
     git.ts              git pull/push/sync with timeouts
     distill.ts          Session auto-distillation with secrets scrubbing
   sessions/
-    parser.ts           JSONL parsing with mtime-based cache
+    parser.ts           Multi-format session parsing with mtime-based cache
     indexer.ts           Background indexing for sessions
     search.ts           TF-IDF ranked search with 60s global index cache
     scopes.ts           Search scopes (errors, plans, configs, tools, files, decisions)
     summary.ts          Session summaries, topic extraction, file path detection
+    adapters/
+      index.ts          SessionAdapter interface, adapter registry, auto-init
+      opencode.ts       OpenCode adapter (SQLite database)
+      cline.ts          Cline adapter (VS Code globalStorage JSON)
+      continue.ts       Continue.dev adapter (JSON session files)
+      aider.ts          Aider adapter (Markdown chat history + JSONL LLM history)
   search/
     tfidf.ts            TF-IDF scoring engine (tokenizer, stopwords, index)
     fuzzy.ts            Levenshtein distance, sliding window fuzzy matching
@@ -85,9 +91,22 @@ npm run dev        # watch mode (tsc --watch)
 - **Dashboard**: HTTP + WebSocket at port 3423, REST API for entries/sessions/search
 - **Git sync**: Auto pull/push on write, manual sync via `knowledge_sync`
 
+## Supported Session Sources
+
+Sessions are auto-discovered from all installed AI coding tools via the adapter system:
+
+- **Claude Code** -- JSONL files in `$KNOWLEDGE_DATA_DIR/projects/`
+- **Cursor** -- JSONL files in `~/.cursor/projects/*/agent-transcripts/`
+- **OpenCode** -- SQLite database at `~/.local/share/opencode/opencode.db` (or `$OPENCODE_DATA_DIR`)
+- **Cline** -- JSON task files in VS Code globalStorage `saoudrizwan.claude-dev/tasks/`
+- **Continue.dev** -- JSON session files in `~/.continue/sessions/`
+- **Aider** -- `.aider.chat.history.md` and `.aider.llm.history` in project directories
+
+Additional roots: `EXTRA_SESSION_ROOTS` env var (comma-separated). New tools: implement `SessionAdapter` in `src/sessions/adapters/`.
+
 ## Knowledge Base
 
-- Entries are Markdown files with YAML frontmatter stored in `~/claude-memory/`
+- Entries are Markdown files with YAML frontmatter stored in `~/agent-knowledge/`
 - Categories: `projects`, `people`, `decisions`, `workflows`, `notes`
 - Search: hybrid semantic (embeddings) + TF-IDF with fuzzy fallback
 - Session search scopes: `errors`, `plans`, `configs`, `tools`, `files`, `decisions`, `all`

CONTRIBUTING.md

@@ -24,7 +24,7 @@
 - **Git** (for knowledge base sync)
 - A knowledge base repo (or create one):
   ```bash
-  mkdir -p ~/claude-memory && cd ~/claude-memory && git init
+  mkdir -p ~/agent-knowledge && cd ~/agent-knowledge && git init
   mkdir projects people decisions workflows notes
   ```
 
@@ -45,8 +45,8 @@ npm run test:watch
 ### Environment
 
 ```bash
-export KNOWLEDGE_MEMORY_DIR=~/claude-memory
-export CLAUDE_DIR=~/.claude
+export KNOWLEDGE_MEMORY_DIR=~/agent-knowledge
+export KNOWLEDGE_DATA_DIR=~/.claude       # primary session dir (other tools auto-detected)
 export KNOWLEDGE_PORT=3423
 ```
 
@@ -64,10 +64,16 @@ agent-knowledge/
       search.ts           TF-IDF search over knowledge entries with regex fallback
       git.ts              git pull/push/sync with timeouts
     sessions/
-      parser.ts           JSONL parsing with mtime-based cache
+      parser.ts           Multi-format session parsing with mtime-based cache
       search.ts           TF-IDF ranked search with 60s global index cache
       scopes.ts           6 search scopes (errors, plans, configs, tools, files, decisions)
       summary.ts          Session summaries, topic extraction, file path detection
+      adapters/
+        index.ts          SessionAdapter interface, registry, auto-init
+        opencode.ts       OpenCode adapter (SQLite)
+        cline.ts          Cline adapter (JSON)
+        continue.ts       Continue.dev adapter (JSON)
+        aider.ts          Aider adapter (Markdown/JSONL)
     search/
       tfidf.ts            TF-IDF scoring engine (tokenizer, stopwords, index)
       fuzzy.ts            Levenshtein distance, sliding window fuzzy matching
@@ -112,6 +118,71 @@ Tests use **vitest** with `fs.mkdtempSync` for temp directories in filesystem te
 - TF-IDF: tokenization, stopwords, ranking correctness, edge cases
 - Fuzzy: Levenshtein distance, threshold filtering, sliding window
 - Sessions: JSONL parsing, malformed line handling, message extraction
+- Session adapters: `isAvailable()` detection, `parseSession()` output normalization, graceful handling of missing/corrupt data
+
+## Adding a Session Adapter
+
+agent-knowledge uses a pluggable adapter system to read sessions from different AI coding tools. To add support for a new tool:
+
+### 1. Create the adapter file
+
+Create `src/sessions/adapters/<tool>.ts` implementing the `SessionAdapter` interface:
+
+```typescript
+import type { SessionEntry } from '../parser.js';
+import type { SessionAdapter } from './index.js';
+
+export const myToolAdapter: SessionAdapter = {
+  prefix: 'mytool', // Unique prefix for virtual descriptors
+  name: 'My Tool', // Human-readable name
+
+  isAvailable(): boolean {
+    // Return true if this tool is installed on the current machine.
+    // Check for the existence of data files/directories.
+    return existsSync('/path/to/mytool/data');
+  },
+
+  discoverProjects(): Array<{ name: string; path: string }> {
+    // Return a list of projects/groups found for this tool.
+    // Use `mytool://` prefixed paths as virtual descriptors.
+    return [{ name: 'mytool', path: 'mytool://all' }];
+  },
+
+  listSessions(projectDescriptor: string): Array<{ id: string; file: string }> {
+    // List individual sessions within a project.
+    // Return virtual descriptors that parseSession() can handle.
+    return [{ id: 'session-1', file: 'mytool://session:session-1' }];
+  },
+
+  parseSession(descriptor: string): SessionEntry[] {
+    // Parse a session into normalized SessionEntry[] objects.
+    // Each entry needs at minimum: type ('user'|'assistant'), message.role, message.content
+    return [{ type: 'user', message: { role: 'user', content: 'Hello' } }];
+  },
+};
+```
+
+### 2. Register the adapter
+
+Add a dynamic import to `src/sessions/adapters/index.ts` in the `initAdapters()` function:
+
+```typescript
+import('./mytool.js').then((m) => registerAdapter(m.myToolAdapter)).catch(() => {});
+```
+
+### 3. Key guidelines
+
+- **Auto-detection only**: `isAvailable()` should check for the tool's data files on disk. No user configuration required.
+- **Virtual descriptors**: Use `<prefix>://` URIs so the parser can dispatch to the correct adapter.
+- **Graceful failure**: All methods should catch errors and return empty arrays rather than throwing.
+- **Read-only access**: Never modify the source tool's data files. Use `{ readonly: true }` for database connections.
+- **Platform-aware paths**: Handle Windows, macOS, and Linux path differences (see `cline.ts` for an example).
+
+### 4. Update documentation
+
+- Add the tool to the "Supported Tools" table in `README.md`
+- Add the tool to the "Supported Session Sources" list in `CLAUDE.md`
+- Add a changelog entry in `CHANGELOG.md`
 
 ## Pull Requests
 

README.md

@@ -5,7 +5,7 @@
 [![Tests: 280 passing](https://img.shields.io/badge/Tests-280%20passing-brightgreen.svg)]()
 [![MCP Tools: 12](https://img.shields.io/badge/MCP%20Tools-12-blueviolet.svg)]()
 
-**Cross-session memory and recall for AI agents** -- git-synced knowledge base, hybrid semantic+TF-IDF search, auto-distillation with secrets scrubbing.
+**Cross-session memory and recall for AI coding assistants** -- works with Claude Code, Cursor, OpenCode, Cline, Continue.dev, and Aider out of the box. Git-synced knowledge base, hybrid semantic+TF-IDF search, auto-distillation with secrets scrubbing.
 
 <table>
 <tr>
@@ -20,23 +20,40 @@
 
 ## Why
 
-Claude Code sessions are ephemeral. When a session ends, everything it learned -- architecture decisions, debugging insights, project context -- is gone. The next session starts from scratch.
+AI coding sessions are ephemeral. When a session ends, everything it learned -- architecture decisions, debugging insights, project context -- is gone. The next session starts from scratch.
 
 **agent-knowledge** solves this with two complementary systems:
 
 1. **Knowledge Base** -- a git-synced markdown vault of structured entries (decisions, workflows, project context) that persists across sessions and machines.
-2. **Session Search** -- TF-IDF ranked full-text search across JSONL session transcripts, so agents can recall what happened before.
+2. **Session Search** -- TF-IDF ranked full-text search across session transcripts from all your coding tools, so agents can recall what happened before -- regardless of which tool was used.
+
+## Supported Tools
+
+Sessions from all major AI coding assistants are auto-discovered -- if a tool is installed, its sessions appear automatically.
+
+| Tool             | Format         | Auto-detected path                                              |
+| ---------------- | -------------- | --------------------------------------------------------------- |
+| **Claude Code**  | JSONL          | `$KNOWLEDGE_DATA_DIR/projects/` (default `~/.claude/projects/`) |
+| **Cursor**       | JSONL          | `~/.cursor/projects/*/agent-transcripts/`                       |
+| **OpenCode**     | SQLite         | `~/.local/share/opencode/opencode.db` (or `$OPENCODE_DATA_DIR`) |
+| **Cline**        | JSON           | VS Code globalStorage `saoudrizwan.claude-dev/tasks/`           |
+| **Continue.dev** | JSON           | `~/.continue/sessions/`                                         |
+| **Aider**        | Markdown/JSONL | `.aider.chat.history.md` / `.aider.llm.history` in project dirs |
+
+No configuration needed. Additional session roots can be added via the `EXTRA_SESSION_ROOTS` env var (comma-separated paths).
 
 ## Features
 
+- **Multi-tool session search** -- unified search across Claude Code, Cursor, OpenCode, Cline, Continue.dev, and Aider sessions
 - **Hybrid search** -- semantic vector similarity blended with TF-IDF keyword ranking
 - **Git-synced knowledge base** -- markdown vault with YAML frontmatter, auto commit and push on writes
 - **Auto-distillation** -- session insights automatically extracted and pushed to git with secrets scrubbing
+- **Pluggable adapter system** -- add support for new tools by implementing the `SessionAdapter` interface
 - **Embeddings** -- local (Hugging Face), OpenAI, Claude/Voyage, or Gemini providers
 - **Fuzzy matching** -- typo-tolerant search using Levenshtein distance
 - **6 search scopes** -- errors, plans, configs, tools, files, decisions
 - **Configurable git URL** -- `knowledge_config` tool for runtime setup, persisted at XDG/AppData location
-- **Cross-machine persistence** -- knowledge syncs via git, sessions read from local JSONL
+- **Cross-machine persistence** -- knowledge syncs via git, sessions read from local storage of each tool
 - **Real-time dashboard** -- browse, search, and manage at `localhost:3423`
 - **Secrets scrubbing** -- API keys, tokens, passwords, private keys automatically redacted before git push
 
@@ -48,24 +65,18 @@ cd agent-knowledge
 npm install && npm run build
 ```
 
-### Configure in Claude Code
+### Configure your MCP client
+
+See [Setup Guide](docs/SETUP.md) for client-specific instructions (Claude Code, Cursor, Windsurf, OpenCode).
+
+Example (Claude Code):
 
 ```bash
 claude mcp add agent-knowledge -s user \
-  -e KNOWLEDGE_MEMORY_DIR="$HOME/claude-memory" \
+  -e KNOWLEDGE_MEMORY_DIR="$HOME/agent-knowledge" \
   -- node /path/to/agent-knowledge/dist/index.js
 ```
 
-Or add to `settings.json` permissions:
-
-```json
-{
-  "permissions": {
-    "allow": ["mcp__agent-knowledge__*"]
-  }
-}
-```
-
 Dashboard: **http://localhost:3423** (auto-starts with MCP server)
 
 ## MCP Tools
@@ -116,29 +127,44 @@ Dashboard: **http://localhost:3423** (auto-starts with MCP server)
 ```mermaid
 graph LR
     subgraph Storage
-        KB[(Knowledge Base<br/>~/claude-memory<br/>Git Repository)]
-        SF[(Session Files<br/>~/.claude/projects<br/>JSONL Logs)]
+        KB[(Knowledge Base<br/>~/agent-knowledge<br/>Git Repository)]
+    end
+
+    subgraph Session Sources
+        CC[(Claude Code<br/>JSONL)]
+        CU[(Cursor<br/>JSONL)]
+        OC[(OpenCode<br/>SQLite)]
+        CL[(Cline<br/>JSON)]
+        CD[(Continue.dev<br/>JSON)]
+        AI[(Aider<br/>MD / JSONL)]
     end
 
     subgraph agent-knowledge
         KM[Knowledge Module<br/>store / search / git]
+        AD[Session Adapters<br/>auto-discovery]
         SE[Search Engine<br/>TF-IDF + Fuzzy]
         DS[Dashboard<br/>:3423]
         MCP[MCP Server<br/>stdio]
     end
 
     subgraph Clients
-        CC[Claude Code Sessions]
+        AG[Agent Sessions]
         WB[Web Browser]
     end
 
     KB <-->|git pull/push| KM
-    SF -->|parse JSONL| SE
+    CC --> AD
+    CU --> AD
+    OC --> AD
+    CL --> AD
+    CD --> AD
+    AI --> AD
+    AD --> SE
     KM --> MCP
     SE --> MCP
     KM --> DS
     SE --> DS
-    MCP --> CC
+    MCP --> AG
     DS --> WB
 ```
 
@@ -169,16 +195,19 @@ npm run lint          # Type-check (tsc --noEmit)
 
 ## Environment Variables
 
-| Variable                           | Default           | Description                                                       |
-| ---------------------------------- | ----------------- | ----------------------------------------------------------------- |
-| `KNOWLEDGE_MEMORY_DIR`             | `~/claude-memory` | Path to git-synced knowledge base                                 |
-| `KNOWLEDGE_GIT_URL`                | --                | Git remote URL (auto-clones if dir missing)                       |
-| `KNOWLEDGE_AUTO_DISTILL`           | `true`            | Auto-distill session insights to knowledge base                   |
-| `KNOWLEDGE_EMBEDDING_PROVIDER`     | `local`           | Embedding provider: `local`, `openai`, `claude`, `gemini`         |
-| `KNOWLEDGE_EMBEDDING_ALPHA`        | `0.3`             | TF-IDF vs semantic blend weight (0=pure semantic, 1=pure TF-IDF)  |
-| `KNOWLEDGE_EMBEDDING_IDLE_TIMEOUT` | `60`              | Seconds before unloading local model from memory (0 = keep alive) |
-| `CLAUDE_DIR`                       | `~/.claude`       | Directory containing session transcripts (JSONL files)            |
-| `KNOWLEDGE_PORT`                   | `3423`            | Dashboard HTTP port                                               |
+| Variable                                            | Default             | Description                                                           |
+| --------------------------------------------------- | ------------------- | --------------------------------------------------------------------- |
+| `KNOWLEDGE_MEMORY_DIR`                              | `~/agent-knowledge` | Path to git-synced knowledge base                                     |
+| `KNOWLEDGE_GIT_URL`                                 | --                  | Git remote URL (auto-clones if dir missing)                           |
+| `KNOWLEDGE_AUTO_DISTILL`                            | `true`              | Auto-distill session insights to knowledge base                       |
+| `KNOWLEDGE_EMBEDDING_PROVIDER`                      | `local`             | Embedding provider: `local`, `openai`, `claude`, `gemini`             |
+| `KNOWLEDGE_EMBEDDING_ALPHA`                         | `0.3`               | TF-IDF vs semantic blend weight (0=pure semantic, 1=pure TF-IDF)      |
+| `KNOWLEDGE_EMBEDDING_IDLE_TIMEOUT`                  | `60`                | Seconds before unloading local model from memory (0 = keep alive)     |
+| `KNOWLEDGE_DATA_DIR`                                | `~/.claude`         | Primary session data directory (Claude Code JSONL files)              |
+| `EXTRA_SESSION_ROOTS`                               | --                  | Additional session directories, comma-separated paths                 |
+| `OPENCODE_DATA_DIR`                                 | (see below)         | Override OpenCode data directory (default: `~/.local/share/opencode`) |
+| `KNOWLEDGE_ANTHROPIC_API_KEY` / `ANTHROPIC_API_KEY` | --                  | API key for Claude/Voyage embeddings                                  |
+| `KNOWLEDGE_PORT`                                    | `3423`              | Dashboard HTTP port                                                   |
 
 ## Documentation