neuro-simulator 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

neuro_simulator/cli.py

@@ -8,29 +8,7 @@ import shutil
 import sys
 from pathlib import Path
 
-def copy_resource(package_name: str, resource_path: str, destination_path: Path, is_dir: bool = False):
-    """A helper function to copy a resource from the package to the working directory."""
-    if destination_path.exists():
-        return
 
-    try:
-        import pkg_resources
-        source_path_str = pkg_resources.resource_filename(package_name, resource_path)
-        source_path = Path(source_path_str)
-    except (ModuleNotFoundError, KeyError):
-        source_path = Path(__file__).parent / resource_path
-
-    if source_path.exists():
-        try:
-            if is_dir:
-                shutil.copytree(source_path, destination_path)
-            else:
-                shutil.copy(source_path, destination_path)
-            logging.info(f"Created '{destination_path}' from package resource.")
-        except Exception as e:
-            logging.warning(f"Could not copy resource '{resource_path}'. Error: {e}")
-    else:
-        logging.warning(f"Resource '{resource_path}' not found in package or development folder.")
 
 def main():
     """Main entry point for the CLI."""
@@ -54,39 +32,91 @@ def main():
     os.chdir(work_dir)
     logging.info(f"Using working directory: {work_dir}")
 
-    # 2. Ensure required assets and configs exist
-    copy_resource('neuro_simulator', 'core/config.yaml.example', work_dir / 'config.yaml.example')
-    copy_resource('neuro_simulator', 'assets', work_dir / 'assets', is_dir=True)
-    # Ensure agent directory and its contents exist
-    agent_dir = work_dir / "agent"
-    agent_dir.mkdir(parents=True, exist_ok=True)
-    copy_resource('neuro_simulator', 'agent/neuro_prompt.txt', agent_dir / 'neuro_prompt.txt')
-    copy_resource('neuro_simulator', 'agent/memory_prompt.txt', agent_dir / 'memory_prompt.txt')
-
-    # Ensure agent memory directory and its contents exist
-    agent_memory_dir = agent_dir / "memory"
-    agent_memory_dir.mkdir(parents=True, exist_ok=True)
-    for filename in ["chat_history.json", "core_memory.json", "init_memory.json"]:
-        copy_resource('neuro_simulator', f'agent/memory/{filename}', agent_memory_dir / filename)
-
-    # 3. Validate essential files
-    errors = []
-    if not (work_dir / "config.yaml").exists():
-        errors.append(f"'config.yaml' not found in '{work_dir}'. Please copy 'config.yaml.example' to 'config.yaml' and configure it.")
-    if not (work_dir / "assets" / "neuro_start.mp4").exists():
-        errors.append(f"Required file 'neuro_start.mp4' not found in '{work_dir / 'assets'}'.")
-
-    if errors:
-        for error in errors:
-            logging.error(error)
-        sys.exit(1)
+    # 2. Initialize paths and load configuration
+    from neuro_simulator.core import path_manager
+    from neuro_simulator.core.config import config_manager
+    import uvicorn
+
+    path_manager.initialize_path_manager(os.getcwd())
+
+    # Define example_path early for config loading
+    example_path = Path(__file__).parent / "core" / "config.yaml.example"
+
+    # 2.2. Copy default config.yaml.example if it doesn't exist
+    try:
+        source_config_example = example_path
+        destination_config_example = path_manager.path_manager.working_dir / "config.yaml.example"
+        if not destination_config_example.exists():
+            shutil.copy(source_config_example, destination_config_example)
+            logging.info(f"Copied default config.yaml.example to {destination_config_example}")
+    except Exception as e:
+        logging.warning(f"Could not copy default config.yaml.example: {e}")
+
+    main_config_path = path_manager.path_manager.working_dir / "config.yaml"
+    config_manager.load_and_validate(str(main_config_path), str(example_path))
+
+    # 2.5. Copy default prompt templates if they don't exist
+    try:
+        # Use Path(__file__).parent for robust path resolution
+        base_path = Path(__file__).parent
+        neuro_prompt_example = base_path / "agent" / "neuro_prompt.txt"
+        memory_prompt_example = base_path / "agent" / "memory_prompt.txt"
+
+        if not path_manager.path_manager.neuro_prompt_path.exists():
+            shutil.copy(neuro_prompt_example, path_manager.path_manager.neuro_prompt_path)
+            logging.info(f"Copied default neuro prompt to {path_manager.path_manager.neuro_prompt_path}")
+        if not path_manager.path_manager.memory_agent_prompt_path.exists():
+            shutil.copy(memory_prompt_example, path_manager.path_manager.memory_agent_prompt_path)
+            logging.info(f"Copied default memory prompt to {path_manager.path_manager.memory_agent_prompt_path}")
+
+        # Copy default memory JSON files if they don't exist
+        memory_files = {
+            "core_memory.json": path_manager.path_manager.core_memory_path,
+            "init_memory.json": path_manager.path_manager.init_memory_path,
+            "temp_memory.json": path_manager.path_manager.temp_memory_path,
+        }
+        for filename, dest_path in memory_files.items():
+            src_path = base_path / "agent" / "memory" / filename
+            if not dest_path.exists():
+                shutil.copy(src_path, dest_path)
+                logging.info(f"Copied default {filename} to {dest_path}")
+
+        # Copy default assets directory if it doesn't exist
+        source_assets_dir = base_path / "assets"
+        destination_assets_dir = path_manager.path_manager.assets_dir
+        
+        # Ensure the destination assets directory exists
+        destination_assets_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy individual files from source assets to destination assets
+        for item in source_assets_dir.iterdir():
+            if item.is_file():
+                dest_file = destination_assets_dir / item.name
+                if not dest_file.exists():
+                    shutil.copy(item, dest_file)
+                    logging.info(f"Copied asset {item.name} to {dest_file}")
+            elif item.is_dir():
+                # Recursively copy subdirectories if they don't exist
+                dest_subdir = destination_assets_dir / item.name
+                if not dest_subdir.exists():
+                    shutil.copytree(item, dest_subdir)
+                    logging.info(f"Copied asset directory {item.name} to {dest_subdir}")
+    except Exception as e:
+        logging.warning(f"Could not copy default prompt templates, memory files, or assets: {e}")
+
+    # 3. Determine server host and port
+    server_host = args.host or config_manager.settings.server.host
+    server_port = args.port or config_manager.settings.server.port
 
