arch-ops-server 3.3.1__tar.gz → 3.3.3__tar.gz

{arch_ops_server-3.3.1 → arch_ops_server-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arch-ops-server
-Version: 3.3.1
+Version: 3.3.3
 Summary: MCP server bridging AI assistants with Arch Linux ecosystem (Wiki, AUR, official repos)
 Keywords: arch-linux,mcp,model-context-protocol,aur,pacman,wiki,ai-assistant
 Author: Nihal

{arch_ops_server-3.3.1 → arch_ops_server-3.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arch-ops-server"
-version = "3.3.1"
+version = "3.3.3"
 description = "MCP server bridging AI assistants with Arch Linux ecosystem (Wiki, AUR, official repos)"
 readme = {file = "README.md", content-type = "text/markdown"}
 license = { text = "GPL-3.0-only OR MIT" }

{arch_ops_server-3.3.1 → arch_ops_server-3.3.3}/src/arch_ops_server/__init__.py

@@ -6,7 +6,7 @@ A Model Context Protocol server that bridges AI assistants with the Arch Linux
 ecosystem, providing access to the Arch Wiki, AUR, and official repositories.
 """
 
-__version__ = "3.3.1"
+__version__ = "3.3.3"
 
 from .wiki import search_wiki, get_wiki_page, get_wiki_page_as_text
 from .aur import (
@@ -23,17 +23,21 @@ from .pacman import (
     check_updates_dry_run,
     remove_package,
     remove_packages_batch,
+    remove_packages,
     list_orphan_packages,
     remove_orphans,
+    manage_orphans,
     find_package_owner,
     list_package_files,
     search_package_files,
+    query_file_ownership,
     verify_package_integrity,
     list_package_groups,
     list_group_packages,
     list_explicit_packages,
     mark_as_explicit,
     mark_as_dependency,
+    manage_install_reason,
     check_database_freshness
 )
 from .system import (
@@ -130,17 +134,21 @@ __all__ = [
     "check_updates_dry_run",
     "remove_package",
     "remove_packages_batch",
+    "remove_packages",
     "list_orphan_packages",
     "remove_orphans",
+    "manage_orphans",
     "find_package_owner",
     "list_package_files",
     "search_package_files",
+    "query_file_ownership",
     "verify_package_integrity",
     "list_package_groups",
     "list_group_packages",
     "list_explicit_packages",
     "mark_as_explicit",
     "mark_as_dependency",
+    "manage_install_reason",
     "check_database_freshness",
     # System
     "get_system_info",

{arch_ops_server-3.3.1 → arch_ops_server-3.3.3}/src/arch_ops_server/pacman.py

@@ -472,6 +472,70 @@ async def remove_packages_batch(
         )
 
 
+async def remove_packages(
+    packages: Union[str, List[str]],
+    remove_dependencies: bool = False,
+    force: bool = False
+) -> Dict[str, Any]:
+    """
+    Unified tool for removing packages (single or multiple).
+    
+    This consolidates two operations:
+    - Single package removal (replaces remove_package)
+    - Batch package removal (replaces remove_packages_batch)
+
+    Args:
+        packages: Package name (string) or list of package names to remove
+        remove_dependencies: If True, remove unneeded dependencies (pacman -Rs)
+        force: If True, force removal ignoring dependencies (pacman -Rdd). Only works for single package.
+
+    Returns:
+        Dict with removal status and information
+    """
+    if not IS_ARCH:
+        return create_error_response(
+            "NotSupported",
+            "Package removal is only available on Arch Linux"
+        )
+
+    if not check_command_exists("pacman"):
+        return create_error_response(
+            "CommandNotFound",
+            "pacman command not found"
+        )
+
+    # Normalize input to list
+    if isinstance(packages, str):
+        package_list = [packages]
+        is_single = True
+    else:
+        package_list = packages
+        is_single = False
+
+    if not package_list:
+        return create_error_response(
+            "ValidationError",
+            "No packages specified for removal"
+        )
+
+    # Validate force flag usage
+    if force and not is_single:
+        return create_error_response(
+            "ValidationError",
+            "force flag can only be used with single package removal"
+        )
+
+    logger.info(f"Removing {len(package_list)} package(s): {package_list} (deps={remove_dependencies}, force={force})")
+
+    # Route to appropriate implementation based on input type and flags
+    if is_single:
+        # Single package removal
+        return await remove_package(package_list[0], remove_dependencies, force)
+    else:
+        # Batch package removal (force not supported)
+        return await remove_packages_batch(package_list, remove_dependencies)
+
+
 async def list_orphan_packages() -> Dict[str, Any]:
     """
     List all orphaned packages (dependencies no longer required).
@@ -628,6 +692,64 @@ async def remove_orphans(dry_run: bool = True, exclude: Optional[List[str]] = No
         )
 
 
+async def manage_orphans(
+    action: str,
+    dry_run: bool = True,
+    exclude: Optional[List[str]] = None
+) -> Dict[str, Any]:
+    """
+    Unified tool for managing orphaned packages.
+    
+    This consolidates two operations:
+    - list: List all orphaned packages (replaces list_orphan_packages)
+    - remove: Remove orphaned packages (replaces remove_orphans)
+
+    Args:
+        action: Action to perform - "list" or "remove"
+        dry_run: If True (default), show what would be removed without removing (only for remove action)
+        exclude: List of packages to exclude from removal (only for remove action)
+
+    Returns:
+        Dict with action results
+    """
+    if not IS_ARCH:
+        return create_error_response(
+            "NotSupported",
+            "Orphan package management is only available on Arch Linux"
+        )
+
+    if not check_command_exists("pacman"):
+        return create_error_response(
+            "CommandNotFound",
+            "pacman command not found"
+        )
+
+    # Validate action
+    valid_actions = ["list", "remove"]
+    if action not in valid_actions:
+        return create_error_response(
+            "ValidationError",
+            f"Invalid action '{action}'. Must be one of: {', '.join(valid_actions)}"
+        )
+
+    logger.info(f"Orphan management: action={action}, dry_run={dry_run}")
+
+    # Route to appropriate implementation based on action
+    if action == "list":
+        # List orphaned packages
+        return await list_orphan_packages()
+    
+    elif action == "remove":
+        # Remove orphaned packages
+        return await remove_orphans(dry_run, exclude)
+    
+    # This should never be reached due to validation above
+    return create_error_response(
+        "InternalError",
+        f"Unexpected action: {action}"
+    )
+
+
 async def find_package_owner(file_path: str) -> Dict[str, Any]:
     """
     Find which package owns a specific file.
@@ -861,6 +983,69 @@ async def search_package_files(filename_pattern: str) -> Dict[str, Any]:
         )
 
 
+async def query_file_ownership(
+    query: str,
+    mode: str,
+    filter_pattern: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Unified tool for querying file ownership relationships.
+    
+    This consolidates three operations:
+    - file_to_package: Find which package owns a specific file (replaces find_package_owner)
+    - package_to_files: List all files owned by a package (replaces list_package_files)
+    - filename_search: Search for files across all packages (replaces search_package_files)
+
+    Args:
+        query: The query string (file path, package name, or filename pattern depending on mode)
+        mode: Query mode - "file_to_package", "package_to_files", or "filename_search"
+        filter_pattern: Optional regex pattern to filter files (only used in package_to_files mode)
+
+    Returns:
+        Dict with query results appropriate to the mode
+    """
+    if not IS_ARCH:
+        return create_error_response(
+            "NotSupported",
+            "File ownership queries are only available on Arch Linux"
+        )
+
+    if not check_command_exists("pacman"):
+        return create_error_response(
+            "CommandNotFound",
+            "pacman command not found"
+        )
+
+    # Validate mode
+    valid_modes = ["file_to_package", "package_to_files", "filename_search"]
+    if mode not in valid_modes:
+        return create_error_response(
+            "ValidationError",
+            f"Invalid mode '{mode}'. Must be one of: {', '.join(valid_modes)}"
+        )
+
+    logger.info(f"File ownership query: mode={mode}, query={query}")
+
+    # Route to appropriate implementation based on mode
+    if mode == "file_to_package":
+        # Find which package owns a specific file (replaces find_package_owner)
+        return await find_package_owner(query)
+    
+    elif mode == "package_to_files":
+        # List all files owned by a package (replaces list_package_files)
+        return await list_package_files(query, filter_pattern)
+    
+    elif mode == "filename_search":
+        # Search for files across all packages (replaces search_package_files)
+        return await search_package_files(query)
+    
+    # This should never be reached due to validation above
+    return create_error_response(
+        "InternalError",
+        f"Unexpected mode: {mode}"
+    )
+
+
 async def verify_package_integrity(package_name: str, thorough: bool = False) -> Dict[str, Any]:
     """
     Verify integrity of an installed package.
@@ -1213,6 +1398,75 @@ async def mark_as_dependency(package_name: str) -> Dict[str, Any]:
         )
 
 
+async def manage_install_reason(
+    action: str,
+    package_name: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Unified tool for managing package install reasons.
+    
+    This consolidates three operations:
+    - list: List all explicitly installed packages (replaces list_explicit_packages)
+    - mark_explicit: Mark a package as explicitly installed (replaces mark_as_explicit)
+    - mark_dependency: Mark a package as a dependency (replaces mark_as_dependency)
+
+    Args:
+        action: Action to perform - "list", "mark_explicit", or "mark_dependency"
+        package_name: Package name (required for mark_explicit and mark_dependency actions)
+
+    Returns:
+        Dict with operation results appropriate to the action
+    """
+    if not IS_ARCH:
+        return create_error_response(
+            "NotSupported",
+            "Install reason management is only available on Arch Linux"
+        )
+
+    if not check_command_exists("pacman"):
+        return create_error_response(
+            "CommandNotFound",
+            "pacman command not found"
+        )
+
+    # Validate action
+    valid_actions = ["list", "mark_explicit", "mark_dependency"]
+    if action not in valid_actions:
+        return create_error_response(
+            "ValidationError",
+            f"Invalid action '{action}'. Must be one of: {', '.join(valid_actions)}"
+        )
+
+    # Validate package_name for marking actions
+    if action in ["mark_explicit", "mark_dependency"] and not package_name:
+        return create_error_response(
+            "ValidationError",
+            f"package_name is required for action '{action}'"
+        )
+
+    logger.info(f"Install reason management: action={action}, package={package_name}")
+
+    # Route to appropriate implementation based on action
+    if action == "list":
+        # List all explicitly installed packages
+        return await list_explicit_packages()
+    
+    elif action == "mark_explicit":
+        # Mark package as explicitly installed
+        return await mark_as_explicit(package_name)
+    
+    elif action == "mark_dependency":
+        # Mark package as dependency
+        return await mark_as_dependency(package_name)
+    
+    # This should never be reached due to validation above
+    return create_error_response(
+        "InternalError",
+        f"Unexpected action: {action}"
+    )
+
+
+
 async def check_database_freshness() -> Dict[str, Any]:
     """
     Check when package databases were last synchronized.

{arch_ops_server-3.3.1 → arch_ops_server-3.3.3}/src/arch_ops_server/server.py

@@ -40,17 +40,15 @@ from . import (
     check_updates_dry_run,
     remove_package,
     remove_packages_batch,
+    remove_packages,
     list_orphan_packages,
     remove_orphans,
-    find_package_owner,
-    list_package_files,
-    search_package_files,
+    manage_orphans,
+    query_file_ownership,
     verify_package_integrity,
     list_package_groups,
     list_group_packages,
-    list_explicit_packages,
-    mark_as_explicit,
-    mark_as_dependency,
+    manage_install_reason,
     check_database_freshness,
     # System functions
     get_system_info,
@@ -751,20 +749,23 @@ async def list_tools() -> list[Tool]:
             annotations=ToolAnnotations(readOnlyHint=True)
         ),
 
-        # Package Removal Tools
+        # Package Removal
         Tool(
-            name="remove_package",
-            description="[LIFECYCLE] 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. Example: Remove 'firefox' with dependencies using remove_dependencies=true, or force removal with force=true (dangerous!).",
+            name="remove_packages",
+            description="[LIFECYCLE] Unified tool for removing packages (single or multiple). Accepts either a single package name or a list of packages. Supports removal with dependencies and forced removal. Only works on Arch Linux. Requires sudo access. Examples: packages='firefox', remove_dependencies=true → removes Firefox with its dependencies; packages=['pkg1', 'pkg2', 'pkg3'] → batch removal of multiple packages; packages='lib', force=true → force removal ignoring dependencies (dangerous!).",
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "package_name": {
-                        "type": "string",
-                        "description": "Name of the package to remove"
+                    "packages": {
+                        "oneOf": [
+                            {"type": "string"},
+                            {"type": "array", "items": {"type": "string"}}
+                        ],
+                        "description": "Package name (string) or list of package names (array) to remove"
                     },
                     "remove_dependencies": {
                         "type": "boolean",
-                        "description": "Remove package and its dependencies (pacman -Rs). Default: false",
+                        "description": "Remove packages and their dependencies (pacman -Rs). Default: false",
                         "default": False
                     },
                     "force": {
@@ -773,118 +774,65 @@ async def list_tools() -> list[Tool]:
                         "default": False
                     }
                 },
-                "required": ["package_name"]
-            },
-            annotations=ToolAnnotations(destructiveHint=True)
-        ),
-
-        Tool(
-            name="remove_packages_batch",
-            description="[LIFECYCLE] Remove multiple packages in a single transaction. More efficient than removing packages one by one. Only works on Arch Linux. Requires sudo access. Use case: Clean up multiple packages at once: ['package1', 'package2', 'package3'] with optional dependency removal.",
-            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"]
+                "required": ["packages"]
             },
             annotations=ToolAnnotations(destructiveHint=True)
         ),
 
         # Orphan Package Management
         Tool(
-            name="list_orphan_packages",
-            description="[MAINTENANCE] 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. When to use: After removing packages, find orphaned dependencies that are no longer needed.",
-            inputSchema={
-                "type": "object",
-                "properties": {}
-            },
-            annotations=ToolAnnotations(readOnlyHint=True)
-        ),
-
-        Tool(
-            name="remove_orphans",
-            description="[MAINTENANCE] 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. Example: Use dry_run=true first to preview, then dry_run=false to actually remove. Exclude critical packages with exclude=['pkg1'].",
+            name="manage_orphans",
+            description="[MAINTENANCE] Unified tool for managing orphaned packages (dependencies no longer required). Supports two actions: 'list' (show orphaned packages) and 'remove' (remove orphaned packages). Only works on Arch Linux. Requires sudo access for removal. Examples: action='list' → shows all orphaned packages with disk usage; action='remove', dry_run=true → preview what would be removed; action='remove', dry_run=false, exclude=['pkg1'] → remove all orphans except 'pkg1'.",
             inputSchema={
                 "type": "object",
                 "properties": {
+                    "action": {
+                        "type": "string",
+                        "enum": ["list", "remove"],
+                        "description": "Action to perform: 'list' (list orphaned packages) or 'remove' (remove orphaned packages)"
+                    },
                     "dry_run": {
                         "type": "boolean",
-                        "description": "Preview what would be removed without actually removing. Default: true",
+                        "description": "Preview what would be removed without actually removing (only for remove action). Default: true",
                         "default": True
                     },
                     "exclude": {
                         "type": "array",
                         "items": {"type": "string"},
-                        "description": "List of package names to exclude from removal"
+                        "description": "List of package names to exclude from removal (only for remove action)"
                     }
                 },
-                "required": []
+                "required": ["action"]
             },
-            annotations=ToolAnnotations(destructiveHint=True)
+            annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False)  # Mixed: list is read-only, remove is destructive
         ),
 
-        # Package Ownership Tools
+        # File Ownership Query (Consolidated)
         Tool(
-            name="find_package_owner",
-            description="[ORGANIZATION] Find which package owns a specific file on the system. Useful for troubleshooting and understanding file origins. Only works on Arch Linux. Example: '/usr/bin/python' → returns 'python' package that owns this file.",
+            name="query_file_ownership",
+            description="[ORGANIZATION] Unified tool for querying file-package ownership relationships. Supports three modes: 'file_to_package' (find which package owns a file), 'package_to_files' (list all files in a package with optional filtering), and 'filename_search' (search for files across all packages). Only works on Arch Linux. Examples: mode='file_to_package', query='/usr/bin/python' → returns 'python' package; mode='package_to_files', query='systemd', filter_pattern='*.service' → lists all systemd service files; mode='filename_search', query='*.desktop' → finds all packages with desktop entries.",
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "file_path": {
+                    "query": {
                         "type": "string",
-                        "description": "Absolute path to the file (e.g., /usr/bin/vim)"
-                    }
-                },
-                "required": ["file_path"]
-            },
-            annotations=ToolAnnotations(readOnlyHint=True)
-        ),
-
-        Tool(
-            name="list_package_files",
-            description="[ORGANIZATION] List all files owned by a package. Supports optional filtering by pattern. Only works on Arch Linux. Use case: See all files installed by 'systemd' package, optionally filter with pattern='*.service'.",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "package_name": {
+                        "description": "Query string: file path for file_to_package mode, package name for package_to_files mode, or filename pattern for filename_search mode"
+                    },
+                    "mode": {
                         "type": "string",
-                        "description": "Name of the package"
+                        "enum": ["file_to_package", "package_to_files", "filename_search"],
+                        "description": "Query mode: 'file_to_package' (find package owner), 'package_to_files' (list package files), or 'filename_search' (search across packages)"
                     },
                     "filter_pattern": {
                         "type": "string",
-                        "description": "Optional regex pattern to filter files (e.g., '*.conf' or '/etc/')"
+                        "description": "Optional regex pattern to filter files (only used in package_to_files mode, e.g., '*.conf' or '/etc/')"
                     }
                 },
-                "required": ["package_name"]
+                "required": ["query", "mode"]
             },
             annotations=ToolAnnotations(readOnlyHint=True)
         ),
 
-        Tool(
-            name="search_package_files",
-            description="[ORGANIZATION] Search for files across all packages in repositories. Requires package database sync (pacman -Fy). Only works on Arch Linux. Example: Search for '*.desktop' to find all packages that install desktop entries.",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "filename_pattern": {
-                        "type": "string",
-                        "description": "File name or pattern to search for (e.g., 'vim' or '*.service')"
-                    }
-                },
-                "required": ["filename_pattern"]
-            },
-            annotations=ToolAnnotations(readOnlyHint=True)
-        ),
 
         # Package Verification
         Tool(
@@ -937,45 +885,24 @@ async def list_tools() -> list[Tool]:
 
         # Install Reason Management
         Tool(
-            name="list_explicit_packages",
-            description="[MAINTENANCE] 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. When to use: Find packages you explicitly installed (vs dependencies) for system documentation.",
-            inputSchema={
-                "type": "object",
-                "properties": {}
-            },
-            annotations=ToolAnnotations(readOnlyHint=True)
-        ),
-
-        Tool(
-            name="mark_as_explicit",
-            description="[MAINTENANCE] Mark a package as explicitly installed. Prevents it from being removed as an orphan. Only works on Arch Linux. Example: Mark 'python-pip' as explicit if you want to keep it even when dependencies change.",
+            name="manage_install_reason",
+            description="[MAINTENANCE] Unified tool for managing package install reasons. Supports three actions: 'list' (list all explicitly installed packages), 'mark_explicit' (prevent package from being removed as orphan), and 'mark_dependency' (allow package to be auto-removed with orphans). Only works on Arch Linux. Examples: action='list' → returns all user-installed packages; action='mark_explicit', package_name='python-pip' → keeps package even when dependencies change; action='mark_dependency', package_name='lib32-gcc-libs' → allows auto-removal with orphans.",
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "package_name": {
+                    "action": {
                         "type": "string",
-                        "description": "Name of the package to mark as explicit"
-                    }
-                },
-                "required": ["package_name"]
-            },
-            annotations=ToolAnnotations(destructiveHint=True)
-        ),
-
-        Tool(
-            name="mark_as_dependency",
-            description="[MAINTENANCE] 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. Use case: Mark 'lib32-gcc-libs' as dependency so it can be auto-removed with orphans later.",
-            inputSchema={
-                "type": "object",
-                "properties": {
+                        "enum": ["list", "mark_explicit", "mark_dependency"],
+                        "description": "Action to perform: 'list' (list explicit packages), 'mark_explicit' (mark as user-installed), or 'mark_dependency' (mark as auto-removable)"
+                    },
                     "package_name": {
                         "type": "string",
-                        "description": "Name of the package to mark as dependency"
+                        "description": "Package name (required for mark_explicit and mark_dependency actions)"
                     }
                 },
-                "required": ["package_name"]
+                "required": ["action"]
             },
-            annotations=ToolAnnotations(destructiveHint=True)
+            annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False)  # Mixed: list is read-only, marking is destructive
         ),
 
         # System Diagnostic Tools
@@ -1334,66 +1261,36 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent |
         return [TextContent(type="text", text=json.dumps(result, indent=2))]
 
     # Package Removal Tools
-    elif name == "remove_package":
+    elif name == "remove_packages":
         if not IS_ARCH:
-            return [TextContent(type="text", text=create_platform_error_message("remove_package"))]
+            return [TextContent(type="text", text=create_platform_error_message("remove_packages"))]
 
-        package_name = arguments["package_name"]
+        packages = arguments["packages"]
         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=create_platform_error_message("remove_packages_batch"))]
-
-        package_names = arguments["package_names"]
-        remove_dependencies = arguments.get("remove_dependencies", False)
-        result = await remove_packages_batch(package_names, remove_dependencies)
+        result = await remove_packages(packages, remove_dependencies, force)
         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=create_platform_error_message("list_orphan_packages"))]
-
-        result = await list_orphan_packages()
-        return [TextContent(type="text", text=json.dumps(result, indent=2))]
-
-    elif name == "remove_orphans":
+    elif name == "manage_orphans":
         if not IS_ARCH:
-            return [TextContent(type="text", text=create_platform_error_message("remove_orphans"))]
+            return [TextContent(type="text", text=create_platform_error_message("manage_orphans"))]
 
+        action = arguments["action"]
         dry_run = arguments.get("dry_run", True)
         exclude = arguments.get("exclude", None)
-        result = await remove_orphans(dry_run, exclude)
+        result = await manage_orphans(action, dry_run, exclude)
         return [TextContent(type="text", text=json.dumps(result, indent=2))]
 
-    # Package Ownership Tools
-    elif name == "find_package_owner":
+    # File Ownership Query
+    elif name == "query_file_ownership":
         if not IS_ARCH:
-            return [TextContent(type="text", text=create_platform_error_message("find_package_owner"))]
+            return [TextContent(type="text", text=create_platform_error_message("query_file_ownership"))]
 
-        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=create_platform_error_message("list_package_files"))]
-
-        package_name = arguments["package_name"]
+        query = arguments["query"]
+        mode = arguments["mode"]
         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=create_platform_error_message("search_package_files"))]
-
-        filename_pattern = arguments["filename_pattern"]
-        result = await search_package_files(filename_pattern)
+        result = await query_file_ownership(query, mode, filter_pattern)
         return [TextContent(type="text", text=json.dumps(result, indent=2))]
 
     # Package Verification
@@ -1423,27 +1320,13 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent |
         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=create_platform_error_message("list_explicit_packages"))]
-
-        result = await list_explicit_packages()
-        return [TextContent(type="text", text=json.dumps(result, indent=2))]
-
-    elif name == "mark_as_explicit":
+    elif name == "manage_install_reason":
         if not IS_ARCH:
-            return [TextContent(type="text", text=create_platform_error_message("mark_as_explicit"))]
+            return [TextContent(type="text", text=create_platform_error_message("manage_install_reason"))]
 
-        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=create_platform_error_message("mark_as_dependency"))]
-
-        package_name = arguments["package_name"]
-        result = await mark_as_dependency(package_name)
+        action = arguments["action"]
+        package_name = arguments.get("package_name", None)
+        result = await manage_install_reason(action, package_name)
         return [TextContent(type="text", text=json.dumps(result, indent=2))]
 
     # System Diagnostic Tools
@@ -2107,7 +1990,7 @@ paru -S {package_name}  # or yay -S {package_name}
                         text=f"""Please perform a comprehensive system cleanup:
 
 1. **Check Orphaned Packages**:
-   - Run list_orphan_packages
+   - Run manage_orphans with action='list'
    - Review the list for packages that can be safely removed
    {'   - Be aggressive: remove all orphans unless critical' if aggressive else '   - Be conservative: keep packages that might be useful'}
 
@@ -2303,7 +2186,7 @@ Be detailed and provide specific mirror URLs and configuration commands."""
    - Identify any package operation failures
 
 5. **Package Integrity**:
-   - Run list_orphan_packages
+   - Run manage_orphans with action='list'
    - Count orphaned packages and space used
    - Suggest running verify_package_integrity on critical packages
 

{arch_ops_server-3.3.1 → arch_ops_server-3.3.3}/src/arch_ops_server/system_health_check.py

@@ -7,19 +7,6 @@ Provides a comprehensive system health check by integrating multiple system diag
 import logging
 from typing import Dict, Any
 
-from .utils import IS_ARCH
-from . import (
-    get_system_info,
-    check_disk_space,
-    check_failed_services,
-    get_pacman_cache_stats,
-    check_updates_dry_run,
-    check_critical_news,
-    list_orphan_packages,
-    check_database_freshness,
-    check_mirrorlist_health
-)
-
 logger = logging.getLogger(__name__)
 
 
@@ -33,6 +20,20 @@ async def run_system_health_check() -> Dict[str, Any]:
     Returns:
         Dict with comprehensive health check results
     """
+    from .system import (
+        get_system_info,
+        check_disk_space,
+        check_failed_services,
+        get_pacman_cache_stats
+    )
+    from .pacman import (
+        check_updates_dry_run,
+        list_orphan_packages,
+        check_database_freshness
+    )
+    from .news import check_critical_news
+    from .mirrors import check_mirrorlist_health
+    
     logger.info("Starting comprehensive system health check")
     
     health_report = {