claude-mpm 5.4.14__py3-none-any.whl → 5.4.36__py3-none-any.whl

claude_mpm/services/monitor/server.py

@@ -29,7 +29,6 @@ from watchdog.observers import Observer
 
 from ...core.enums import ServiceState
 from ...core.logging_config import get_logger
-from ...dashboard.api.simple_directory import list_directory
 from .event_emitter import get_event_emitter
 from .handlers.code_analysis import CodeAnalysisHandler
 from .handlers.dashboard import DashboardHandler
@@ -588,6 +587,243 @@ class UnifiedMonitorServer:
                         {"success": False, "error": str(e)}, status=500
                     )
 
+            # File listing endpoint for file browser
+            async def api_files_handler(request):
+                """List files in a directory for the file browser."""
+                try:
+                    # Get path from query param, default to working directory
+                    path = request.query.get("path", str(Path.cwd()))
+                    dir_path = Path(path)
+
+                    if not dir_path.exists():
+                        return web.json_response(
+                            {"success": False, "error": "Directory not found"},
+                            status=404,
+                        )
+
+                    if not dir_path.is_dir():
+                        return web.json_response(
+                            {"success": False, "error": "Path is not a directory"},
+                            status=400,
+                        )
+
+                    # Patterns to exclude
+                    exclude_patterns = {
+                        ".git",
+                        "node_modules",
+                        "__pycache__",
+                        ".svelte-kit",
+                        "venv",
+                        ".venv",
+                        "dist",
+                        "build",
+                        ".next",
+                        ".cache",
+                        ".pytest_cache",
+                        ".mypy_cache",
+                        ".ruff_cache",
+                        "eggs",
+                        "*.egg-info",
+                        ".tox",
+                        ".nox",
+                        "htmlcov",
+                        ".coverage",
+                    }
+
+                    entries = []
+                    try:
+                        for entry in sorted(
+                            dir_path.iterdir(),
+                            key=lambda x: (not x.is_dir(), x.name.lower()),
+                        ):
+                            # Skip hidden files and excluded patterns
+                            if entry.name.startswith(".") and entry.name not in {
+                                ".env",
+                                ".gitignore",
+                            }:
+                                if entry.name in {".git", ".svelte-kit", ".cache"}:
+                                    continue
+                            if entry.name in exclude_patterns:
+                                continue
+                            if any(
+                                entry.name.endswith(p.replace("*", ""))
+                                for p in exclude_patterns
+                                if "*" in p
+                            ):
+                                continue
+
+                            try:
+                                stat = entry.stat()
+                                entries.append(
+                                    {
+                                        "name": entry.name,
+                                        "path": str(entry),
+                                        "type": "directory"
+                                        if entry.is_dir()
+                                        else "file",
+                                        "size": stat.st_size if entry.is_file() else 0,
+                                        "modified": stat.st_mtime,
+                                        "extension": entry.suffix.lstrip(".")
+                                        if entry.is_file()
+                                        else None,
+                                    }
+                                )
+                            except (PermissionError, OSError):
+                                continue
+
+                    except PermissionError:
+                        return web.json_response(
+                            {"success": False, "error": "Permission denied"},
+                            status=403,
+                        )
+
+                    # Separate directories and files
+                    directories = [e for e in entries if e["type"] == "directory"]
+                    files = [e for e in entries if e["type"] == "file"]
+
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "path": str(dir_path),
+                            "directories": directories,
+                            "files": files,
+                            "total_directories": len(directories),
+                            "total_files": len(files),
+                        }
+                    )
+
+                except Exception as e:
+                    self.logger.error(f"Error listing directory: {e}")
+                    return web.json_response(
+                        {"success": False, "error": str(e)}, status=500
+                    )
+
+            # File read endpoint (GET) for file browser
+            async def api_file_read_handler(request):
+                """Read file content via GET request."""
+                import base64
+
+                try:
+                    file_path = request.query.get("path", "")
+
+                    if not file_path:
+                        return web.json_response(
+                            {"success": False, "error": "Path parameter required"},
+                            status=400,
+                        )
+
+                    path = Path(file_path)
+
+                    if not path.exists():
+                        return web.json_response(
+                            {"success": False, "error": "File not found"},
+                            status=404,
+                        )
+
+                    if not path.is_file():
+                        return web.json_response(
+                            {"success": False, "error": "Path is not a file"},
+                            status=400,
+                        )
+
+                    # Get file info
+                    file_size = path.stat().st_size
+                    file_ext = path.suffix.lstrip(".").lower()
+
+                    # Define image extensions
+                    image_extensions = {
+                        "png",
+                        "jpg",
+                        "jpeg",
+                        "gif",
+                        "svg",
+                        "webp",
+                        "ico",
+                        "bmp",
+                    }
+
+                    # Check if file is an image
+                    if file_ext in image_extensions:
+                        # Read as binary and encode to base64
+                        try:
+                            binary_content = path.read_bytes()
+                            base64_content = base64.b64encode(binary_content).decode(
+                                "utf-8"
+                            )
+
+                            # Map extension to MIME type
+                            mime_types = {
+                                "png": "image/png",
+                                "jpg": "image/jpeg",
+                                "jpeg": "image/jpeg",
+                                "gif": "image/gif",
+                                "svg": "image/svg+xml",
+                                "webp": "image/webp",
+                                "ico": "image/x-icon",
+                                "bmp": "image/bmp",
+                            }
+                            mime_type = mime_types.get(file_ext, "image/png")
+
+                            return web.json_response(
+                                {
+                                    "success": True,
+                                    "path": str(path),
+                                    "content": base64_content,
+                                    "size": file_size,
+                                    "type": "image",
+                                    "mime": mime_type,
+                                    "extension": file_ext,
+                                }
+                            )
+                        except Exception as e:
+                            self.logger.error(f"Error reading image file: {e}")
+                            return web.json_response(
+                                {
+                                    "success": False,
+                                    "error": f"Failed to read image: {e!s}",
+                                },
+                                status=500,
+                            )
+
+                    # Read text file content
+                    try:
+                        content = path.read_text(encoding="utf-8")
+                        lines = content.count("\n") + 1
+                    except UnicodeDecodeError:
+                        return web.json_response(
+                            {"success": False, "error": "File is not a text file"},
+                            status=415,
+                        )
+
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "path": str(path),
+                            "content": content,
+                            "lines": lines,
+                            "size": file_size,
+                            "type": file_ext or "text",
+                        }
+                    )
+
+                except Exception as e:
+                    self.logger.error(f"Error reading file: {e}")
+                    return web.json_response(
+                        {"success": False, "error": str(e)}, status=500
+                    )
+
+            # Favicon handler
+            async def favicon_handler(request):
+                """Serve favicon.svg from static directory."""
+                from aiohttp.web_fileresponse import FileResponse
+
+                favicon_path = static_dir / "svelte-build" / "favicon.svg"
+                if favicon_path.exists():
+                    return FileResponse(
+                        favicon_path, headers={"Content-Type": "image/svg+xml"}
+                    )
+                raise web.HTTPNotFound()
+
             # Version endpoint for dashboard build tracker
             async def version_handler(request):
                 """Serve version information for dashboard build tracker."""