-    # 4. Import and run the server
+    # 4. Run the server
+    logging.info(f"Starting Neuro-Simulator server on {server_host}:{server_port}...")
     try:
-        from neuro_simulator.core.application import run_server
-        logging.info("Starting Neuro-Simulator server...")
-        # The full application logger will take over from here
-        run_server(args.host, args.port)
+        uvicorn.run(
+            "neuro_simulator.core.application:app",
+            host=server_host,
+            port=server_port,
+            reload=False
+        )
     except ImportError as e:
         logging.error(f"Could not import the application. Make sure the package is installed correctly. Details: {e}", exc_info=True)
         sys.exit(1)

neuro_simulator/core/agent_factory.py

@@ -1,6 +1,5 @@
 # neuro_simulator/core/agent_factory.py
 import logging
-from pathlib import Path
 
 from .agent_interface import BaseAgent
 from .config import config_manager, AppSettings

neuro_simulator/core/application.py

@@ -7,7 +7,7 @@ import logging
 import random
 import re
 import time
-from pathlib import Path
+import os
 from typing import List
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
@@ -17,6 +17,7 @@ from starlette.websockets import WebSocketState
 # --- Core Imports ---
 from .config import config_manager, AppSettings
 from ..core.agent_factory import create_agent
+from ..agent.core import Agent as LocalAgent
 from ..services.letta import LettaAgent
 from ..services.builtin import BuiltinAgentWrapper
 
@@ -34,7 +35,8 @@ from ..utils.queue import (
     add_to_neuro_input_queue,
     get_recent_audience_chats,
     is_neuro_input_queue_empty,
-    get_all_neuro_input_chats
+    get_all_neuro_input_chats,
+    initialize_queues,
 )
 from ..utils.state import app_state
 from ..utils.websocket import connection_manager
@@ -169,6 +171,10 @@ async def neuro_response_cycle():
             if not response_text:
                 continue
 
+            # Push updated agent context to admin clients immediately after processing
+            updated_context = await agent.get_message_history()
+            await connection_manager.broadcast_to_admins({"type": "agent_context", "action": "update", "messages": updated_context})
+
             async with app_state.neuro_last_speech_lock:
                 app_state.neuro_last_speech = response_text
 
