npcpy 1.2.17__tar.gz → 1.2.19__tar.gz

{npcpy-1.2.17/npcpy.egg-info → npcpy-1.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.17
+Version: 1.2.19
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.2.17 → npcpy-1.2.19}/npcpy/ft/memory_trainer.py

@@ -1,7 +1,10 @@
-import torch
-import torch.nn as nn
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
-from torch.utils.data import Dataset
+try:
+    from torch.utils.data import Dataset
+    import torch
+    import torch.nn as nn
+    from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
+except:
+    pass 
 import json
 from typing import List, Dict, Tuple
 import random

npcpy-1.2.19/npcpy/memory/memory_processor.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import threading
+import queue
+import time
+
+@dataclass
+class MemoryItem:
+    message_id: str
+    conversation_id: str
+    npc: str
+    team: str
+    directory_path: str
+    content: str
+    context: str
+    model: str
+    provider: str
+
+
+def memory_approval_ui(memories: List[Dict]) -> List[Dict]:
+    """Simple CLI interface for memory approval"""
+    if not memories:
+        return []
+    
+    print(f"\n📝 {len(memories)} memories ready for approval:")
+    
+    approvals = []
+    for i, memory in enumerate(memories, 1):
+        print(f"\n--- Memory {i}/{len(memories)} ---")
+        print(f"NPC: {memory['npc']}")
+        print(f"Content: {memory['content'][:200]}{'...' if len(memory['content']) > 200 else ''}")
+        
+        while True:
+            choice = input("(a)pprove, (r)eject, (e)dit, (s)kip, (q)uit, (A)pprove all: ").strip().lower()
+            
+            if choice == 'a':
+                approvals.append({"memory_id": memory['memory_id'], "decision": "human-approved"})
+                break
+            elif choice == 'r':
+                approvals.append({"memory_id": memory['memory_id'], "decision": "human-rejected"})
+                break
+            elif choice == 'e':
+                edited = input("Edit memory: ").strip()
+                if edited:
+                    approvals.append({
+                        "memory_id": memory['memory_id'], 
+                        "decision": "human-edited",
+                        "final_memory": edited
+                    })
+                break
+            elif choice == 's':
+                break
+            elif choice == 'q':
+                return approvals
+            elif choice == 'A':
+                
+                for remaining_memory in memories[i-1:]:
+                    approvals.append({
+                        "memory_id": remaining_memory['memory_id'], 
+                        "decision": "human-approved"
+                    })
+                return approvals
+    
+    return approvals

{npcpy-1.2.17 → npcpy-1.2.19}/npcpy/npc_compiler.py

@@ -26,7 +26,7 @@ from npcpy.npc_sysenv import (
     get_system_message, 
 
     )
-from npcpy.memory.command_history import CommandHistory
+from npcpy.memory.command_history import CommandHistory, generate_message_id
 
 class SilentUndefined(Undefined):
     def _fail_with_undefined_error(self, *args, **kwargs):
@@ -498,7 +498,7 @@ def load_jinxs_from_directory(directory):
     return jinxs
 
 def get_npc_action_space(npc=None, team=None):
-    """Get action space for NPC including memory search, db query, and core capabilities"""
+    """Get action space for NPC including memory CRUD and core capabilities"""
     actions = DEFAULT_ACTION_SPACE.copy()
     
     if npc:
@@ -510,24 +510,35 @@ def get_npc_action_space(npc=None, team=None):
         if npc.command_history:
             core_tools.extend([
                 npc.search_my_conversations,
-                npc.search_my_memories
+                npc.search_my_memories,
+                npc.create_memory,
+                npc.read_memory,
+                npc.update_memory,
+                npc.delete_memory,
+                npc.search_memories,
+                npc.get_all_memories,
+                npc.archive_old_memories,
+                npc.get_memory_stats
             ])
         
         if npc.db_conn:
             core_tools.append(npc.query_database)
         
         if hasattr(npc, 'tools') and npc.tools:
+            core_tools.extend([func for func in npc.tool_map.values() if callable(func)])
+        
+        if core_tools:
             tools_schema, tool_map = auto_tools(core_tools)
             actions.update({
                 f"use_{tool.__name__}": {
-                    "description": extract_function_info(tool).get('description'),
+                    "description": f"Use {tool.__name__} capability",
                     "handler": tool,
                     "context": lambda **_: f"Available as automated capability",
                     "output_keys": {"result": {"description": "Tool execution result", "type": "string"}}
                 }
                 for tool in core_tools
             })
