arch-ops-server 0.1.3__py3-none-any.whl → 3.0.0__py3-none-any.whl

arch_ops_server/server.py

@@ -24,16 +24,59 @@ from mcp.types import (
 )
 
 from . import (
+    # Wiki functions
     search_wiki,
     get_wiki_page_as_text,
+    # AUR functions
     search_aur,
     get_aur_info,
     get_pkgbuild,
     analyze_pkgbuild_safety,
     analyze_package_metadata_risk,
+    install_package_secure,
+    # Pacman functions
     get_official_package_info,
     check_updates_dry_run,
-    install_package_secure,
+    remove_package,
+    remove_packages_batch,
+    list_orphan_packages,
+    remove_orphans,
+    find_package_owner,
+    list_package_files,
+    search_package_files,
+    verify_package_integrity,
+    list_package_groups,
+    list_group_packages,
+    list_explicit_packages,
+    mark_as_explicit,
+    mark_as_dependency,
+    check_database_freshness,
+    # System functions
+    get_system_info,
+    check_disk_space,
+    get_pacman_cache_stats,
+    check_failed_services,
+    get_boot_logs,
+    # News functions
+    get_latest_news,
+    check_critical_news,
+    get_news_since_last_update,
+    # Logs functions
+    get_transaction_history,
+    find_when_installed,
+    find_failed_transactions,
+    get_database_sync_history,
+    # Mirrors functions
+    list_active_mirrors,
+    test_mirror_speed,
+    suggest_fastest_mirrors,
+    check_mirrorlist_health,
+    # Config functions
+    analyze_pacman_conf,
+    analyze_makepkg_conf,
+    check_ignored_packages,
+    get_parallel_downloads_setting,
+    # Utils
     IS_ARCH,
     run_command,
 )
@@ -58,12 +101,14 @@ async def list_resources() -> list[Resource]:
         List of Resource objects describing available URI schemes
     """
     return [
+        # Wiki resources
         Resource(
             uri="archwiki://Installation_guide",
             name="Arch Wiki - Installation Guide",
             mimeType="text/markdown",
             description="Example: Fetch Arch Wiki pages as Markdown"
         ),
+        # AUR resources
         Resource(
             uri="aur://yay/pkgbuild",
             name="AUR - yay PKGBUILD",
@@ -76,18 +121,134 @@ async def list_resources() -> list[Resource]:
             mimeType="application/json",
             description="Example: Fetch AUR package metadata (votes, maintainer, etc)"
         ),
+        # Official repository resources
         Resource(
             uri="archrepo://vim",
             name="Official Repository - Package Info",
             mimeType="application/json",
             description="Example: Fetch official repository package details"
         ),
+        # Pacman resources
         Resource(
             uri="pacman://installed",
             name="System - Installed Packages",
             mimeType="application/json",
             description="List installed packages on Arch Linux system"
         ),
+        Resource(
+            uri="pacman://orphans",
+            name="System - Orphan Packages",
+            mimeType="application/json",
+            description="List orphaned packages (dependencies no longer required)"
+        ),
+        Resource(
+            uri="pacman://explicit",
+            name="System - Explicitly Installed Packages",
+            mimeType="application/json",
+            description="List packages explicitly installed by user"
+        ),
+        Resource(
+            uri="pacman://groups",
+            name="System - Package Groups",
+            mimeType="application/json",
+            description="List all available package groups"
+        ),
+        Resource(
+            uri="pacman://group/base-devel",
+            name="System - Packages in base-devel Group",
+            mimeType="application/json",
+            description="Example: List packages in a specific group"
+        ),
+        # System resources
+        Resource(
+            uri="system://info",
+            name="System - System Information",
+            mimeType="application/json",
+            description="Get system information (kernel, arch, memory, uptime)"
+        ),
+        Resource(
+            uri="system://disk",
+            name="System - Disk Space",
+            mimeType="application/json",
+            description="Check disk space usage for critical paths"
+        ),
+        Resource(
+            uri="system://services/failed",
+            name="System - Failed Services",
+            mimeType="application/json",
+            description="List failed systemd services"
+        ),
+        Resource(
+            uri="system://logs/boot",
+            name="System - Boot Logs",
+            mimeType="text/plain",
+            description="Get recent boot logs from journalctl"
+        ),
+        # News resources
+        Resource(
+            uri="archnews://latest",
+            name="Arch News - Latest",
+            mimeType="application/json",
+            description="Get latest Arch Linux news announcements"
+        ),
+        Resource(
+            uri="archnews://critical",
+            name="Arch News - Critical",
+            mimeType="application/json",
+            description="Get critical Arch Linux news requiring manual intervention"
+        ),
+        Resource(
+            uri="archnews://since-update",
+            name="Arch News - Since Last Update",
+            mimeType="application/json",
+            description="Get news posted since last pacman update"
+        ),
+        # Transaction log resources
+        Resource(
+            uri="pacman://log/recent",
+            name="Pacman Log - Recent Transactions",
+            mimeType="application/json",
+            description="Get recent package transactions from pacman log"
+        ),
+        Resource(
+            uri="pacman://log/failed",
+            name="Pacman Log - Failed Transactions",
+            mimeType="application/json",
+            description="Get failed package transactions"
+        ),
+        # Mirror resources
+        Resource(
+            uri="mirrors://active",
+            name="Mirrors - Active Configuration",
+            mimeType="application/json",
+            description="Get currently configured mirrors"
+        ),
+        Resource(
+            uri="mirrors://health",
+            name="Mirrors - Health Status",
+            mimeType="application/json",
+            description="Get mirror configuration health assessment"
+        ),
+        # Config resources
+        Resource(
+            uri="config://pacman",
+            name="Config - pacman.conf",
+            mimeType="application/json",
+            description="Get parsed pacman.conf configuration"
+        ),
+        Resource(
+            uri="config://makepkg",
+            name="Config - makepkg.conf",
+            mimeType="application/json",
+            description="Get parsed makepkg.conf configuration"
+        ),
+        # Database resources
+        Resource(
+            uri="pacman://database/freshness",
+            name="Pacman - Database Freshness",
+            mimeType="application/json",
+            description="Check when package databases were last synchronized"
+        ),
     ]
 
 
@@ -95,20 +256,28 @@ async def list_resources() -> list[Resource]:
 async def read_resource(uri: str) -> str:
     """
     Read a resource by URI.
