superlocalmemory 2.8.6 → 3.0.0

package/src/tree/nodes.py

@@ -1,202 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tree Nodes — CRUD operations and count aggregation.
-
-Provides TreeNodesMixin with add_node, delete_node, update_counts,
-and internal helper methods for materialized-path management.
-"""
-import sqlite3
-from typing import Optional, Dict, Any
-from datetime import datetime
-
-
-class TreeNodesMixin:
-    """Node CRUD and aggregation logic for the memory tree."""
-
-    def add_node(
-        self,
-        node_type: str,
-        name: str,
-        parent_id: int,
-        description: Optional[str] = None,
-        memory_id: Optional[int] = None
-    ) -> int:
-        """
-        Add a new node to the tree.
-
-        Args:
-            node_type: Type of node ('root', 'project', 'category', 'memory')
-            name: Display name
-            parent_id: Parent node ID
-            description: Optional description
-            memory_id: Link to memories table (for leaf nodes)
-
-        Returns:
-            New node ID
-        """
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            # Get parent path and depth
-            cursor.execute('SELECT tree_path, depth FROM memory_tree WHERE id = ?', (parent_id,))
-            result = cursor.fetchone()
-
-            if not result:
-                raise ValueError(f"Parent node {parent_id} not found")
-
-            parent_path, parent_depth = result
-
-            # Calculate new node position
-            depth = parent_depth + 1
-
-            cursor.execute('''
-                INSERT INTO memory_tree (
-                    node_type, name, description,
-                    parent_id, tree_path, depth,
-                    memory_id, last_updated
-                )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            ''', (
-                node_type,
-                name,
-                description,
-                parent_id,
-                '',  # Placeholder, updated below
-                depth,
-                memory_id,
-                datetime.now().isoformat()
-            ))
-
-            node_id = cursor.lastrowid
-
-            # Update tree_path with actual node_id
-            tree_path = f"{parent_path}.{node_id}"
-            cursor.execute('UPDATE memory_tree SET tree_path = ? WHERE id = ?', (tree_path, node_id))
-
-            conn.commit()
-        finally:
-            conn.close()
-
-        return node_id
-
-    def delete_node(self, node_id: int) -> bool:
-        """
-        Delete a node and all its descendants.
-
-        Args:
-            node_id: Node ID to delete
-
-        Returns:
-            True if deleted, False if not found
-        """
-        if node_id == self.root_id:
-            raise ValueError("Cannot delete root node")
-
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            # Get tree_path
-            cursor.execute('SELECT tree_path, parent_id FROM memory_tree WHERE id = ?', (node_id,))
-            result = cursor.fetchone()
-
-            if not result:
-                return False
-
-            tree_path, parent_id = result
-
-            # Delete node and all descendants (CASCADE handles children)
-            cursor.execute('DELETE FROM memory_tree WHERE id = ? OR tree_path LIKE ?',
-                          (node_id, f"{tree_path}.%"))
-
-            deleted = cursor.rowcount > 0
-            conn.commit()
-        finally:
-            conn.close()
-
-        # Update parent counts
-        if deleted and parent_id:
-            self.update_counts(parent_id)
-
-        return deleted
-
-    def update_counts(self, node_id: int):
-        """
-        Update aggregated counts for a node (memory_count, total_size).
-        Recursively updates all ancestors.
-
-        Args:
-            node_id: Node ID to update
-        """
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            # Get all descendant memory nodes
-            cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
-            result = cursor.fetchone()
-
-            if not result:
-                return
-
-            tree_path = result[0]
-
-            # Count memories in subtree
-            cursor.execute('''
-                SELECT COUNT(*), COALESCE(SUM(LENGTH(m.content)), 0)
-                FROM memory_tree t
-                LEFT JOIN memories m ON t.memory_id = m.id
-                WHERE t.tree_path LIKE ? AND t.memory_id IS NOT NULL
-            ''', (f"{tree_path}%",))
-
-            memory_count, total_size = cursor.fetchone()
-
-            # Update node
-            cursor.execute('''
-                UPDATE memory_tree
-                SET memory_count = ?, total_size = ?, last_updated = ?
-                WHERE id = ?
-            ''', (memory_count, total_size, datetime.now().isoformat(), node_id))
-
-            # Update all ancestors
-            path_ids = [int(x) for x in tree_path.split('.')]
-            for ancestor_id in path_ids[:-1]:  # Exclude current node
-                self.update_counts(ancestor_id)
-
-            conn.commit()
-        finally:
-            conn.close()
-
-    def _update_all_counts(self):
-        """Update counts for all nodes (used after build_tree)."""
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            # Get all nodes in reverse depth order (leaves first)
-            cursor.execute('''
-                SELECT id FROM memory_tree
-                ORDER BY depth DESC
-            ''')
-
-            node_ids = [row[0] for row in cursor.fetchall()]
-        finally:
-            conn.close()
-
-        # Update each node (will cascade to parents)
-        processed = set()
-        for node_id in node_ids:
-            if node_id not in processed:
-                self.update_counts(node_id)
-                processed.add(node_id)
-
-    def _generate_tree_path(self, parent_path: str, node_id: int) -> str:
-        """Generate tree_path for a new node."""
-        if parent_path:
-            return f"{parent_path}.{node_id}"
-        return str(node_id)
-
-    def _calculate_depth(self, tree_path: str) -> int:
-        """Calculate depth from tree_path (count dots)."""
-        return tree_path.count('.')

package/src/tree/queries.py

@@ -1,257 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tree Queries — Read-only tree traversal and statistics.
-
-Provides TreeQueriesMixin with get_tree, get_subtree,
-get_path_to_root, and get_stats.
-"""
-import sqlite3
-from typing import Optional, List, Dict, Any
-
-
-class TreeQueriesMixin:
-    """Read-only query methods for the memory tree."""
-
-    def get_tree(
-        self,
-        project_name: Optional[str] = None,
-        max_depth: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """
-        Get tree structure as nested dictionary.
-
-        Args:
-            project_name: Filter by specific project
-            max_depth: Maximum depth to retrieve
-
-        Returns:
-            Nested dictionary representing tree structure
-        """
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            # Build query
-            if project_name:
-                # Find project node
-                cursor.execute('''
-                    SELECT id, tree_path FROM memory_tree
-                    WHERE node_type = 'project' AND name = ?
-                ''', (project_name,))
-                result = cursor.fetchone()
-
-                if not result:
-                    return {'error': f"Project '{project_name}' not found"}
-
-                project_id, project_path = result
-
-                # Get subtree
-                if max_depth is not None:
-                    cursor.execute('''
-                        SELECT id, node_type, name, description, parent_id, tree_path,
-                               depth, memory_count, total_size, last_updated, memory_id
-                        FROM memory_tree
-                        WHERE (id = ? OR tree_path LIKE ?) AND depth <= ?
-                        ORDER BY tree_path
-                    ''', (project_id, f"{project_path}.%", max_depth))
-                else:
-                    cursor.execute('''
-                        SELECT id, node_type, name, description, parent_id, tree_path,
-                               depth, memory_count, total_size, last_updated, memory_id
-                        FROM memory_tree
-                        WHERE id = ? OR tree_path LIKE ?
-                        ORDER BY tree_path
-                    ''', (project_id, f"{project_path}.%"))
-            else:
-                # Get entire tree
-                if max_depth is not None:
-                    cursor.execute('''
-                        SELECT id, node_type, name, description, parent_id, tree_path,
-                               depth, memory_count, total_size, last_updated, memory_id
-                        FROM memory_tree
-                        WHERE depth <= ?
-                        ORDER BY tree_path
-                    ''', (max_depth,))
-                else:
-                    cursor.execute('''
-                        SELECT id, node_type, name, description, parent_id, tree_path,
-                               depth, memory_count, total_size, last_updated, memory_id
-                        FROM memory_tree
-                        ORDER BY tree_path
-                    ''')
-
-            rows = cursor.fetchall()
-        finally:
-            conn.close()
-
-        if not rows:
-            return {'error': 'No tree nodes found'}
-
-        # Build nested structure
-        nodes = {}
-        root = None
-
-        for row in rows:
-            node = {
-                'id': row[0],
-                'type': row[1],
-                'name': row[2],
-                'description': row[3],
-                'parent_id': row[4],
-                'tree_path': row[5],
-                'depth': row[6],
-                'memory_count': row[7],
-                'total_size': row[8],
-                'last_updated': row[9],
-                'memory_id': row[10],
-                'children': []
-            }
-            nodes[node['id']] = node
-
-            if node['parent_id'] is None or (project_name and node['type'] == 'project'):
-                root = node
-            elif node['parent_id'] in nodes:
-                nodes[node['parent_id']]['children'].append(node)
-
-        return root or {'error': 'Root node not found'}
-
-    def get_subtree(self, node_id: int) -> List[Dict[str, Any]]:
-        """
-        Get all descendants of a specific node (flat list).
-
-        Args:
-            node_id: Node ID to get subtree for
-
-        Returns:
-            List of descendant nodes
-        """
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            # Get node's tree_path
-            cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
-            result = cursor.fetchone()
-
-            if not result:
-                return []
-
-            tree_path = result[0]
-
-            # Get all descendants
-            cursor.execute('''
-                SELECT id, node_type, name, description, parent_id, tree_path,
-                       depth, memory_count, total_size, last_updated, memory_id
-                FROM memory_tree
-                WHERE tree_path LIKE ?
-                ORDER BY tree_path
-            ''', (f"{tree_path}.%",))
-
-            results = []
-            for row in cursor.fetchall():
-                results.append({
-                    'id': row[0],
-                    'type': row[1],
-                    'name': row[2],
-                    'description': row[3],
-                    'parent_id': row[4],
-                    'tree_path': row[5],
-                    'depth': row[6],
-                    'memory_count': row[7],
-                    'total_size': row[8],
-                    'last_updated': row[9],
-                    'memory_id': row[10]
-                })
-        finally:
-            conn.close()
-
-        return results
-
-    def get_path_to_root(self, node_id: int) -> List[Dict[str, Any]]:
-        """
-        Get path from node to root (breadcrumb trail).
-
-        Args:
-            node_id: Starting node ID
-
-        Returns:
-            List of nodes from root to target node
-        """
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            # Get node's tree_path
-            cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
-            result = cursor.fetchone()
-
-            if not result:
-                return []
-
-            tree_path = result[0]
-
-            # Parse path to get all ancestor IDs
-            path_ids = [int(x) for x in tree_path.split('.')]
-
-            # Get all ancestor nodes
-            placeholders = ','.join('?' * len(path_ids))
-            cursor.execute(f'''
-                SELECT id, node_type, name, description, parent_id, tree_path,
-                       depth, memory_count, total_size, last_updated, memory_id
-                FROM memory_tree
-                WHERE id IN ({placeholders})
-                ORDER BY depth
-            ''', path_ids)
-
-            results = []
-            for row in cursor.fetchall():
-                results.append({
-                    'id': row[0],
-                    'type': row[1],
-                    'name': row[2],
-                    'description': row[3],
-                    'parent_id': row[4],
-                    'tree_path': row[5],
-                    'depth': row[6],
-                    'memory_count': row[7],
-                    'total_size': row[8],
-                    'last_updated': row[9],
-                    'memory_id': row[10]
-                })
-        finally:
-            conn.close()
-
-        return results
-
-    def get_stats(self) -> Dict[str, Any]:
-        """Get tree statistics."""
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            cursor.execute('SELECT COUNT(*) FROM memory_tree')
-            total_nodes = cursor.fetchone()[0]
-
-            cursor.execute('SELECT node_type, COUNT(*) FROM memory_tree GROUP BY node_type')
-            by_type = dict(cursor.fetchall())
-
-            cursor.execute('SELECT MAX(depth) FROM memory_tree')
-            max_depth = cursor.fetchone()[0] or 0
-
-            cursor.execute('''
-                SELECT SUM(memory_count), SUM(total_size)
-                FROM memory_tree
-                WHERE node_type = 'root'
-            ''')
-            total_memories, total_size = cursor.fetchone()
-
-        finally:
-            conn.close()
-
-        return {
-            'total_nodes': total_nodes,
-            'by_type': by_type,
-            'max_depth': max_depth,
-            'total_memories': total_memories or 0,
-            'total_size_bytes': total_size or 0
-        }

package/src/tree/schema.py

@@ -1,80 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tree Schema — Database initialization and root node management.
-
-Provides the TreeSchemaMixin with DB init and root-node bootstrap logic
-for the materialized-path tree structure.
-"""
-import sqlite3
-from pathlib import Path
-from typing import Optional
-from datetime import datetime
-
-MEMORY_DIR = Path.home() / ".claude-memory"
-DB_PATH = MEMORY_DIR / "memory.db"
-
-
-class TreeSchemaMixin:
-    """Database schema and root-node management for the memory tree."""
-
-    def _init_db(self):
-        """Initialize memory_tree table."""
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS memory_tree (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    node_type TEXT NOT NULL,
-                    name TEXT NOT NULL,
-                    description TEXT,
-
-                    parent_id INTEGER,
-                    tree_path TEXT NOT NULL,
-                    depth INTEGER DEFAULT 0,
-
-                    memory_count INTEGER DEFAULT 0,
-                    total_size INTEGER DEFAULT 0,
-                    last_updated TIMESTAMP,
-
-                    memory_id INTEGER,
-
-                    FOREIGN KEY (parent_id) REFERENCES memory_tree(id) ON DELETE CASCADE,
-                    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
-                )
-            ''')
-
-            cursor.execute('CREATE INDEX IF NOT EXISTS idx_tree_path_layer2 ON memory_tree(tree_path)')
-            cursor.execute('CREATE INDEX IF NOT EXISTS idx_node_type ON memory_tree(node_type)')
-            cursor.execute('CREATE INDEX IF NOT EXISTS idx_parent_id_tree ON memory_tree(parent_id)')
-
-            conn.commit()
-        finally:
-            conn.close()
-
-    def _ensure_root(self) -> int:
-        """Ensure root node exists and return its ID."""
-        conn = sqlite3.connect(self.db_path)
-        try:
-            cursor = conn.cursor()
-
-            cursor.execute('SELECT id FROM memory_tree WHERE node_type = ? AND parent_id IS NULL', ('root',))
-            result = cursor.fetchone()
-
-            if result:
-                root_id = result[0]
-            else:
-                cursor.execute('''
-                    INSERT INTO memory_tree (node_type, name, tree_path, depth, last_updated)
-                    VALUES (?, ?, ?, ?, ?)
-                ''', ('root', 'Root', '1', 0, datetime.now().isoformat()))
-                root_id = cursor.lastrowid
-
-                # Update tree_path with actual ID
-                cursor.execute('UPDATE memory_tree SET tree_path = ? WHERE id = ?', (str(root_id), root_id))
-                conn.commit()
-
-        finally:
-            conn.close()
-        return root_id

package/src/tree_manager.py

@@ -1,19 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-TreeManager - Thin re-export shim.
-
-Implementation lives in src/tree/ (schema, nodes, queries, builder).
-This file preserves backward compatibility for any existing imports.
-"""
-
-from tree.schema import MEMORY_DIR, DB_PATH
-from tree import TreeManager
-
-__all__ = ['TreeManager', 'MEMORY_DIR', 'DB_PATH']
-
-# CLI interface
-if __name__ == "__main__":
-    from tree.builder import run_cli
-    run_cli()

package/src/trust/__init__.py

@@ -1,45 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Trust scoring package -- Bayesian Beta-Binomial trust for AI agents.
-
-Re-exports all public symbols for backward compatibility.
-"""
-
-from .constants import (
-    SIGNAL_WEIGHTS,
-    SIGNAL_DELTAS,
-    INITIAL_ALPHA,
-    INITIAL_BETA,
-    DECAY_FACTOR,
-    DECAY_INTERVAL,
-    ALPHA_FLOOR,
-    BETA_FLOOR,
-    QUICK_DELETE_HOURS,
-    BURST_THRESHOLD,
-    BURST_WINDOW_MINUTES,
-)
-
-from .schema import init_trust_schema
-
-from .scorer import TrustScorer
-
-__all__ = [
-    # Class
-    "TrustScorer",
-    # Constants
-    "SIGNAL_WEIGHTS",
-    "SIGNAL_DELTAS",
-    "INITIAL_ALPHA",
-    "INITIAL_BETA",
-    "DECAY_FACTOR",
-    "DECAY_INTERVAL",
-    "ALPHA_FLOOR",
-    "BETA_FLOOR",
-    "QUICK_DELETE_HOURS",
-    "BURST_THRESHOLD",
-    "BURST_WINDOW_MINUTES",
-    # Schema
-    "init_trust_schema",
-]

package/src/trust/constants.py

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Beta-Binomial signal weights and trust scoring constants.
-
-Extracted from trust_scorer.py for modularity.
-"""
-
-# ---------------------------------------------------------------------------
-# Beta-Binomial signal weights
-# ---------------------------------------------------------------------------
-# Positive signals increment alpha (building trust).
-# Negative signals increment beta (eroding trust).
-# Neutral signals give a tiny alpha nudge to reward normal activity.
-#
-# Asymmetry: negative weights are larger than positive weights.
-# This means it's harder to build trust than to lose it -- the system
-# is intentionally skeptical. One poisoning event takes many good
-# actions to recover from.
-# ---------------------------------------------------------------------------
-
-SIGNAL_WEIGHTS = {
-    # Positive signals -> alpha += weight
-    "memory_recalled_by_others": ("positive", 0.30),   # cross-agent validation
-    "memory_updated":            ("positive", 0.15),   # ongoing relevance
-    "high_importance_write":     ("positive", 0.20),   # valuable content (importance >= 7)
-    "consistent_pattern":        ("positive", 0.15),   # stable write behavior
-
-    # Negative signals -> beta += weight
-    "quick_delete":              ("negative", 0.50),   # deleted within 1 hour
-    "high_volume_burst":         ("negative", 0.40),   # >20 writes in 5 minutes
-    "content_overwritten_by_user": ("negative", 0.25), # user had to fix output
-
-    # Neutral signals -> tiny alpha nudge
-    "normal_write":              ("neutral", 0.01),
-    "normal_recall":             ("neutral", 0.01),
-}
-
-# Backward-compatible: expose SIGNAL_DELTAS as a derived dict so that
-# bm6_trust.py (which imports SIGNAL_DELTAS) and any other consumer
-# continues to work. The values represent the *direction* and *magnitude*
-# of each signal: positive for alpha, negative for beta, zero for neutral.
-SIGNAL_DELTAS = {}
-for _sig, (_direction, _weight) in SIGNAL_WEIGHTS.items():
-    if _direction == "positive":
-        SIGNAL_DELTAS[_sig] = +_weight
-    elif _direction == "negative":
-        SIGNAL_DELTAS[_sig] = -_weight
-    else:
-        SIGNAL_DELTAS[_sig] = 0.0
-
-# ---------------------------------------------------------------------------
-# Beta prior and decay parameters
-# ---------------------------------------------------------------------------
-INITIAL_ALPHA = 2.0        # Slight positive prior
-INITIAL_BETA = 1.0         # -> initial trust = 2/(2+1) = 0.667
-DECAY_FACTOR = 0.995       # Multiply alpha & beta every DECAY_INTERVAL signals
-DECAY_INTERVAL = 50        # Apply decay every N signals per agent
-ALPHA_FLOOR = 1.0          # Never decay alpha below this
-BETA_FLOOR = 0.5           # Never decay beta below this
-
-# Thresholds
-QUICK_DELETE_HOURS = 1       # Delete within 1 hour = negative signal
-BURST_THRESHOLD = 20         # >20 writes in burst window = negative
-BURST_WINDOW_MINUTES = 5     # Burst detection window