@smilintux/skmemory 0.5.0 → 0.7.2

package/skmemory/agents.py

@@ -0,0 +1,233 @@
+"""
+Dynamic agent discovery and management for SKMemory.
+
+Scans ~/.skcapstone/agents/ to discover all configured agents,
+excludes templates, and provides agent-aware path resolution.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+def _agents_base() -> Path:
+    """Platform-aware base directory for all agents."""
+    skcap_home = os.environ.get("SKCAPSTONE_HOME", "")
+    if skcap_home:
+        return Path(skcap_home) / "agents"
+    if platform.system() == "Windows":
+        local = os.environ.get("LOCALAPPDATA", "")
+        if local:
+            return Path(local) / "skcapstone" / "agents"
+    return Path.home() / ".skcapstone" / "agents"
+
+
+# Base directory for all agents
+AGENTS_BASE_DIR = _agents_base()
+
+# Template directory name (ignored by default)
+TEMPLATE_AGENT = "lumina-template"
+
+
+def list_agents() -> list[str]:
+    """Discover all non-template agents in ~/.skcapstone/agents/
+
+    Scans the agents directory and returns all agent names
+    except the template agent.
+
+    Returns:
+        list[str]: Sorted list of agent names (e.g., ['lumina', 'john'])
+    """
+    if not AGENTS_BASE_DIR.exists():
+        return []
+
+    agents = []
+    for entry in AGENTS_BASE_DIR.iterdir():
+        if entry.is_dir() and entry.name != TEMPLATE_AGENT:
+            # Check if it has a valid config
+            config_file = entry / "config" / "skmemory.yaml"
+            if config_file.exists():
+                agents.append(entry.name)
+
+    return sorted(agents)
+
+
+def get_agent_dir(agent_name: str) -> Path:
+    """Get the base directory for a specific agent.
+
+    Args:
+        agent_name: Name of the agent (e.g., 'lumina', 'john')
+
+    Returns:
+        Path: Agent's base directory
+    """
+    return AGENTS_BASE_DIR / agent_name
+
+
+def get_agent_config(agent_name: str) -> Optional[dict]:
+    """Load agent configuration from YAML.
+
+    Args:
+        agent_name: Name of the agent
+
+    Returns:
+        dict with agent config, or None if not found/invalid
+    """
+    config_path = get_agent_dir(agent_name) / "config" / "skmemory.yaml"
+
+    if not config_path.exists():
+        return None
+
+    try:
+        with open(config_path) as f:
+            return yaml.safe_load(f)
+    except Exception:
+        return None
+
+
+def is_template_agent(agent_name: str) -> bool:
+    """Check if an agent is a template (should be ignored).
+
+    Args:
+        agent_name: Name of the agent
+
+    Returns:
+        bool: True if this is the template agent
+    """
+    return agent_name == TEMPLATE_AGENT
+
+
+def get_active_agent() -> Optional[str]:
+    """Get the currently active agent from environment or default to first non-template.
+
+    Checks in order:
+    1. SKMEMORY_AGENT environment variable
+    2. First non-template agent in the directory
+
+    Returns:
+        str: Agent name, or None if no agents found
+    """
+    # Check environment variable first
+    env_agent = os.environ.get("SKMEMORY_AGENT")
+    if env_agent and not is_template_agent(env_agent):
+        agent_dir = get_agent_dir(env_agent)
+        if agent_dir.exists():
+            return env_agent
+
+    # Fall back to first non-template agent
+    agents = list_agents()
+    if agents:
+        return agents[0]
+
+    return None
+
+
+def get_agent_paths(agent_name: Optional[str] = None) -> dict[str, Path]:
+    """Get all standard paths for an agent.
+
+    Args:
+        agent_name: Name of the agent, or None to use active agent
+
+    Returns:
+        dict with keys: base, config, seeds, memory_short, memory_medium, memory_long, logs, index_db
+    """
+    if agent_name is None:
+        agent_name = get_active_agent()
+
+    if agent_name is None:
+        raise ValueError(
+            "No agent configured. Create one by copying ~/.skcapstone/agents/lumina-template"
+        )
+
+    base = get_agent_dir(agent_name)
+
+    return {
+        "base": base,
+        "config": base / "config",
+        "seeds": base / "seeds",
+        "memory_short": base / "memory" / "short-term",
+        "memory_medium": base / "memory" / "mid-term",
+        "memory_long": base / "memory" / "long-term",
+        "logs": base / "logs",
+        "archive": base / "archive",
+        "index_db": base / "index.db",
+        "config_yaml": base / "config" / "skmemory.yaml",
+    }
+
+
+def ensure_agent_dirs(agent_name: str) -> Path:
+    """Create all standard directories for an agent if they don't exist.
+
+    Args:
+        agent_name: Name of the agent
+
+    Returns:
+        Path: Agent's base directory
+    """
+    paths = get_agent_paths(agent_name)
+
+    # Create all directories
+    for key, path in paths.items():
+        if key != "config_yaml":
+            path.mkdir(parents=True, exist_ok=True)
+
+    return paths["base"]
+
+
+def copy_template(target_name: str, source: str = TEMPLATE_AGENT) -> Path:
+    """Create a new agent by copying the template.
+
+    Args:
+        target_name: Name for the new agent
+        source: Template to copy from (default: lumina-template)
+
+    Returns:
+        Path: New agent's base directory
+    """
+    import shutil
+
+    source_dir = get_agent_dir(source)
+    target_dir = get_agent_dir(target_name)
+
+    if not source_dir.exists():
+        raise ValueError(f"Template '{source}' not found at {source_dir}")
+
+    if target_dir.exists():
+        raise ValueError(f"Agent '{target_name}' already exists at {target_dir}")
+
+    # Copy template
+    shutil.copytree(source_dir, target_dir)
+
+    # Update agent name in config
+    config_path = target_dir / "config" / "skmemory.yaml"
+    if config_path.exists():
+        with open(config_path, "r") as f:
+            content = f.read()
+
+        # Replace template agent name with new name
+        content = content.replace(f"name: {source}", f"name: {target_name}")
+        # Use platform-aware base dir for config path values.
+        # Always use forward slashes in YAML for cross-platform consistency.
+        base = AGENTS_BASE_DIR.as_posix()
+        content = content.replace(
+            f"sync_root: ~/.skcapstone/agents/{source}",
+            f"sync_root: {base}/{target_name}",
+        )
+        content = content.replace(
+            f"seeds_dir: ~/.skcapstone/agents/{source}/seeds",
+            f"seeds_dir: {base}/{target_name}/seeds",
+        )
+        content = content.replace(
+            f"local_db: ~/.skcapstone/agents/{source}/index.db",
+            f"local_db: {base}/{target_name}/index.db",
+        )
+
+        with open(config_path, "w") as f:
+            f.write(content)
+
+    return target_dir

package/skmemory/ai_client.py

@@ -93,6 +93,46 @@ class AIClient:
         except Exception:
             return ""
 
+    def embed(self, text: str, model: Optional[str] = None) -> list[float]:
+        """Generate an embedding vector using Ollama's embed API.
+
+        Args:
+            text: The text to embed.
+            model: Override embedding model (default: nomic-embed-text).
+
+        Returns:
+            list[float]: Embedding vector, or empty list on failure.
+        """
+        embed_model = model or os.environ.get(
+            "SKMEMORY_EMBED_MODEL", "nomic-embed-text"
+        )
+        payload = {"model": embed_model, "input": text}
+
+        try:
+            data = json.dumps(payload).encode("utf-8")
+            req = urllib.request.Request(
+                f"{self.base_url}/api/embed",
+                data=data,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                result = json.loads(resp.read().decode("utf-8"))
+                embeddings = result.get("embeddings", [])
+                if embeddings and isinstance(embeddings[0], list):
+                    return embeddings[0]
+                return embeddings
+        except Exception:
+            return []
+
+    def embed_available(self) -> bool:
+        """Check if the embedding endpoint is reachable.
+
+        Returns:
+            bool: True if Ollama embed API responds.
+        """
+        return bool(self.embed("test"))
+
     def summarize_memory(self, title: str, content: str) -> str:
         """Generate a concise summary for a memory.
 

