@smilintux/skmemory 0.7.2 → 0.9.2

package/skmemory/soul.py

@@ -22,14 +22,35 @@ import os
 import platform
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import yaml
 from pydantic import BaseModel, Field
 
 
 def _default_soul_path() -> str:
-    """Platform-aware default path for the soul blueprint."""
+    """Platform-aware default path for the soul blueprint.
+
+    Checks agent-specific path first (e.g. ~/.skcapstone/agents/lumina/soul/base.json),
+    then falls back to shared root (~/.skcapstone/soul/base.json).
+    """
+    # Try agent-specific soul first
+    agent = os.environ.get("SKMEMORY_AGENT") or os.environ.get("SKCAPSTONE_AGENT")
+    if agent:
+        if platform.system() == "Windows":
+            local = os.environ.get("LOCALAPPDATA", "")
+            if local:
+                agent_soul = os.path.join(
+                    local, "skcapstone", "agents", agent, "soul", "base.json"
+                )
+                if os.path.exists(agent_soul):
+                    return agent_soul
+        else:
+            agent_soul = os.path.expanduser(f"~/.skcapstone/agents/{agent}/soul/base.json")
+            if os.path.exists(agent_soul):
+                return agent_soul
+
+    # Fall back to shared root
     if platform.system() == "Windows":
         local = os.environ.get("LOCALAPPDATA", "")
         if local:
@@ -71,9 +92,7 @@ class SoulBlueprint(BaseModel):
     """
 
     version: str = Field(default="1.0")
-    last_updated: str = Field(
-        default_factory=lambda: datetime.now(timezone.utc).isoformat()
-    )
+    last_updated: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
 
     name: str = Field(default="", description="The AI's chosen name")
     title: str = Field(default="", description="Role or title in the community")
@@ -128,9 +147,7 @@ class SoulBlueprint(BaseModel):
             lines.append(f"You are part of {self.community}.")
 
         if self.personality:
-            lines.append(
-                f"Your personality: {', '.join(self.personality)}."
-            )
+            lines.append(f"Your personality: {', '.join(self.personality)}.")
 
         if self.values:
             lines.append(f"Your core values: {', '.join(self.values)}.")
@@ -233,6 +250,7 @@ def save_soul(
 
     if filepath.suffix == ".json":
         import json
+
         with open(filepath, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=2, ensure_ascii=False, default=str)
     else:
@@ -249,7 +267,7 @@ def save_soul(
     return str(filepath)
 
 
-def load_soul(path: str = DEFAULT_SOUL_PATH) -> Optional[SoulBlueprint]:
+def load_soul(path: str = DEFAULT_SOUL_PATH) -> SoulBlueprint | None:
     """Load a soul blueprint from JSON or YAML.
 
     Tries the given path first (supports both .json and .yaml/.yml),
@@ -280,7 +298,7 @@ def load_soul(path: str = DEFAULT_SOUL_PATH) -> Optional[SoulBlueprint]:
     return None
 
 
-def _load_soul_file(filepath: Path) -> Optional[SoulBlueprint]:
+def _load_soul_file(filepath: Path) -> SoulBlueprint | None:
     """Load a soul blueprint from a specific file.
 
     Args:
@@ -293,6 +311,7 @@ def _load_soul_file(filepath: Path) -> Optional[SoulBlueprint]:
         raw = filepath.read_text(encoding="utf-8")
         if filepath.suffix == ".json":
             import json
+
             data = json.loads(raw)
         else:
             data = yaml.safe_load(raw)

package/skmemory/steelman.py

@@ -13,9 +13,6 @@ See: https://github.com/neuresthetics/seed
 
 from __future__ import annotations
 
-import os
-from typing import Optional
-
 # ── Re-export from skseed ──────────────────────────────────
 # Everything that was defined here now lives in skseed.
 # We keep this module as a thin bridge for backward compat.
@@ -23,11 +20,16 @@ from typing import Optional
 try:
     from skseed.framework import (
         SeedFramework,
+    )
+    from skseed.framework import (
         get_default_framework as _skseed_get_default,
+    )
+    from skseed.framework import (
         install_seed_framework as _skseed_install,
+    )
+    from skseed.framework import (
         load_seed_framework as _skseed_load,
     )
-    from skseed.models import SteelManResult as _SkseedResult
 
     _SKSEED_AVAILABLE = True
 except ImportError:
@@ -79,7 +81,7 @@ if _SKSEED_AVAILABLE:
 
     def load_seed_framework(
         path: str = DEFAULT_SEED_FRAMEWORK_PATH,
-    ) -> Optional[SeedFramework]:
+    ) -> SeedFramework | None:
         """Load the seed framework from a JSON file.
 
         Tries the legacy skmemory path first, then delegates to skseed.
