@bonginkan/maria 1.8.10 → 1.8.12

package/dist/bin/maria.js

@@ -8266,6 +8266,15 @@ var init_dual_memory_engine = __esm({
       processingLock = false;
       performanceCache = /* @__PURE__ */ new Map();
       constructor(config2) {
+        if (!config2) {
+          throw new Error("DualMemoryEngine: config parameter is required");
+        }
+        if (!config2.system1) {
+          throw new Error("DualMemoryEngine: config.system1 is required");
+        }
+        if (!config2.system2) {
+          throw new Error("DualMemoryEngine: config.system2 is required");
+        }
         this.config = config2;
         this.system1 = new System1MemoryManager(config2.system1);
         this.system2 = new System2MemoryManager(config2.system2);
@@ -8371,6 +8380,30 @@ var init_dual_memory_engine = __esm({
           urgency: "high"
         });
       }
+      async recall(options) {
+        try {
+          const result = await this.query({
+            type: options.type,
+            query: options.query,
+            limit: options.limit || 10
+          });
+          return Array.isArray(result.data) ? result.data : [result.data];
+        } catch (error) {
+          console.warn("Memory recall failed:", error);
+          return [];
+        }
+      }
+      async clearMemory() {
+        try {
+          this.performanceCache.clear();
+          this.eventQueue.length = 0;
+          this.resetMetrics();
+          console.log("Memory cleared successfully");
+        } catch (error) {
+          console.error("Failed to clear memory:", error);
+          throw error;
+        }
+      }
       // ========== Memory Strategy Selection ==========
       async selectMemoryStrategy(query) {
         const factors = {
@@ -8773,6 +8806,17 @@ var init_dual_memory_engine = __esm({
       getQueueSize() {
         return this.eventQueue.length;
       }
+      // ========== Initialization ==========
+      async initialize() {
+        try {
+          this.resetMetrics();
+          this.performanceCache.clear();
+          console.log("DualMemoryEngine initialized successfully");
+        } catch (error) {
+          console.error("Failed to initialize DualMemoryEngine:", error);
+          throw error;
+        }
+      }
       // ========== Configuration Management ==========
       updateConfig(newConfig) {
         Object.assign(this.config, newConfig);
@@ -8780,6 +8824,49 @@ var init_dual_memory_engine = __esm({
       getConfig() {
         return { ...this.config };
       }
+      async getStatistics() {
+        try {
+          const metrics = this.getMetrics();
+          const system1Stats = {
+            totalNodes: 0,
+            // Will be populated when system1 interface is stable
+            patterns: 0,
+            // Will be populated when system1 interface is stable
+            preferences: 0,
+            // Will be populated when system1 interface is stable
+            cacheHitRate: metrics.cacheHitRate || 0
+          };
+          const system2Stats = {
+            reasoningTraces: 0,
+            // Will be populated when system2 interface is stable
+            decisionTrees: 0,
+            // Will be populated when system2 interface is stable
+            activeSessions: 0,
+            // Will be populated when system2 interface is stable
+            memoryUsage: 0
+            // Will be populated when system2 interface is stable
+          };
+          return {
+            system1: system1Stats,
+            system2: system2Stats
+          };
+        } catch (error) {
+          return {
+            system1: {
+              totalNodes: 0,
+              patterns: 0,
+              preferences: 0,
+              cacheHitRate: 0
+            },
+            system2: {
+              reasoningTraces: 0,
+              decisionTrees: 0,
+              activeSessions: 0,
+              memoryUsage: 0
+            }
+          };
+        }
+      }
     };
   }
 });
@@ -24987,15 +25074,59 @@ function createInteractiveSession(maria) {
       running = true;
       try {
         console.log(chalk13__default.default.cyan("\u{1F9E0} Initializing Memory System..."));
-        memoryEngine2 = new DualMemoryEngine();
+        const memoryConfig = {
+          system1: {
+            maxKnowledgeNodes: 1e3,
+            embeddingDimension: 1536,
+            cacheSize: 100,
+            compressionThreshold: 0.75,
+            accessDecayRate: 0.03
+          },
+          system2: {
+            maxReasoningTraces: 100,
+            qualityThreshold: 0.75,
+            reflectionFrequency: 12,
+            enhancementEvaluationInterval: 6
+          },
+          coordinator: {
+            syncInterval: 5e3,
+            conflictResolutionStrategy: "balanced",
+            learningRate: 0.15,
+            adaptationThreshold: 0.7
+          },
+          performance: {
+            targetLatency: 50,
+            maxMemoryUsage: 256,
+            cacheStrategy: "lru",
+            preloadPriority: "medium",
+            backgroundOptimization: true,
+            batchSize: 10
+          }
+        };
+        if (!memoryConfig || !memoryConfig.system1 || !memoryConfig.system2) {
+          throw new Error("Invalid memory configuration: missing required sections");
+        }
+        memoryEngine2 = new DualMemoryEngine(memoryConfig);
         memoryCoordinator2 = new MemoryCoordinator(memoryEngine2);
-        maria.setMemorySystem(memoryEngine2, memoryCoordinator2);
+        if (maria && typeof maria.setMemorySystem === "function") {
+          maria.setMemorySystem(memoryEngine2, memoryCoordinator2);
+        }
         Promise.resolve().then(async () => {
-          await memoryEngine2?.initialize();
-          console.log(chalk13__default.default.green("\u2705 Memory System initialized"));
+          try {
+            if (memoryEngine2 && typeof memoryEngine2.initialize === "function") {
+              await memoryEngine2.initialize();
+              console.log(chalk13__default.default.green("\u2705 Memory System initialized"));
+            } else {
+              console.log(chalk13__default.default.green("\u2705 Memory System created (no initialization required)"));
+            }
+          } catch (initError) {
+            console.warn(chalk13__default.default.yellow("\u26A0\uFE0F Memory System initialization failed:"), initError);
+          }
         });
       } catch (error) {
-        console.warn(chalk13__default.default.yellow("\u26A0\uFE0F Memory System initialization deferred:", error));
+        console.warn(chalk13__default.default.yellow("\u26A0\uFE0F Memory System initialization deferred:"), error);
+        memoryEngine2 = null;
+        memoryCoordinator2 = null;
       }
       const { BackgroundAIChecker: BackgroundAIChecker2 } = await Promise.resolve().then(() => (init_background_ai_checker(), background_ai_checker_exports));
       BackgroundAIChecker2.startBackgroundCheck();
@@ -25049,8 +25180,12 @@ function createInteractiveSession(maria) {
           process.stdout.write(chalk13__default.default.gray("Thinking..."));
           try {
             const stream = maria.chatStream(message);
-            process.stdout.write("\r" + TEXT_HIERARCHY.SUBTITLE("MARIA: "));
+            let isFirstChunk = true;
             for await (const chunk of stream) {
+              if (isFirstChunk) {
+                process.stdout.write("\r" + TEXT_HIERARCHY.SUBTITLE("MARIA: "));
+                isFirstChunk = false;
+              }
               process.stdout.write(chunk);
             }
             console.log("\n");
@@ -28190,7 +28325,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@bonginkan/maria",
-      version: "1.8.10",
+      version: "1.8.12",
       description: "Enterprise-Grade AI Development Platform - Intelligent CLI with Complete Local AI Integration (Ollama + vLLM + LM Studio), 50 Cognitive Modes, Vector-based Code Search, and Comprehensive Quality Analysis",
       keywords: [
         "ai",