loki-mode 6.3.1 → 6.5.0

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '6.3.1'
+__version__ = '6.5.0'

package/mcp/server.py

@@ -20,6 +20,7 @@ import os
 import json
 import logging
 import threading
+import uuid
 from datetime import datetime, timezone
 from typing import Optional, List, Dict, Any
 
@@ -563,11 +564,11 @@ async def loki_memory_store_pattern(
         from memory.schemas import SemanticPattern
 
         base_path = safe_path_join('.loki', 'memory')
-        engine = MemoryEngine(base_path)
+        engine = MemoryEngine(base_path=base_path)
         engine.initialize()
 
         pattern_obj = SemanticPattern(
-            id=f"pattern-{datetime.now(timezone.utc).strftime('%Y%m%d%H%M%S')}",
+            id=f"pattern-{datetime.now(timezone.utc).strftime('%Y%m%d%H%M%S')}-{uuid.uuid4().hex[:8]}",
             pattern=pattern,
             category=category,
             conditions=[],
@@ -821,7 +822,7 @@ async def loki_state_get() -> str:
         try:
             from memory.engine import MemoryEngine
             memory_path = safe_path_join('.loki', 'memory')
-            engine = MemoryEngine(memory_path)
+            engine = MemoryEngine(base_path=memory_path)
             state["memory_stats"] = engine.get_stats()
         except Exception:
             state["memory_stats"] = None
@@ -1004,9 +1005,13 @@ async def loki_start_project(prd_content: str = "", prd_path: str = "") -> str:
     try:
         content = prd_content
         if not content and prd_path:
-            resolved = safe_path_join('.', prd_path)
-            if os.path.exists(resolved):
-                with safe_open(resolved, 'r') as f:
+            # Resolve relative paths against project root, absolute paths used as-is
+            if os.path.isabs(prd_path):
+                resolved = os.path.realpath(prd_path)
+            else:
+                resolved = os.path.realpath(os.path.join(get_project_root(), prd_path))
+            if os.path.exists(resolved) and os.path.isfile(resolved):
+                with open(resolved, 'r', encoding='utf-8') as f:
                     content = f.read()
             else:
                 return json.dumps({"error": f"PRD file not found: {prd_path}"})

package/memory/embeddings.py

@@ -307,6 +307,10 @@ class TextChunker:
         if len(text) <= max_size:
             return [text]
 
+        # Guard against infinite loop when overlap >= max_size
+        if overlap >= max_size:
+            overlap = 0
+
         chunks = []
         start = 0
         while start < len(text):
@@ -1062,12 +1066,17 @@ class EmbeddingEngine:
         # Find texts that need computing
         texts_to_compute = []
         indices_to_compute = []
-        for i, (text, key) in enumerate(zip(texts, cache_keys)):
-            if not self.config.cache_enabled or cached_results.get(key) is None:
-                texts_to_compute.append(text)
-                indices_to_compute.append(i)
-            else:
-                self._metrics["cache_hits"] += 1
+        if not self.config.cache_enabled:
+            # No cache - all texts need computing
+            texts_to_compute = list(texts)
+            indices_to_compute = list(range(len(texts)))
+        else:
+            for i, (text, key) in enumerate(zip(texts, cache_keys)):
+                if cached_results.get(key) is None:
+                    texts_to_compute.append(text)
+                    indices_to_compute.append(i)
+                else:
+                    self._metrics["cache_hits"] += 1
 
         # Compute missing embeddings
         new_embeddings = None

package/memory/engine.py

@@ -881,6 +881,21 @@ class MemoryEngine:
             for e in errors_raw
         ]
 
+        # Parse last_accessed datetime
+        last_accessed = None
+        last_accessed_raw = data.get("last_accessed")
+        if last_accessed_raw:
+            if isinstance(last_accessed_raw, str):
+                if last_accessed_raw.endswith("Z"):
+                    last_accessed_raw = last_accessed_raw[:-1]
+                last_accessed = datetime.fromisoformat(last_accessed_raw)
+                if last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
+            elif isinstance(last_accessed_raw, datetime):
+                last_accessed = last_accessed_raw
+                if last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
+
         return EpisodeTrace(
             id=data.get("id", ""),
             task_id=data.get("task_id", ""),
@@ -897,6 +912,9 @@ class MemoryEngine:
             tokens_used=data.get("tokens_used", 0),
             files_read=data.get("files_read", context.get("files_involved", [])),
             files_modified=data.get("files_modified", []),
+            importance=data.get("importance", 0.5),
+            last_accessed=last_accessed,
+            access_count=data.get("access_count", 0),
         )
 
     def _dict_to_pattern(self, data: Dict[str, Any]) -> SemanticPattern:
@@ -924,6 +942,21 @@ class MemoryEngine:
             for link in links_raw
         ]
 