-        
+    
     if team and hasattr(team, 'npcs') and len(team.npcs) > 1:
         available_npcs = [name for name in team.npcs.keys() if name != (npc.name if npc else None)]
         
@@ -537,13 +548,11 @@ def get_npc_action_space(npc=None, team=None):
             return agent_pass_handler(command, extracted_data, **kwargs)
         
         actions["pass_to_npc"] = {
-            "description": "Pass the request to another NPC in the team - BUT ONLY if the task truly requires their specific expertise and you cannot handle it yourself",
+            "description": "Pass request to another NPC - only when task requires their specific expertise",
             "handler": team_aware_handler,
             "context": lambda npc=npc, team=team, **_: (
-                f"Use this SPARINGLY when the request absolutely requires another team member's expertise. "
                 f"Available NPCs: {', '.join(available_npcs)}. "
-                f"IMPORTANT: If you can handle the task yourself with your {npc.name if npc else 'current'} skills, DO NOT pass it. "
-                f"Only pass when you genuinely cannot complete the task due to lack of domain expertise."
+                f"Only pass when you genuinely cannot complete the task."
             ),
             "output_keys": {
                 "target_npc": {
@@ -556,8 +565,6 @@ def get_npc_action_space(npc=None, team=None):
     return actions
 
 
-
-
 def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
     inputs = {}
 
@@ -1074,14 +1081,14 @@ class NPC:
         
     def get_llm_response(self, 
                             request,
-                            jinxs= None,
+                            jinxs=None,
                             tools=None,
-                            tool_map= None,
+                            tool_map=None,
                             tool_choice=None, 
-                            messages: Optional[List[Dict[str, str]]] = None,
-                            auto_process_tool_calls: bool = True,
+                            messages=None,
+                            auto_process_tool_calls=True,
                             **kwargs):
-        """Get a response from the LLM with automatic tool integration"""
+        """Get response from LLM with automatic tool integration including memory CRUD"""
         
         if tools is None and tool_map is None and tool_choice is None:
             core_tools = [
@@ -1092,7 +1099,15 @@ class NPC:
             if self.command_history:
                 core_tools.extend([
                     self.search_my_conversations,
-                    self.search_my_memories
+                    self.search_my_memories,
+                    self.create_memory,
+                    self.read_memory, 
+                    self.update_memory,
+                    self.delete_memory,
+                    self.search_memories,
+                    self.get_all_memories,
+                    self.archive_old_memories,
+                    self.get_memory_stats
                 ])
             
             if self.db_conn:
@@ -1122,6 +1137,7 @@ class NPC:
         )        
         
         return response
+
     
 
 
@@ -1674,7 +1690,7 @@ class NPC:
 
 
 
-    def execute_jinx_command(
+    def execute_jinx_command(self, 
         jinx: Jinx,
         args: List[str],
         messages=None,
@@ -1695,6 +1711,159 @@ class NPC:
         )
 
         return {"messages": messages, "output": jinx_output}
+    def create_memory(self, content: str, memory_type: str = "observation") -> Optional[int]:
+        """Create a new memory entry"""
+        if not self.command_history:
+            return None
+        
+        message_id = generate_message_id()
+        conversation_id = self.command_history.get_most_recent_conversation_id()
+        conversation_id = conversation_id.get('conversation_id') if conversation_id else 'direct_memory'
+        
+        team_name = getattr(self.team, 'name', 'default_team') if self.team else 'default_team'
+        directory_path = os.getcwd()
+        
+        return self.command_history.add_memory_to_database(
+            message_id=message_id,
+            conversation_id=conversation_id,
+            npc=self.name,
+            team=team_name,
+            directory_path=directory_path,
+            initial_memory=content,
+            status='active',
+            model=self.model,
+            provider=self.provider
+        )
+
+    def read_memory(self, memory_id: int) -> Optional[Dict[str, Any]]:
+        """Read a specific memory by ID"""
+        if not self.command_history:
+            return None
+        
+        stmt = "SELECT * FROM memory_lifecycle WHERE id = :memory_id"
+        return self.command_history._fetch_one(stmt, {"memory_id": memory_id})
+
+    def update_memory(self, memory_id: int, new_content: str = None, status: str = None) -> bool:
+        """Update memory content or status"""
+        if not self.command_history:
+            return False
+        
+        updates = []
+        params = {"memory_id": memory_id}
+        
+        if new_content is not None:
+            updates.append("final_memory = :final_memory")
+            params["final_memory"] = new_content
+        
+        if status is not None:
+            updates.append("status = :status") 
+            params["status"] = status
+        
+        if not updates:
+            return False
+        
+        stmt = f"UPDATE memory_lifecycle SET {', '.join(updates)} WHERE id = :memory_id"
+        
+        try:
+            with self.command_history.engine.begin() as conn:
+                conn.execute(text(stmt), params)
+            return True
+        except Exception as e:
+            print(f"Error updating memory {memory_id}: {e}")
+            return False
+
+    def delete_memory(self, memory_id: int) -> bool:
+        """Delete a memory by ID"""
+        if not self.command_history:
+            return False
+        
+        stmt = "DELETE FROM memory_lifecycle WHERE id = :memory_id AND npc = :npc"
+        
+        try:
+            with self.command_history.engine.begin() as conn:
+                result = conn.execute(text(stmt), {"memory_id": memory_id, "npc": self.name})
+                return result.rowcount > 0
+        except Exception as e:
+            print(f"Error deleting memory {memory_id}: {e}")
+            return False
+
+    def search_memories(self, query: str, limit: int = 10, status_filter: str = None) -> List[Dict[str, Any]]:
+        """Search memories with optional status filtering"""
+        if not self.command_history:
+            return []
+        
+        team_name = getattr(self.team, 'name', 'default_team') if self.team else 'default_team'
+        directory_path = os.getcwd()
+        
+        return self.command_history.search_memory(
+            query=query,
+            npc=self.name,
+            team=team_name,
+            directory_path=directory_path,
+            status_filter=status_filter,
+            limit=limit
+        )
+
+    def get_all_memories(self, limit: int = 50, status_filter: str = None) -> List[Dict[str, Any]]:
+        """Get all memories for this NPC with optional status filtering"""
+        if not self.command_history:
+            return []
+        
+        if limit is None:
+            limit = 50
+        
+        conditions = ["npc = :npc"]
+        params = {"npc": self.name, "limit": limit}
+        
+        if status_filter:
+            conditions.append("status = :status")
+            params["status"] = status_filter
+        
+        stmt = f"""
+            SELECT * FROM memory_lifecycle 
+            WHERE {' AND '.join(conditions)}
+            ORDER BY created_at DESC 
+            LIMIT :limit
+            """
+        
+        return self.command_history._fetch_all(stmt, params)
+
+
+    def archive_old_memories(self, days_old: int = 30) -> int:
+        """Archive memories older than specified days"""
+        if not self.command_history:
+            return 0
+        
+        stmt = """
+            UPDATE memory_lifecycle 
+            SET status = 'archived' 
+            WHERE npc = :npc 
+            AND status = 'active'
+            AND datetime(created_at) < datetime('now', '-{} days')
+        """.format(days_old)
+        
+        try:
+            with self.command_history.engine.begin() as conn:
+                result = conn.execute(text(stmt), {"npc": self.name})
+                return result.rowcount
+        except Exception as e:
+            print(f"Error archiving memories: {e}")
+            return 0
+
+    def get_memory_stats(self) -> Dict[str, int]:
+        """Get memory statistics for this NPC"""
+        if not self.command_history:
+            return {}
+        
+        stmt = """
+            SELECT status, COUNT(*) as count
+            FROM memory_lifecycle 
+            WHERE npc = :npc
+            GROUP BY status
+        """
+        
+        results = self.command_history._fetch_all(stmt, {"npc": self.name})
+        return {row['status']: row['count'] for row in results}
 
 
 class Team:

{npcpy-1.2.17 → npcpy-1.2.19/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.17
+Version: 1.2.19
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.2.17 → npcpy-1.2.19}/setup.py

@@ -82,7 +82,7 @@ extra_files = package_files("npcpy/npc_team/")
 
 setup(
     name="npcpy",
-    version="1.2.17",
+    version="1.2.19",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  
     extras_require={

{npcpy-1.2.17 → npcpy-1.2.19}/tests/test_npc_compiler.py

@@ -223,3 +223,117 @@ def test_npc_execute_jinx():
         print(f"NPC jinx execution result: {result}")
     except Exception as e:
         print(f"NPC jinx execution failed: {e}")
+
+
+
+import os
+import tempfile
+import sqlite3
+from datetime import datetime
+import sys
+
+
+from npcpy.memory.command_history import CommandHistory, get_db_connection
+from npcpy.tools import auto_tools
+
+def test_npc_memory_crud_integration():
+    """Integration test for NPC memory CRUD operations via auto tools"""
+    
+    test_db_path = "test_npc.db"
+    db_conn = get_db_connection(test_db_path)
+    
+    test_npc = NPC(
+        name="memory_test_npc",
+        primary_directive="Test NPC with memory CRUD capabilities", 
+        model="llama3.2",
+        provider="ollama", 
+        db_conn=db_conn,
+        memory=True
+    )
+    
+    print(f"NPC '{test_npc.name}' initialized successfully")
+    print(f"Database connection: {test_npc.db_conn is not None}")
+    print(f"Command history: {test_npc.command_history is not None}")
+    
+    print("\n=== Testing Memory CRUD via Auto Tools ===")
+    
+    print("\n1. Testing create_memory via LLM response")
+    create_response = test_npc.get_llm_response(
+        "Create a memory about user preferring Python over JavaScript for backend work",
+        auto_process_tool_calls=True
+    )
+    
+    if create_response.get('tool_results'):
+        memory_id = create_response['tool_results'][0]['result']
+        print(f"✓ Memory created with ID: {memory_id}")
+    else:
+        print("✗ No memory created")
+    
+    print("\n2. Testing search_memories via LLM")
+    search_response = test_npc.get_llm_response(
+        "Search my memories for anything about Python",
+        auto_process_tool_calls=True
+    )
+    
+    if search_response.get('tool_results'):
+        search_results = search_response['tool_results'][0]['result']
+        print(f"✓ Found {len(search_results) if isinstance(search_results, list) else 1} memories")
+    else:
+        print("✗ No search results")
+    
+    print("\n3. Testing get_all_memories via LLM")
+    all_memories_response = test_npc.get_llm_response(
+        "Show me all my current memories",
+        auto_process_tool_calls=True
+    )
+    
+    if all_memories_response.get('tool_results'):
+        all_memories = all_memories_response['tool_results'][0]['result']
+        print(f"✓ Retrieved {len(all_memories) if isinstance(all_memories, list) else 1} total memories")
+    else:
+        print("✗ No memories retrieved")
+    
+    print("\n4. Testing memory stats via LLM")
+    stats_response = test_npc.get_llm_response(
+        "Give me statistics about my memories",
+        auto_process_tool_calls=True
+    )
+    
+    if stats_response.get('tool_results'):
+        stats = stats_response['tool_results'][0]['result']
+        print(f"✓ Memory stats: {stats}")
+    else:
+        print("✗ No stats retrieved")
+    
+    print("\n=== Testing Direct Tool Access ===")
+    
+    print("\n5. Direct memory creation")
+    memory_id = test_npc.create_memory("Direct memory creation test", "test")
+    print(f"✓ Created memory ID: {memory_id}")
+    
+    if memory_id:
+        print("\n6. Reading created memory")
+        memory_data = test_npc.read_memory(memory_id)
+        print(f"✓ Memory content: {memory_data['initial_memory'] if memory_data else 'None'}")
+        
+        print("\n7. Updating memory")
+        update_success = test_npc.update_memory(
+            memory_id, 
+            new_content="Updated test memory content",
+            status="verified"
+        )
+        print(f"✓ Update success: {update_success}")
+        
+        print("\n8. Reading updated memory")
+        updated_memory = test_npc.read_memory(memory_id)
+        if updated_memory:
+            print(f"✓ Updated content: {updated_memory['final_memory']}")
+            print(f"✓ New status: {updated_memory['status']}")
+    
+    print("\n9. Getting final memory statistics")
+    final_stats = test_npc.get_memory_stats()
+    print(f"✓ Final memory stats: {final_stats}")
+    
+    print("\n=== Test Complete ===")
+    print("✓ Memory CRUD operations successfully integrated as auto tools")
+    return True

npcpy-1.2.17/npcpy/memory/memory_processor.py

@@ -1,155 +0,0 @@
-from dataclasses import dataclass
-from typing import List, Dict, Any, Optional
-from datetime import datetime
-import threading
-import queue
-import time
-
-@dataclass
-class MemoryItem:
-    message_id: str
-    conversation_id: str
-    npc: str
-    team: str
-    directory_path: str
-    content: str
-    context: str
-    model: str
-    provider: str
-
-class MemoryApprovalQueue:
-    def __init__(self, command_history):
-        self.command_history = command_history
-        self.pending_queue = queue.Queue()
-        self.approval_results = queue.Queue()
-        self.processing_thread = None
-        self.running = False
-
-    def add_memory(self, memory_item: MemoryItem):
-        """Add memory to processing queue (non-blocking)"""
-        self.pending_queue.put(memory_item)
-        
-    def start_background_processing(self):
-        """Start background thread for memory processing"""
-        if self.processing_thread and self.processing_thread.is_alive():
-            return
-            
-        self.running = True
-        self.processing_thread = threading.Thread(target=self._process_queue)
-        self.processing_thread.daemon = True
-        self.processing_thread.start()
-
-    def _process_queue(self):
-        """Background processing of memory queue"""
-        while self.running:
-            try:
-                
-                batch = []
-                try:
-                    
-                    memory = self.pending_queue.get(timeout=1.0)
-                    batch.append(memory)
-                    
-                    
-                    while len(batch) < 10:
-                        try:
-                            memory = self.pending_queue.get_nowait()
-                            batch.append(memory)
-                        except queue.Empty:
-                            break
-                    
-                    self._process_memory_batch(batch)
-                    
-                except queue.Empty:
-                    continue
-                    
-            except Exception as e:
-                print(f"Error in memory processing: {e}")
-                time.sleep(1)
-
-    def _process_memory_batch(self, memories: List[MemoryItem]):
-        """Process a batch of memories"""
-        for memory in memories:
-            
-            memory_id = self.command_history.add_memory_to_database(
-                message_id=memory.message_id,
-                conversation_id=memory.conversation_id,
-                npc=memory.npc,
-                team=memory.team,
-                directory_path=memory.directory_path,
-                initial_memory=memory.content,
-                status="pending_approval",
-                model=memory.model,
-                provider=memory.provider
-            )
-            
-            
-            self.approval_results.put({
-                "memory_id": memory_id,
-                "content": memory.content,
-                "context": memory.context,
-                "npc": memory.npc
-            })
-
-    def get_approval_batch(self, max_items: int = 5) -> List[Dict]:
-        """Get batch of memories ready for approval"""
-        batch = []
-        try:
-            while len(batch) < max_items:
-                item = self.approval_results.get_nowait()
-                batch.append(item)
-        except queue.Empty:
-            pass
-        return batch
-
-    def stop_processing(self):
-        """Stop background processing"""
-        self.running = False
-        if self.processing_thread:
-            self.processing_thread.join(timeout=2.0)
-
-def memory_approval_ui(memories: List[Dict]) -> List[Dict]:
-    """Simple CLI interface for memory approval"""
-    if not memories:
-        return []
-    
-    print(f"\n📝 {len(memories)} memories ready for approval:")
-    
-    approvals = []
-    for i, memory in enumerate(memories, 1):
-        print(f"\n--- Memory {i}/{len(memories)} ---")
-        print(f"NPC: {memory['npc']}")
-        print(f"Content: {memory['content'][:200]}{'...' if len(memory['content']) > 200 else ''}")
-        
-        while True:
-            choice = input("(a)pprove, (r)eject, (e)dit, (s)kip, (q)uit, (A)pprove all: ").strip().lower()
-            
-            if choice == 'a':
-                approvals.append({"memory_id": memory['memory_id'], "decision": "human-approved"})
-                break
-            elif choice == 'r':
-                approvals.append({"memory_id": memory['memory_id'], "decision": "human-rejected"})
-                break
-            elif choice == 'e':
-                edited = input("Edit memory: ").strip()
-                if edited:
-                    approvals.append({
-                        "memory_id": memory['memory_id'], 
-                        "decision": "human-edited",
-                        "final_memory": edited
-                    })
-                break
-            elif choice == 's':
-                break
-            elif choice == 'q':
-                return approvals
-            elif choice == 'A':
-                
-                for remaining_memory in memories[i-1:]:
-                    approvals.append({
-                        "memory_id": remaining_memory['memory_id'], 
-                        "decision": "human-approved"
-                    })
-                return approvals
-    
-    return approvals