claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/memory/in-memory-store.js

@@ -1,216 +1,164 @@
 /**
  * In-memory store for environments where SQLite is not available
  * Provides the same API as SQLite store but data is not persistent
- */
-
-import { sessionSerializer } from './enhanced-session-serializer.js';
-
-class InMemoryStore {
-  constructor(options = {}) {
-    this.options = options;
-    this.data = new Map(); // namespace -> Map(key -> entry)
-    this.isInitialized = false;
-    this.cleanupInterval = null;
-  }
-
-  async initialize() {
-    if (this.isInitialized) return;
-
-    // Initialize default namespace
-    this.data.set('default', new Map());
-
-    // Start cleanup interval for expired entries
-    this.cleanupInterval = setInterval(() => {
-      this.cleanup().catch((err) =>
-        console.error(`[${new Date().toISOString()}] ERROR [in-memory-store] Cleanup failed:`, err),
-      );
-    }, 60000); // Run cleanup every minute
-
-    this.isInitialized = true;
-    console.error(
-      `[${new Date().toISOString()}] INFO [in-memory-store] Initialized in-memory store`,
-    );
-  }
-
-  _getNamespaceMap(namespace) {
-    if (!this.data.has(namespace)) {
-      this.data.set(namespace, new Map());
-    }
-    return this.data.get(namespace);
-  }
-
-  async store(key, value, options = {}) {
-    await this.initialize();
-
-    const namespace = options.namespace || 'default';
-    const namespaceMap = this._getNamespaceMap(namespace);
-
-    const now = Date.now();
-    const ttl = options.ttl || null;
-    const expiresAt = ttl ? now + ttl * 1000 : null;
-    const valueStr = typeof value === 'string' ? value : sessionSerializer.serializer.serialize(value);
-
-    const entry = {
-      key,
-      value: valueStr,
-      namespace,
-      metadata: options.metadata || null,
-      createdAt: namespaceMap.has(key) ? namespaceMap.get(key).createdAt : now,
-      updatedAt: now,
-      accessedAt: now,
-      accessCount: namespaceMap.has(key) ? namespaceMap.get(key).accessCount + 1 : 1,
-      ttl,
-      expiresAt,
-    };
-
-    namespaceMap.set(key, entry);
-
-    return {
-      success: true,
-      id: `${namespace}:${key}`,
-      size: valueStr.length,
-    };
-  }
-
-  async retrieve(key, options = {}) {
-    await this.initialize();
-
-    const namespace = options.namespace || 'default';
-    const namespaceMap = this._getNamespaceMap(namespace);
-
-    const entry = namespaceMap.get(key);
-
-    if (!entry) {
-      return null;
-    }
-
-    // Check if expired
-    if (entry.expiresAt && entry.expiresAt < Date.now()) {
-      namespaceMap.delete(key);
-      return null;
-    }
-
-    // Update access stats
-    entry.accessedAt = Date.now();
-    entry.accessCount++;
-
-    // Try to deserialize, fall back to raw string
-    try {
-      return sessionSerializer.serializer.deserialize(entry.value);
-    } catch {
-      return entry.value;
-    }
-  }
-
-  async list(options = {}) {
-    await this.initialize();
-
-    const namespace = options.namespace || 'default';
-    const limit = options.limit || 100;
-    const namespaceMap = this._getNamespaceMap(namespace);
-
-    const entries = Array.from(namespaceMap.values())
-      .filter((entry) => !entry.expiresAt || entry.expiresAt > Date.now())
-      .sort((a, b) => b.updatedAt - a.updatedAt)
-      .slice(0, limit);
-
-    return entries.map((entry) => ({
-      key: entry.key,
-      value: this._tryParseJson(entry.value),
-      namespace: entry.namespace,
-      metadata: entry.metadata,
-      createdAt: new Date(entry.createdAt),
-      updatedAt: new Date(entry.updatedAt),
-      accessCount: entry.accessCount,
-    }));
-  }
-
-  async delete(key, options = {}) {
-    await this.initialize();
-
-    const namespace = options.namespace || 'default';
-    const namespaceMap = this._getNamespaceMap(namespace);
-
-    return namespaceMap.delete(key);
-  }
-
-  async search(pattern, options = {}) {
-    await this.initialize();
-
-    const namespace = options.namespace || 'default';
-    const limit = options.limit || 50;
-    const namespaceMap = this._getNamespaceMap(namespace);
-
-    const searchLower = pattern.toLowerCase();
-    const results = [];
-
-    for (const [key, entry] of namespaceMap.entries()) {
-      // Skip expired entries
-      if (entry.expiresAt && entry.expiresAt < Date.now()) {
-        continue;
-      }
-
-      // Search in key and value
-      if (
-        key.toLowerCase().includes(searchLower) ||
-        entry.value.toLowerCase().includes(searchLower)
-      ) {
-        results.push({
-          key: entry.key,
-          value: this._tryParseJson(entry.value),
-          namespace: entry.namespace,
-          score: entry.accessCount,
-          updatedAt: new Date(entry.updatedAt),
-        });
-      }
-
-      if (results.length >= limit) {
-        break;
-      }
-    }
-
-    // Sort by score (access count) and updated time
-    return results.sort((a, b) => {
-      if (a.score !== b.score) return b.score - a.score;
-      return b.updatedAt - a.updatedAt;
-    });
-  }
-
-  async cleanup() {
-    await this.initialize();
-
-    let cleaned = 0;
-    const now = Date.now();
-
-    for (const [namespace, namespaceMap] of this.data.entries()) {
-      for (const [key, entry] of namespaceMap.entries()) {
-        if (entry.expiresAt && entry.expiresAt <= now) {
-          namespaceMap.delete(key);
-          cleaned++;
-        }
-      }
-    }
-
-    return cleaned;
-  }
-
-  _tryParseJson(value) {
-    try {
-      return sessionSerializer.serializer.deserialize(value);
-    } catch {
-      return value;
-    }
-  }
-
-  close() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    this.data.clear();
-    this.isInitialized = false;
-  }
-}
-
-export { InMemoryStore };
-export default InMemoryStore;
+ */ import { sessionSerializer } from "./enhanced-session-serializer.js";
+let InMemoryStore = class InMemoryStore {
+    async initialize() {
+        if (this.isInitialized) return;
+        // Initialize default namespace
+        this.data.set('default', new Map());
+        // Start cleanup interval for expired entries
+        this.cleanupInterval = setInterval(()=>{
+            this.cleanup().catch((err)=>console.error(`[${new Date().toISOString()}] ERROR [in-memory-store] Cleanup failed:`, err));
+        }, 60000); // Run cleanup every minute
+        this.isInitialized = true;
+        console.error(`[${new Date().toISOString()}] INFO [in-memory-store] Initialized in-memory store`);
+    }
+    _getNamespaceMap(namespace) {
+        if (!this.data.has(namespace)) {
+            this.data.set(namespace, new Map());
+        }
+        return this.data.get(namespace);
+    }
+    async store(key, value, options = {}) {
+        await this.initialize();
+        const namespace = options.namespace || 'default';
+        const namespaceMap = this._getNamespaceMap(namespace);
+        const now = Date.now();
+        const ttl = options.ttl || null;
+        const expiresAt = ttl ? now + ttl * 1000 : null;
+        const valueStr = typeof value === 'string' ? value : sessionSerializer.serializer.serialize(value);
+        const entry = {
+            key,
+            value: valueStr,
+            namespace,
+            metadata: options.metadata || null,
+            createdAt: namespaceMap.has(key) ? namespaceMap.get(key).createdAt : now,
+            updatedAt: now,
+            accessedAt: now,
+            accessCount: namespaceMap.has(key) ? namespaceMap.get(key).accessCount + 1 : 1,
+            ttl,
+            expiresAt
+        };
+        namespaceMap.set(key, entry);
+        return {
+            success: true,
+            id: `${namespace}:${key}`,
+            size: valueStr.length
+        };
+    }
+    async retrieve(key, options = {}) {
+        await this.initialize();
+        const namespace = options.namespace || 'default';
+        const namespaceMap = this._getNamespaceMap(namespace);
+        const entry = namespaceMap.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check if expired
+        if (entry.expiresAt && entry.expiresAt < Date.now()) {
+            namespaceMap.delete(key);
+            return null;
+        }
+        // Update access stats
+        entry.accessedAt = Date.now();
+        entry.accessCount++;
+        // Try to deserialize, fall back to raw string
+        try {
+            return sessionSerializer.serializer.deserialize(entry.value);
+        } catch  {
+            return entry.value;
+        }
+    }
+    async list(options = {}) {
+        await this.initialize();
+        const namespace = options.namespace || 'default';
+        const limit = options.limit || 100;
+        const namespaceMap = this._getNamespaceMap(namespace);
+        const entries = Array.from(namespaceMap.values()).filter((entry)=>!entry.expiresAt || entry.expiresAt > Date.now()).sort((a, b)=>b.updatedAt - a.updatedAt).slice(0, limit);
+        return entries.map((entry)=>({
+                key: entry.key,
+                value: this._tryParseJson(entry.value),
+                namespace: entry.namespace,
+                metadata: entry.metadata,
+                createdAt: new Date(entry.createdAt),
+                updatedAt: new Date(entry.updatedAt),
+                accessCount: entry.accessCount
+            }));
+    }
+    async delete(key, options = {}) {
+        await this.initialize();
+        const namespace = options.namespace || 'default';
+        const namespaceMap = this._getNamespaceMap(namespace);
+        return namespaceMap.delete(key);
+    }
+    async search(pattern, options = {}) {
+        await this.initialize();
+        const namespace = options.namespace || 'default';
+        const limit = options.limit || 50;
+        const namespaceMap = this._getNamespaceMap(namespace);
+        const searchLower = pattern.toLowerCase();
+        const results = [];
+        for (const [key, entry] of namespaceMap.entries()){
+            // Skip expired entries
+            if (entry.expiresAt && entry.expiresAt < Date.now()) {
+                continue;
+            }
+            // Search in key and value
+            if (key.toLowerCase().includes(searchLower) || entry.value.toLowerCase().includes(searchLower)) {
+                results.push({
+                    key: entry.key,
+                    value: this._tryParseJson(entry.value),
+                    namespace: entry.namespace,
+                    score: entry.accessCount,
+                    updatedAt: new Date(entry.updatedAt)
+                });
+            }
+            if (results.length >= limit) {
+                break;
+            }
+        }
+        // Sort by score (access count) and updated time
+        return results.sort((a, b)=>{
+            if (a.score !== b.score) return b.score - a.score;
+            return b.updatedAt - a.updatedAt;
+        });
+    }
+    async cleanup() {
+        await this.initialize();
+        let cleaned = 0;
+        const now = Date.now();
+        for (const [namespace, namespaceMap] of this.data.entries()){
+            for (const [key, entry] of namespaceMap.entries()){
+                if (entry.expiresAt && entry.expiresAt <= now) {
+                    namespaceMap.delete(key);
+                    cleaned++;
+                }
+            }
+        }
+        return cleaned;
+    }
+    _tryParseJson(value) {
+        try {
+            return sessionSerializer.serializer.deserialize(value);
+        } catch  {
+            return value;
+        }
+    }
+    close() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.data.clear();
+        this.isInitialized = false;
+    }
+    constructor(options = {}){
+        this.options = options;
+        this.data = new Map(); // namespace -> Map(key -> entry)
+        this.isInitialized = false;
+        this.cleanupInterval = null;
+    }
+};
+export { InMemoryStore };
+export default InMemoryStore;