+        # Parse last_accessed datetime
+        last_accessed = None
+        last_accessed_raw = data.get("last_accessed")
+        if last_accessed_raw:
+            if isinstance(last_accessed_raw, str):
+                if last_accessed_raw.endswith("Z"):
+                    last_accessed_raw = last_accessed_raw[:-1]
+                last_accessed = datetime.fromisoformat(last_accessed_raw)
+                if last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
+            elif isinstance(last_accessed_raw, datetime):
+                last_accessed = last_accessed_raw
+                if last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
+
         return SemanticPattern(
             id=data.get("id", ""),
             pattern=data.get("pattern", ""),
@@ -936,6 +969,9 @@ class MemoryEngine:
             usage_count=data.get("usage_count", 0),
             last_used=last_used,
             links=links,
+            importance=data.get("importance", 0.5),
+            last_accessed=last_accessed,
+            access_count=data.get("access_count", 0),
         )
 
     def _dict_to_skill(self, data: Dict[str, Any]) -> ProceduralSkill:
@@ -945,6 +981,22 @@ class MemoryEngine:
             ErrorFix.from_dict(e) if isinstance(e, dict) else e
             for e in raw_errors
         ]
+
+        # Parse last_accessed datetime
+        last_accessed = None
+        last_accessed_raw = data.get("last_accessed")
+        if last_accessed_raw:
+            if isinstance(last_accessed_raw, str):
+                if last_accessed_raw.endswith("Z"):
+                    last_accessed_raw = last_accessed_raw[:-1]
+                last_accessed = datetime.fromisoformat(last_accessed_raw)
+                if last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
+            elif isinstance(last_accessed_raw, datetime):
+                last_accessed = last_accessed_raw
+                if last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
+
         return ProceduralSkill(
             id=data.get("id", ""),
             name=data.get("name", ""),
@@ -953,6 +1005,10 @@ class MemoryEngine:
             steps=data.get("steps", []),
             common_errors=common_errors,
             exit_criteria=data.get("exit_criteria", []),
+            example_usage=data.get("example_usage"),
+            importance=data.get("importance", 0.5),
+            last_accessed=last_accessed,
+            access_count=data.get("access_count", 0),
         )
 
     def _skill_to_markdown(self, skill: Dict[str, Any]) -> str:

package/memory/schemas.py

@@ -20,9 +20,13 @@ from typing import Optional, List, Dict, Any
 def _to_utc_isoformat(dt: datetime) -> str:
     """Convert datetime to UTC ISO 8601 string with Z suffix.
 
-    Handles both timezone-aware and timezone-naive datetimes,
-    and avoids double-suffixing if already has timezone info.
+    Handles both timezone-aware and timezone-naive datetimes.
+    If dt has a non-UTC timezone, converts to UTC first.
     """
+    # If timezone-aware and not UTC, convert to UTC
+    if dt.tzinfo is not None and dt.utcoffset() != timezone.utc.utcoffset(None):
+        dt = dt.astimezone(timezone.utc)
+
     iso = dt.isoformat()
     # If already has timezone offset like +00:00, replace with Z
     if iso.endswith("+00:00"):

package/memory/storage.py

@@ -233,7 +233,7 @@ class MemoryStorage:
             path: Path to JSON file
 
         Returns:
-            Parsed JSON as dictionary, or None if file doesn't exist
+            Parsed JSON as dictionary, or None if file doesn't exist or is corrupted
         """
         path = Path(path)
         if not path.exists():
@@ -241,7 +241,10 @@ class MemoryStorage:
 
         with self._file_lock(path, exclusive=False):
             with open(path, "r") as f:
-                return json.load(f)
+                try:
+                    return json.load(f)
+                except json.JSONDecodeError:
+                    return None
 
     def _generate_id(self, prefix: str) -> str:
         """

package/memory/token_economics.py

@@ -505,9 +505,12 @@ class TokenEconomics:
             Ratio of discovery_tokens / read_tokens (0.0 if no reads)
         """
         read_tokens = self.metrics["read_tokens"]
+        discovery_tokens = self.metrics["discovery_tokens"]
         if read_tokens == 0:
+            if discovery_tokens > 0:
+                return 999.99  # Sentinel: all discovery, no productive reads
             return 0.0
-        return self.metrics["discovery_tokens"] / read_tokens
+        return discovery_tokens / read_tokens
 
     def get_savings_percent(self) -> float:
         """

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "6.3.1",
+  "version": "6.5.0",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",