@sparkleideas/memory 3.0.0-alpha.10 → 3.0.0-alpha.20

package/benchmarks/vector-search.bench.ts

@@ -360,7 +360,7 @@ export const vectorSearchOptimizations = {
     description: 'Use HNSW for O(log n) approximate nearest neighbor search',
     expectedImprovement: '150x-12500x',
     implementation: `
-      import { HNSW } from '@sparkleideas/agentdb';
+      import { HNSW } from 'agentdb';
 
       const index = new HNSW({
         dimensions: 384,

package/examples/agentdb-example.ts

@@ -1,7 +1,7 @@
 /**
  * AgentDB Backend Example
  *
- * Demonstrates @sparkleideas/agentdb@2.0.0-alpha.3.4 integration with V3 memory system
+ * Demonstrates agentdb@2.0.0-alpha.3.4 integration with V3 memory system
  */
 
 import { AgentDBBackend, HybridBackend, createDefaultEntry } from '../src/index.js';
@@ -119,7 +119,7 @@ async function hybridExample() {
     sqlite: {
       dbPath: ':memory:',
     },
-    @sparkleideas/agentdb: {
+    agentdb: {
       dbPath: ':memory:',
       vectorDimension: 384,
       hnswM: 16,
@@ -278,7 +278,7 @@ async function vectorSearchExample() {
 async function gracefulDegradationExample() {
   console.log('\n=== Graceful Degradation Example ===\n');
 
-  // Create backend that might not have @sparkleideas/agentdb
+  // Create backend that might not have agentdb
   const backend = new AgentDBBackend({
     dbPath: ':memory:',
   });
@@ -290,7 +290,7 @@ async function gracefulDegradationExample() {
     console.log('✓ AgentDB available - using HNSW indexing');
   } else {
     console.log('⚠ AgentDB not available - using fallback in-memory storage');
-    console.log('  (Install: npm install @sparkleideas/agentdb@2.0.0-alpha.3.4)');
+    console.log('  (Install: npm install agentdb@2.0.0-alpha.3.4)');
   }
 
   // Store entries (works either way)
@@ -319,7 +319,7 @@ async function gracefulDegradationExample() {
 async function main() {
   console.log('╔═══════════════════════════════════════════════════════════╗');
   console.log('║  AgentDB Integration Examples                             ║');
-  console.log('║  V3 Memory Module with @sparkleideas/agentdb@2.0.0-alpha.3.4            ║');
+  console.log('║  V3 Memory Module with agentdb@2.0.0-alpha.3.4            ║');
   console.log('╚═══════════════════════════════════════════════════════════╝');
 
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparkleideas/memory",
-  "version": "3.0.0-alpha.10",
+  "version": "3.0.0-alpha.20",
   "type": "module",
   "description": "Memory module - AgentDB unification, HNSW indexing, vector search, hybrid SQLite+AgentDB backend (ADR-009)",
   "main": "dist/index.js",

package/src/agentdb-backend.test.ts

@@ -1,7 +1,7 @@
 /**
  * AgentDB Backend Tests
  *
- * Tests for @sparkleideas/agentdb@2.0.0-alpha.3.4 integration with V3 memory system
+ * Tests for agentdb@2.0.0-alpha.3.4 integration with V3 memory system
  */
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
@@ -29,7 +29,7 @@ describe('AgentDBBackend', () => {
       expect(backend).toBeDefined();
     });
 
-    it('should handle missing @sparkleideas/agentdb gracefully', async () => {
+    it('should handle missing agentdb gracefully', async () => {
       const fallbackBackend = new AgentDBBackend();
       await fallbackBackend.initialize();
 
@@ -177,7 +177,7 @@ describe('AgentDBBackend', () => {
   });
 
   describe('Vector Search', () => {
-    it('should perform brute-force search when @sparkleideas/agentdb unavailable', async () => {
+    it('should perform brute-force search when agentdb unavailable', async () => {
       const entry = createDefaultEntry({
         key: 'vector-test',
         content: 'Vector content',
@@ -311,7 +311,7 @@ describe('AgentDBBackend', () => {
   });
 
   describe('Graceful Degradation', () => {
-    it('should work without @sparkleideas/agentdb package', async () => {
+    it('should work without agentdb package', async () => {
       const fallbackBackend = new AgentDBBackend({
         dbPath: ':memory:',
       });

package/src/agentdb-backend.ts

@@ -1,5 +1,5 @@
 /**
- * AgentDB Backend - Integration with @sparkleideas/agentdb@2.0.0-alpha.3.4
+ * AgentDB Backend - Integration with agentdb@2.0.0-alpha.3.4
  *
  * Provides IMemoryBackend implementation using AgentDB with:
  * - HNSW vector search (150x-12,500x faster than brute-force)
@@ -36,14 +36,14 @@ let AgentDB: any;
 let HNSWIndex: any;
 let isHnswlibAvailable: (() => Promise<boolean>) | undefined;
 
-// Dynamically import @sparkleideas/agentdb (handled at runtime)
+// Dynamically import agentdb (handled at runtime)
 let agentdbImportPromise: Promise<void> | undefined;
 
 function ensureAgentDBImport(): Promise<void> {
   if (!agentdbImportPromise) {
     agentdbImportPromise = (async () => {
       try {
-        const agentdbModule = await import('@sparkleideas/agentdb');
+        const agentdbModule = await import('agentdb');
         AgentDB = agentdbModule.AgentDB || agentdbModule.default;
         HNSWIndex = agentdbModule.HNSWIndex;
         isHnswlibAvailable = agentdbModule.isHnswlibAvailable;
@@ -134,7 +134,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     dbPath?: string;
     embeddingGenerator?: EmbeddingGenerator;
   };
-  private @sparkleideas/agentdb: any;
+  private agentdb: any;
   private initialized: boolean = false;
   private available: boolean = false;
 
@@ -179,7 +179,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
 
     try {
       // Initialize AgentDB with config
-      this.@sparkleideas/agentdb = new AgentDB({
+      this.agentdb = new AgentDB({
         dbPath: this.config.dbPath || ':memory:',
         namespace: this.config.namespace,
         forceWasm: this.config.forceWasm,
@@ -187,15 +187,15 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
         vectorDimension: this.config.vectorDimension,
       });
 
-      await this.@sparkleideas/agentdb.initialize();
+      await this.agentdb.initialize();
 
       // Create memory_entries table if it doesn't exist
       await this.createSchema();
 
       this.initialized = true;
       this.emit('initialized', {
-        backend: this.@sparkleideas/agentdb.vectorBackendName,
-        isWasm: this.@sparkleideas/agentdb.isWasm,
+        backend: this.agentdb.vectorBackendName,
+        isWasm: this.agentdb.isWasm,
       });
     } catch (error) {
       console.error('Failed to initialize AgentDB:', error);
@@ -211,8 +211,8 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
   async shutdown(): Promise<void> {
     if (!this.initialized) return;
 
-    if (this.@sparkleideas/agentdb) {
-      await this.@sparkleideas/agentdb.close();
+    if (this.agentdb) {
+      await this.agentdb.close();
     }
 
     this.initialized = false;
@@ -238,7 +238,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     this.updateIndexes(entry);
 
     // Store in AgentDB if available
-    if (this.@sparkleideas/agentdb) {
+    if (this.agentdb) {
       await this.storeInAgentDB(entry);
     }
 
@@ -254,7 +254,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     if (cached) return cached;
 
     // Query AgentDB if available
-    if (this.@sparkleideas/agentdb) {
+    if (this.agentdb) {
       return this.getFromAgentDB(id);
     }
 
@@ -311,7 +311,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     entry.version++;
 
     // Update in AgentDB
-    if (this.@sparkleideas/agentdb) {
+    if (this.agentdb) {
       await this.updateInAgentDB(entry);
     }
 
@@ -334,7 +334,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     this.keyIndex.delete(keyIndexKey);
 
     // Delete from AgentDB
-    if (this.@sparkleideas/agentdb) {
+    if (this.agentdb) {
       await this.deleteFromAgentDB(id);
     }
 
@@ -374,7 +374,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
   ): Promise<SearchResult[]> {
     const startTime = performance.now();
 
-    if (!this.@sparkleideas/agentdb) {
+    if (!this.agentdb) {
       // Fallback to brute-force search
       return this.bruteForceSearch(embedding, options);
     }
@@ -473,9 +473,9 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
 
     // Get HNSW stats if available
     let hnswStats: HNSWStats | undefined;
-    if (this.@sparkleideas/agentdb && HNSWIndex) {
+    if (this.agentdb && HNSWIndex) {
       try {
-        const hnsw = this.@sparkleideas/agentdb.getController('hnsw');
+        const hnsw = this.agentdb.getController('hnsw');
         if (hnsw) {
           const stats = hnsw.getStats();
           hnswStats = {
@@ -516,7 +516,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     const recommendations: string[] = [];
 
     // Check AgentDB availability
-    const storageHealth: ComponentHealth = this.@sparkleideas/agentdb
+    const storageHealth: ComponentHealth = this.agentdb
       ? { status: 'healthy', latency: 0 }
       : {
           status: 'degraded',
@@ -526,10 +526,10 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
 
     // Check index health
     const indexHealth: ComponentHealth = { status: 'healthy', latency: 0 };
-    if (!this.@sparkleideas/agentdb) {
+    if (!this.agentdb) {
       indexHealth.status = 'degraded';
       indexHealth.message = 'HNSW index not available';
-      recommendations.push('Install @sparkleideas/agentdb for 150x-12,500x faster vector search');
+      recommendations.push('Install agentdb for 150x-12,500x faster vector search');
     }
 
     // Check cache health
@@ -561,9 +561,9 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
    * Create database schema
    */
   private async createSchema(): Promise<void> {
-    if (!this.@sparkleideas/agentdb) return;
+    if (!this.agentdb) return;
 
-    const db = this.@sparkleideas/agentdb.database;
+    const db = this.agentdb.database;
     if (!db || typeof db.run !== 'function') {
       // AgentDB doesn't expose raw database - using native API
       return;
@@ -608,12 +608,12 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
    * Store entry in AgentDB
    */
   private async storeInAgentDB(entry: MemoryEntry): Promise<void> {
-    if (!this.@sparkleideas/agentdb) return;
+    if (!this.agentdb) return;
 
-    // Try to use @sparkleideas/agentdb's native store method if available
+    // Try to use agentdb's native store method if available
     try {
-      if (typeof this.@sparkleideas/agentdb.store === 'function') {
-        await this.@sparkleideas/agentdb.store(entry.id, {
+      if (typeof this.agentdb.store === 'function') {
+        await this.agentdb.store(entry.id, {
           key: entry.key,
           content: entry.content,
           embedding: entry.embedding,
@@ -626,9 +626,9 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
       }
 
       // Fallback: use database directly if available
-      const db = this.@sparkleideas/agentdb.database;
+      const db = this.agentdb.database;
       if (!db || typeof db.run !== 'function') {
-        // No compatible database interface - skip @sparkleideas/agentdb storage
+        // No compatible database interface - skip agentdb storage
         // Entry is already stored in-memory
         return;
       }
@@ -668,7 +668,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     // Add to vector index if HNSW is available
     if (entry.embedding && HNSWIndex) {
       try {
-        const hnsw = this.@sparkleideas/agentdb.getController('hnsw');
+        const hnsw = this.agentdb.getController('hnsw');
         if (hnsw) {
           // Convert string ID to number for HNSW (use hash)
           const numericId = this.stringIdToNumeric(entry.id);
@@ -684,17 +684,17 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
    * Get entry from AgentDB
    */
   private async getFromAgentDB(id: string): Promise<MemoryEntry | null> {
-    if (!this.@sparkleideas/agentdb) return null;
+    if (!this.agentdb) return null;
 
     try {
       // Try native get method first
-      if (typeof this.@sparkleideas/agentdb.get === 'function') {
-        const data = await this.@sparkleideas/agentdb.get(id);
+      if (typeof this.agentdb.get === 'function') {
+        const data = await this.agentdb.get(id);
         if (data) return this.dataToEntry(id, data);
       }
 
       // Fallback to database
-      const db = this.@sparkleideas/agentdb.database;
+      const db = this.agentdb.database;
       if (!db || typeof db.get !== 'function') return null;
 
       const row = await db.get('SELECT * FROM memory_entries WHERE id = ?', [id]);
@@ -706,7 +706,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
   }
 
   /**
-   * Convert @sparkleideas/agentdb data to MemoryEntry
+   * Convert agentdb data to MemoryEntry
    */
   private dataToEntry(id: string, data: any): MemoryEntry {
     const now = Date.now();
@@ -742,17 +742,17 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
    * Delete entry from AgentDB
    */
   private async deleteFromAgentDB(id: string): Promise<void> {
-    if (!this.@sparkleideas/agentdb) return;
+    if (!this.agentdb) return;
 
     try {
       // Try native delete method first
-      if (typeof this.@sparkleideas/agentdb.delete === 'function') {
-        await this.@sparkleideas/agentdb.delete(id);
+      if (typeof this.agentdb.delete === 'function') {
+        await this.agentdb.delete(id);
         return;
       }
 
       // Fallback to database
-      const db = this.@sparkleideas/agentdb.database;
+      const db = this.agentdb.database;
       if (!db || typeof db.run !== 'function') return;
 
       await db.run('DELETE FROM memory_entries WHERE id = ?', [id]);
@@ -768,12 +768,12 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
     embedding: Float32Array,
     options: SearchOptions
   ): Promise<SearchResult[]> {
-    if (!this.@sparkleideas/agentdb || !HNSWIndex) {
+    if (!this.agentdb || !HNSWIndex) {
       return [];
     }
 
     try {
-      const hnsw = this.@sparkleideas/agentdb.getController('hnsw');
+      const hnsw = this.agentdb.getController('hnsw');
       if (!hnsw) {
         return this.bruteForceSearch(embedding, options);
       }
@@ -1009,7 +1009,7 @@ export class AgentDBBackend extends EventEmitter implements IMemoryBackend {
    * Get underlying AgentDB instance
    */
   getAgentDB(): any {
-    return this.@sparkleideas/agentdb;
+    return this.agentdb;
   }
 }
 

package/src/hybrid-backend.test.ts

@@ -28,7 +28,7 @@ describe('HybridBackend - ADR-009', () => {
         databasePath: ':memory:', // In-memory for testing
         verbose: false,
       },
-      @sparkleideas/agentdb: {
+      agentdb: {
         vectorDimension: 128,
       },
       embeddingGenerator: mockEmbedding,

package/src/hybrid-backend.ts

@@ -35,7 +35,7 @@ export interface HybridBackendConfig {
   sqlite?: Partial<SQLiteBackendConfig>;
 
   /** AgentDB configuration */
-  @sparkleideas/agentdb?: Partial<AgentDBBackendConfig>;
+  agentdb?: Partial<AgentDBBackendConfig>;
 
   /** Default namespace */
   defaultNamespace?: string;
@@ -61,7 +61,7 @@ export interface HybridBackendConfig {
  */
 const DEFAULT_CONFIG: Required<HybridBackendConfig> = {
   sqlite: {},
-  @sparkleideas/agentdb: {},
+  agentdb: {},
   defaultNamespace: 'default',
   embeddingGenerator: undefined as any,
   routingStrategy: 'auto',
@@ -153,7 +153,7 @@ export interface HybridQuery {
  */
 export class HybridBackend extends EventEmitter implements IMemoryBackend {
   private sqlite: SQLiteBackend;
-  private @sparkleideas/agentdb: AgentDBBackend;
+  private agentdb: AgentDBBackend;
   private config: Required<HybridBackendConfig>;
   private initialized: boolean = false;
 
@@ -177,8 +177,8 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
     });
 
     // Initialize AgentDB backend
-    this.@sparkleideas/agentdb = new AgentDBBackend({
-      ...this.config.@sparkleideas/agentdb,
+    this.agentdb = new AgentDBBackend({
+      ...this.config.agentdb,
       namespace: this.config.defaultNamespace,
       embeddingGenerator: this.config.embeddingGenerator,
     });
@@ -188,11 +188,11 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
     this.sqlite.on('entry:updated', (data) => this.emit('sqlite:updated', data));
     this.sqlite.on('entry:deleted', (data) => this.emit('sqlite:deleted', data));
 
-    this.@sparkleideas/agentdb.on('entry:stored', (data) => this.emit('@sparkleideas/agentdb:stored', data));
-    this.@sparkleideas/agentdb.on('entry:updated', (data) => this.emit('@sparkleideas/agentdb:updated', data));
-    this.@sparkleideas/agentdb.on('entry:deleted', (data) => this.emit('@sparkleideas/agentdb:deleted', data));
-    this.@sparkleideas/agentdb.on('cache:hit', (data) => this.emit('cache:hit', data));
-    this.@sparkleideas/agentdb.on('cache:miss', (data) => this.emit('cache:miss', data));
+    this.agentdb.on('entry:stored', (data) => this.emit('agentdb:stored', data));
+    this.agentdb.on('entry:updated', (data) => this.emit('agentdb:updated', data));
+    this.agentdb.on('entry:deleted', (data) => this.emit('agentdb:deleted', data));
+    this.agentdb.on('cache:hit', (data) => this.emit('cache:hit', data));
+    this.agentdb.on('cache:miss', (data) => this.emit('cache:miss', data));
   }
 
   /**
@@ -201,7 +201,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
   async initialize(): Promise<void> {
     if (this.initialized) return;
 
-    await Promise.all([this.sqlite.initialize(), this.@sparkleideas/agentdb.initialize()]);
+    await Promise.all([this.sqlite.initialize(), this.agentdb.initialize()]);
 
     this.initialized = true;
     this.emit('initialized');
@@ -213,7 +213,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
   async shutdown(): Promise<void> {
     if (!this.initialized) return;
 
-    await Promise.all([this.sqlite.shutdown(), this.@sparkleideas/agentdb.shutdown()]);
+    await Promise.all([this.sqlite.shutdown(), this.agentdb.shutdown()]);
 
     this.initialized = false;
     this.emit('shutdown');
@@ -225,10 +225,10 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
   async store(entry: MemoryEntry): Promise<void> {
     if (this.config.dualWrite) {
       // Write to both backends in parallel
-      await Promise.all([this.sqlite.store(entry), this.@sparkleideas/agentdb.store(entry)]);
+      await Promise.all([this.sqlite.store(entry), this.agentdb.store(entry)]);
     } else {
       // Write to primary backend only (AgentDB has vector search)
-      await this.@sparkleideas/agentdb.store(entry);
+      await this.agentdb.store(entry);
     }
 
     this.emit('entry:stored', { id: entry.id });
@@ -238,7 +238,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
    * Get from AgentDB (has caching enabled)
    */
   async get(id: string): Promise<MemoryEntry | null> {
-    return this.@sparkleideas/agentdb.get(id);
+    return this.agentdb.get(id);
   }
 
   /**
@@ -256,11 +256,11 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
       // Update both backends
       const [sqliteResult, agentdbResult] = await Promise.all([
         this.sqlite.update(id, update),
-        this.@sparkleideas/agentdb.update(id, update),
+        this.agentdb.update(id, update),
       ]);
       return agentdbResult || sqliteResult;
     } else {
-      return this.@sparkleideas/agentdb.update(id, update);
+      return this.agentdb.update(id, update);
     }
   }
 
@@ -271,11 +271,11 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
     if (this.config.dualWrite) {
       const [sqliteResult, agentdbResult] = await Promise.all([
         this.sqlite.delete(id),
-        this.@sparkleideas/agentdb.delete(id),
+        this.agentdb.delete(id),
       ]);
       return sqliteResult || agentdbResult;
     } else {
-      return this.@sparkleideas/agentdb.delete(id);
+      return this.agentdb.delete(id);
     }
   }
 
@@ -310,7 +310,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
       case 'semantic':
         // AgentDB optimized for semantic search
         this.stats.agentdbQueries++;
-        results = await this.@sparkleideas/agentdb.query(query);
+        results = await this.agentdb.query(query);
         break;
 
       case 'hybrid':
@@ -374,7 +374,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
       throw new Error('SemanticQuery requires either content or embedding');
     }
 
-    const searchResults = await this.@sparkleideas/agentdb.search(embedding, {
+    const searchResults = await this.agentdb.search(embedding, {
       k: query.k || 10,
       threshold: query.threshold || this.config.semanticThreshold,
       filters: query.filters as MemoryQuery | undefined,
@@ -423,7 +423,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
    */
   async search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]> {
     this.stats.agentdbQueries++;
-    return this.@sparkleideas/agentdb.search(embedding, options);
+    return this.agentdb.search(embedding, options);
   }
 
   /**
@@ -431,9 +431,9 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
    */
   async bulkInsert(entries: MemoryEntry[]): Promise<void> {
     if (this.config.dualWrite) {
-      await Promise.all([this.sqlite.bulkInsert(entries), this.@sparkleideas/agentdb.bulkInsert(entries)]);
+      await Promise.all([this.sqlite.bulkInsert(entries), this.agentdb.bulkInsert(entries)]);
     } else {
-      await this.@sparkleideas/agentdb.bulkInsert(entries);
+      await this.agentdb.bulkInsert(entries);
     }
   }
 
@@ -444,11 +444,11 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
     if (this.config.dualWrite) {
       const [sqliteCount, agentdbCount] = await Promise.all([
         this.sqlite.bulkDelete(ids),
-        this.@sparkleideas/agentdb.bulkDelete(ids),
+        this.agentdb.bulkDelete(ids),
       ]);
       return Math.max(sqliteCount, agentdbCount);
     } else {
-      return this.@sparkleideas/agentdb.bulkDelete(ids);
+      return this.agentdb.bulkDelete(ids);
     }
   }
 
@@ -473,11 +473,11 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
     if (this.config.dualWrite) {
       const [sqliteCount, agentdbCount] = await Promise.all([
         this.sqlite.clearNamespace(namespace),
-        this.@sparkleideas/agentdb.clearNamespace(namespace),
+        this.agentdb.clearNamespace(namespace),
       ]);
       return Math.max(sqliteCount, agentdbCount);
     } else {
-      return this.@sparkleideas/agentdb.clearNamespace(namespace);
+      return this.agentdb.clearNamespace(namespace);
     }
   }
 
@@ -487,7 +487,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
   async getStats(): Promise<BackendStats> {
     const [sqliteStats, agentdbStats] = await Promise.all([
       this.sqlite.getStats(),
-      this.@sparkleideas/agentdb.getStats(),
+      this.agentdb.getStats(),
     ]);
 
     return {
@@ -512,7 +512,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
   async healthCheck(): Promise<HealthCheckResult> {
     const [sqliteHealth, agentdbHealth] = await Promise.all([
       this.sqlite.healthCheck(),
-      this.@sparkleideas/agentdb.healthCheck(),
+      this.agentdb.healthCheck(),
     ]);
 
     const allIssues = [...sqliteHealth.issues, ...agentdbHealth.issues];
@@ -558,7 +558,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
     const hasEmbeddingGenerator = typeof this.config.embeddingGenerator === 'function';
     if (query.embedding || (query.content && hasEmbeddingGenerator)) {
       this.stats.agentdbQueries++;
-      return this.@sparkleideas/agentdb.query(query);
+      return this.agentdb.query(query);
     }
 
     // If has exact key or prefix, use structured search (SQLite)
@@ -575,13 +575,13 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
 
       case 'agentdb-first':
         this.stats.agentdbQueries++;
-        return this.@sparkleideas/agentdb.query(query);
+        return this.agentdb.query(query);
 
       case 'auto':
       default:
         // Default to AgentDB (has caching)
         this.stats.agentdbQueries++;
-        return this.@sparkleideas/agentdb.query(query);
+        return this.agentdb.query(query);
     }
   }
 
@@ -687,7 +687,7 @@ export class HybridBackend extends EventEmitter implements IMemoryBackend {
   }
 
   getAgentDBBackend(): AgentDBBackend {
-    return this.@sparkleideas/agentdb;
+    return this.agentdb;
   }
 }