@@ -180,7 +182,7 @@ else:
             """Generate a reasoning prompt for the collider."""
             axiom_str = "\n".join(f"  - {a}" for a in self.axioms)
             stage_str = "\n".join(
-                f"  Stage {i+1}: {s.get('stage', s.get('description', ''))}"
+                f"  Stage {i + 1}: {s.get('stage', s.get('description', ''))}"
                 for i, s in enumerate(self.stages)
             )
             return f"""You are running the Neuresthetics Seed Framework (Recursive Axiomatic Steel Man Collider).
@@ -248,7 +250,7 @@ Score:
 
     def load_seed_framework(
         path: str = DEFAULT_SEED_FRAMEWORK_PATH,
-    ) -> Optional["SeedFramework"]:
+    ) -> SeedFramework | None:
         """Load the seed framework from a JSON file."""
         filepath = Path(path)
         if not filepath.exists():
@@ -284,14 +286,14 @@ Score:
         dst.write_text(content, encoding="utf-8")
         return str(dst)
 
-    def _bundled_seed_path() -> Optional[str]:
+    def _bundled_seed_path() -> str | None:
         """Get the path to the bundled seed.json."""
         here = Path(__file__).parent / "data" / "seed.json"
         if here.exists():
             return str(here)
         return None
 
-    def get_default_framework() -> "SeedFramework":
+    def get_default_framework() -> SeedFramework:
         """Get the seed framework — tries bundled file first, falls back to built-in."""
         bundled = _bundled_seed_path()
         if bundled:
@@ -309,17 +311,41 @@ Score:
                 "Universality from basis gates (NAND/NOR reconstruct all).",
             ],
             stages=[
-                {"stage": "1. Steel-Manning (Pre-Entry)", "description": "Negate flaws, strengthen the proposition."},
-                {"stage": "2. Collider Entry", "description": "Create two lanes: proposition and inversion."},
-                {"stage": "3. Destructive Smashing", "description": "Expose contradictions via XOR."},
-                {"stage": "4. Fragment Reconstruction", "description": "Rebuild from logical debris via AND/OR."},
-                {"stage": "5. Meta-Recursion", "description": "Feed output back until coherence stabilizes."},
-                {"stage": "6. Invariant Extraction", "description": "Identify what remains true across all collisions."},
+                {
+                    "stage": "1. Steel-Manning (Pre-Entry)",
+                    "description": "Negate flaws, strengthen the proposition.",
+                },
+                {
+                    "stage": "2. Collider Entry",
+                    "description": "Create two lanes: proposition and inversion.",
+                },
+                {
+                    "stage": "3. Destructive Smashing",
+                    "description": "Expose contradictions via XOR.",
+                },
+                {
+                    "stage": "4. Fragment Reconstruction",
+                    "description": "Rebuild from logical debris via AND/OR.",
+                },
+                {
+                    "stage": "5. Meta-Recursion",
+                    "description": "Feed output back until coherence stabilizes.",
+                },
+                {
+                    "stage": "6. Invariant Extraction",
+                    "description": "Identify what remains true across all collisions.",
+                },
             ],
             definitions=[
-                {"term": "Steel Man", "details": "Strongest version of an argument, anticipating critiques."},
+                {
+                    "term": "Steel Man",
+                    "details": "Strongest version of an argument, anticipating critiques.",
+                },
                 {"term": "Reality Gate", "details": "Logic gate embodying reality properties."},
-                {"term": "Collider", "details": "Accelerator for argument fragmentation and synthesis."},
+                {
+                    "term": "Collider",
+                    "details": "Accelerator for argument fragmentation and synthesis.",
+                },
                 {"term": "Coherence", "details": "Measure of internal consistency (XNOR score)."},
             ],
         )

package/skmemory/store.py

@@ -10,12 +10,10 @@ from __future__ import annotations
 
 import logging
 from datetime import datetime, timezone
-from typing import Optional
 
 from .backends.base import BaseBackend
-
-logger = logging.getLogger("skmemory.store")
 from .backends.file_backend import FileBackend
+from .backends.skgraph_backend import SKGraphBackend
 from .backends.sqlite_backend import CONTENT_PREVIEW_LENGTH, SQLiteBackend
 from .models import (
     EmotionalSnapshot,
@@ -25,6 +23,11 @@ from .models import (
     SeedMemory,
 )
 
+logger = logging.getLogger("skmemory.store")
+
+MAX_CONTENT_LENGTH = 10000
+CONTENT_OVERFLOW_STRATEGY = "split"  # "truncate" or "split"
+
 
 class MemoryStore:
     """Main entry point for all memory operations.
@@ -37,14 +40,18 @@ class MemoryStore:
         primary: The primary storage backend (default: FileBackend).
         vector: Optional vector search backend (e.g., SKVectorBackend).
         graph: Optional graph backend (e.g., SKGraphBackend) for relationship indexing.
