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

sirchmunk/api/monitor.py

@@ -0,0 +1,219 @@
+# Copyright (c) ModelScope Contributors. All rights reserved.
+"""
+Real-time system monitoring API endpoints
+Provides actual system metrics and activity tracking
+"""
+
+from fastapi import APIRouter, HTTPException
+from datetime import datetime
+
+from sirchmunk.api.components.monitor_tracker import get_monitor_tracker, llm_usage_tracker
+
+router = APIRouter(prefix="/api/v1/monitor", tags=["monitor"])
+
+# === API Endpoints ===
+
+@router.get("/overview")
+async def get_monitoring_overview():
+    """
+    Get comprehensive monitoring overview
+    
+    Returns:
+        - System metrics (CPU, memory, disk)
+        - Chat activity statistics
+        - Knowledge cluster statistics
+        - Storage information
+        - Health status
+    """
+    try:
+        tracker = get_monitor_tracker()
+        overview = tracker.get_overview()
+        
+        return {
+            "success": True,
+            "data": overview
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/system")
+async def get_system_metrics():
+    """
+    Get current system metrics
+    
+    Returns:
+        - CPU usage and count
+        - Memory usage and capacity
+        - Disk usage and capacity
+        - Network connections
+        - System uptime
+        - Process-specific metrics
+    """
+    try:
+        tracker = get_monitor_tracker()
+        metrics = tracker.get_system_metrics()
+        
+        return {
+            "success": True,
+            "data": metrics
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/health")
+async def get_health_status():
+    """
+    Get comprehensive health status
+    
+    Returns:
+        - Overall health score
+        - Status (excellent/good/warning/critical)
+        - Issues list
+        - Service availability
+    """
+    try:
+        tracker = get_monitor_tracker()
+        health = tracker.get_health_status()
+        
+        return {
+            "success": True,
+            "data": health
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/chat")
+async def get_chat_activity(hours: int = 24):
+    """
+    Get chat activity statistics
+    
+    Query params:
+        hours: Time window in hours (default: 24)
+    
+    Returns:
+        - Total sessions
+        - Total messages
+        - Recent sessions (top 10)
+        - Active sessions count
+    """
+    try:
+        tracker = get_monitor_tracker()
+        activity = tracker.get_chat_activity(hours=hours)
+        
+        return {
+            "success": True,
+            "data": activity
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/knowledge")
+async def get_knowledge_activity():
+    """
+    Get knowledge cluster activity statistics
+    
+    Returns:
+        - Total clusters
+        - Recent clusters (top 10)
+        - Lifecycle distribution
+        - Average confidence
+    """
+    try:
+        tracker = get_monitor_tracker()
+        activity = tracker.get_knowledge_activity()
+        
+        return {
+            "success": True,
+            "data": activity
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/storage")
+async def get_storage_info():
+    """
+    Get storage information
+    
+    Returns:
+        - Work path
+        - Cache path
+        - Database sizes
+        - Total cache size
+    """
+    try:
+        tracker = get_monitor_tracker()
+        storage = tracker.get_storage_info()
+        
+        return {
+            "success": True,
+            "data": storage
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/llm")
+async def get_llm_usage():
+    """
+    Get LLM usage statistics
+    
+    Returns:
+        - Total calls
+        - Total input/output/total tokens
+        - Calls per minute
+        - Models usage breakdown
+    """
+    try:
+        stats = llm_usage_tracker.get_stats()
+        return {
+            "success": True,
+            "data": stats
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/status")
+async def get_simple_status():
+    """
+    Get simple status summary (for quick health checks)
+    
+    Returns:
+        Basic system status information
+    """
+    try:
+        tracker = get_monitor_tracker()
+        health = tracker.get_health_status()
+        metrics = tracker.get_system_metrics()
+        
+        return {
+            "success": True,
+            "status": health["overall_status"],
+            "health_score": health["health_score"],
+            "cpu_usage": metrics.get("cpu", {}).get("usage_percent", 0),
+            "memory_usage": metrics.get("memory", {}).get("usage_percent", 0),
+            "disk_usage": metrics.get("disk", {}).get("usage_percent", 0),
+            "uptime": metrics.get("uptime", ""),
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/refresh")
+async def refresh_metrics():
+    """
+    Force refresh of monitoring metrics
+    
+    Returns:
+        Updated overview data
+    """
+    try:
+        # Simply get fresh data
+        tracker = get_monitor_tracker()
+        overview = tracker.get_overview()
+        
+        return {
+            "success": True,
+            "message": "Metrics refreshed successfully",
+            "data": overview
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

sirchmunk/api/run_server.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+FastAPI server runner for Sirchmunk API
+Provides a simple way to start the API server with proper configuration
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+def main():
+    """Main entry point for running the FastAPI server"""
+    try:
+        import uvicorn
+        from sirchmunk.api.main import app
+        
+        # Get configuration from environment
+        host = os.environ.get("API_HOST", "0.0.0.0")
+        port = int(os.environ.get("API_PORT", os.environ.get("BACKEND_PORT", "8584")))
+        reload = os.environ.get("API_RELOAD", "true").lower() == "true"
+        log_level = os.environ.get("API_LOG_LEVEL", "info")
+        
+        print(f"🚀 Starting Sirchmunk API server...")
+        print(f"   Host: {host}")
+        print(f"   Port: {port}")
+        print(f"   Reload: {reload}")
+        print(f"   Log Level: {log_level}")
+        print(f"   Docs: http://{host}:{port}/docs")
+        
+        # Start the server
+        uvicorn.run(
+            app,
+            host=host,
+            port=port,
+            reload=reload,
+            log_level=log_level,
+            access_log=True
+        )
+        
+    except ImportError as e:
+        print(f"❌ Failed to import required modules: {e}")
+        print("   Please install required dependencies:")
+        print("   pip install fastapi uvicorn")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ Failed to start server: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

sirchmunk/api/search.py

@@ -0,0 +1,230 @@
+# Copyright (c) ModelScope Contributors. All rights reserved.
+"""
+Search API endpoints for CLI and programmatic access.
+
+Provides HTTP endpoints for executing AgenticSearch queries,
+designed for CLI client mode and external integrations.
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import List, Optional, Literal
+import logging
+
+from sirchmunk.search import AgenticSearch
+from sirchmunk.llm.openai_chat import OpenAIChat
+from sirchmunk.utils.constants import (
+    LLM_BASE_URL, 
+    LLM_API_KEY, 
+    LLM_MODEL_NAME,
+    DEFAULT_SIRCHMUNK_WORK_PATH,
+)
+
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v1", tags=["search"])
+
+
+# === Request/Response Models ===
+
+class SearchRequest(BaseModel):
+    """Request model for search endpoint."""
+    query: str = Field(..., description="Search query or question")
+    search_paths: List[str] = Field(
+        default_factory=list,
+        description="Paths to search (directories or files)"
+    )
+    mode: Literal["FAST", "DEEP", "FILENAME_ONLY"] = Field(
+        default="DEEP",
+        description="Search mode: FAST, DEEP, or FILENAME_ONLY"
+    )
+    max_depth: Optional[int] = Field(
+        default=None,
+        description="Maximum directory depth to search"
+    )
+    top_k_files: Optional[int] = Field(
+        default=None,
+        description="Number of top files to return"
+    )
+    keyword_levels: Optional[int] = Field(
+        default=None,
+        description="Number of keyword granularity levels"
+    )
+    include_patterns: Optional[List[str]] = Field(
+        default=None,
+        description="File patterns to include (glob)"
+    )
+    exclude_patterns: Optional[List[str]] = Field(
+        default=None,
+        description="File patterns to exclude (glob)"
+    )
+    return_cluster: bool = Field(
+        default=False,
+        description="Return full KnowledgeCluster object"
+    )
+
+
+class SearchResponse(BaseModel):
+    """Response model for search endpoint."""
+    success: bool
+    data: dict
+    error: Optional[str] = None
+
+
+# === Cached Search Instance ===
+
+_search_instance: Optional[AgenticSearch] = None
+
+
+def _get_search_instance() -> AgenticSearch:
+    """Get or create AgenticSearch instance.
+    
+    Uses lazy initialization and caches the instance for reuse.
+    
+    Returns:
+        AgenticSearch instance
+        
+    Raises:
+        HTTPException: If LLM API key is not configured
+    """
+    global _search_instance
+    
+    if _search_instance is None:
+        if not LLM_API_KEY:
+            raise HTTPException(
+                status_code=500,
+                detail="LLM_API_KEY is not configured. Set it in your environment or .env file."
+            )
+        
+        llm = OpenAIChat(
+            base_url=LLM_BASE_URL,
+            api_key=LLM_API_KEY,
+            model=LLM_MODEL_NAME,
+        )
+        
+        _search_instance = AgenticSearch(
+            llm=llm,
+            work_path=DEFAULT_SIRCHMUNK_WORK_PATH,
+            verbose=False,
+        )
+        
+        logger.info("AgenticSearch instance created for API")
+    
+    return _search_instance
+
+
+# === API Endpoints ===
+
+@router.post("/search")
+async def execute_search(request: SearchRequest) -> SearchResponse:
+    """Execute an AgenticSearch query.
+    
+    This endpoint performs a full search using AgenticSearch,
+    including keyword extraction, file retrieval, content analysis,
+    and summary generation.
+    
+    Args:
+        request: Search request parameters
+        
+    Returns:
+        SearchResponse with search results
+        
+    Raises:
+        HTTPException: If search fails or configuration is invalid
+    """
+    try:
+        searcher = _get_search_instance()
+        
+        # Use current directory if no paths provided
+        search_paths = request.search_paths if request.search_paths else ["."]
+        
+        logger.info(f"Executing search: query='{request.query}', mode={request.mode}, paths={search_paths}")
+        
+        # Build search kwargs
+        search_kwargs = {
+            "input": request.query,
+            "search_paths": search_paths,
+            "mode": request.mode,
+            "return_cluster": request.return_cluster,
+        }
+        
+        # Add optional parameters if provided
+        if request.max_depth is not None:
+            search_kwargs["max_depth"] = request.max_depth
+        if request.top_k_files is not None:
+            search_kwargs["top_k_files"] = request.top_k_files
+        if request.keyword_levels is not None:
+            search_kwargs["keyword_levels"] = request.keyword_levels
+        if request.include_patterns:
+            search_kwargs["include"] = request.include_patterns
+        if request.exclude_patterns:
+            search_kwargs["exclude"] = request.exclude_patterns
+        
+        # Execute search
+        result = await searcher.search(**search_kwargs)
+        
+        # Format response
+        if request.return_cluster and hasattr(result, "to_dict"):
+            # Return full cluster data
+            return SearchResponse(
+                success=True,
+                data={
+                    "type": "cluster",
+                    "cluster": result.to_dict(),
+                }
+            )
+        elif isinstance(result, list):
+            # FILENAME_ONLY mode returns list
+            return SearchResponse(
+                success=True,
+                data={
+                    "type": "files",
+                    "files": result,
+                    "count": len(result),
+                }
+            )
+        else:
+            # Standard text summary
+            return SearchResponse(
+                success=True,
+                data={
+                    "type": "summary",
+                    "summary": str(result) if result else "No results found.",
+                }
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Search failed: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Search failed: {str(e)}"
+        )
+
+
+@router.get("/search/status")
+async def get_search_status():
+    """Get search service status.
+    
+    Returns:
+        Service status information
+    """
+    try:
+        has_api_key = bool(LLM_API_KEY)
+        
+        return {
+            "success": True,
+            "data": {
+                "status": "ready" if has_api_key else "not_configured",
+                "llm_configured": has_api_key,
+                "llm_model": LLM_MODEL_NAME if has_api_key else None,
+                "work_path": DEFAULT_SIRCHMUNK_WORK_PATH,
+            }
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+        }