claude-memory-store 0.1.0

package/README.md

@@ -0,0 +1,364 @@
+# Claude Memory
+
+**The first developer-focused persistent memory system for Claude Code.**
+
+Claude forgets everything when the context window clears. Claude Memory fixes that. Your architecture decisions, deploy commands, database configs, team conventions, and project patterns persist across every session — stored in your own MongoDB Atlas instance, searchable in under 50ms.
+
+One command to install. Zero config after setup. Your data, your database, forever.
+
+```bash
+npx claude-memory-store init
+```
+
+[![npm version](https://img.shields.io/npm/v/claude-memory-store)](https://www.npmjs.com/package/claude-memory-store)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## The Problem
+
+You spend 10 minutes explaining your deploy process to Claude. Next session — gone. You tell Claude about your database clusters, your migration rules, your team conventions. Context clears — gone. Every session starts from zero.
+
+Claude Code's context window is powerful but temporary. When it fills up or you start a new session, everything disappears.
+
+## The Solution
+
+Claude Memory gives Claude persistent, searchable memory powered entirely by MongoDB Atlas:
+
+- **Architecture decisions** — "MongoDB Atlas prod-cluster-east, database api_prod, staging on staging-cluster"
+- **Deploy commands** — "docker build → ECR push → Dokploy webhook → health check" (with aliases like "deploy", "ship it")
+- **Team conventions** — "always use pnpm", "prefer Vitest over Jest", "strict TypeScript everywhere"
+- **Avoid rules** — "never run migrations directly on prod", "never deploy on Fridays"
+- **Open threads** — "production index on users collection is missing — causing slow queries"
+- **Developer preferences** — follow you across every project, every machine
+
+Every memory item is an individual document with its own vector embedding. Search returns the **specific decision** you need, not a truncated blob.
+
+---
+
+## How It Works
+
+Claude Memory integrates with Claude Code at four levels:
+
+### 1. Hooks (Passive — Automatic)
+Lifecycle hooks fire automatically during every Claude Code session:
+- **Startup** — ultra-minimal banner showing memory stats (zero context cost)
+- **Pre-tool-use** — queries Atlas on every prompt, injects relevant context if found
+- **Post-tool-use** — detects "remember this" intents and stores automatically
+- **Session end** — saves working memory, increments session counters
+
+### 2. MCP Server (Active — Claude Decides)
+Four MCP tools Claude can call on its own:
+- `recall(topic)` — search memory for relevant decisions
+- `remember(text)` — store a decision with auto-classification
+- `memory_threads()` — list open threads
+- `memory_stats()` — show memory statistics
+
+### 3. Skill File (Discoverable — User Types `/`)
+Slash commands available when you type `/` in Claude Code:
+- `/recall <topic>` — search memory
+- `/remember <text>` — store a decision
+- `/threads` — view open threads
+- `/stats` — memory statistics
+
+### 4. CLAUDE.md Instructions (Context — Always Present)
+Instructions in your global CLAUDE.md tell Claude it has memory available and when to use it.
+
+### The Lazy Injection Strategy
+
+Claude Memory does **not** dump everything into the context window at startup. Atlas queries take under 50ms — there's no reason to waste context space.
+
+- Startup banner: **<500 characters** (just stats: "3 decisions, 2 patterns, 1 thread")
+- Continue context: **1-2 line summary** of last session
+- New session: **zero context cost**
+- Memory surfaces **on-demand** via pre-tool-use search when relevant
+
+The full memory dump is only loaded when you explicitly ask for it (`?` at the startup menu).
+
+---
+
+## Quick Start
+
+### Prerequisites
+- Node.js 18+
+- MongoDB Atlas account ([free tier works](https://cloud.mongodb.com/register) — no credit card required)
+
+### Install
+
+```bash
+npx claude-memory-store init
+```
+
+That single command:
+1. Prompts for your Atlas connection string (auto-detects from `CLAUDE_MEMORY_ATLAS_URI` env var or `.env` file)
+2. Tests the connection
+3. Creates the `claude_memory` database and indexes
+4. Sets up Atlas vector search index (M10+ only, skipped gracefully on free tier)
+5. Installs Claude Code hooks (startup, pre-tool-use, post-tool-use, stop)
+6. Registers the MCP server (recall, remember, threads, stats tools)
+7. Installs the skill file (`/recall`, `/remember`, `/threads`, `/stats`)
+8. Adds memory instructions to your global CLAUDE.md
+
+**That's it.** No other setup. No API keys. No external services. Just Atlas.
+
+### Verify Installation
+
+```bash
+claude-memory info      # Show project ID, developer ID, config path
+claude-memory stats     # Show memory statistics
+claude-memory memory    # Show memory summary
+```
+
+---
+
+## Commands
+
+### CLI Commands
+
+```bash
+claude-memory init                    # First-time setup (one command does everything)
+claude-memory info                    # Show project/developer IDs and config path
+claude-memory memory                  # Show memory summary
+claude-memory stats                   # Show detailed statistics
+claude-memory recall <topic>          # Search memory for a topic
+claude-memory remember <text>         # Store a decision/pattern/rule
+claude-memory threads                 # Show open threads
+claude-memory commands                # Show verified commands
+claude-memory edit                    # TUI memory editor
+claude-memory edit --file             # Edit memory in $EDITOR (JSON)
+claude-memory edit --developer        # Edit developer memory
+claude-memory clear --working         # Clear session history
+claude-memory clear --all             # Clear all project memory
+```
+
+### MCP Tools (Claude calls these automatically)
+
+| Tool | Description |
+|------|-------------|
+| `recall(topic, limit?)` | Search memory via semantic + keyword search |
+| `remember(text, category?)` | Store with auto-classification (avoid/pattern/architecture/preference) |
+| `memory_threads()` | List open threads with status and age |
+| `memory_stats()` | Full memory statistics |
+
+### Slash Commands (Type `/` in Claude Code)
+
+| Command | Description |
+|---------|-------------|
+| `/recall <topic>` | Search memory |
+| `/remember <text>` | Store a decision |
+| `/threads` | View open threads |
+| `/stats` | Memory statistics |
+
+---
+
+## What Gets Stored
+
+### Auto-Classification
+
+When you tell Claude to remember something, it classifies automatically:
+
+| Your input | Classification | Example |
+|------------|---------------|---------|
+| "never..." / "don't..." / "avoid..." | **Avoid rule** | "never deploy on Fridays" |
+| "always use..." / "pattern..." / "convention..." | **Pattern** | "always use pnpm not npm" |
+| "architecture..." / "database..." / "schema..." | **Architecture decision** | "MongoDB Atlas on prod-cluster-east" |
+| "across all projects..." | **Developer preference** | "prefer Vitest over Jest everywhere" |
+| Everything else | **Architecture decision** | (default) |
+
+### Memory Types
+
+| Type | Scope | Persists Across |
+|------|-------|----------------|
+| Architecture decisions | Per project | Sessions |
+| Patterns | Per project | Sessions |
+| Avoid rules | Per project | Sessions |
+| Verified commands | Per project | Sessions |
+| Open threads | Per project | Sessions |
+| Working memory | Per project | Sessions (auto-saved) |
+| Developer preferences | Per developer | All projects |
+| Style rules | Per developer | All projects |
+
+### Verified Commands
+
+Store multi-step workflows with trigger aliases:
+
+```
+Store: "deploy" command with steps:
+  1. docker build -t myteam/api-service .
+  2. aws ecr push to us-east-1
+  3. curl -X POST https://deploy.example.com/webhook/abc123
+  4. curl https://api.example.com/health
+
+Triggers: "deploy", "ship it", "push to prod"
+```
+
+Next session, say "deploy" and Claude gets the full pipeline injected automatically.
+
+---
+
+## Architecture
+
+### Powered Entirely by MongoDB Atlas
+
+Claude Memory uses a single MongoDB Atlas collection (`claude_memory`) with a type discriminator. No Redis. No Postgres. No external APIs. No vector database. Just Atlas.
+
+**Why Atlas?**
+- Free tier (M0) — no credit card, never expires
+- Atlas Vector Search with automated embedding via Voyage AI (M10+)
+- Global availability, automatic backups, zero maintenance
+- Your data stays in your own database — not a third-party service
+
+### Individual Document Architecture
+
+Every memory item is its own document:
+
+```
+claude_memory collection:
+  ├── type: "working"         — session snapshots (one per session)
+  ├── type: "project_meta"    — project metadata (one per project)
+  ├── type: "developer_meta"  — developer metadata (one per developer)
+  ├── type: "architecture"    — individual decisions
+  ├── type: "pattern"         — individual patterns
+  ├── type: "avoid"           — individual avoid rules
+  ├── type: "thread"          — individual open threads
+  ├── type: "command"         — individual verified commands
+  ├── type: "preference"      — individual developer preferences (cross-project)
+  ├── type: "style"           — individual style rules (cross-project)
+  ├── type: "dev_default"     — individual defaults (cross-project)
+  └── type: "dev_avoid"       — individual developer avoid rules (cross-project)
+```
+
+Each document has its own `searchable_text` field — Atlas generates vector embeddings per item, so search returns the **specific decision** you need, not a truncated snippet of a giant concatenated blob.
+
+### TTL with Renewal
+
+Memories aren't permanent by default. Unused memories expire naturally:
+
+- Every document has a `last_accessed` timestamp
+- When a search returns a document, `last_accessed` is renewed (fire-and-forget)
+- On startup, documents older than `memory_ttl_days` (configurable, default 30 days) are cleaned up
+- `project_meta` and `developer_meta` never expire
+- **Active memories live forever** — only forgotten ones decay
+
+### Deduplication
+
+Two-layer dedup prevents duplicate entries:
+1. Application-level check (`findOne` before `insertOne`)
+2. Unique compound indexes as safety net
+
+---
+
+## Configuration
+
+Config is stored at `~/.claude-memory/config.json`:
+
+```json
+{
+  "atlas_uri": "mongodb+srv://...",
+  "team_memory": false,
+  "memory_ttl_days": 30
+}
+```
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `atlas_uri` | — | MongoDB Atlas connection string |
+| `team_memory` | `false` | Reserved for future team memory features |
+| `memory_ttl_days` | `30` | Days before unused memories expire (0 = never) |
+
+You can also set `CLAUDE_MEMORY_ATLAS_URI` as an environment variable or in a `.env` file — the init command auto-detects both.
+
+---
+
+## Atlas Tier Comparison
+
+Claude Memory works on all Atlas tiers. The difference is search precision:
+
+| Feature | Free Tier (M0) | M10+ |
+|---------|---------------|------|
+| Store/recall memory | Yes | Yes |
+| Hooks (startup, pre/post-tool-use, stop) | Yes | Yes |
+| MCP tools (recall, remember, threads, stats) | Yes | Yes |
+| Keyword search (regex matching) | Yes | Yes |
+| TTL with renewal | Yes | Yes |
+| Verified commands with aliases | Yes | Yes |
+| Open threads | Yes | Yes |
+| **Semantic vector search** | No | **Yes** |
+| **Atlas Automated Embedding (Voyage AI)** | No | **Yes** |
+
+**Free tier** uses keyword search — your query terms need to match the words in stored memories. Works well when you search with the same terms you used when storing.
+
+**M10+** adds semantic vector search via Voyage AI auto-embedding. Atlas automatically generates and maintains vector embeddings for every document. This means "what's our production database?" finds "MongoDB Atlas prod-cluster-east with database api_prod" even though the words don't overlap.
+
+**Recommendation:** Start with the free tier. It's fully functional. Upgrade to M10+ if you find keyword search isn't precise enough for your workflow.
+
+---
+
+## Project Identity
+
+Claude Memory identifies projects by hashing the git remote URL (first 16 chars of SHA-256). This means:
+- Same project = same memory, regardless of machine or directory
+- Rename the folder? Memory stays
+- Clone on a different machine? Memory is there
+- Different developer on the same project? Same project memory, different developer preferences
+
+Developer identity is based on hostname + username hash — your preferences follow you across all projects.
+
+---
+
+## File Structure
+
+```
+src/
+  atlas/          — MongoDB Atlas client, indexes, vector search
+  memory/         — CRUD for all memory types
+  hooks/          — Claude Code lifecycle hooks
+  startup/        — Startup banner, context injection, feature search
+  cache/          — In-memory command cache (<1ms lookups)
+  natural-language/ — Intent detection, parsing, routing
+  slash-commands/  — /memory, /recall, /remember, /threads, /stats, /edit
+  editor/         — TUI and file-based memory editors
+  bin/            — CLI entry point + MCP server
+  cleanup.ts      — TTL-based memory expiration
+  config.ts       — Configuration management
+  types.ts        — TypeScript type definitions
+```
+
+---
+
+## Development
+
+```bash
+git clone git@github.com:TheDecipherist/claude-memory.git
+cd claude-memory
+npm install
+npm run build       # Compile TypeScript
+npm run dev         # Watch mode
+npm test            # Run tests (requires Atlas connection)
+npm run lint        # Type check
+```
+
+### Testing
+
+Tests run against a real Atlas cluster (no mocks). Set `CLAUDE_MEMORY_ATLAS_URI` in `.env`:
+
+```
+CLAUDE_MEMORY_ATLAS_URI=mongodb+srv://...
+```
+
+```bash
+npm test                                    # Full suite (270 tests)
+npx vitest run tests/multi-session.test.ts  # Multi-session simulation
+npx vitest run tests/scenarios.test.ts      # Real-world developer scenarios
+npx vitest run tests/context-budget.test.ts # Context budget guarantees
+```
+
+---
+
+## License
+
+MIT
+
+---
+
+**Built by [TheDecipherist](https://github.com/TheDecipherist)** — because Claude should remember what you told it yesterday.

package/dist/acknowledgement.d.ts

@@ -0,0 +1,14 @@
+import type { SummaryItem } from './types.js';
+/**
+ * Save a single summary item to the appropriate memory store.
+ */
+export declare function saveSummaryItem(item: SummaryItem): Promise<void>;
+/**
+ * Save all summary items at once.
+ */
+export declare function saveAllSummaryItems(items: SummaryItem[]): Promise<number>;
+/**
+ * Format the acknowledgement prompt shown to the developer.
+ */
+export declare function buildAcknowledgementPrompt(items: SummaryItem[], formattedSummary: string): string;
+//# sourceMappingURL=acknowledgement.d.ts.map

package/dist/acknowledgement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acknowledgement.d.ts","sourceRoot":"","sources":["../src/acknowledgement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAK9C;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBtE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAS/E;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,WAAW,EAAE,EACpB,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAMR"}

package/dist/acknowledgement.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSummaryItem = saveSummaryItem;
+exports.saveAllSummaryItems = saveAllSummaryItems;
+exports.buildAcknowledgementPrompt = buildAcknowledgementPrompt;
+const project_js_1 = require("./memory/project.js");
+const developer_js_1 = require("./memory/developer.js");
+const threads_js_1 = require("./memory/threads.js");
+/**
+ * Save a single summary item to the appropriate memory store.
+ */
+async function saveSummaryItem(item) {
+    switch (item.category) {
+        case 'ARCHITECTURE':
+            await (0, project_js_1.addArchitectureDecision)(item.content);
+            break;
+        case 'PATTERN':
+            await (0, project_js_1.addPattern)(item.content);
+            break;
+        case 'AVOID':
+            await (0, project_js_1.addAvoid)(item.content);
+            break;
+        case 'OPEN_THREAD':
+            await (0, threads_js_1.createThread)(item.content, 'Detected during session summarization');
+            break;
+        case 'DEVELOPER_PREF':
+            await (0, developer_js_1.addPreference)(item.content);
+            break;
+        // WORKING is handled separately via working memory
+        // TRANSIENT is discarded
+        default:
+            break;
+    }
+}
+/**
+ * Save all summary items at once.
+ */
+async function saveAllSummaryItems(items) {
+    let saved = 0;
+    for (const item of items) {
+        if (item.category !== 'WORKING' && item.category !== 'TRANSIENT') {
+            await saveSummaryItem(item);
+            saved++;
+        }
+    }
+    return saved;
+}
+/**
+ * Format the acknowledgement prompt shown to the developer.
+ */
+function buildAcknowledgementPrompt(items, formattedSummary) {
+    const nonWorking = items.filter((i) => i.category !== 'WORKING' && i.category !== 'TRANSIENT');
+    return `Session complete. ${nonWorking.length} items flagged for memory:\n\n${formattedSummary}\nSave all? (a)  Review individually? (r)  Skip all? (s)`;
+}
+//# sourceMappingURL=acknowledgement.js.map

package/dist/acknowledgement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acknowledgement.js","sourceRoot":"","sources":["../src/acknowledgement.ts"],"names":[],"mappings":";;AAQA,0CAsBC;AAKD,kDASC;AAKD,gEASC;AAzDD,oDAAoF;AACpF,wDAAsD;AACtD,oDAAmD;AAEnD;;GAEG;AACI,KAAK,UAAU,eAAe,CAAC,IAAiB;IACrD,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;QACtB,KAAK,cAAc;YACjB,MAAM,IAAA,oCAAuB,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC5C,MAAM;QACR,KAAK,SAAS;YACZ,MAAM,IAAA,uBAAU,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC/B,MAAM;QACR,KAAK,OAAO;YACV,MAAM,IAAA,qBAAQ,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC7B,MAAM;QACR,KAAK,aAAa;YAChB,MAAM,IAAA,yBAAY,EAAC,IAAI,CAAC,OAAO,EAAE,uCAAuC,CAAC,CAAC;YAC1E,MAAM;QACR,KAAK,gBAAgB;YACnB,MAAM,IAAA,4BAAa,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAClC,MAAM;QACR,mDAAmD;QACnD,yBAAyB;QACzB;YACE,MAAM;IACV,CAAC;AACH,CAAC;AAED;;GAEG;AACI,KAAK,UAAU,mBAAmB,CAAC,KAAoB;IAC5D,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,QAAQ,KAAK,WAAW,EAAE,CAAC;YACjE,MAAM,eAAe,CAAC,IAAI,CAAC,CAAC;YAC5B,KAAK,EAAE,CAAC;QACV,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,SAAgB,0BAA0B,CACxC,KAAoB,EACpB,gBAAwB;IAExB,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAC7B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,QAAQ,KAAK,WAAW,CAC9D,CAAC;IAEF,OAAO,qBAAqB,UAAU,CAAC,MAAM,iCAAiC,gBAAgB,0DAA0D,CAAC;AAC3J,CAAC"}

package/dist/atlas/client.d.ts

@@ -0,0 +1,9 @@
+import { Db, Collection } from 'mongodb';
+import type { MemoryDocument } from '../types.js';
+export declare function connect(uri?: string): Promise<Db>;
+export declare function getCollection(): Promise<Collection<MemoryDocument>>;
+export declare function disconnect(): Promise<void>;
+export declare function testConnection(uri: string): Promise<boolean>;
+export declare function getDbName(): string;
+export declare function getCollectionName(): string;
+//# sourceMappingURL=client.d.ts.map

package/dist/atlas/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/atlas/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,EAAE,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAQlD,wBAAsB,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,CAkBvD;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAGzE;AAED,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAMhD;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAclE;AAED,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/atlas/client.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = connect;
+exports.getCollection = getCollection;
+exports.disconnect = disconnect;
+exports.testConnection = testConnection;
+exports.getDbName = getDbName;
+exports.getCollectionName = getCollectionName;
+const mongodb_1 = require("mongodb");
+const config_js_1 = require("../config.js");
+const DB_NAME = 'claude_memory';
+const COLLECTION_NAME = 'claude_memory';
+let client = null;
+let db = null;
+async function connect(uri) {
+    if (db)
+        return db;
+    const atlasUri = uri || (0, config_js_1.getAtlasUri)();
+    if (!atlasUri) {
+        throw new Error('No Atlas URI configured. Run "claude-memory init" or set CLAUDE_MEMORY_ATLAS_URI.');
+    }
+    client = new mongodb_1.MongoClient(atlasUri, {
+        connectTimeoutMS: 10000,
+        serverSelectionTimeoutMS: 10000,
+    });
+    await client.connect();
+    db = client.db(DB_NAME);
+    return db;
+}
+async function getCollection() {
+    const database = await connect();
+    return database.collection(COLLECTION_NAME);
+}
+async function disconnect() {
+    if (client) {
+        await client.close();
+        client = null;
+        db = null;
+    }
+}
+async function testConnection(uri) {
+    const testClient = new mongodb_1.MongoClient(uri, {
+        connectTimeoutMS: 10000,
+        serverSelectionTimeoutMS: 10000,
+    });
+    try {
+        await testClient.connect();
+        await testClient.db(DB_NAME).command({ ping: 1 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await testClient.close();
+    }
+}
+function getDbName() {
+    return DB_NAME;
+}
+function getCollectionName() {
+    return COLLECTION_NAME;
+}
+//# sourceMappingURL=client.js.map

package/dist/atlas/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/atlas/client.ts"],"names":[],"mappings":";;AAUA,0BAkBC;AAED,sCAGC;AAED,gCAMC;AAED,wCAcC;AAED,8BAEC;AAED,8CAEC;AAjED,qCAAsD;AACtD,4CAA2C;AAG3C,MAAM,OAAO,GAAG,eAAe,CAAC;AAChC,MAAM,eAAe,GAAG,eAAe,CAAC;AAExC,IAAI,MAAM,GAAuB,IAAI,CAAC;AACtC,IAAI,EAAE,GAAc,IAAI,CAAC;AAElB,KAAK,UAAU,OAAO,CAAC,GAAY;IACxC,IAAI,EAAE;QAAE,OAAO,EAAE,CAAC;IAElB,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAA,uBAAW,GAAE,CAAC;IACtC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CACb,mFAAmF,CACpF,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,IAAI,qBAAW,CAAC,QAAQ,EAAE;QACjC,gBAAgB,EAAE,KAAK;QACvB,wBAAwB,EAAE,KAAK;KAChC,CAAC,CAAC;IAEH,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;IACvB,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;IACxB,OAAO,EAAE,CAAC;AACZ,CAAC;AAEM,KAAK,UAAU,aAAa;IACjC,MAAM,QAAQ,GAAG,MAAM,OAAO,EAAE,CAAC;IACjC,OAAO,QAAQ,CAAC,UAAU,CAAiB,eAAe,CAAC,CAAC;AAC9D,CAAC;AAEM,KAAK,UAAU,UAAU;IAC9B,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACrB,MAAM,GAAG,IAAI,CAAC;QACd,EAAE,GAAG,IAAI,CAAC;IACZ,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,cAAc,CAAC,GAAW;IAC9C,MAAM,UAAU,GAAG,IAAI,qBAAW,CAAC,GAAG,EAAE;QACtC,gBAAgB,EAAE,KAAK;QACvB,wBAAwB,EAAE,KAAK;KAChC,CAAC,CAAC;IACH,IAAI,CAAC;QACH,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;QAC3B,MAAM,UAAU,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;QAClD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;YAAS,CAAC;QACT,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC;AACH,CAAC;AAED,SAAgB,SAAS;IACvB,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAgB,iBAAiB;IAC/B,OAAO,eAAe,CAAC;AACzB,CAAC"}

package/dist/atlas/embeddings.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Local embedding generation via HuggingFace Transformers (ONNX).
+ *
+ * Uses all-MiniLM-L6-v2 — a sentence-transformer that produces 384-dimension
+ * vectors. Runs entirely in Node.js, no API keys, no external services.
+ * Model downloads on first use (~23MB) and is cached locally.
+ */
+export declare const EMBEDDING_DIMENSIONS = 384;
+/**
+ * Generate an embedding vector for a text string.
+ * Returns a plain number array of 384 dimensions.
+ */
+export declare function generateEmbedding(text: string): Promise<number[]>;
+/**
+ * Generate embeddings for multiple texts in one batch.
+ */
+export declare function generateEmbeddings(texts: string[]): Promise<number[][]>;
+//# sourceMappingURL=embeddings.d.ts.map

package/dist/atlas/embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.d.ts","sourceRoot":"","sources":["../../src/atlas/embeddings.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAwBxC;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAIvE;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAM7E"}

package/dist/atlas/embeddings.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Local embedding generation via HuggingFace Transformers (ONNX).
+ *
+ * Uses all-MiniLM-L6-v2 — a sentence-transformer that produces 384-dimension
+ * vectors. Runs entirely in Node.js, no API keys, no external services.
+ * Model downloads on first use (~23MB) and is cached locally.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMBEDDING_DIMENSIONS = void 0;
+exports.generateEmbedding = generateEmbedding;
+exports.generateEmbeddings = generateEmbeddings;
+let pipeline = null;
+let loading = null;
+const MODEL_NAME = 'Xenova/all-MiniLM-L6-v2';
+exports.EMBEDDING_DIMENSIONS = 384;
+/**
+ * Initialize the embedding pipeline. Lazy — only loads on first call.
+ * Subsequent calls return the cached pipeline.
+ */
+async function getPipeline() {
+    if (pipeline)
+        return pipeline;
+    if (loading)
+        return loading;
+    loading = (async () => {
+        const { pipeline: createPipeline } = await import('@huggingface/transformers');
+        pipeline = await createPipeline('feature-extraction', MODEL_NAME, {
+            dtype: 'fp32',
+        });
+        return pipeline;
+    })();
+    pipeline = await loading;
+    loading = null;
+    return pipeline;
+}
+/**
+ * Generate an embedding vector for a text string.
+ * Returns a plain number array of 384 dimensions.
+ */
+async function generateEmbedding(text) {
+    const pipe = await getPipeline();
+    const output = await pipe(text, { pooling: 'mean', normalize: true });
+    return Array.from(output.data);
+}
+/**
+ * Generate embeddings for multiple texts in one batch.
+ */
+async function generateEmbeddings(texts) {
+    const results = [];
+    for (const text of texts) {
+        results.push(await generateEmbedding(text));
+    }
+    return results;
+}
+//# sourceMappingURL=embeddings.js.map

package/dist/atlas/embeddings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.js","sourceRoot":"","sources":["../../src/atlas/embeddings.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAkCH,8CAIC;AAKD,gDAMC;AA/CD,IAAI,QAAQ,GAAQ,IAAI,CAAC;AACzB,IAAI,OAAO,GAAwB,IAAI,CAAC;AAExC,MAAM,UAAU,GAAG,yBAAyB,CAAC;AAChC,QAAA,oBAAoB,GAAG,GAAG,CAAC;AAExC;;;GAGG;AACH,KAAK,UAAU,WAAW;IACxB,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAE9B,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAE5B,OAAO,GAAG,CAAC,KAAK,IAAI,EAAE;QACpB,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,2BAA2B,CAAC,CAAC;QAC/E,QAAQ,GAAG,MAAM,cAAc,CAAC,oBAAoB,EAAE,UAAU,EAAE;YAChE,KAAK,EAAE,MAAM;SACd,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC,EAAE,CAAC;IAEL,QAAQ,GAAG,MAAM,OAAO,CAAC;IACzB,OAAO,GAAG,IAAI,CAAC;IACf,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;GAGG;AACI,KAAK,UAAU,iBAAiB,CAAC,IAAY;IAClD,MAAM,IAAI,GAAG,MAAM,WAAW,EAAE,CAAC;IACjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACtE,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAoB,CAAC,CAAC;AACjD,CAAC;AAED;;GAEG;AACI,KAAK,UAAU,kBAAkB,CAAC,KAAe;IACtD,MAAM,OAAO,GAAe,EAAE,CAAC;IAC/B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,OAAO,CAAC,IAAI,CAAC,MAAM,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9C,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/atlas/indexes.d.ts

@@ -0,0 +1,4 @@
+import { Db } from 'mongodb';
+export declare function createIndexes(db: Db): Promise<void>;
+export declare function createVectorSearchIndex(db: Db): Promise<void>;
+//# sourceMappingURL=indexes.d.ts.map

package/dist/atlas/indexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.d.ts","sourceRoot":"","sources":["../../src/atlas/indexes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAI7B,wBAAsB,aAAa,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsEzD;AAED,wBAAsB,uBAAuB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAgCnE"}