@@ -653,7 +889,7 @@ class UnifiedMonitorServer:
             async def working_directory_handler(request):
                 """Return the current working directory."""
                 return web.json_response(
-                    {"working_directory": Path.cwd(), "success": True}
+                    {"working_directory": str(Path.cwd()), "success": True}
                 )
 
             # Monitor page routes
@@ -671,15 +907,249 @@ class UnifiedMonitorServer:
                     return web.Response(text=content, content_type="text/html")
                 return web.Response(text="Page not found", status=404)
 
+            # Git history handler
+            async def git_history_handler(request: web.Request) -> web.Response:
+                """Get git history for a file."""
+                import subprocess
+
+                try:
+                    data = await request.json()
+                    file_path = data.get("path", "")
+                    limit = data.get("limit", 10)
+
+                    if not file_path:
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "No path provided",
+                                "commits": [],
+                            },
+                            status=400,
+                        )
+
+                    path = Path(file_path)
+                    if not path.exists():
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "File not found",
+                                "commits": [],
+                            },
+                            status=404,
+                        )
+
+                    # Get git log for file
+                    result = subprocess.run(
+                        [
+                            "git",
+                            "log",
+                            f"-{limit}",
+                            "--pretty=format:%H|%an|%ar|%s",
+                            "--",
+                            str(path),
+                        ],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(path.parent),
+                    )
+
+                    commits = []
+                    if result.returncode == 0 and result.stdout:
+                        for line in result.stdout.strip().split("\n"):
+                            if line:
+                                parts = line.split("|", 3)
+                                if len(parts) == 4:
+                                    commits.append(
+                                        {
+                                            "hash": parts[0][:7],
+                                            "author": parts[1],
+                                            "date": parts[2],
+                                            "message": parts[3],
+                                        }
+                                    )
+
+                    return web.json_response({"success": True, "commits": commits})
+                except Exception as e:
+                    return web.json_response(
+                        {"success": False, "error": str(e), "commits": []}, status=500
+                    )
+
+            # Git diff handler
+            async def git_diff_handler(request: web.Request) -> web.Response:
+                """Get git diff for a file with optional commit selection."""
+                import subprocess
+
+                try:
+                    file_path = request.query.get("path", "")
+                    commit_hash = request.query.get(
+                        "commit", ""
+                    )  # Optional commit hash
+
+                    if not file_path:
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "No path provided",
+                                "diff": "",
+                                "has_changes": False,
+                            },
+                            status=400,
+                        )
+
+                    path = Path(file_path)
+                    if not path.exists():
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "File not found",
+                                "diff": "",
+                                "has_changes": False,
+                            },
+                            status=404,
+                        )
+
+                    # Find git repository root
+                    git_root_result = subprocess.run(
+                        ["git", "rev-parse", "--show-toplevel"],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(path.parent),
+                    )
+
+                    if git_root_result.returncode != 0:
+                        # Not in a git repository
+                        return web.json_response(
+                            {
+                                "success": True,
+                                "diff": "",
+                                "has_changes": False,
+                                "tracked": False,
+                                "history": [],
+                                "has_uncommitted": False,
+                            }
+                        )
+
+                    git_root = Path(git_root_result.stdout.strip())
+
+                    # Check if file is tracked by git
+                    ls_files_result = subprocess.run(
+                        ["git", "ls-files", "--error-unmatch", str(path)],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(git_root),
+                    )
+
+                    if ls_files_result.returncode != 0:
+                        # File is not tracked by git
+                        return web.json_response(
+                            {
+                                "success": True,
+                                "diff": "",
+                                "has_changes": False,
+                                "tracked": False,
+                                "history": [],
+                                "has_uncommitted": False,
+                            }
+                        )
+
+                    # Get commit history for this file (last 5 commits)
+                    history_result = subprocess.run(
+                        [
+                            "git",
+                            "log",
+                            "-5",
+                            "--pretty=format:%H|%s|%ar",
+                            "--",
+                            str(path),
+                        ],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(git_root),
+                    )
+
+                    history = []
+                    if history_result.returncode == 0 and history_result.stdout:
+                        for line in history_result.stdout.strip().split("\n"):
+                            if line:
+                                parts = line.split("|", 2)
+                                if len(parts) == 3:
+                                    history.append(
+                                        {
+                                            "hash": parts[0][:7],  # Short hash
+                                            "full_hash": parts[0],  # Full hash for API
+                                            "message": parts[1],
+                                            "time_ago": parts[2],
+                                        }
+                                    )
+
+                    # Check for uncommitted changes
+                    uncommitted_result = subprocess.run(
+                        ["git", "diff", "HEAD", str(path)],
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                        cwd=str(git_root),
+                    )
+
+                    has_uncommitted = bool(uncommitted_result.stdout.strip())
+
+                    # Get diff based on commit parameter
+                    if commit_hash:
+                        # Get diff for specific commit
+                        result = subprocess.run(
+                            ["git", "show", commit_hash, "--", str(path)],
+                            check=False,
+                            capture_output=True,
+                            text=True,
+                            cwd=str(git_root),
+                        )
+                        diff_output = result.stdout if result.returncode == 0 else ""
+                        has_changes = bool(diff_output.strip())
+                    else:
+                        # Get uncommitted diff (default behavior)
+                        diff_output = uncommitted_result.stdout
+                        has_changes = has_uncommitted
+
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "diff": diff_output,
+                            "has_changes": has_changes,
+                            "tracked": True,
+                            "history": history,
+                            "has_uncommitted": has_uncommitted,
+                        }
+                    )
+                except Exception as e:
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": str(e),
+                            "diff": "",
+                            "has_changes": False,
+                            "history": [],
+                            "has_uncommitted": False,
+                        },
+                        status=500,
+                    )
+
             # Register routes
             self.app.router.add_get("/", dashboard_index)
+            self.app.router.add_get("/favicon.svg", favicon_handler)
             self.app.router.add_get("/health", health_check)
             self.app.router.add_get("/version.json", version_handler)
             self.app.router.add_get("/api/config", config_handler)
             self.app.router.add_get("/api/working-directory", working_directory_handler)
-            self.app.router.add_get("/api/directory", list_directory)
+            self.app.router.add_get("/api/files", api_files_handler)
+            self.app.router.add_get("/api/file/read", api_file_read_handler)
+            self.app.router.add_get("/api/file/diff", git_diff_handler)
             self.app.router.add_post("/api/events", api_events_handler)
             self.app.router.add_post("/api/file", api_file_handler)
+            self.app.router.add_post("/api/git-history", git_history_handler)
 
             # Monitor page routes
             self.app.router.add_get("/monitor", lambda r: monitor_page_handler(r))