tool_discovery.py

import json
import os
import sys
from typing import List, Dict, Any

class ToolDiscovery:
    def __init__(self, tools_file: str = "tools.json"):
        """Initialize the tool discovery engine with a tools file."""
        self.tools_file = tools_file
        self.tools = self._load_tools()

    def _load_tools(self) -> List[Dict[str, Any]]:
        """Load tools from the JSON file."""
        if not os.path.exists(self.tools_file):
            raise FileNotFoundError(f"Tools file {self.tools_file} not found")

        with open(self.tools_file, 'r') as f:
            data = json.load(f)

        return data.get("tools", [])

    def search_tools(self, query: str, top_n: int = 3) -> List[Dict[str, Any]]:
        """Search tools by description using simple keyword matching."""
        if not query.strip():
            return []

        query_words = set(query.lower().split())
        results = []

        for tool in self.tools:
            description = tool.get("description", "").lower()
            tags = tool.get("tags", [])

            # Check if any query words are in description or tags
            match_score = sum(1 for word in query_words
                            if word in description or word in str(tags))

            if match_score > 0:
                results.append((match_score, tool))

        # Sort by score (descending) and return top_n results
        results.sort(key=lambda x: x[0], reverse=True)
        return [tool for score, tool in results[:top_n]]

    def get_tool_by_name(self, name: str) -> Dict[str, Any]:
        """Get a tool by its name."""
        for tool in self.tools:
            if tool.get("name").lower() == name.lower():
                return tool
        return {}

    def get_all_tools(self) -> List[Dict[str, Any]]:
        """Get all available tools."""
        return self.tools

if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="Tool Discovery & Selection Engine")
    parser.add_argument("--query", type=str, help="Search query for tools")
    parser.add_argument("--top-n", type=int, default=3, help="Number of top results to return")
    parser.add_argument("--list", action="store_true", help="List all available tools")
    parser.add_argument("--tool", type=str, help="Get details for a specific tool by name")

    args = parser.parse_args()

    try:
        engine = ToolDiscovery()

        if args.list:
            for tool in engine.get_all_tools():
                print(f"{tool['name']}: {tool['description']}")
        elif args.tool:
            tool = engine.get_tool_by_name(args.tool)
            if tool:
                print(f"Name: {tool['name']}")
                print(f"Description: {tool['description']}")
                print(f"Tags: {', '.join(tool['tags'])}")
            else:
                print(f"Tool '{args.tool}' not found")
        elif args.query:
            results = engine.search_tools(args.query, args.top_n)
            if results:
                print(f"Top {len(results)} results for '{args.query}':")
                for i, tool in enumerate(results, 1):
                    print(f"{i}. {tool['name']}: {tool['description']}")
            else:
                print(f"No tools found matching '{args.query}'")
        else:
            parser.print_help()

    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)