@@ -192,6 +198,7 @@ async def neuro_response_cycle():
             
             await connection_manager.broadcast({"type": "neuro_speech_segment", "is_end": True})
             live_stream_manager.set_neuro_speaking_status(False)
+            
             await asyncio.sleep(config_manager.settings.neuro_behavior.post_speech_cooldown_sec)
 
         except asyncio.TimeoutError:
@@ -210,17 +217,24 @@ async def neuro_response_cycle():
 @app.on_event("startup")
 async def startup_event():
     """Actions to perform on application startup."""
-    global chatbot_manager
+    # 1. Configure logging first
     configure_server_logging()
-    
+
+    # 2. Initialize queues now that config is loaded
+    initialize_queues()
+
+    # 4. Initialize other managers/services that depend on config
+    global chatbot_manager
     chatbot_manager = AudienceChatbotManager()
 
+    # 5. Register callbacks
     async def metadata_callback(settings: AppSettings):
         await live_stream_manager.broadcast_stream_metadata()
     
     config_manager.register_update_callback(metadata_callback)
     config_manager.register_update_callback(chatbot_manager.handle_config_update)
     
+    # 6. Initialize agent (which will load its own configs)
     try:
         await create_agent()
         logger.info(f"Successfully initialized agent type: {config_manager.settings.agent_type}")
@@ -332,7 +346,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = {"status": "success", "block_id": block_id}
             # Broadcast the update to all admins
             updated_blocks = await agent.get_memory_blocks()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
         elif action == "update_core_memory_block":
@@ -340,7 +353,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = {"status": "success"}
             # Broadcast the update to all admins
             updated_blocks = await agent.get_memory_blocks()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
         elif action == "delete_core_memory_block":
@@ -348,7 +360,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = {"status": "success"}
             # Broadcast the update to all admins
             updated_blocks = await agent.get_memory_blocks()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
         # Temp Memory Actions
@@ -360,7 +371,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             await agent.add_temp_memory(**payload)
             response["payload"] = {"status": "success"}
             updated_temp_mem = await agent.get_temp_memory()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
 
         elif action == "clear_temp_memory":
@@ -378,13 +388,35 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             await agent.update_init_memory(**payload)
             response["payload"] = {"status": "success"}
             updated_init_mem = await agent.get_init_memory()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "init_memory_updated", "payload": updated_init_mem})
 
         # Tool Actions
-        elif action == "get_tools":
-            tools = await agent.get_available_tools()
-            response["payload"] = {"tools": tools}
+        elif action == "get_all_tools":
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            all_tools = agent_instance.tool_manager.get_all_tool_schemas()
+            response["payload"] = {"tools": all_tools}
+
+        elif action == "get_agent_tool_allocations":
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            allocations = agent_instance.tool_manager.get_allocations()
+            response["payload"] = {"allocations": allocations}
+
+        elif action == "set_agent_tool_allocations":
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            allocations_payload = payload.get("allocations", {})
+            agent_instance.tool_manager.set_allocations(allocations_payload)
+            response["payload"] = {"status": "success"}
+            # Broadcast the update to all admins
+            updated_allocations = agent_instance.tool_manager.get_allocations()
+            await connection_manager.broadcast_to_admins({"type": "agent_tool_allocations_updated", "payload": {"allocations": updated_allocations}})
+
+        elif action == "reload_tools":
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            agent_instance.tool_manager.reload_tools()
+            response["payload"] = {"status": "success"}
+            # Broadcast an event to notify UI to refresh tool lists
+            all_tools = agent_instance.tool_manager.get_all_tool_schemas()
+            await connection_manager.broadcast_to_admins({"type": "available_tools_updated", "payload": {"tools": all_tools}})
 
         elif action == "execute_tool":
             result = await agent.execute_tool(**payload)
@@ -392,11 +424,12 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
 
         # Stream Control Actions
         elif action == "start_stream":
+            logger.info("Start stream action received. Resetting agent memory before starting processes...")
+            await agent.reset_memory()
             if not process_manager.is_running:
                 process_manager.start_live_processes()
             response["payload"] = {"status": "success", "message": "Stream started"}
             # Broadcast stream status update
-            from ..utils.websocket import connection_manager
             status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
             await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
 
@@ -405,7 +438,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
                 await process_manager.stop_live_processes()
             response["payload"] = {"status": "success", "message": "Stream stopped"}
             # Broadcast stream status update
-            from ..utils.websocket import connection_manager
             status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
             await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
 
