mindroot 0.1.0__tar.gz

mindroot-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jason Livesay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mindroot-0.1.0/MANIFEST.in

@@ -0,0 +1,24 @@
+global-exclude *.py[cod]
+prune src/ah/local
+prune src/ah/data
+prune src/ah/personas
+prune src/ah/static
+prune src/ah/imgs
+prune src/ah/models
+
+recursive-include src/mindroot/coreplugins/agent *.j2
+recursive-include src/mindroot/coreplugins/chat/templates *
+recursive-include src/mindroot/coreplugins/chat/static *
+recursive-include src/mindroot/coreplugins/admin/templates *
+recursive-include src/mindroot/coreplugins/admin/static *
+recursive-include src/mindroot/coreplugins/index/static *
+recursive-include src/mindroot/coreplugins/index/templates *
+recursive-include srx/mindroot/coreplugins/index *.json
+recursive-include src/mindroot/coreplugins/home/static *
+recursive-include src/mindroot/coreplugins/home/templates *
+recursive-include src/mindroot/coreplugins/index *
+recursive-include src/mindroot/coreplugins/agent *
+recursive-include src/mindroot/coreplugins/persona *
+recursive-include src/mindroot/coreplugins/login *
+recursive-include src/mindroot/lib/plugins *.json
+

mindroot-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: mindroot
+Version: 0.1.0
+Summary: An agent framework using LLMs
+Author-email: Jason Livesay <runvnc@gmail.com>
+Project-URL: Homepage, https://github.com/runvncmindroot
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: jinja2
+Requires-Dist: nanoid
+Requires-Dist: termcolor
+Requires-Dist: colored
+Requires-Dist: loguru
+Requires-Dist: python-multipart
+Requires-Dist: pytz
+Requires-Dist: PyJWT
+Requires-Dist: pluggy
+Requires-Dist: sse_starlette
+Requires-Dist: partial-json-parser
+Requires-Dist: pydantic
+Requires-Dist: setuptools
+Requires-Dist: requests
+Requires-Dist: aiohttp
+Requires-Dist: Pillow
+Requires-Dist: psutil
+
+
+Mindroot
+
+[![PyPI](https://img.shields.io/pypi/v/mindroot)](https://pypi.org/project/mindroot/)
+
+**Note: some of the following is a work in progress and not yet functional. A few of them aren't really started.**
+
+Mindroot is a powerful plugin-based Python framework for creating, deploying, and sharing AI agents and related models. It offers a flexible architecture with indices and a public registry (coming soon) for easily sharing and finding plugins, agents, personas, services, knowledgebases, and apps.
+
+Installation
+------------
+
+You can install Mindroot using pip:
+
+```bash
+pip install mindroot
+```
+
+For development, you can install the package in editable mode:
+
+```bash
+git clone https://github.com/mindroot/mindroot.git
+cd mindroot
+pip install -e .
+```
+
+
+Key Features:
+
+- Public registry for sharing and finding plugins, agents, personas, models, and knowledgebases
+  - https://registry.agenthost.org (work in progress)
+  - Customizable and swappable for user-specific registries
+- Extensible plugin architecture for adding services, commands, and building arbitrary web apps
+- Customizable AI agents with persona definitions
+- Intelligent service management based on agent requirements
+- Flexible service providers for various AI capabilities
+- Plugins can add/use hooks and pipelines such as for modifying prompts, running startup commands, or anything you want
+- Easily customizable UI built on Jinja2 and Lit Web Components
+- Support for both local and remote AI services
+- RAG: easily share, find and use pre-generated embeddings and documents for topic knowledgebases
+
+Core Concepts Overview
+----------------------
+
+mindroot revolves around several key concepts:
+
+1. **Open Public Registry**: A flexible system for indexing and sharing plugins, agents, personas, and potentially models. It can be customized or replaced with user-specific registries.
+
+2. **Plugins**: Extend the functionality of mindroot, providing new features, services, or integrations.
+
+3. **Agents and Personas**: AI agents with defined capabilities and customizable personalities.
+
+4. **Services and Providers**: Backend services that power agent capabilities, with support for swapping between local and remote implementations.
+
+5. **Intelligent Service Management**: The system automatically determines and installs required services based on agent definitions.
+
+6. **UI Customization**: Easily modifiable user interface through theme overrides and injections.
+
+7. **RAG and Knowledgebases**: The community can easily share and search for topic embeddings and document sets rather than everyone rebuilding them per topic.

mindroot-0.1.0/README.md

@@ -0,0 +1,59 @@
+
+Mindroot
+
+[![PyPI](https://img.shields.io/pypi/v/mindroot)](https://pypi.org/project/mindroot/)
+
+**Note: some of the following is a work in progress and not yet functional. A few of them aren't really started.**
+
+Mindroot is a powerful plugin-based Python framework for creating, deploying, and sharing AI agents and related models. It offers a flexible architecture with indices and a public registry (coming soon) for easily sharing and finding plugins, agents, personas, services, knowledgebases, and apps.
+
+Installation
+------------
+
+You can install Mindroot using pip:
+
+```bash
+pip install mindroot
+```
+
+For development, you can install the package in editable mode:
+
+```bash
+git clone https://github.com/mindroot/mindroot.git
+cd mindroot
+pip install -e .
+```
+
+
+Key Features:
+
+- Public registry for sharing and finding plugins, agents, personas, models, and knowledgebases
+  - https://registry.agenthost.org (work in progress)
+  - Customizable and swappable for user-specific registries
+- Extensible plugin architecture for adding services, commands, and building arbitrary web apps
+- Customizable AI agents with persona definitions
+- Intelligent service management based on agent requirements
+- Flexible service providers for various AI capabilities
+- Plugins can add/use hooks and pipelines such as for modifying prompts, running startup commands, or anything you want
+- Easily customizable UI built on Jinja2 and Lit Web Components
+- Support for both local and remote AI services
+- RAG: easily share, find and use pre-generated embeddings and documents for topic knowledgebases
+
+Core Concepts Overview
+----------------------
+
+mindroot revolves around several key concepts:
+
+1. **Open Public Registry**: A flexible system for indexing and sharing plugins, agents, personas, and potentially models. It can be customized or replaced with user-specific registries.
+
+2. **Plugins**: Extend the functionality of mindroot, providing new features, services, or integrations.
+
+3. **Agents and Personas**: AI agents with defined capabilities and customizable personalities.
+
+4. **Services and Providers**: Backend services that power agent capabilities, with support for swapping between local and remote implementations.
+
+5. **Intelligent Service Management**: The system automatically determines and installs required services based on agent definitions.
+
+6. **UI Customization**: Easily modifiable user interface through theme overrides and injections.
+
+7. **RAG and Knowledgebases**: The community can easily share and search for topic embeddings and document sets rather than everyone rebuilding them per topic.

mindroot-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mindroot"
+version = "0.1.0"
+description = "An agent framework using LLMs"
+authors = [{name = "Jason Livesay", email = "runvnc@gmail.com"}]
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+]
+dependencies = [
+    "fastapi",
+    "uvicorn",
+    "jinja2",
+    "nanoid",
+    "termcolor",
+    "colored",
+    "loguru",
+    "python-multipart",
+    "pytz",
+    "PyJWT",
+    "pluggy",
+    "sse_starlette",
+    "partial-json-parser",
+    "pydantic",
+    "setuptools",
+    "requests",
+    "aiohttp", # now ad python image library
+    "Pillow",
+    "psutil"
+]
+
+
+[project.urls]
+Homepage = "https://github.com/runvncmindroot"
+
+
+[project.scripts]
+mindroot = "mindroot.server:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+
+[tool.setuptools.packages.find]
+where = ["src"]
+exclude = ["*local*", "*data*", "*personas*", "*static*", "*imgs*", "*models*"]
+
+
+

mindroot-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mindroot-0.1.0/src/mindroot/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left empty to mark the directory as a Python package.

mindroot-0.1.0/src/mindroot/coreplugins/admin/__init__.py

@@ -0,0 +1 @@
+ # This file is required to make Python treat the directory as a package.

mindroot-0.1.0/src/mindroot/coreplugins/admin/agent_importer.py

@@ -0,0 +1,173 @@
+from pathlib import Path
+import json
+import shutil
+import logging
+from typing import Dict, List
+import os
+import tempfile
+import requests
+import zipfile
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# These should be moved to a config file or environment variables
+AGENT_BASE_DIR = Path('data/agents')
+PERSONA_BASE_DIR = Path('personas')
+
+CONFIRM_OVERWRITE_AGENT = os.environ.get('CONFIRM_OVERWRITE_AGENT', 'false')
+if CONFIRM_OVERWRITE_AGENT.lower() in ['true', '1']:
+    CONFIRM_OVERWRITE_AGENT = True
+else:
+    CONFIRM_OVERWRITE_AGENT = False
+
+def download_github_files(repo_path: str, tag: str = None) -> tuple[str, str]:
+    """Download GitHub repo files to temp directory"""
+    # Format the download URL
+    if tag:
+        download_url = f"https://github.com/{repo_path}/archive/refs/tags/{tag}.zip"
+    else:
+        download_url = f"https://github.com/{repo_path}/archive/refs/heads/main.zip"
+    
+    # Create temp directory
+    temp_dir = tempfile.mkdtemp()
+    zip_path = os.path.join(temp_dir, 'repo.zip')
+    
+    try:
+        # Download the zip file
+        response = requests.get(download_url)
+        response.raise_for_status()
+        
+        with open(zip_path, 'wb') as f:
+            f.write(response.content)
+        
+        # Extract zip
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(temp_dir)
+        
+        return temp_dir, os.path.dirname(zip_path)
+            
+    except Exception as e:
+        shutil.rmtree(temp_dir)
+        raise e
+
+def scan_for_agents(directory: Path) -> Dict[str, Dict]:
+    discovered_agents = {}
+    for agent_file in directory.rglob('agent.json'):
+        try:
+            with agent_file.open('r') as f:
+                agent_data = json.load(f)
+            agent_name = agent_data.get('name')
+            if agent_name:
+                discovered_agents[agent_name] = {
+                    'path': agent_file.parent,
+                    'data': agent_data
+                }
+        except json.JSONDecodeError:
+            logger.error(f"Failed to parse agent file: {agent_file}")
+        except PermissionError:
+            logger.error(f"Permission denied when reading: {agent_file}")
+    return discovered_agents
+
+def validate_agent_structure(agent_data: Dict) -> bool:
+    required_fields = ['name', 'persona', 'commands']
+    return all(field in agent_data for field in required_fields)
+
+def import_agent(agent_name: str, agent_info: Dict, scope: str) -> None:
+    target_dir = Path(AGENT_BASE_DIR) / scope / agent_name
+    if CONFIRM_OVERWRITE_AGENT and target_dir.exists():
+        logger.warning(f"Agent {agent_name} already exists in {scope} scope, skipping")
+        return
+    
+    if not validate_agent_structure(agent_info['data']):
+        logger.error(f"Agent {agent_name} has invalid structure, skipping")
+        return
+
+    try:
+        shutil.copytree(agent_info['path'], target_dir, dirs_exist_ok=True)
+        logger.info(f"Imported agent {agent_name} to {target_dir}")
+
+        persona_name = agent_info['data'].get('persona')
+        if persona_name:
+            persona_dir = os.path.join(agent_info['path'].parent.parent, "personas")
+            import_persona(persona_name, persona_dir, scope)
+    except PermissionError:
+        logger.error(f"Permission denied when copying agent {agent_name}")
+    except shutil.Error as e:
+        logger.error(f"Error copying agent {agent_name}: {e}")
+
+def import_persona(persona_name: str, source_dir: Path, scope: str) -> None:
+    persona_source = Path(source_dir) / persona_name
+    if not persona_source.exists():
+        logger.warning(f"Referenced persona {persona_name} not found in {source_dir}")
+        return
+    
+    persona_target = PERSONA_BASE_DIR / scope / persona_name
+    if CONFIRM_OVERWRITE_AGENT and persona_target.exists():
+        logger.warning(f"Persona {persona_name} already exists, skipping import")
+        return
+    
+    try:
+        shutil.copytree(persona_source, persona_target, dirs_exist_ok=True)
+        logger.info(f"Imported persona {persona_name} to {persona_target}")
+    except PermissionError:
+        logger.error(f"Permission denied when copying persona {persona_name}")
+    except shutil.Error as e:
+        logger.error(f"Error copying persona {persona_name}: {e}")
+
+def scan_and_import_agents(directory: Path, scope: str) -> Dict[str, List[str]]:
+    if not directory.is_dir():
+        raise ValueError(f"Invalid directory path: {directory}")
+    
+    if scope not in ['local', 'shared']:
+        raise ValueError(f"Invalid scope: {scope}")
+    
+    discovered_agents = scan_for_agents(directory)
+    
+    imported_agents = []
+    for agent_name, agent_info in discovered_agents.items():
+        try:
+            import_agent(agent_name, agent_info, scope)
+            imported_agents.append(agent_name)
+        except Exception as e:
+            logger.error(f"Failed to import agent {agent_name}: {e}")
+    
+    return {
+        'imported_agents': imported_agents,
+        'total_imported': len(imported_agents),
+        'total_discovered': len(discovered_agents)
+    }
+
+def import_github_agent(repo_path: str, scope: str, tag: str = None) -> Dict[str, any]:
+    """Import an agent from a GitHub repository"""
+    try:
+        # Download and extract GitHub repository
+        temp_dir, extract_path = download_github_files(repo_path, tag)
+        
+        try:
+            # Scan the downloaded directory for agents
+            discovered = scan_for_agents(Path(temp_dir))
+            if not discovered:
+                raise ValueError("No valid agents found in repository")
+            
+            # Import each discovered agent
+            result = scan_and_import_agents(Path(temp_dir), scope)
+            
+            return {
+                'success': True,
+                'message': f"Successfully imported {result['total_imported']} agents from GitHub",
+                'imported_agents': result['imported_agents']
+            }
+            
+        finally:
+            # Clean up temp directory
+            shutil.rmtree(temp_dir)
+            
+    except Exception as e:
+        logger.error(f"Failed to import agent from GitHub: {str(e)}")
+        return {
+            'success': False,
+            'message': f"Failed to import agent: {str(e)}",
+            'imported_agents': []
+        }

mindroot-0.1.0/src/mindroot/coreplugins/admin/agent_router.py

@@ -0,0 +1,163 @@
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from pydantic import BaseModel
+from pathlib import Path
+import json
+from .agent_importer import scan_and_import_agents, import_github_agent
+from .persona_handler import handle_persona_import
+
+router = APIRouter()
+
+BASE_DIR = Path('data/agents')
+local_dir = BASE_DIR / "local"
+shared_dir = BASE_DIR / "shared"
+local_dir.mkdir(parents=True, exist_ok=True)
+shared_dir.mkdir(parents=True, exist_ok=True)
+
+class GitHubImportRequest(BaseModel):
+    repo_path: str  # Format: "owner/repo"
+    scope: str
+    tag: str = None
+
+async def load_persona_data(persona_name: str) -> dict:
+    """Load persona data from local or shared directory"""
+    persona_path = Path('personas/local') / persona_name / 'persona.json'
+    if not persona_path.exists():
+        persona_path = Path('personas/shared') / persona_name / 'persona.json'
+        
+    if not persona_path.exists():
+        return {}
+        
+    with open(persona_path, 'r') as f:
+        return json.load(f)
+
+async def load_agent_data(agent_name: str) -> dict:
+    """Load agent data from local or shared directory"""
+    agent_path = BASE_DIR / 'local' / agent_name / 'agent.json'
+    if not agent_path.exists():
+        agent_path = BASE_DIR / 'shared' / agent_name / 'agent.json'
+        if not agent_path.exists():
+            raise FileNotFoundError(f'Agent {agent_name} not found')
+    
+    with open(agent_path, 'r') as f:
+        agent_data = json.load(f)
+        
+    # Get the persona data if specified
+    if 'persona' in agent_data:
+        persona_data = await load_persona_data(agent_data['persona'])
+        agent_data['persona'] = persona_data
+        
+    return agent_data
+
+@router.get('/agents/full/{scope}/{name}')
+async def get_full_agent_data(scope: str, name: str):
+    """Get complete agent data including persona"""
+    if scope not in ['local', 'shared']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    
+    try:
+        agent_data = await load_agent_data(name)
+        return agent_data
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/agents/{scope}/{name}')
+def read_agent(scope: str, name: str):
+    if scope not in ['local', 'shared']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    agent_path = BASE_DIR / scope / name / 'agent.json'
+    if not agent_path.exists():
+        raise HTTPException(status_code=404, detail='Agent not found')
+    with open(agent_path, 'r') as f:
+        agent = json.load(f)
+    return agent
+
+@router.get('/agents/{scope}')
+def list_agents(scope: str):
+    if scope not in ['local', 'shared']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    scope_dir = BASE_DIR / scope
+    agents = [p.name for p in scope_dir.iterdir() if p.is_dir()]
+    return [{'name': name} for name in agents]
+
+@router.post('/agents/{scope}')
+def create_agent(scope: str, agent: str = Form(...)):
+    try:
+        agent_data = json.loads(agent)
+        if scope not in ['local', 'shared']:
+            raise HTTPException(status_code=400, detail='Invalid scope')
+        
+        agent_name = agent_data.get('name')
+        if not agent_name:
+            raise HTTPException(status_code=400, detail='Agent name is required')
+            
+        # Handle persona if present
+        if 'persona' in agent_data:
+            # This will either return the persona name or handle the import
+            # and return the name
+            persona_name = handle_persona_import(agent_data['persona'], scope)
+            agent_data['persona'] = persona_name
+            
+        agent_path = BASE_DIR / scope / agent_name / 'agent.json'
+        if agent_path.exists():
+            raise HTTPException(status_code=400, detail='Agent already exists')
+            
+        agent_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(agent_path, 'w') as f:
+            json.dump(agent_data, f, indent=2)
+            
+        return {'status': 'success'}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail='Internal server error ' + str(e))
+
+@router.put('/agents/{scope}/{name}')
+def update_agent(scope: str, name: str, agent: str = Form(...)):
+    try:
+        agent = json.loads(agent)
+        if scope not in ['local', 'shared']:
+            raise HTTPException(status_code=400, detail='Invalid scope')
+        agent_path = BASE_DIR / scope / name / 'agent.json'
+        if not agent_path.exists():
+            raise HTTPException(status_code=404, detail='Agent not found')
+        with open(agent_path, 'w') as f:
+            json.dump(agent, f, indent=2)
+        return {'status': 'success'}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail='Internal server error ' + str(e))
+
+class ScanDirectoryRequest(BaseModel):
+    directory: str
+    scope: str
+
+@router.post('/scan-and-import-agents')
+def scan_and_import_agents_endpoint(request: ScanDirectoryRequest):
+    try:
+        result = scan_and_import_agents(Path(request.directory), request.scope)
+        return {
+            'success': True,
+            'message': f"Imported {result['total_imported']} out of {result['total_discovered']} discovered agents",
+            'imported_agents': result['imported_agents']
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error during import: {str(e)}")
+
+@router.post('/import-github-agent')
+def import_github_agent_endpoint(request: GitHubImportRequest):
+    try:
+        if request.scope not in ['local', 'shared']:
+            raise HTTPException(status_code=400, detail='Invalid scope')
+
+        result = import_github_agent(request.repo_path, request.scope, request.tag)
+        
+        if not result['success']:
+            raise HTTPException(status_code=400, detail=result['message'])
+            
+        return result
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error during GitHub import: {str(e)}")

mindroot-0.1.0/src/mindroot/coreplugins/admin/persona_handler.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+import json
+import logging
+from fastapi import HTTPException
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def handle_persona_import(persona_data: dict, scope: str) -> str:
+    """Handle importing a persona from embedded data in agent configuration.
+    Returns the persona name to be used in agent configuration.
+    
+    Args:
+        persona_data: Dictionary containing persona data or string with persona name
+        scope: 'local' or 'shared'
+        
+    Returns:
+        str: Name of the persona to reference in agent config
+    """
+    
+    # If persona_data is already a string, just return it
+    if isinstance(persona_data, str):
+        return persona_data
+        
+    # Validate persona data
+    if not isinstance(persona_data, dict):
+        raise HTTPException(
+            status_code=400,
+            detail='Persona data must be either a string name or a dictionary'
+        )
+    
+    persona_name = persona_data.get('name')
+    if not persona_name:
+        raise HTTPException(
+            status_code=400,
+            detail='Persona name required in persona data'
+        )
+    
+    # Create persona path
+    persona_path = Path('personas') / scope / persona_name / 'persona.json'
+    
+    # Check if persona already exists
+    if persona_path.exists():
+        logger.warning(f"Persona '{persona_name}' already exists in {scope} scope - skipping import")
+        return persona_name
+    
+    try:
+        # Create persona directory and save data
+        persona_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(persona_path, 'w') as f:
+            json.dump(persona_data, f, indent=2)
+        
+        logger.info(f"Successfully imported persona '{persona_name}' to {scope} scope")
+        return persona_name
+        
+    except Exception as e:
+        logger.error(f"Failed to import persona '{persona_name}': {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to import persona: {str(e)}"
+        )