-    
+
     Supported schemes:
     - archwiki://{page_title} - Returns Wiki page as Markdown
     - aur://{package}/pkgbuild - Returns raw PKGBUILD file
     - aur://{package}/info - Returns AUR package metadata
     - archrepo://{package} - Returns official repository package info
     - pacman://installed - Returns list of installed packages (Arch only)
-    
+    - pacman://orphans - Returns list of orphaned packages (Arch only)
+    - pacman://explicit - Returns list of explicitly installed packages (Arch only)
+    - pacman://groups - Returns list of all package groups (Arch only)
+    - pacman://group/{group_name} - Returns packages in a specific group (Arch only)
+    - system://info - Returns system information
+    - system://disk - Returns disk space information
+    - system://services/failed - Returns failed systemd services
+    - system://logs/boot - Returns recent boot logs
+
     Args:
         uri: Resource URI (can be string or AnyUrl object)
-    
+
     Returns:
         Resource content as string
-    
+
     Raises:
         ValueError: If URI scheme is unsupported or resource not found
     """
@@ -169,26 +338,159 @@ async def read_resource(uri: str) -> str:
         return json.dumps(package_info, indent=2)
     
     elif scheme == "pacman":
-        if parsed.netloc == "installed" or parsed.path == "/installed":
-            if not IS_ARCH:
-                raise ValueError("pacman://installed only available on Arch Linux systems")
-            
+        if not IS_ARCH:
+            raise ValueError(f"pacman:// resources only available on Arch Linux systems")
+
+        resource_path = parsed.netloc or parsed.path.lstrip('/')
+
+        if resource_path == "installed":
             # Get installed packages
-            result = run_command(["pacman", "-Q"])
-            if result.returncode != 0:
-                raise ValueError(f"Failed to get installed packages: {result.stderr}")
-            
+            exit_code, stdout, stderr = await run_command(["pacman", "-Q"])
+            if exit_code != 0:
+                raise ValueError(f"Failed to get installed packages: {stderr}")
+
             # Parse pacman output
             packages = []
-            for line in result.stdout.strip().split('\n'):
+            for line in stdout.strip().split('\n'):
                 if line.strip():
                     name, version = line.strip().rsplit(' ', 1)
                     packages.append({"name": name, "version": version})
-            
+
             return json.dumps(packages, indent=2)
+
+        elif resource_path == "orphans":
+            # Get orphan packages
+            result = await list_orphan_packages()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "explicit":
+            # Get explicitly installed packages
+            result = await list_explicit_packages()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "groups":
+            # Get all package groups
+            result = await list_package_groups()
+            return json.dumps(result, indent=2)
+
+        elif resource_path.startswith("group/"):
+            # Get packages in specific group
+            group_name = resource_path.split('/', 1)[1]
+            if not group_name:
+                raise ValueError("Group name required (e.g., pacman://group/base-devel)")
+            result = await list_group_packages(group_name)
+            return json.dumps(result, indent=2)
+
+        elif resource_path.startswith("log/"):
+            # Transaction log resources
+            log_type = resource_path.split('/', 1)[1] if '/' in resource_path else ""
+            
+            if log_type == "recent":
+                result = await get_transaction_history()
+                return json.dumps(result, indent=2)
+            elif log_type == "failed":
+                result = await find_failed_transactions()
+                return json.dumps(result, indent=2)
+            else:
+                raise ValueError(f"Unsupported log resource: {log_type}")
+
+        elif resource_path == "database/freshness":
+            # Database freshness check
+            result = await check_database_freshness()
+            return json.dumps(result, indent=2)
+
         else:
-            raise ValueError("Unsupported pacman resource (only pacman://installed supported)")
-    
+            raise ValueError(f"Unsupported pacman resource: {resource_path}")
+
+    elif scheme == "system":
+        resource_path = parsed.netloc or parsed.path.lstrip('/')
+
+        if resource_path == "info":
+            # Get system information
+            result = await get_system_info()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "disk":
+            # Get disk space information
+            result = await check_disk_space()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "services/failed":
+            # Get failed services
+            result = await check_failed_services()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "logs/boot":
+            # Get boot logs
+            result = await get_boot_logs()
+            # Return raw text for logs
+            if result.get("success"):
+                return result.get("logs", "")
+            else:
+                raise ValueError(result.get("error", "Failed to get boot logs"))
+
+        else:
+            raise ValueError(f"Unsupported system resource: {resource_path}")
+
+    elif scheme == "archnews":
+        resource_path = parsed.netloc or parsed.path.lstrip('/')
+
+        if resource_path == "latest":
+            # Get latest news
+            result = await get_latest_news()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "critical":
+            # Get critical news
+            result = await check_critical_news()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "since-update":
+            # Get news since last update
+            result = await get_news_since_last_update()
+            return json.dumps(result, indent=2)
+
+        else:
+            raise ValueError(f"Unsupported archnews resource: {resource_path}")
+
+    elif scheme == "mirrors":
+        if not IS_ARCH:
+            raise ValueError(f"mirrors:// resources only available on Arch Linux systems")
+
+        resource_path = parsed.netloc or parsed.path.lstrip('/')
+
+        if resource_path == "active":
+            # Get active mirrors
+            result = await list_active_mirrors()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "health":
+            # Get mirror health
+            result = await check_mirrorlist_health()
+            return json.dumps(result, indent=2)
+
+        else:
+            raise ValueError(f"Unsupported mirrors resource: {resource_path}")
+
+    elif scheme == "config":
+        if not IS_ARCH:
+            raise ValueError(f"config:// resources only available on Arch Linux systems")
+
+        resource_path = parsed.netloc or parsed.path.lstrip('/')
+
+        if resource_path == "pacman":
+            # Get pacman.conf
+            result = await analyze_pacman_conf()
+            return json.dumps(result, indent=2)
+
+        elif resource_path == "makepkg":
+            # Get makepkg.conf
+            result = await analyze_makepkg_conf()
+            return json.dumps(result, indent=2)
+
+        else:
+            raise ValueError(f"Unsupported config resource: {resource_path}")
+
     else:
         raise ValueError(f"Unsupported URI scheme: {scheme}")
 
@@ -253,73 +555,549 @@ async def list_tools() -> list[Tool]:
                 "required": ["query"]
             }
         ),
-        
+        
+        Tool(
+            name="get_official_package_info",
+            description="Get information about an official Arch repository package (Core, Extra, etc.). Uses local pacman if available, otherwise queries archlinux.org API. Always prefer official packages over AUR when available.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_name": {
+                        "type": "string",
+                        "description": "Exact package name"
+                    }
+                },
+                "required": ["package_name"]
+            }
+        ),
+        
+        Tool(
+            name="check_updates_dry_run",
+            description="Check for available system updates without applying them. Only works on Arch Linux systems. Requires pacman-contrib package. Safe read-only operation that shows pending updates.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+        
+        Tool(
+            name="install_package_secure",
+            description="Install a package with comprehensive security checks. Workflow: 1. Check official repos first (safer) 2. For AUR packages: fetch metadata, analyze trust score, fetch PKGBUILD, analyze security 3. Block installation if critical security issues found 4. Check for AUR helper (paru > yay) 5. Install with --noconfirm if all checks pass. Only works on Arch Linux. Requires sudo access and paru/yay for AUR packages.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_name": {
+                        "type": "string",
+                        "description": "Name of package to install (checks official repos first, then AUR)"
+                    }
+                },
+                "required": ["package_name"]
+            }
+        ),
+        
+        Tool(
+            name="analyze_pkgbuild_safety",
+            description="Analyze PKGBUILD content for security issues and dangerous patterns. Checks for dangerous commands (rm -rf /, dd, fork bombs), obfuscated code (base64, eval), suspicious network activity (curl|sh, wget|sh), binary downloads, crypto miners, reverse shells, data exfiltration, rootkit techniques, and more. Returns risk score (0-100) and detailed findings. Use this tool to manually audit AUR packages before installation.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "pkgbuild_content": {
+                        "type": "string",
+                        "description": "Raw PKGBUILD content to analyze"
+                    }
+                },
+                "required": ["pkgbuild_content"]
+            }
+        ),
+        
+        Tool(
+            name="analyze_package_metadata_risk",
+            description="Analyze AUR package metadata for trustworthiness and security indicators. Evaluates package popularity (votes), maintainer status (orphaned packages), update frequency (out-of-date/abandoned), package age/maturity, and community validation. Returns trust score (0-100) with risk factors and trust indicators. Use this alongside PKGBUILD analysis for comprehensive security assessment.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_info": {
+                        "type": "object",
+                        "description": "Package metadata from AUR (from search_aur or get_aur_info results)"
+                    }
+                },
+                "required": ["package_info"]
+            }
+        ),
+
+        # Package Removal Tools
+        Tool(
+            name="remove_package",
+            description="Remove a package from the system. Supports various removal strategies: basic removal, removal with dependencies, or forced removal. Only works on Arch Linux. Requires sudo access.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_name": {
+                        "type": "string",
+                        "description": "Name of the package to remove"
+                    },
+                    "remove_dependencies": {
+                        "type": "boolean",
+                        "description": "Remove package and its dependencies (pacman -Rs). Default: false",
+                        "default": False
+                    },
+                    "force": {
+                        "type": "boolean",
+                        "description": "Force removal ignoring dependencies (pacman -Rdd). Use with caution! Default: false",
+                        "default": False
+                    }
+                },
+                "required": ["package_name"]
+            }
+        ),
+
+        Tool(
+            name="remove_packages_batch",
+            description="Remove multiple packages in a single transaction. More efficient than removing packages one by one. Only works on Arch Linux. Requires sudo access.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_names": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of package names to remove"
+                    },
+                    "remove_dependencies": {
+                        "type": "boolean",
+                        "description": "Remove packages and their dependencies. Default: false",
+                        "default": False
+                    }
+                },
+                "required": ["package_names"]
+            }
+        ),
+
+        # Orphan Package Management
+        Tool(
+            name="list_orphan_packages",
+            description="List all orphaned packages (dependencies no longer required by any installed package). Shows package names and total disk space usage. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="remove_orphans",
+            description="Remove all orphaned packages to free up disk space. Supports dry-run mode to preview changes and package exclusion. Only works on Arch Linux. Requires sudo access.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "dry_run": {
+                        "type": "boolean",
+                        "description": "Preview what would be removed without actually removing. Default: true",
+                        "default": True
+                    },
+                    "exclude": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of package names to exclude from removal"
+                    }
+                },
+                "required": []
+            }
+        ),
+
+        # Package Ownership Tools
+        Tool(
+            name="find_package_owner",
+            description="Find which package owns a specific file on the system. Useful for troubleshooting and understanding file origins. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Absolute path to the file (e.g., /usr/bin/vim)"
+                    }
+                },
+                "required": ["file_path"]
+            }
+        ),
+
+        Tool(
+            name="list_package_files",
+            description="List all files owned by a package. Supports optional filtering by pattern. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_name": {
+                        "type": "string",
+                        "description": "Name of the package"
+                    },
+                    "filter_pattern": {
+                        "type": "string",
+                        "description": "Optional regex pattern to filter files (e.g., '*.conf' or '/etc/')"
+                    }
+                },
+                "required": ["package_name"]
+            }
+        ),
+
+        Tool(
+            name="search_package_files",
+            description="Search for files across all packages in repositories. Requires package database sync (pacman -Fy). Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "filename_pattern": {
+                        "type": "string",
+                        "description": "File name or pattern to search for (e.g., 'vim' or '*.service')"
+                    }
+                },
+                "required": ["filename_pattern"]
+            }
+        ),
+
+        # Package Verification
+        Tool(
+            name="verify_package_integrity",
+            description="Verify the integrity of installed package files. Detects modified, missing, or corrupted files. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_name": {
+                        "type": "string",
+                        "description": "Name of the package to verify"
+                    },
+                    "thorough": {
+                        "type": "boolean",
+                        "description": "Perform thorough check including file attributes. Default: false",
+                        "default": False
+                    }
+                },
+                "required": ["package_name"]
+            }
+        ),
+
+        # Package Groups
+        Tool(
+            name="list_package_groups",
+            description="List all available package groups (e.g., base, base-devel, gnome). Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="list_group_packages",
+            description="List all packages in a specific group. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "group_name": {
+                        "type": "string",
+                        "description": "Name of the package group (e.g., 'base-devel', 'gnome')"
+                    }
+                },
+                "required": ["group_name"]
+            }
+        ),
+
+        # Install Reason Management
+        Tool(
+            name="list_explicit_packages",
+            description="List all packages explicitly installed by the user (not installed as dependencies). Useful for creating backup lists or understanding system composition. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="mark_as_explicit",
+            description="Mark a package as explicitly installed. Prevents it from being removed as an orphan. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_name": {
+                        "type": "string",
+                        "description": "Name of the package to mark as explicit"
+                    }
+                },
+                "required": ["package_name"]
+            }
+        ),
+
+        Tool(
+            name="mark_as_dependency",
+            description="Mark a package as a dependency. Allows it to be removed as an orphan if no packages depend on it. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_name": {
+                        "type": "string",
+                        "description": "Name of the package to mark as dependency"
+                    }
+                },
+                "required": ["package_name"]
+            }
+        ),
+
+        # System Diagnostic Tools
+        Tool(
+            name="get_system_info",
+            description="Get comprehensive system information including kernel version, architecture, hostname, uptime, and memory statistics. Works on any system.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="check_disk_space",
+            description="Check disk space usage for critical filesystem paths including root, home, var, and pacman cache. Warns when space is low. Works on any system.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="get_pacman_cache_stats",
+            description="Analyze pacman package cache statistics including size, package count, and cache age. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="check_failed_services",
+            description="Check for failed systemd services. Useful for diagnosing system issues. Works on systemd-based systems.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="get_boot_logs",
+            description="Retrieve recent boot logs from journalctl. Useful for troubleshooting boot issues. Works on systemd-based systems.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "lines": {
+                        "type": "integer",
+                        "description": "Number of log lines to retrieve. Default: 100",
+                        "default": 100
+                    }
+                },
+                "required": []
+            }
+        ),
+
+        # News Tools
+        Tool(
+            name="get_latest_news",
+            description="Fetch recent Arch Linux news from RSS feed. Returns title, date, summary, and link for each news item.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of news items to return (default 10)",
+                        "default": 10
+                    },
+                    "since_date": {
+                        "type": "string",
+                        "description": "Optional date in ISO format (YYYY-MM-DD) to filter news"
+                    }
+                },
+                "required": []
+            }
+        ),
+
+        Tool(
+            name="check_critical_news",
+            description="Check for critical Arch Linux news requiring manual intervention. Scans recent news for keywords: 'manual intervention', 'action required', 'breaking change', etc.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "description": "Number of recent news items to check (default 20)",
+                        "default": 20
+                    }
+                },
+                "required": []
+            }
+        ),
+
+        Tool(
+            name="get_news_since_last_update",
+            description="Get news posted since last pacman update. Parses /var/log/pacman.log for last update timestamp. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        # Transaction Log Tools
+        Tool(
+            name="get_transaction_history",
+            description="Get recent package transactions from pacman log. Shows installed, upgraded, and removed packages. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of transactions to return (default 50)",
+                        "default": 50
+                    },
+                    "transaction_type": {
+                        "type": "string",
+                        "description": "Filter by type: install/remove/upgrade/all (default all)",
+                        "enum": ["all", "install", "remove", "upgrade"],
+                        "default": "all"
+                    }
+                },
+                "required": []
+            }
+        ),
+
+        Tool(
+            name="find_when_installed",
+            description="Find when a package was first installed and its upgrade history. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "package_name": {
+                        "type": "string",
+                        "description": "Name of the package to search for"
+                    }
+                },
+                "required": ["package_name"]
+            }
+        ),
+
+        Tool(
+            name="find_failed_transactions",
+            description="Find failed package transactions in pacman log. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="get_database_sync_history",
+            description="Get database synchronization history. Shows when 'pacman -Sy' was run. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of sync events to return (default 20)",
+                        "default": 20
+                    }
+                },
+                "required": []
+            }
+        ),
+
+        # Mirror Management Tools
+        Tool(
+            name="list_active_mirrors",
+            description="List currently configured mirrors from mirrorlist. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        Tool(
+            name="test_mirror_speed",
+            description="Test mirror response time. Can test a specific mirror or all active mirrors. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "mirror_url": {
+                        "type": "string",
+                        "description": "Specific mirror URL to test, or omit to test all active mirrors"
+                    }
+                },
+                "required": []
+            }
+        ),
+
+        Tool(
+            name="suggest_fastest_mirrors",
+            description="Suggest optimal mirrors based on official mirror status from archlinux.org. Filters by country if specified.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "country": {
+                        "type": "string",
+                        "description": "Optional country code to filter mirrors (e.g., 'US', 'DE')"
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Number of mirrors to suggest (default 10)",
+                        "default": 10
+                    }
+                },
+                "required": []
+            }
+        ),
+
+        Tool(
+            name="check_mirrorlist_health",
+            description="Verify mirror configuration health. Checks for common issues like no active mirrors, outdated mirrorlist, high latency. Only works on Arch Linux.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+
+        # Configuration Tools
         Tool(
-            name="get_official_package_info",
-            description="Get information about an official Arch repository package (Core, Extra, etc.). Uses local pacman if available, otherwise queries archlinux.org API. Always prefer official packages over AUR when available.",
+            name="analyze_pacman_conf",
+            description="Parse and analyze pacman.conf. Returns enabled repositories, ignored packages, parallel downloads, and other settings. Only works on Arch Linux.",
             inputSchema={
                 "type": "object",
-                "properties": {
-                    "package_name": {
-                        "type": "string",
-                        "description": "Exact package name"
-                    }
-                },
-                "required": ["package_name"]
+                "properties": {}
             }
         ),
-        
+
         Tool(
-            name="check_updates_dry_run",
-            description="Check for available system updates without applying them. Only works on Arch Linux systems. Requires pacman-contrib package. Safe read-only operation that shows pending updates.",
+            name="analyze_makepkg_conf",
+            description="Parse and analyze makepkg.conf. Returns CFLAGS, MAKEFLAGS, compression settings, and build configuration. Only works on Arch Linux.",
             inputSchema={
                 "type": "object",
                 "properties": {}
             }
         ),
-        
+
         Tool(
-            name="install_package_secure",
-            description="Install a package with comprehensive security checks. Workflow: 1. Check official repos first (safer) 2. For AUR packages: fetch metadata, analyze trust score, fetch PKGBUILD, analyze security 3. Block installation if critical security issues found 4. Check for AUR helper (paru > yay) 5. Install with --noconfirm if all checks pass. Only works on Arch Linux. Requires sudo access and paru/yay for AUR packages.",
+            name="check_ignored_packages",
+            description="List packages ignored in updates from pacman.conf. Warns if critical system packages are ignored. Only works on Arch Linux.",
             inputSchema={
                 "type": "object",
-                "properties": {
-                    "package_name": {
-                        "type": "string",
-                        "description": "Name of package to install (checks official repos first, then AUR)"
-                    }
-                },
-                "required": ["package_name"]
+                "properties": {}
             }
         ),
-        
+
         Tool(
-            name="analyze_pkgbuild_safety",
-            description="Analyze PKGBUILD content for security issues and dangerous patterns. Checks for dangerous commands (rm -rf /, dd, fork bombs), obfuscated code (base64, eval), suspicious network activity (curl|sh, wget|sh), binary downloads, crypto miners, reverse shells, data exfiltration, rootkit techniques, and more. Returns risk score (0-100) and detailed findings. Use this tool to manually audit AUR packages before installation.",
+            name="get_parallel_downloads_setting",
+            description="Get parallel downloads configuration from pacman.conf and provide recommendations. Only works on Arch Linux.",
             inputSchema={
                 "type": "object",
-                "properties": {
-                    "pkgbuild_content": {
-                        "type": "string",
-                        "description": "Raw PKGBUILD content to analyze"
-                    }
-                },
-                "required": ["pkgbuild_content"]
+                "properties": {}
             }
         ),
-        
+
         Tool(
-            name="analyze_package_metadata_risk",
-            description="Analyze AUR package metadata for trustworthiness and security indicators. Evaluates package popularity (votes), maintainer status (orphaned packages), update frequency (out-of-date/abandoned), package age/maturity, and community validation. Returns trust score (0-100) with risk factors and trust indicators. Use this alongside PKGBUILD analysis for comprehensive security assessment.",
+            name="check_database_freshness",
+            description="Check when package databases were last synchronized. Warns if databases are stale (> 24 hours). Only works on Arch Linux.",
             inputSchema={
                 "type": "object",
-                "properties": {
-                    "package_info": {
-                        "type": "object",
-                        "description": "Package metadata from AUR (from search_aur or get_aur_info results)"
-                    }
-                },
-                "required": ["package_info"]
+                "properties": {}
             }
         ),
     ]
@@ -384,7 +1162,265 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent |
         package_info = arguments["package_info"]
         result = analyze_package_metadata_risk(package_info)
         return [TextContent(type="text", text=json.dumps(result, indent=2))]
-    
+
+    # Package Removal Tools
+    elif name == "remove_package":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: remove_package only available on Arch Linux systems")]
+
+        package_name = arguments["package_name"]
+        remove_dependencies = arguments.get("remove_dependencies", False)
+        force = arguments.get("force", False)
+        result = await remove_package(package_name, remove_dependencies, force)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "remove_packages_batch":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: remove_packages_batch only available on Arch Linux systems")]
+
+        package_names = arguments["package_names"]
+        remove_dependencies = arguments.get("remove_dependencies", False)
+        result = await remove_packages_batch(package_names, remove_dependencies)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # Orphan Package Management
+    elif name == "list_orphan_packages":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: list_orphan_packages only available on Arch Linux systems")]
+
+        result = await list_orphan_packages()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "remove_orphans":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: remove_orphans only available on Arch Linux systems")]
+
+        dry_run = arguments.get("dry_run", True)
+        exclude = arguments.get("exclude", None)
+        result = await remove_orphans(dry_run, exclude)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # Package Ownership Tools
+    elif name == "find_package_owner":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: find_package_owner only available on Arch Linux systems")]
+
+        file_path = arguments["file_path"]
+        result = await find_package_owner(file_path)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "list_package_files":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: list_package_files only available on Arch Linux systems")]
+
+        package_name = arguments["package_name"]
+        filter_pattern = arguments.get("filter_pattern", None)
+        result = await list_package_files(package_name, filter_pattern)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "search_package_files":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: search_package_files only available on Arch Linux systems")]
+
+        filename_pattern = arguments["filename_pattern"]
+        result = await search_package_files(filename_pattern)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # Package Verification
+    elif name == "verify_package_integrity":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: verify_package_integrity only available on Arch Linux systems")]
+
+        package_name = arguments["package_name"]
+        thorough = arguments.get("thorough", False)
+        result = await verify_package_integrity(package_name, thorough)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # Package Groups
+    elif name == "list_package_groups":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: list_package_groups only available on Arch Linux systems")]
+
+        result = await list_package_groups()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "list_group_packages":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: list_group_packages only available on Arch Linux systems")]
+
+        group_name = arguments["group_name"]
+        result = await list_group_packages(group_name)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # Install Reason Management
+    elif name == "list_explicit_packages":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: list_explicit_packages only available on Arch Linux systems")]
+
+        result = await list_explicit_packages()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "mark_as_explicit":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: mark_as_explicit only available on Arch Linux systems")]
+
+        package_name = arguments["package_name"]
+        result = await mark_as_explicit(package_name)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "mark_as_dependency":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: mark_as_dependency only available on Arch Linux systems")]
+
+        package_name = arguments["package_name"]
+        result = await mark_as_dependency(package_name)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # System Diagnostic Tools
+    elif name == "get_system_info":
+        result = await get_system_info()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "check_disk_space":
+        result = await check_disk_space()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "get_pacman_cache_stats":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: get_pacman_cache_stats only available on Arch Linux systems")]
+
+        result = await get_pacman_cache_stats()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "check_failed_services":
+        result = await check_failed_services()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "get_boot_logs":
+        lines = arguments.get("lines", 100)
+        result = await get_boot_logs(lines)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # News tools
+    elif name == "get_latest_news":
+        limit = arguments.get("limit", 10)
+        since_date = arguments.get("since_date")
+        result = await get_latest_news(limit=limit, since_date=since_date)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "check_critical_news":
+        limit = arguments.get("limit", 20)
+        result = await check_critical_news(limit=limit)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "get_news_since_last_update":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: get_news_since_last_update only available on Arch Linux systems")]
+        
+        result = await get_news_since_last_update()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # Transaction log tools
+    elif name == "get_transaction_history":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: get_transaction_history only available on Arch Linux systems")]
+        
+        limit = arguments.get("limit", 50)
+        transaction_type = arguments.get("transaction_type", "all")
+        result = await get_transaction_history(limit=limit, transaction_type=transaction_type)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "find_when_installed":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: find_when_installed only available on Arch Linux systems")]
+        
+        package_name = arguments.get("package_name")
+        if not package_name:
+            return [TextContent(type="text", text="Error: package_name required")]
+        
+        result = await find_when_installed(package_name)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "find_failed_transactions":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: find_failed_transactions only available on Arch Linux systems")]
+        
+        result = await find_failed_transactions()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "get_database_sync_history":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: get_database_sync_history only available on Arch Linux systems")]
+        
+        limit = arguments.get("limit", 20)
+        result = await get_database_sync_history(limit=limit)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # Mirror management tools
+    elif name == "list_active_mirrors":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: list_active_mirrors only available on Arch Linux systems")]
+        
+        result = await list_active_mirrors()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "test_mirror_speed":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: test_mirror_speed only available on Arch Linux systems")]
+        
+        mirror_url = arguments.get("mirror_url")
+        result = await test_mirror_speed(mirror_url=mirror_url)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "suggest_fastest_mirrors":
+        country = arguments.get("country")
+        limit = arguments.get("limit", 10)
+        result = await suggest_fastest_mirrors(country=country, limit=limit)
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "check_mirrorlist_health":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: check_mirrorlist_health only available on Arch Linux systems")]
+        
+        result = await check_mirrorlist_health()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    # Configuration tools
+    elif name == "analyze_pacman_conf":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: analyze_pacman_conf only available on Arch Linux systems")]
+        
+        result = await analyze_pacman_conf()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "analyze_makepkg_conf":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: analyze_makepkg_conf only available on Arch Linux systems")]
+        
+        result = await analyze_makepkg_conf()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "check_ignored_packages":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: check_ignored_packages only available on Arch Linux systems")]
+        
+        result = await check_ignored_packages()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "get_parallel_downloads_setting":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: get_parallel_downloads_setting only available on Arch Linux systems")]
+        
+        result = await get_parallel_downloads_setting()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    elif name == "check_database_freshness":
+        if not IS_ARCH:
+            return [TextContent(type="text", text="Error: check_database_freshness only available on Arch Linux systems")]
+        
+        result = await check_database_freshness()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
     else:
         raise ValueError(f"Unknown tool: {name}")
 
@@ -440,6 +1476,11 @@ async def list_prompts() -> list[Prompt]:
                 }
             ]
         ),
+        Prompt(
+            name="safe_system_update",
+            description="Enhanced system update workflow that checks for critical news, disk space, and failed services before updating",
+            arguments=[]
+        ),
     ]
 
 
@@ -669,5 +1710,160 @@ paru -S {package_name}  # or yay -S {package_name}
             ]
         )
     
+    elif name == "safe_system_update":
+        if not IS_ARCH:
+            return GetPromptResult(
+                description="Safe system update workflow",
+                messages=[
+                    PromptMessage(
+                        role="assistant",
+                        content=PromptMessage.TextContent(
+                            type="text",
+                            text="Error: safe_system_update prompt only available on Arch Linux systems"
+                        )
+                    )
+                ]
+            )
+        
+        analysis = "# Safe System Update Workflow\n\n"
+        warnings = []
+        recommendations = []
+        
+        # Step 1: Check for critical news
+        try:
+            critical_news = await check_critical_news(limit=10)
+            
+            if critical_news.get("has_critical"):
+                analysis += "## ⚠️ Critical Arch Linux News\n\n"
+                for news_item in critical_news.get("critical_news", [])[:3]:
+                    analysis += f"**{news_item['title']}**\n"
+                    analysis += f"Published: {news_item['published']}\n"
+                    analysis += f"{news_item['summary'][:200]}...\n"
+                    analysis += f"[Read more]({news_item['link']})\n\n"
+                
+                warnings.append("Critical news requiring manual intervention found!")
+                recommendations.append("Read all critical news articles before updating")
+            else:
+                analysis += "## ✓ No Critical News\n\nNo manual intervention required for recent updates.\n\n"
+        except Exception as e:
+            analysis += f"## ⚠️ News Check Failed\n\n{str(e)}\n\n"
+        
+        # Step 2: Check disk space
+        try:
+            disk_space = await check_disk_space()
+            disk_usage = disk_space.get("disk_usage", {})
+            
+            analysis += "## Disk Space Status\n\n"
+            for path, info in disk_usage.items():
+                if "warning" in info:
+                    analysis += f"- ⚠️ {path}: {info['available']} available ({info['use_percent']} used) - {info['warning']}\n"
+                    warnings.append(f"Low disk space on {path}")
+                else:
+                    analysis += f"- ✓ {path}: {info['available']} available ({info['use_percent']} used)\n"
+            analysis += "\n"
+        except Exception as e:
+            analysis += f"## ⚠️ Disk Space Check Failed\n\n{str(e)}\n\n"
+        
+        # Step 3: Check pending updates
+        try:
+            updates = await check_updates_dry_run()
+            
+            if updates.get("updates_available"):
+                count = updates.get("count", 0)
+                analysis += f"## Pending Updates ({count} packages)\n\n"
+                
+                # Show first 10 updates
+                for update in updates.get("packages", [])[:10]:
+                    analysis += f"- {update['package']}: {update['current_version']} → {update['new_version']}\n"
+                
+                if count > 10:
+                    analysis += f"\n...and {count - 10} more packages\n"
+                analysis += "\n"
+            else:
+                analysis += "## ✓ System Up to Date\n\nNo updates available.\n\n"
+                return GetPromptResult(
+                    description="System is already up to date",
+                    messages=[
+                        PromptMessage(
+                            role="assistant",
+                            content=PromptMessage.TextContent(
+                                type="text",
+                                text=analysis
+                            )
+                        )
+                    ]
+                )
+        except Exception as e:
+            analysis += f"## ⚠️ Update Check Failed\n\n{str(e)}\n\n"
+        
+        # Step 4: Check failed services
+        try:
+            failed_services = await check_failed_services()
+            
+            if not failed_services.get("all_ok"):
+                analysis += "## ⚠️ Failed Services Detected\n\n"
+                for service in failed_services.get("failed_services", [])[:5]:
+                    analysis += f"- {service['unit']}\n"
+                warnings.append("System has failed services")
+                recommendations.append("Investigate failed services before updating")
+                analysis += "\n"
+            else:
+                analysis += "## ✓ All Services Running\n\nNo failed systemd services.\n\n"
+        except Exception as e:
+            analysis += f"## ⚠️ Service Check Failed\n\n{str(e)}\n\n"
+        
+        # Step 5: Check database freshness
+        try:
+            db_freshness = await check_database_freshness()
+            
+            if db_freshness.get("needs_sync"):
+                analysis += "## Database Synchronization\n\n"
+                analysis += f"Databases are {db_freshness.get('oldest_age_hours', 0):.1f} hours old.\n"
+                recommendations.append("Database will be synchronized during update")
+                analysis += "\n"
+        except Exception as e:
+            logger.warning(f"Database freshness check failed: {e}")
+        
+        # Step 6: Summary and recommendations
+        analysis += "## Recommendations\n\n"
+        
+        if warnings:
+            analysis += "### Warnings:\n"
+            for warning in warnings:
+                analysis += f"- ⚠️ {warning}\n"
+            analysis += "\n"
+        
+        if recommendations:
+            analysis += "### Before Updating:\n"
+            for rec in recommendations:
+                analysis += f"- {rec}\n"
+            analysis += "\n"
+        
+        if not warnings:
+            analysis += "✓ System is ready for update\n\n"
+            analysis += "Run: `sudo pacman -Syu`\n"
+        else:
+            analysis += "⚠️ **Address warnings before updating**\n"
+        
+        return GetPromptResult(
+            description="Safe system update analysis",
+            messages=[
+                PromptMessage(
+                    role="user",
+                    content=PromptMessage.TextContent(
+                        type="text",
+                        text="Check if my system is ready for a safe update"
+                    )
+                ),
+                PromptMessage(
+                    role="assistant",
+                    content=PromptMessage.TextContent(
+                        type="text",
+                        text=analysis
+                    )
+                )
+            ]
+        )
+    
     else:
         raise ValueError(f"Unknown prompt: {name}")