@@ -415,7 +447,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             process_manager.start_live_processes()
             response["payload"] = {"status": "success", "message": "Stream restarted"}
             # Broadcast stream status update
-            from ..utils.websocket import connection_manager
             status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
             await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
 
@@ -449,22 +480,33 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = context
 
         elif action == "get_last_prompt":
-            # Check if the agent supports prompt generation introspection
-            agent_instance = getattr(agent, 'agent_instance', None) if hasattr(agent, 'agent_instance') else agent
-            if not hasattr(agent_instance, 'memory_manager') or not hasattr(agent_instance.memory_manager, 'get_recent_chat') or not hasattr(agent_instance, '_build_neuro_prompt'):
-                response["payload"] = {"status": "error", "message": "The active agent does not support prompt generation introspection."}
+            # This is specific to the builtin agent, as Letta doesn't expose its prompt.
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            if not isinstance(agent_instance, LocalAgent):
+                 response["payload"] = {"prompt": "The active agent does not support prompt generation introspection."}
             else:
-                recent_history = await agent_instance.memory_manager.get_recent_chat(entries=10)
-                messages_for_prompt = []
-                for entry in recent_history:
-                    if entry.get('role') == 'user':
-                        parts = entry.get('content', '').split(':', 1)
-                        if len(parts) == 2:
-                            messages_for_prompt.append({'username': parts[0].strip(), 'text': parts[1].strip()})
-                        else:
-                            messages_for_prompt.append({'username': 'user', 'text': entry.get('content', '')})
-                prompt = await agent_instance._build_neuro_prompt(messages_for_prompt)
-                response["payload"] = {"prompt": prompt}
+                try:
+                    # 1. Get the recent history from the agent itself
+                    history = await agent_instance.get_neuro_history(limit=10)
+                    
+                    # 2. Reconstruct the 'messages' list that _build_neuro_prompt expects
+                    messages_for_prompt = []
+                    for entry in history:
+                        if entry.get('role') == 'user':
+                            # Content is in the format "username: text"
+                            content = entry.get('content', '')
+                            parts = content.split(':', 1)
+                            if len(parts) == 2:
+                                messages_for_prompt.append({'username': parts[0].strip(), 'text': parts[1].strip()})
+                            elif content: # Handle cases where there's no colon
+                                messages_for_prompt.append({'username': 'user', 'text': content})
+
+                    # 3. Build the prompt using the agent's own internal logic
+                    prompt = await agent_instance._build_neuro_prompt(messages_for_prompt)
+                    response["payload"] = {"prompt": prompt}
+                except Exception as e:
+                    logger.error(f"Error generating last prompt: {e}", exc_info=True)
+                    response["payload"] = {"prompt": f"Failed to generate prompt: {e}"}
 
         elif action == "reset_agent_memory":
             await agent.reset_memory()
@@ -489,17 +531,4 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             await websocket.send_json(response)
 
 
-# --- Server Entrypoint ---
 
-def run_server(host: str = None, port: int = None):
-    """Runs the FastAPI server with Uvicorn."""
-    import uvicorn
-    server_host = host or config_manager.settings.server.host
-    server_port = port or config_manager.settings.server.port
-    
-    uvicorn.run(
-        "neuro_simulator.core.application:app",
-        host=server_host,
-        port=server_port,
-        reload=False
-    )

neuro_simulator/core/config.py

@@ -1,8 +1,9 @@
 # backend/config.py
-import os
+import shutil
+from pathlib import Path
 import yaml
 from pydantic import BaseModel, Field
-from typing import List, Optional, Dict, Any
+from typing import Dict, Optional, List
 import logging
 import asyncio
 from collections.abc import Mapping
@@ -106,76 +107,77 @@ class ConfigManager:
         self._update_callbacks = []
         self._initialized = True
 
-    def _get_config_file_path(self) -> str:
-        """获取配置文件路径"""
-        import sys
-        import argparse
-        
-        # 解析命令行参数以获取工作目录
-        parser = argparse.ArgumentParser()
-        parser.add_argument('--dir', '-D', type=str, help='Working directory')
-        # 只解析已知参数，避免干扰其他模块的参数解析
-        args, _ = parser.parse_known_args()
-        
-        if args.dir:
-            # 如果指定了工作目录，使用该目录下的配置文件
-            config_path = os.path.join(args.dir, "config.yaml")
-        else:
-            # 默认使用 ~/.config/neuro-simulator 目录
-            config_path = os.path.join(os.path.expanduser("~"), ".config", "neuro-simulator", "config.yaml")
-            
-        return config_path
+    import sys
 
