sirchmunk 0.0.1.post1__py3-none-any.whl → 0.0.2__py3-none-any.whl

sirchmunk/api/settings.py

@@ -0,0 +1,309 @@
+# Copyright (c) ModelScope Contributors. All rights reserved.
+"""
+Settings API endpoints with persistent storage
+Provides UI settings and environment variable management
+"""
+
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any, Optional
+from pydantic import BaseModel
+
+from sirchmunk.api.components.settings_storage import SettingsStorage
+from sirchmunk.utils.constants import (
+    GREP_CONCURRENT_LIMIT,
+    LLM_BASE_URL,
+    LLM_API_KEY,
+    LLM_MODEL_NAME,
+    SIRCHMUNK_WORK_PATH
+)
+
+router = APIRouter(prefix="/api/v1/settings", tags=["settings"])
+
+# Initialize settings storage (with error handling)
+try:
+    settings_storage = SettingsStorage()
+except Exception as e:
+    print(f"[ERROR] Failed to initialize SettingsStorage: {e}")
+    settings_storage = None
+
+# === Request/Response Models ===
+
+class UISettings(BaseModel):
+    theme: str = "light"
+    language: str = "en"
+
+class EnvironmentVariables(BaseModel):
+    SIRCHMUNK_WORK_PATH: Optional[str] = None
+    LLM_BASE_URL: Optional[str] = None
+    LLM_API_KEY: Optional[str] = None
+    LLM_MODEL_NAME: Optional[str] = None
+    GREP_CONCURRENT_LIMIT: Optional[int] = None
+
+class SaveSettingsRequest(BaseModel):
+    ui: Optional[UISettings] = None
+    environment: Optional[Dict[str, str]] = None
+
+# === Helper Functions ===
+
+def get_default_ui_settings() -> Dict[str, Any]:
+    """Get default UI settings"""
+    return {
+        "theme": settings_storage.get_setting("ui.theme", "light"),
+        "language": settings_storage.get_setting("ui.language", "en"),
+    }
+
+def get_current_env_variables() -> Dict[str, Any]:
+    """Get current environment variables with saved overrides"""
+    # Get saved values from storage
+    saved_work_path = settings_storage.get_env_variable("SIRCHMUNK_WORK_PATH")
+    saved_llm_base_url = settings_storage.get_env_variable("LLM_BASE_URL")
+    saved_llm_api_key = settings_storage.get_env_variable("LLM_API_KEY")
+    saved_llm_model = settings_storage.get_env_variable("LLM_MODEL_NAME")
+    saved_grep_limit = settings_storage.get_env_variable("GREP_CONCURRENT_LIMIT")
+    
+    return {
+        "SIRCHMUNK_WORK_PATH": {
+            "value": saved_work_path or str(SIRCHMUNK_WORK_PATH),
+            "default": str(SIRCHMUNK_WORK_PATH),
+            "description": "Working directory for Sirchmunk data",
+            "category": "system"
+        },
+        "LLM_BASE_URL": {
+            "value": saved_llm_base_url or LLM_BASE_URL,
+            "default": LLM_BASE_URL,
+            "description": "Base URL for LLM API (OpenAI-compatible endpoint)",
+            "category": "llm"
+        },
+        "LLM_API_KEY": {
+            "value": "***" if (saved_llm_api_key or LLM_API_KEY) else "",
+            "default": "***" if LLM_API_KEY else "",
+            "description": "API key for LLM service",
+            "category": "llm",
+                "sensitive": True
+            },
+        "LLM_MODEL_NAME": {
+            "value": saved_llm_model or LLM_MODEL_NAME,
+            "default": LLM_MODEL_NAME,
+            "description": "Model name for LLM",
+            "category": "llm"
+        },
+        "GREP_CONCURRENT_LIMIT": {
+            "value": saved_grep_limit or str(GREP_CONCURRENT_LIMIT),
+            "default": str(GREP_CONCURRENT_LIMIT),
+            "description": "Maximum concurrent grep requests",
+            "category": "system"
+        }
+    }
+
+# === API Endpoints ===
+
+@router.get("")
+async def get_all_settings():
+    """Get all settings including UI and environment variables"""
+    if settings_storage is None:
+        raise HTTPException(status_code=503, detail="Settings storage not available")
+    
+    try:
+        ui_settings = get_default_ui_settings()
+        env_variables = get_current_env_variables()
+    
+        return {
+            "success": True,
+            "data": {
+                    "ui": ui_settings,
+                    "environment": env_variables
+                }
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/ui")
+async def get_ui_settings():
+    """Get UI settings"""
+    if settings_storage is None:
+        # Return default settings if storage not available
+        return {
+            "success": True,
+            "data": {
+                    "theme": "light",
+                    "language": "en"
+                }
+            }
+    
+    try:
+        ui_settings = get_default_ui_settings()
+        return {
+            "success": True,
+                "data": ui_settings
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/environment")
+async def get_environment_variables():
+    """Get environment variables"""
+    if settings_storage is None:
+        raise HTTPException(status_code=503, detail="Settings storage not available")
+    
+    try:
+        env_variables = get_current_env_variables()
+        return {
+            "success": True,
+                "data": env_variables
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("")
+async def save_settings(request: SaveSettingsRequest):
+    """Save settings (UI and/or environment variables)"""
+    if settings_storage is None:
+        raise HTTPException(status_code=503, detail="Settings storage not available")
+    
+    try:
+        saved_items = []
+        
+        # Save UI settings
+        if request.ui:
+            if request.ui.theme:
+                settings_storage.save_setting("ui.theme", request.ui.theme, "ui")
+                saved_items.append("theme")
+            
+            if request.ui.language:
+                settings_storage.save_setting("ui.language", request.ui.language, "ui")
+                saved_items.append("language")
+        
+        # Save environment variables
+        if request.environment:
+            for key, value in request.environment.items():
+                if value:  # Only save non-empty values
+                    # For sensitive fields, store the actual value (not masked)
+                    settings_storage.save_env_variable(
+                        key, 
+                        value,
+                        description=f"User-configured {key}",
+                        category="llm" if "LLM" in key else "system"
+                    )
+                    saved_items.append(key)
+    
+        return {
+            "success": True,
+                "message": f"Settings saved successfully: {', '.join(saved_items)}",
+                "saved_items": saved_items
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to save settings: {str(e)}")
+
+@router.post("/ui")
+async def update_ui_settings(ui: UISettings):
+    """Update UI settings"""
+    if settings_storage is None:
+        raise HTTPException(status_code=503, detail="Settings storage not available")
+    
+    try:
+        settings_storage.save_setting("ui.theme", ui.theme, "ui")
+        settings_storage.save_setting("ui.language", ui.language, "ui")
+        
+        return {
+            "success": True,
+            "message": "UI settings updated successfully",
+            "data": {
+                "theme": ui.theme,
+                "language": ui.language
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/test/llm")
+async def test_llm_connection():
+    """Test LLM connection"""
+    from sirchmunk.llm import OpenAIChat
+
+    try:
+        # Get current LLM settings
+        base_url = settings_storage.get_env_variable("LLM_BASE_URL") or LLM_BASE_URL
+        api_key = settings_storage.get_env_variable("LLM_API_KEY") or LLM_API_KEY
+        model = settings_storage.get_env_variable("LLM_MODEL_NAME") or LLM_MODEL_NAME
+
+        print(f"[DEBUG] Testing LLM connection with base_url={base_url}, model={model}, api_key={'***' if api_key else '(not set)'}")
+        
+        # Simple validation
+        if not api_key:
+            return {
+                "success": False,
+                    "status": "error",
+                    "message": "LLM API key is not configured",
+                    "model": None
+                }
+        
+        if not base_url:
+            return {
+                        "success": False,
+                        "status": "error",
+                        "message": "LLM base URL is not configured",
+                        "model": None
+                    }
+        
+
+        llm = OpenAIChat(
+            base_url=base_url,
+            api_key=api_key,
+            model=model
+        )
+
+        messages = [
+            {"role": "system",
+             "content": "You are a helpful AI assistant."},
+            {"role": "user", "content": "Output the word: 'test'."}
+        ]
+        resp = await llm.achat(
+            messages=messages,
+            stream=False
+        )
+        print(f"[DEBUG] LLM response: {resp.content}")
+
+        return {
+            "success": True,
+                "status": "configured",
+                "message": "LLM connection successful",
+                "model": model,
+                "base_url": base_url
+            }
+    except Exception as e:
+        return {
+                "success": False,
+                "status": "error",
+                "message": str(e),
+                "model": None
+        }
+
+@router.get("/status")
+async def get_settings_status():
+    """Get settings status for quick overview"""
+    try:
+        ui_settings = get_default_ui_settings()
+        
+        # Check LLM configuration
+        llm_api_key = settings_storage.get_env_variable("LLM_API_KEY") or LLM_API_KEY
+        llm_base_url = settings_storage.get_env_variable("LLM_BASE_URL") or LLM_BASE_URL
+        llm_model = settings_storage.get_env_variable("LLM_MODEL_NAME") or LLM_MODEL_NAME
+        
+        llm_configured = bool(llm_api_key and llm_base_url and llm_model)
+    
+        return {
+            "success": True,
+            "data": {
+                    "ui": {
+                        "theme": ui_settings.get("theme", "light"),
+                        "language": ui_settings.get("language", "en")
+                    },
+                    "llm": {
+                        "configured": llm_configured,
+                        "model": llm_model if llm_configured else None,
+                        "status": "ready" if llm_configured else "not_configured"
+                    }
+                }
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

sirchmunk/api/tools.py

@@ -0,0 +1,315 @@
+# Copyright (c) ModelScope Contributors. All rights reserved.
+"""
+Tools API endpoints for Sirchmunk
+Handles quick actions like file export, PPT generation, document conversion, etc.
+"""
+
+from fastapi import APIRouter, HTTPException
+from typing import Dict, List, Any, Optional
+import uuid
+from datetime import datetime, timedelta
+import random
+
+router = APIRouter(prefix="/api/v1/tools", tags=["tools"])
+
+# Mock tool configurations
+TOOL_CONFIGS = {
+    "export-pdf": {
+        "name": "PDF Export",
+        "description": "Export conversation or content to PDF format",
+        "processing_time": (2, 5),  # seconds range
+        "output_format": "pdf"
+    },
+    "generate-ppt": {
+        "name": "PPT Generation", 
+        "description": "Generate PowerPoint presentation from content",
+        "processing_time": (5, 10),
+        "output_format": "pptx"
+    },
+    "convert-doc": {
+        "name": "Document Conversion",
+        "description": "Convert documents between different formats",
+        "processing_time": (3, 7),
+        "output_format": "various"
+    },
+    "generate-video": {
+        "name": "Video Generation",
+        "description": "Create video content from text or images",
+        "processing_time": (15, 30),
+        "output_format": "mp4"
+    },
+    "create-image": {
+        "name": "Image Creation",
+        "description": "Generate images using AI",
+        "processing_time": (3, 8),
+        "output_format": "png"
+    },
+    "export-excel": {
+        "name": "Excel Export",
+        "description": "Export data to Excel spreadsheet",
+        "processing_time": (2, 4),
+        "output_format": "xlsx"
+    }
+}
+
+@router.get("/")
+async def list_available_tools():
+    """List all available tools and their configurations"""
+    try:
+        tools = []
+        for tool_id, config in TOOL_CONFIGS.items():
+            tools.append({
+                "id": tool_id,
+                "name": config["name"],
+                "description": config["description"],
+                "output_format": config["output_format"],
+                "estimated_time": f"{config['processing_time'][0]}-{config['processing_time'][1]}s"
+            })
+        
+        return {
+            "success": True,
+            "data": tools,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to list tools: {str(e)}")
+
+@router.post("/{tool_id}")
+async def execute_tool(tool_id: str, request: Dict[str, Any]):
+    """
+    Execute a specific tool
+    
+    Args:
+        tool_id: ID of the tool to execute
+        request: Tool execution parameters
+    """
+    try:
+        if tool_id not in TOOL_CONFIGS:
+            raise HTTPException(status_code=404, detail=f"Tool '{tool_id}' not found")
+        
+        config = TOOL_CONFIGS[tool_id]
+        
+        # Simulate processing time
+        processing_time = random.randint(*config["processing_time"])
+        
+        # Generate mock result based on tool type
+        result = await _generate_tool_result(tool_id, config, request)
+        
+        return {
+            "success": True,
+            "data": result,
+            "message": f"{config['name']} completed successfully",
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to execute tool: {str(e)}")
+
+async def _generate_tool_result(tool_id: str, config: Dict[str, Any], request: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate mock result for tool execution"""
+    
+    base_result = {
+        "task_id": str(uuid.uuid4()),
+        "tool_id": tool_id,
+        "tool_name": config["name"],
+        "started_at": datetime.now().isoformat(),
+        "completed_at": (datetime.now() + timedelta(seconds=random.randint(*config["processing_time"]))).isoformat(),
+        "status": "completed"
+    }
+    
+    if tool_id == "export-pdf":
+        return {
+            **base_result,
+            "output": {
+                "file_name": f"conversation_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf",
+                "file_size": f"{random.randint(500, 2000)} KB",
+                "pages": random.randint(3, 15),
+                "download_url": f"https://example.com/downloads/pdf_{base_result['task_id']}.pdf"
+            },
+            "metadata": {
+                "format": "PDF",
+                "quality": "high",
+                "includes_images": True,
+                "includes_formatting": True
+            }
+        }
+    
+    elif tool_id == "generate-ppt":
+        return {
+            **base_result,
+            "output": {
+                "file_name": f"presentation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pptx",
+                "file_size": f"{random.randint(2, 8)} MB",
+                "slides": random.randint(8, 20),
+                "download_url": f"https://example.com/downloads/ppt_{base_result['task_id']}.pptx"
+            },
+            "metadata": {
+                "template": "professional",
+                "theme": "modern",
+                "includes_charts": True,
+                "includes_animations": False
+            }
+        }
+    
+    elif tool_id == "convert-doc":
+        source_format = request.get("source_format", "docx")
+        target_format = request.get("target_format", "pdf")
+        
+        return {
+            **base_result,
+            "output": {
+                "file_name": f"converted_document_{datetime.now().strftime('%Y%m%d_%H%M%S')}.{target_format}",
+                "file_size": f"{random.randint(800, 3000)} KB",
+                "download_url": f"https://example.com/downloads/converted_{base_result['task_id']}.{target_format}"
+            },
+            "metadata": {
+                "source_format": source_format,
+                "target_format": target_format,
+                "conversion_quality": "high",
+                "preserved_formatting": True
+            }
+        }
+    
+    elif tool_id == "generate-video":
+        return {
+            **base_result,
+            "output": {
+                "file_name": f"generated_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4",
+                "file_size": f"{random.randint(10, 50)} MB",
+                "duration": f"{random.randint(30, 180)} seconds",
+                "download_url": f"https://example.com/downloads/video_{base_result['task_id']}.mp4"
+            },
+            "metadata": {
+                "resolution": "1920x1080",
+                "fps": 30,
+                "codec": "H.264",
+                "audio": True
+            }
+        }
+    
+    elif tool_id == "create-image":
+        return {
+            **base_result,
+            "output": {
+                "file_name": f"generated_image_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png",
+                "file_size": f"{random.randint(500, 2000)} KB",
+                "dimensions": "1024x1024",
+                "download_url": f"https://example.com/downloads/image_{base_result['task_id']}.png"
+            },
+            "metadata": {
+                "format": "PNG",
+                "quality": "high",
+                "style": "photorealistic",
+                "ai_model": "DALL-E 3"
+            }
+        }
+    
+    elif tool_id == "export-excel":
+        return {
+            **base_result,
+            "output": {
+                "file_name": f"data_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx",
+                "file_size": f"{random.randint(200, 1500)} KB",
+                "sheets": random.randint(1, 5),
+                "rows": random.randint(100, 5000),
+                "download_url": f"https://example.com/downloads/excel_{base_result['task_id']}.xlsx"
+            },
+            "metadata": {
+                "format": "Excel 2019",
+                "includes_charts": True,
+                "includes_formulas": True,
+                "data_types": ["text", "numbers", "dates"]
+            }
+        }
+    
+    else:
+        return {
+            **base_result,
+            "output": {
+                "message": "Tool executed successfully",
+                "result": "Generic tool result"
+            }
+        }
+
+@router.get("/{tool_id}/status")
+async def get_tool_status(tool_id: str):
+    """Get the current status of a tool"""
+    try:
+        if tool_id not in TOOL_CONFIGS:
+            raise HTTPException(status_code=404, detail=f"Tool '{tool_id}' not found")
+        
+        config = TOOL_CONFIGS[tool_id]
+        
+        status_data = {
+            "tool_id": tool_id,
+            "name": config["name"],
+            "status": "available",
+            "description": config["description"],
+            "output_format": config["output_format"],
+            "estimated_processing_time": f"{config['processing_time'][0]}-{config['processing_time'][1]} seconds",
+            "usage_stats": {
+                "total_executions": random.randint(50, 500),
+                "success_rate": round(random.uniform(0.85, 0.99), 2),
+                "average_processing_time": f"{random.randint(config['processing_time'][0], config['processing_time'][1])} seconds"
+            },
+            "last_used": (datetime.now() - timedelta(hours=random.randint(1, 48))).isoformat()
+        }
+        
+        return {
+            "success": True,
+            "data": status_data,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get tool status: {str(e)}")
+
+@router.get("/history")
+async def get_tool_execution_history(
+    tool_id: Optional[str] = None,
+    limit: int = 20,
+    offset: int = 0
+):
+    """Get tool execution history"""
+    try:
+        # Generate mock history
+        history = []
+        
+        for i in range(limit):
+            if tool_id and tool_id not in TOOL_CONFIGS:
+                continue
+                
+            selected_tool_id = tool_id or random.choice(list(TOOL_CONFIGS.keys()))
+            config = TOOL_CONFIGS[selected_tool_id]
+            
+            execution = {
+                "id": str(uuid.uuid4()),
+                "tool_id": selected_tool_id,
+                "tool_name": config["name"],
+                "status": random.choice(["completed", "completed", "completed", "failed"]),
+                "started_at": (datetime.now() - timedelta(hours=random.randint(1, 168))).isoformat(),
+                "completed_at": (datetime.now() - timedelta(hours=random.randint(1, 168))).isoformat(),
+                "processing_time": f"{random.randint(*config['processing_time'])} seconds",
+                "output_size": f"{random.randint(100, 5000)} KB"
+            }
+            
+            history.append(execution)
+        
+        return {
+            "success": True,
+            "data": history,
+            "pagination": {
+                "limit": limit,
+                "offset": offset,
+                "total": random.randint(100, 1000)
+            },
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get tool history: {str(e)}")

sirchmunk/cli/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) ModelScope Contributors. All rights reserved.
+"""
+Sirchmunk Command Line Interface.
+
+Provides CLI commands for initialization, configuration, server management,
+and search operations.
+"""
+
+from .cli import run_cmd
+
+__all__ = ["run_cmd"]