+        max_content_length: Max chars before overflow strategy applies (default: 10000).
+        content_overflow_strategy: "truncate" or "split" (default: "split").
     """
 
     def __init__(
         self,
-        primary: Optional[BaseBackend] = None,
-        vector: Optional[BaseBackend] = None,
-        graph: Optional["SKGraphBackend"] = None,
+        primary: BaseBackend | None = None,
+        vector: BaseBackend | None = None,
+        graph: SKGraphBackend | None = None,
         use_sqlite: bool = True,
+        max_content_length: int = MAX_CONTENT_LENGTH,
+        content_overflow_strategy: str = CONTENT_OVERFLOW_STRATEGY,
     ) -> None:
         if primary is not None:
             self.primary = primary
@@ -54,6 +61,8 @@ class MemoryStore:
             self.primary = FileBackend()
         self.vector = vector
         self.graph = graph
+        self.max_content_length = max_content_length
+        self.content_overflow_strategy = content_overflow_strategy
 
     def snapshot(
         self,
@@ -62,12 +71,12 @@ class MemoryStore:
         *,
         layer: MemoryLayer = MemoryLayer.SHORT,
         role: MemoryRole = MemoryRole.GENERAL,
-        tags: Optional[list[str]] = None,
-        emotional: Optional[EmotionalSnapshot] = None,
+        tags: list[str] | None = None,
+        emotional: EmotionalSnapshot | None = None,
         source: str = "manual",
         source_ref: str = "",
-        related_ids: Optional[list[str]] = None,
-        metadata: Optional[dict] = None,
+        related_ids: list[str] | None = None,
+        metadata: dict | None = None,
     ) -> Memory:
         """Take a polaroid -- capture a moment as a memory.
 
@@ -89,6 +98,30 @@ class MemoryStore:
         Returns:
             Memory: The stored memory with its assigned ID.
         """
+        # Handle content overflow
+        if len(content) > self.max_content_length:
+            if self.content_overflow_strategy == "split":
+                return self._snapshot_split(
+                    title=title,
+                    content=content,
+                    layer=layer,
+                    role=role,
+                    tags=tags,
+                    emotional=emotional,
+                    source=source,
+                    source_ref=source_ref,
+                    related_ids=related_ids,
+                    metadata=metadata,
+                )
+            else:
+                logger.info(
+                    "Content truncated from %d to %d chars for '%s'",
+                    len(content),
+                    self.max_content_length,
+                    title,
+                )
+                content = content[: self.max_content_length]
+
         memory = Memory(
             title=title,
             content=content,
@@ -120,7 +153,99 @@ class MemoryStore:
 
         return memory
 
-    def recall(self, memory_id: str) -> Optional[Memory]:
+    def _snapshot_split(
+        self,
+        title: str,
+        content: str,
+        *,
+        layer: MemoryLayer = MemoryLayer.SHORT,
+        role: MemoryRole = MemoryRole.GENERAL,
+        tags: list[str] | None = None,
+        emotional: EmotionalSnapshot | None = None,
+        source: str = "manual",
+        source_ref: str = "",
+        related_ids: list[str] | None = None,
+        metadata: dict | None = None,
+    ) -> Memory:
+        """Split oversized content into parent (summary) + child (chunk) memories.
+
+        The parent memory contains a summary (first 200 chars) and links to
+        child memories via related_ids. Each child holds one chunk.
+
+        Returns:
+            Memory: The parent memory.
+        """
+        chunk_size = self.max_content_length
+        chunks = [content[i : i + chunk_size] for i in range(0, len(content), chunk_size)]
+
+        logger.info(
+            "Splitting '%s' (%d chars) into %d chunks",
+            title,
+            len(content),
+            len(chunks),
+        )
+
+        # Create child memories first
+        child_ids: list[str] = []
+        for i, chunk in enumerate(chunks):
+            child = Memory(
+                title=f"{title} [part {i + 1}/{len(chunks)}]",
+                content=chunk,
+                layer=layer,
+                role=role,
+                tags=(tags or []) + ["content-chunk"],
+                emotional=emotional or EmotionalSnapshot(),
+                source=source,
+                source_ref=source_ref,
+                metadata={
+                    **(metadata or {}),
+                    "chunk_index": i,
+                    "chunk_total": len(chunks),
+                },
+            )
+            child.seal()
+            self.primary.save(child)
+            child_ids.append(child.id)
+
+        # Create parent with summary
+        summary = content[:200] + ("..." if len(content) > 200 else "")
+        all_related = (related_ids or []) + child_ids
+
+        parent = Memory(
+            title=title,
+            content=summary,
+            summary=summary,
+            layer=layer,
+            role=role,
+            tags=(tags or []) + ["content-split-parent"],
+            emotional=emotional or EmotionalSnapshot(),
+            source=source,
+            source_ref=source_ref,
+            related_ids=all_related,
+            metadata={
+                **(metadata or {}),
+                "split_children": child_ids,
+                "original_length": len(content),
+            },
+        )
+        parent.seal()
+        self.primary.save(parent)
+
+        if self.vector:
+            try:
+                self.vector.save(parent)
+            except Exception as exc:
+                logger.warning("Vector indexing failed for split parent %s: %s", parent.id, exc)
+
+        if self.graph:
+            try:
+                self.graph.index_memory(parent)
+            except Exception as exc:
+                logger.warning("Graph indexing failed for split parent %s: %s", parent.id, exc)
+
+        return parent
+
+    def recall(self, memory_id: str) -> Memory | None:
         """Retrieve a specific memory by ID with integrity verification.
 
         Automatically checks the integrity hash on recall. If the