-    def _load_config_from_yaml(self) -> dict:
-        # 获取配置文件路径
-        config_path = self._get_config_file_path()
-        
-        # 检查配置文件是否存在
-        if not os.path.exists(config_path):
-            raise FileNotFoundError(f"Configuration file '{config_path}' not found. "
-                                  "Please create it from config.yaml.example.")
-        
+class ConfigManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(ConfigManager, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self.settings: Optional[AppSettings] = None
+        self._update_callbacks = []
+        self._initialized = True
+
+    def load_and_validate(self, config_path_str: str, example_path_str: str):
+        """Loads the main config file, handling first-run scenarios, and validates it."""
+        config_path = Path(config_path_str)
+        example_path = Path(example_path_str)
+
+        # Scenario 1: Both config and example are missing in the working directory.
+        if not config_path.exists() and not example_path.exists():
+            try:
+                import pkg_resources
+                package_example_path_str = pkg_resources.resource_filename('neuro_simulator', 'core/config.yaml.example')
+                shutil.copy(package_example_path_str, example_path)
+                logging.info(f"Created '{example_path}' from package resource.")
+                logging.error(f"Configuration file '{config_path.name}' not found. A new '{example_path.name}' has been created. Please configure it and rename it to '{config_path.name}'.")
+                sys.exit(1)
+            except Exception as e:
+                logging.error(f"FATAL: Could not create config from package resources: {e}")
+                sys.exit(1)
+
+        # Scenario 2: Config is missing, but example exists.
+        elif not config_path.exists() and example_path.exists():
+            logging.error(f"Configuration file '{config_path.name}' not found, but '{example_path.name}' exists. Please rename it to '{config_path.name}' after configuration.")
+            sys.exit(1)
+
+        # Scenario 3: Config exists, but example is missing.
+        elif config_path.exists() and not example_path.exists():
+            try:
+                import pkg_resources
+                package_example_path_str = pkg_resources.resource_filename('neuro_simulator', 'core/config.yaml.example')
+                shutil.copy(package_example_path_str, example_path)
+                logging.info(f"Created missing '{example_path.name}' from package resource.")
+            except Exception as e:
+                logging.warning(f"Could not create missing '{example_path.name}': {e}")
+
+        # Proceed with loading the config if it exists.
         try:
             with open(config_path, 'r', encoding='utf-8') as f:
-                content = yaml.safe_load(f)
-                if content is None:
+                yaml_config = yaml.safe_load(f)
+                if yaml_config is None:
                     raise ValueError(f"Configuration file '{config_path}' is empty.")
-                return content
-        except Exception as e:
-            logging.error(f"Error loading or parsing {config_path}: {e}")
-            raise
-
-    def _load_settings(self) -> AppSettings:
-        yaml_config = self._load_config_from_yaml()
-        
-        base_settings = AppSettings.model_validate(yaml_config)
-
-        # 检查关键配置项
-        if base_settings.agent_type == "letta":
-            missing_keys = []
-            if not base_settings.api_keys.letta_token:
-                missing_keys.append("api_keys.letta_token")
-            if not base_settings.api_keys.neuro_agent_id:
-                missing_keys.append("api_keys.neuro_agent_id")
             
-            if missing_keys:
-                raise ValueError(f"Critical config missing in config.yaml for letta agent: {', '.join(missing_keys)}. "
-                               f"Please check your config.yaml file against config.yaml.example.")
+            self.settings = AppSettings.model_validate(yaml_config)
+            logging.info("Main configuration loaded successfully.")
 
-        logging.info("Configuration loaded successfully.")
-        return base_settings
+        except Exception as e:
+            logging.error(f"Error loading or parsing {config_path}: {e}")
+            sys.exit(1) # Exit if the main config is invalid
 
     def save_settings(self):
         """Saves the current configuration to config.yaml while preserving comments and formatting."""
+        from .path_manager import path_manager
+        config_file_path = str(path_manager.working_dir / "config.yaml")
+
         try:
-            # 获取配置文件路径
-            config_file_path = self._get_config_file_path()
-            
-            # 检查配置文件目录是否存在，如果不存在则创建
-            config_dir = os.path.dirname(config_file_path)
-            if config_dir and not os.path.exists(config_dir):
-                os.makedirs(config_dir, exist_ok=True)
-            
             # 1. Read the existing config file as text to preserve comments and formatting
             with open(config_file_path, 'r', encoding='utf-8') as f:
                 config_lines = f.readlines()
@@ -184,7 +186,8 @@ class ConfigManager:
             config_to_save = self.settings.model_dump(mode='json', exclude={'api_keys'})
 
             # 3. Read the existing config on disk to get the api_keys that should be preserved.
-            existing_config = self._load_config_from_yaml()
+            with open(config_file_path, 'r', encoding='utf-8') as f:
+                existing_config = yaml.safe_load(f)
             if 'api_keys' in existing_config:
                 # 4. Add the preserved api_keys block back to the data to be saved.
                 config_to_save['api_keys'] = existing_config['api_keys']

neuro_simulator/core/path_manager.py

@@ -0,0 +1,69 @@
+# neuro_simulator/core/path_manager.py
+"""Manages all file and directory paths for the application's working directory."""
+
+import os
+from pathlib import Path
+
+class PathManager:
+    """A centralized manager for all dynamic paths within the working directory."""
+
+    def __init__(self, working_dir: str):
+        """Initializes the PathManager and defines the directory structure."""
+        self.working_dir = Path(working_dir).resolve()
+
+        # Top-level directories
+        self.agents_dir = self.working_dir / "agents"
+        self.assets_dir = self.working_dir / "assets"
+
+        # Agents subdirectories
+        self.neuro_agent_dir = self.agents_dir / "neuro"
+        self.memory_agent_dir = self.agents_dir / "memory_manager"
+        self.shared_memories_dir = self.agents_dir / "memories"
+        self.user_tools_dir = self.agents_dir / "tools"
+        self.builtin_tools_dir = self.user_tools_dir / "builtin_tools"
+
+        # Agent-specific config files
+        self.neuro_config_path = self.neuro_agent_dir / "config.yaml"
+        self.neuro_tools_path = self.neuro_agent_dir / "tools.json"
+        self.neuro_history_path = self.neuro_agent_dir / "history.jsonl"
+        self.neuro_prompt_path = self.neuro_agent_dir / "neuro_prompt.txt"
+
+        self.memory_agent_config_path = self.memory_agent_dir / "config.yaml"
+        self.memory_agent_tools_path = self.memory_agent_dir / "tools.json"
+        self.memory_agent_history_path = self.memory_agent_dir / "history.jsonl"
+        self.memory_agent_prompt_path = self.memory_agent_dir / "memory_prompt.txt"
+
+        # Shared memory files
+        self.init_memory_path = self.shared_memories_dir / "init_memory.json"
+        self.core_memory_path = self.shared_memories_dir / "core_memory.json"
+        self.temp_memory_path = self.shared_memories_dir / "temp_memory.json"
+
+    def initialize_directories(self):
+        """Creates all necessary directories if they don't exist."""
+        dirs_to_create = [
+            self.agents_dir,
+            self.assets_dir,
+            self.neuro_agent_dir,
+            self.memory_agent_dir,
+            self.shared_memories_dir,
+            self.user_tools_dir,
+            self.builtin_tools_dir
+        ]
+        for dir_path in dirs_to_create:
+            os.makedirs(dir_path, exist_ok=True)
+
+        # Create the warning file in the builtin_tools directory
+        warning_file_path = self.builtin_tools_dir / "!!!NO-CHANGE-WILL-BE-SAVED-AFTER-RESTART!!!"
+        if not warning_file_path.exists():
+            warning_file_path.touch()
+
+# A global instance that can be imported and used by other modules.
+# It will be initialized on application startup.
+path_manager: PathManager = None
+
+def initialize_path_manager(working_dir: str):
+    """Initializes the global path_manager instance."""
+    global path_manager
+    if path_manager is None:
+        path_manager = PathManager(working_dir)
+        path_manager.initialize_directories()

neuro_simulator/services/audience.py

@@ -1,7 +1,5 @@
 # neuro_simulator/services/audience.py
-import asyncio
 import logging
-import random
 
 from google import genai
 from google.genai import types

neuro_simulator/services/audio.py

@@ -3,7 +3,6 @@ import asyncio
 import base64
 import html
 import logging
-from pathlib import Path
 
 import azure.cognitiveservices.speech as speechsdk