package/skmemory/anchor.py

@@ -9,7 +9,7 @@ represents the AI's baseline feeling toward its connections. Every
 session, the anchor updates. On next boot, the anchor loads first
 and the AI starts from warmth instead of cold neutrality.
 
-The anchor file lives at ~/.skmemory/anchor.json
+The anchor file lives at ~/.skcapstone/anchor.json
 """
 
 from __future__ import annotations
@@ -22,7 +22,9 @@ from typing import Optional
 
 from pydantic import BaseModel, Field
 
-DEFAULT_ANCHOR_PATH = os.path.expanduser("~/.skmemory/anchor.json")
+from .config import SKMEMORY_HOME
+
+DEFAULT_ANCHOR_PATH = str(SKMEMORY_HOME / "anchor.json")
 
 
 class WarmthAnchor(BaseModel):

package/skmemory/backends/__init__.py

@@ -1,12 +1,19 @@
 """
 Storage backends for SKMemory.
 
-Level 1 (file)   - JSON files on disk, zero infrastructure.
-Level 2 (qdrant) - Vector search via Qdrant for semantic recall.
-Level 3 (graph)  - FalkorDB graph relationships between memories.
+Level 0 (sqlite)   - SQLite index, zero infrastructure.
+Level 0.5 (vault)  - SQLite + transparent AES-256-GCM at-rest encryption.
+Level 1 (skvector) - Semantic vector search (powered by Qdrant).
+Level 2 (skgraph)  - Graph relationship traversal (powered by FalkorDB).
 """
 
 from .base import BaseBackend
+from .skgraph_backend import SKGraphBackend
 from .file_backend import FileBackend
 
-__all__ = ["BaseBackend", "FileBackend"]
+__all__ = ["BaseBackend", "SKGraphBackend", "FileBackend", "VaultedSQLiteBackend"]
+
+try:
+    from .vaulted_backend import VaultedSQLiteBackend
+except ImportError:
+    VaultedSQLiteBackend = None  # type: ignore[assignment,misc]

package/skmemory/backends/file_backend.py

@@ -23,10 +23,11 @@ import os
 from pathlib import Path
 from typing import Optional
 
+from ..config import SKMEMORY_HOME
 from ..models import Memory, MemoryLayer
 from .base import BaseBackend
 
-DEFAULT_BASE_PATH = os.path.expanduser("~/.skmemory/memories")
+DEFAULT_BASE_PATH = str(SKMEMORY_HOME)
 
 
 class FileBackend(BaseBackend):