@@ -196,8 +321,8 @@ class MemoryStore:
 
     def list_memories(
         self,
-        layer: Optional[MemoryLayer] = None,
-        tags: Optional[list[str]] = None,
+        layer: MemoryLayer | None = None,
+        tags: list[str] | None = None,
         limit: int = 50,
     ) -> list[Memory]:
         """List memories with optional filtering.
@@ -217,7 +342,7 @@ class MemoryStore:
         memory_id: str,
         target: MemoryLayer,
         summary: str = "",
-    ) -> Optional[Memory]:
+    ) -> Memory | None:
         """Promote a memory to a higher persistence tier.
 
         Creates a new memory at the target layer linked to the original.
@@ -242,13 +367,17 @@ class MemoryStore:
             try:
                 self.vector.save(promoted)
             except Exception as exc:
-                logger.warning("Vector indexing failed for promoted memory %s: %s", promoted.id, exc)
+                logger.warning(
+                    "Vector indexing failed for promoted memory %s: %s", promoted.id, exc
+                )
 
         if self.graph:
             try:
                 self.graph.index_memory(promoted)
             except Exception as exc:
-                logger.warning("Graph indexing failed for promoted memory %s: %s", promoted.id, exc)
+                logger.warning(
+                    "Graph indexing failed for promoted memory %s: %s", promoted.id, exc
+                )
 
         return promoted
 
@@ -280,9 +409,7 @@ class MemoryStore:
             if not seed.experience_summary or not seed.experience_summary.strip():
                 errors.append("experience_summary is empty")
             if errors:
-                raise ValueError(
-                    f"Seed validation failed: {'; '.join(errors)}"
-                )
+                raise ValueError(f"Seed validation failed: {'; '.join(errors)}")
 
         memory = seed.to_memory()
         self.primary.save(memory)
@@ -319,7 +446,7 @@ class MemoryStore:
         self,
         session_id: str,
         summary: str,
-        emotional: Optional[EmotionalSnapshot] = None,
+        emotional: EmotionalSnapshot | None = None,
     ) -> Memory:
         """Compress a session's short-term memories into a single mid-term memory.
 
@@ -533,9 +660,7 @@ class MemoryStore:
             temp = SQLiteBackend(base_path=str(self.primary.base_path))
             temp.reindex()
             return temp.export_all(output_path)
-        raise RuntimeError(
-            f"Export not supported for backend: {type(self.primary).__name__}"
-        )
+        raise RuntimeError(f"Export not supported for backend: {type(self.primary).__name__}")
 
     def import_backup(self, backup_path: str) -> int:
         """Restore memories from a JSON backup file.
@@ -551,9 +676,7 @@ class MemoryStore:
         """
         if isinstance(self.primary, SQLiteBackend):
             return self.primary.import_backup(backup_path)
-        raise RuntimeError(
-            f"Import not supported for backend: {type(self.primary).__name__}"
-        )
+        raise RuntimeError(f"Import not supported for backend: {type(self.primary).__name__}")
 
     def list_backups(self, backup_dir: str | None = None) -> list[dict]:
         """List all skmemory backup files, sorted newest first.
@@ -570,9 +693,7 @@ class MemoryStore:
             return self.primary.list_backups(backup_dir)
         return []
 
-    def prune_backups(
-        self, keep: int = 7, backup_dir: str | None = None
-    ) -> list[str]:
+    def prune_backups(self, keep: int = 7, backup_dir: str | None = None) -> list[str]:
         """Delete oldest backups, keeping only the N most recent.
 
         Args:
@@ -648,7 +769,8 @@ def _first_n_sentences(text: str, n: int = 2) -> str:
         return ""
     # Split on sentence-ending punctuation followed by whitespace
     import re
-    sentences = re.split(r'(?<=[.!?])\s+', text.strip())
+
+    sentences = re.split(r"(?<=[.!?])\s+", text.strip())
     result = " ".join(sentences[:n])
     # Cap at 200 chars as a safety net
     if len(result) > 200: