mindroot 8.9.0__py3-none-any.whl → 8.11.0__py3-none-any.whl

mindroot/lib/chatcontext.py

@@ -3,7 +3,8 @@ from .providers.commands import command_manager
 import os
 import json
 from .chatlog import ChatLog
-from typing import TypeVar, Type, Protocol, runtime_checkable
+from .chatlog import extract_delegate_task_log_ids, find_child_logs_by_parent_id, find_chatlog_file
+from typing import TypeVar, Type, Protocol, runtime_checkable, Set
 from .utils.debug import debug_box
 contexts = {}
 
@@ -29,7 +30,7 @@ CommandSetT = TypeVar('CommandSetT', bound=BaseCommandSet)
 
 class ChatContext:
 
-    def __init__(self, command_manager_=None, service_manager_=None, user=None, log_id=None):
+    def __init__(self, command_manager_=None, service_manager_=None, user=None, log_id=None, parent_log_id=None):
         if not user:
             raise ValueError('User is required to create a chat context')
         else:
@@ -39,6 +40,7 @@ class ChatContext:
         self._commands = command_manager.functions
         self._services = service_manager.functions
         self.response_started = False
+        self.current_model = None
         self.uncensored = False
         if user is None:
             raise ValueError('User is required to create a chat context. Use SYSTEM if no user')
@@ -66,6 +68,7 @@ class ChatContext:
         self.agent_name = None
         self.name = None
         self.log_id = None
+        self.parent_log_id = None
         if log_id is not None:
             self.log_id = log_id
         else:
@@ -142,7 +145,10 @@ class ChatContext:
                 pass
             self.flags = self.agent.get('flags', [])
             self.data['log_id'] = log_id
-            self.chat_log = ChatLog(log_id=log_id, agent=self.agent_name, user=self.username)
+            parent_log_id = None
+            if self.parent_log_id:
+                parent_log_id = self.parent_log_id
+            self.chat_log = ChatLog(log_id=log_id, agent=self.agent_name, user=self.username, parent_log_id=parent_log_id)
             self.uncensored = True
         else:
             raise ValueError('Context file not found for id:', log_id)
@@ -160,5 +166,95 @@ class ChatContext:
         if name in self._commands:
             self.command_manager.context = self
             return getattr(self.command_manager, name)
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    @classmethod
+    async def delete_session_by_id(cls, log_id: str, user: str, agent: str, cascade: bool = True, visited_log_ids: Set[str] = None):
+        if visited_log_ids is None:
+            visited_log_ids = set()
+
+        if log_id in visited_log_ids:
+            print(f"Skipping already visited log_id for deletion: {log_id}")
+            return
+        visited_log_ids.add(log_id)
+
+        print(f"Attempting to delete session: log_id={log_id}, user={user}, agent={agent}")
+
+        # --- Cascading Deletion ---
+        if cascade:
+            messages_for_child_finding = []
+            chatlog_dir_base = os.environ.get('CHATLOG_DIR', 'data/chat')
+            chatlog_file_path_current = os.path.join(chatlog_dir_base, user, agent, f'chatlog_{log_id}.json')
+
+            if os.path.exists(chatlog_file_path_current):
+                try:
+                    with open(chatlog_file_path_current, 'r') as f:
+                        log_data = json.load(f)
+                        messages_for_child_finding = log_data.get('messages', [])
+                except Exception as e:
+                    print(f"Error reading chatlog {chatlog_file_path_current} for child finding: {e}")
+            
+            delegated_child_ids = extract_delegate_task_log_ids(messages_for_child_finding)
+            parented_child_ids = find_child_logs_by_parent_id(log_id)
+            all_child_log_ids = set(delegated_child_ids) | set(parented_child_ids)
+
+            for child_id in all_child_log_ids:
+                if child_id in visited_log_ids: # Check again before processing child
+                    continue
+                child_log_path = find_chatlog_file(child_id) # This searches across all users/agents
+                if child_log_path:
+                    try:
+                        relative_path = os.path.relpath(child_log_path, chatlog_dir_base)
+                        path_components = relative_path.split(os.sep)
+                        # Expecting {user}/{agent}/chatlog_{child_id}.json
+                        if len(path_components) >= 3 and path_components[-1] == f"chatlog_{child_id}.json":
+                            child_user = path_components[0]
+                            child_agent = path_components[1]
+                            print(f"Recursively deleting child session: log_id={child_id}, user={child_user}, agent={child_agent}")
+                            await cls.delete_session_by_id(child_id, child_user, child_agent, cascade=True, visited_log_ids=visited_log_ids)
+                        else:
+                            print(f"Could not parse user/agent from child log path: {child_log_path} relative to {chatlog_dir_base}")
+                    except Exception as e:
+                        print(f"Error processing child log {child_id} (path: {child_log_path}): {e}")
+                else:
+                    print(f"Could not find chatlog file for child_id: {child_id} during cascade.")
+
+        # --- Delete Current Session's Files ---
+        # ChatLog File
+        chatlog_file_to_delete = os.path.join(os.environ.get('CHATLOG_DIR', 'data/chat'), user, agent, f'chatlog_{log_id}.json')
+        if os.path.exists(chatlog_file_to_delete):
+            try:
+                os.remove(chatlog_file_to_delete)
+                print(f"Deleted chatlog file: {chatlog_file_to_delete}")
+            except Exception as e:
+                print(f"Error deleting chatlog file {chatlog_file_to_delete}: {e}")
         else:
-            pass
+            print(f"Chatlog file not found for deletion: {chatlog_file_to_delete}")
+
+        # ChatContext File (Agent is not part of the context file path structure)
+        context_file_to_delete = os.path.join('data/context', user, f'context_{log_id}.json')
+        if os.path.exists(context_file_to_delete):
+            try:
+                os.remove(context_file_to_delete)
+                print(f"Deleted context file: {context_file_to_delete}")
+            except Exception as e:
+                print(f"Error deleting context file {context_file_to_delete}: {e}")
+        else:
+            print(f"Context file not found for deletion: {context_file_to_delete}")
+            
+        # --- Clear In-Memory Cache ---
+        if log_id in contexts: # 'contexts' is the global dict at module level
+            try:
+                del contexts[log_id]
+                print(f"Removed log_id {log_id} from in-memory contexts cache.")
+            except Exception as e:
+                print(f"Error removing log_id {log_id} from in-memory contexts cache: {e}")
+
+    async def delete(self, cascade: bool = True):
+        if not self.log_id or not self.username or not self.agent_name:
+            error_msg = "log_id, username, or agent_name not set on ChatContext instance. Cannot call instance delete."
+            print(f"Error: {error_msg}")
+            raise ValueError(error_msg)
+        
+        print(f"Instance delete called for log_id={self.log_id}, user={self.username}, agent={self.agent_name}")
+        await ChatContext.delete_session_by_id(self.log_id, self.username, self.agent_name, cascade=cascade)

mindroot/lib/chatlog.py

@@ -8,9 +8,10 @@ import time
 from mindroot.lib.utils.debug import debug_box
 
 class ChatLog:
-    def __init__(self, log_id=0, agent=None, context_length: int = 4096, user: str = None):
+    def __init__(self, log_id=0, agent=None, parent_log_id=None, context_length: int = 4096, user: str = None):
         self.log_id = log_id
         self.messages = []
+        self.parent_log_id = parent_log_id
         self.agent = agent
         if user is None or user == '' or user == 'None':
             raise ValueError('User must be provided')
@@ -32,10 +33,13 @@ class ChatLog:
         if not os.path.exists(self.log_dir):
             os.makedirs(self.log_dir)
         self.load_log()
+        
     def _get_log_data(self) -> Dict[str, any]:
         return {
             'agent': self.agent,
-            'messages': self.messages
+            'log_id': self.log_id,
+            'messages': self.messages,
+            'parent_log_id': self.parent_log_id
         }
 
     def _calculate_message_length(self, message: Dict[str, str]) -> int:
@@ -124,20 +128,13 @@ class ChatLog:
                 log_data = json.load(f)
                 self.agent = log_data.get('agent')
                 self.messages = log_data.get('messages', [])
+                self.parent_log_id = log_data.get('parent_log_id', None)
             print("Loaded log file at ", log_file)
             print("Message length: ", len(self.messages))
         else:
             print("Could not find log file at ", log_file)
             self.messages = []
 
-    def delete_log(self) -> None:
-        log_file = os.path.join(self.log_dir, f'chatlog_{self.log_id}.json')
-        if os.path.exists(log_file):
-            os.remove(log_file)
-            print("Deleted log file at ", log_file)
-        else:
-            print("Could not find log file at ", log_file)
-
     def count_tokens(self) -> Dict[str, int]:
         """
         Count tokens in the chat log, providing both sequence totals and cumulative request totals.
@@ -198,6 +195,34 @@ def find_chatlog_file(log_id: str) -> str:
     
     return None
 
+def find_child_logs_by_parent_id(parent_log_id: str) -> List[str]:
+    """
+    Find all chat logs that have the given parent_log_id.
+    
+    Args:
+        parent_log_id: The parent log ID to search for
+        
+    Returns:
+        List of log IDs that have this parent_log_id
+    """
+    child_log_ids = []
+    chat_dir = os.environ.get('CHATLOG_DIR', 'data/chat')
+    
+    # Search through all chatlog files
+    for root, dirs, files in os.walk(chat_dir):
+        for file in files:
+            if file.startswith("chatlog_") and file.endswith(".json"):
+                try:
+                    with open(os.path.join(root, file), 'r') as f:
+                        log_data = json.load(f)
+                        if log_data.get('parent_log_id') == parent_log_id:
+                            # Extract log_id from the data
+                            child_log_ids.append(log_data.get('log_id'))
+                except (json.JSONDecodeError, IOError):
+                    continue
+    
+    return child_log_ids
+
 def extract_delegate_task_log_ids(messages: List[Dict]) -> List[str]:
     """
     Extract log IDs from delegate_task commands in messages.
@@ -331,6 +356,9 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     # Load the chat log
     with open(chatlog_path, 'r') as f:
         log_data = json.load(f)
+    
+    # Get parent_log_id if it exists
+    parent_log_id = log_data.get('parent_log_id')
         
     # Create a temporary ChatLog instance to count tokens
     temp_log = ChatLog(log_id=log_id, user="system", agent=log_data.get('agent', 'unknown'))
@@ -349,9 +377,19 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     # Find delegated task log IDs
     delegated_log_ids = extract_delegate_task_log_ids(temp_log.messages)
     
-    # Recursively count tokens for delegated tasks
-    for delegated_id in delegated_log_ids:
-        delegated_counts = count_tokens_for_log_id(delegated_id)
+    # Also find child logs by parent_log_id
+    child_logs_by_parent = find_child_logs_by_parent_id(log_id)
+    
+    # Combine all child log IDs (delegated tasks and parent_log_id children)
+    all_child_log_ids = set(delegated_log_ids) | set(child_logs_by_parent)
+    
+    # If this log has a parent_log_id, we should not double-count it
+    # (it will be counted as part of its parent's cumulative total)
+    # But we still want to count its own children
+    
+    # Recursively count tokens for all child tasks
+    for child_id in all_child_log_ids:
+        delegated_counts = count_tokens_for_log_id(child_id)
         if delegated_counts:
             combined_counts['input_tokens_sequence'] += delegated_counts['input_tokens_sequence']
             combined_counts['output_tokens_sequence'] += delegated_counts['output_tokens_sequence']
@@ -372,4 +410,4 @@ def count_tokens_for_log_id(log_id: str) -> Dict[str, int]:
     # Save to cache
     save_token_counts_to_cache(log_id, token_counts)
     
-    return token_counts
+    return token_counts