skydeckai-code 0.1.23__py3-none-any.whl

aidd/__init__.py

@@ -0,0 +1,11 @@
+import asyncio
+
+from . import server
+
+
+def main():
+    """Main entry point for the package."""
+    asyncio.run(server.main())
+
+# Optionally expose other important items at package level
+__all__ = ['main', 'server', 'cli']

aidd/cli.py

@@ -0,0 +1,141 @@
+"""Command-line interface for the SkyDeckAI Code MCP server."""
+
+import argparse
+import asyncio
+import json
+import sys
+import traceback
+from contextlib import AsyncExitStack
+from typing import Optional
+
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+from mcp.types import CallToolResult, TextContent
+
+
+class MCPClient:
+    """Client for interacting with the SkyDeckAI Code MCP server."""
+
+    def __init__(self):
+        """Initialize the client."""
+        self.session: Optional[ClientSession] = None
+        self.exit_stack = AsyncExitStack()
+        self.debug = False
+
+    async def connect(self):
+        """Connect to the SkyDeckAI Code server."""
+        server_params = StdioServerParameters(command="skydeckai-code", args=[], env=None)
+        transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+        self.session = await self.exit_stack.enter_async_context(ClientSession(*transport))
+        await self.session.initialize()
+
+    async def list_tools(self):
+        """List all available tools."""
+
+        response = await self.session.list_tools()
+        print("\nAvailable tools:")
+        for tool in sorted(response.tools, key=lambda x: x.name):
+            print(f"\n{tool.name}:")
+            print(f"  Description: {tool.description}")
+            print("  Arguments:")
+            if tool.inputSchema and "properties" in tool.inputSchema:
+                for prop_name, prop_info in tool.inputSchema["properties"].items():
+                    required = (
+                        "required" in tool.inputSchema
+                        and prop_name in tool.inputSchema["required"]
+                    )
+                    req_str = "(required)" if required else "(optional)"
+                    desc = prop_info.get("description", "No description available")
+                    print(f"    {prop_name} {req_str}: {desc}")
+            else:
+                print("    No arguments required")
+
+    async def call_tool(self, tool_name: str, args_str: Optional[str] = None) -> None:
+        """Call a specific tool with arguments.
+
+        Args:
+            tool_name: Name of the tool to call
+            args_str: JSON string of tool arguments
+        """
+        if not self.session:
+            raise RuntimeError("Not connected to server")
+
+        args = {}
+        if args_str:
+            try:
+                args = json.loads(args_str)
+            except json.JSONDecodeError as e:
+                print(f"Error parsing arguments: {e}")
+                return
+
+        try:
+            result = await self.session.call_tool(tool_name, args or {})
+            if isinstance(result, CallToolResult):
+                for content in result.content:
+                    if isinstance(content, TextContent):
+                        print(content.text)
+        except Exception as e:
+            print(f"Result type: {type(result)}")
+            print(f"Error calling tool: {e}")
+            if self.debug:
+                traceback.print_exc()
+
+    async def cleanup(self):
+        """Clean up resources."""
+        await self.exit_stack.aclose()
+
+
+def main():
+    """Main entry point for the CLI."""
+    parser = argparse.ArgumentParser(
+        description="CLI for the SkyDeckAI Code MCP server",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # List all available tools
+  skydeckai-code-cli --list-tools
+
+  # List directory contents
+  skydeckai-code-cli --tool list_directory --args '{"path": "."}'
+
+  # Update allowed directory
+  skydeckai-code-cli --tool update_allowed_directory --args '{"directory": "~/Code/project"}'
+
+  # Read a file
+  skydeckai-code-cli --tool read_file --args '{"path": "README.md"}'
+
+  # Enable debug output
+  skydeckai-code-cli --debug --tool read_file --args '{"path": "README.md"}'""")
+    parser.add_argument("--list-tools", action="store_true", help="List available tools")
+    parser.add_argument("--tool", help="Tool to call")
+    parser.add_argument("--args", help='Tool arguments in JSON format (e.g. \'{"directory":"/path/to/dir"}\')')
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+
+    async def run(args):
+        client = MCPClient()
+        client.debug = args.debug
+        try:
+            async with AsyncExitStack() as _:
+                await client.connect()
+                if args.list_tools:
+                    await client.list_tools()
+                elif args.tool:
+                    if args.debug and args.args:
+                        print(f"Parsing JSON arguments: {args.args}")
+                    await client.call_tool(args.tool, args.args)
+                else:
+                    parser.print_help()
+        finally:
+            await client.cleanup()
+
+    try:
+        args = parser.parse_args()
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+
+    asyncio.run(run(args))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aidd/server.py

@@ -0,0 +1,54 @@
+import asyncio
+
+import mcp.server.stdio
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+from mcp.server.models import InitializationOptions
+
+from .tools import TOOL_DEFINITIONS, TOOL_HANDLERS
+
+server = Server("skydeckai-code")
+
+@server.list_tools()
+async def handle_list_tools() -> list[types.Tool]:
+    """
+    List available tools.
+    Each tool specifies its arguments using JSON Schema validation.
+    """
+    return [types.Tool(**tool) for tool in TOOL_DEFINITIONS]
+
+@server.call_tool()
+async def handle_call_tool(
+    name: str, arguments: dict | None
+) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+    """
+    Handle tool execution requests.
+    """
+    if not arguments:
+        arguments = {}
+
+    handler = TOOL_HANDLERS.get(name)
+    if not handler:
+        raise ValueError(f"Unknown tool: {name}")
+
+    return await handler(arguments)
+
+async def main():
+    # Run the server using stdin/stdout streams
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="skydeckai-code",
+                server_version="0.1.0",
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+# This is needed if you'd like to connect to a custom client
+if __name__ == "__main__":
+    asyncio.run(main())

aidd/tools/__init__.py

@@ -0,0 +1,155 @@
+from .code_analysis import handle_codebase_mapper, codebase_mapper_tool
+from .code_execution import (
+    execute_code_tool,
+    execute_shell_script_tool,
+    handle_execute_code,
+    handle_execute_shell_script,
+)
+from .directory_tools import (
+    create_directory_tool,
+    directory_tree_tool,
+    handle_create_directory,
+    handle_directory_tree,
+    handle_list_directory,
+    list_directory_tool,
+)
+from .file_tools import (
+    delete_file_tool,
+    edit_file_tool,
+    get_file_info_tool,
+    handle_delete_file,
+    handle_edit_file,
+    handle_get_file_info,
+    handle_move_file,
+    handle_read_file,
+    handle_read_multiple_files,
+    handle_search_files,
+    handle_write_file,
+    move_file_tool,
+    read_file_tool,
+    read_multiple_files_tool,
+    search_files_tool,
+    write_file_tool,
+)
+from .get_active_apps_tool import get_active_apps_tool, handle_get_active_apps
+from .get_available_windows_tool import get_available_windows_tool, handle_get_available_windows
+from .git_tools import (
+    git_add_tool,
+    git_checkout_tool,
+    git_commit_tool,
+    git_create_branch_tool,
+    git_diff_staged_tool,
+    git_diff_tool,
+    git_diff_unstaged_tool,
+    git_init_tool,
+    git_log_tool,
+    git_reset_tool,
+    git_show_tool,
+    git_status_tool,
+    handle_git_add,
+    handle_git_checkout,
+    handle_git_commit,
+    handle_git_create_branch,
+    handle_git_diff,
+    handle_git_diff_staged,
+    handle_git_diff_unstaged,
+    handle_git_init,
+    handle_git_log,
+    handle_git_reset,
+    handle_git_show,
+    handle_git_status,
+)
+from .image_tools import read_image_file_tool, handle_read_image_file
+from .path_tools import (
+    get_allowed_directory_tool,
+    handle_get_allowed_directory,
+    handle_update_allowed_directory,
+    update_allowed_directory_tool,
+)
+from .screenshot_tool import (
+    capture_screenshot_tool,
+    handle_capture_screenshot,
+)
+from .system_tools import get_system_info_tool, handle_get_system_info
+
+# Export all tools definitions
+TOOL_DEFINITIONS = [
+    get_allowed_directory_tool(),
+    write_file_tool(),
+    update_allowed_directory_tool(),
+    create_directory_tool(),
+    edit_file_tool(),
+    list_directory_tool(),
+    read_file_tool(),
+    read_multiple_files_tool(),
+    move_file_tool(),
+    search_files_tool(),
+    delete_file_tool(),
+    get_file_info_tool(),
+    directory_tree_tool(),
+    execute_code_tool(),
+    execute_shell_script_tool(),
+    codebase_mapper_tool(),
+    # Git tools
+    git_init_tool(),
+    git_status_tool(),
+    git_diff_unstaged_tool(),
+    git_diff_staged_tool(),
+    git_diff_tool(),
+    git_commit_tool(),
+    git_add_tool(),
+    git_reset_tool(),
+    git_log_tool(),
+    git_create_branch_tool(),
+    git_checkout_tool(),
+    git_show_tool(),
+    get_system_info_tool(),
+    # Screenshot tools
+    capture_screenshot_tool(),
+    # System context tools
+    get_active_apps_tool(),
+    get_available_windows_tool(),
+    # Image tools
+    read_image_file_tool(),
+]
+
+# Export all handlers
+TOOL_HANDLERS = {
+    "get_allowed_directory": handle_get_allowed_directory,
+    "update_allowed_directory": handle_update_allowed_directory,
+    "list_directory": handle_list_directory,
+    "create_directory": handle_create_directory,
+    "read_file": handle_read_file,
+    "write_file": handle_write_file,
+    "edit_file": handle_edit_file,
+    "read_multiple_files": handle_read_multiple_files,
+    "move_file": handle_move_file,
+    "search_files": handle_search_files,
+    "delete_file": handle_delete_file,
+    "get_file_info": handle_get_file_info,
+    "directory_tree": handle_directory_tree,
+    "execute_code": handle_execute_code,
+    "execute_shell_script": handle_execute_shell_script,
+    "codebase_mapper": handle_codebase_mapper,
+    # Git handlers
+    "git_init": handle_git_init,
+    "git_status": handle_git_status,
+    "git_diff_unstaged": handle_git_diff_unstaged,
+    "git_diff_staged": handle_git_diff_staged,
+    "git_diff": handle_git_diff,
+    "git_commit": handle_git_commit,
+    "git_add": handle_git_add,
+    "git_reset": handle_git_reset,
+    "git_log": handle_git_log,
+    "git_create_branch": handle_git_create_branch,
+    "git_checkout": handle_git_checkout,
+    "git_show": handle_git_show,
+    "get_system_info": handle_get_system_info,
+    # Screenshot handlers
+    "capture_screenshot": handle_capture_screenshot,
+    # System context handlers
+    "get_active_apps": handle_get_active_apps,
+    "get_available_windows": handle_get_available_windows,
+    # Image handlers
+    "read_image_file": handle_read_image_file,
+}

aidd/tools/base.py

@@ -0,0 +1,18 @@
+from typing import Any, Dict
+
+import mcp.types as types
+
+
+class Tool:
+    """Base class for all tools"""
+    name: str
+    description: str
+    input_schema: Dict[str, Any]
+
+    @classmethod
+    def get_definition(cls) -> types.Tool:
+        return types.Tool(
+            name=cls.name,
+            description=cls.description,
+            inputSchema=cls.input_schema
+        )