Spaces:
Runtime error
Runtime error
| """ | |
| Main entry point for the MCO Hackathon project. | |
| This file integrates the Modal agent implementation with the Gradio UI | |
| to provide a complete end-to-end demonstration of MCO orchestration. | |
| """ | |
| import os | |
| import sys | |
| import json | |
| import subprocess | |
| import tempfile | |
| from pathlib import Path | |
| # Ensure the MCO config directory exists | |
| MCO_CONFIG_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mco-config") | |
| os.makedirs(MCO_CONFIG_DIR, exist_ok=True) | |
| # Import Gradio UI | |
| from gradio_ui import create_ui | |
| # Check if running in Hugging Face Spaces | |
| IS_HF_SPACE = os.environ.get("SPACE_ID") is not None | |
| def setup_mco_server(): | |
| """Set up the MCO MCP server""" | |
| print("Setting up MCO MCP server...") | |
| # Check if mco-mcp-server.js exists | |
| server_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mco-mcp-server.js") | |
| if not os.path.exists(server_path): | |
| print(f"Warning: MCO MCP server not found at {server_path}") | |
| print("Downloading from npm package...") | |
| # Install MCO package if not already installed | |
| try: | |
| subprocess.run( | |
| ["npm", "list", "@paradiselabs/mco-protocol"], | |
| check=True, | |
| stdout=subprocess.PIPE, | |
| stderr=subprocess.PIPE | |
| ) | |
| except subprocess.CalledProcessError: | |
| print("Installing @paradiselabs/mco-protocol...") | |
| subprocess.run( | |
| ["npm", "install", "@paradiselabs/mco-protocol"], | |
| check=True | |
| ) | |
| # Copy server file from node_modules | |
| import shutil | |
| node_modules_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "node_modules") | |
| mco_server_path = os.path.join(node_modules_path, "@paradiselabs/mco-protocol/bin/mco-mcp-server.js") | |
| if os.path.exists(mco_server_path): | |
| shutil.copy(mco_server_path, server_path) | |
| print(f"Copied MCO MCP server to {server_path}") | |
| else: | |
| print(f"Error: Could not find MCO MCP server in node_modules") | |
| # Create sample SNLP files if they don't exist | |
| create_sample_snlp_files() | |
| print("MCO MCP server setup complete") | |
| def create_sample_snlp_files(): | |
| """Create sample SNLP files if they don't exist""" | |
| core_file = os.path.join(MCO_CONFIG_DIR, "mco.core") | |
| sc_file = os.path.join(MCO_CONFIG_DIR, "mco.sc") | |
| features_file = os.path.join(MCO_CONFIG_DIR, "mco.features") | |
| styles_file = os.path.join(MCO_CONFIG_DIR, "mco.styles") | |
| # Only create if none of the files exist | |
| if not (os.path.exists(core_file) or os.path.exists(sc_file) or | |
| os.path.exists(features_file) or os.path.exists(styles_file)): | |
| print("Creating sample SNLP files...") | |
| # Create mco.core | |
| with open(core_file, "w") as f: | |
| f.write("""// MCO Core Configuration | |
| @workflow "Code Review Assistant" | |
| >This is an AI assistant that performs thorough code reviews with a focus on best practices. | |
| >The workflow follows a structured progression to ensure comprehensive and reliable code reviews. | |
| @description "Multi-step code review workflow with progressive revelation" | |
| >This workflow demonstrates MCO's progressive revelation capability - core requirements stay persistent while features and styles are strategically injected at optimal moments. | |
| >The agent should maintain focus on the current step while building upon previous work. | |
| @version "1.0.0" | |
| // Data Section - Persistent state throughout workflow | |
| @data | |
| language: "Python" | |
| review_type: "General" | |
| code_files: [] | |
| issues_found: {} | |
| suggestions: {} | |
| test_results: {} | |
| >Focus on building reliable, autonomous code review workflows that complete successfully without human intervention. | |
| >The agent should maintain context across all steps and build upon previous work iteratively. | |
| >Use the data variables to track state and progress throughout the workflow. | |
| // Agents Section - Workflow execution structure | |
| @agents | |
| orchestrator: | |
| name: "MCO Orchestrator" | |
| description: "Manages workflow state and progressive revelation" | |
| model: "claude-3-5-sonnet" | |
| steps: | |
| - "Understand the code review requirements and scope" | |
| - "Analyze code structure and organization" | |
| - "Identify bugs, errors, and potential issues" | |
| - "Evaluate code quality and adherence to best practices" | |
| - "Generate improvement suggestions with examples" | |
| - "Create comprehensive review report with actionable recommendations" | |
| """) | |
| # Create mco.sc | |
| with open(sc_file, "w") as f: | |
| f.write("""// MCO Success Criteria | |
| @goal "Create a comprehensive code review system" | |
| >The goal is to build a reliable, autonomous code review system that can analyze code, | |
| >identify issues, suggest improvements, and generate test cases. | |
| @success_criteria | |
| - "Correctly identify syntax errors and bugs in code" | |
| - "Provide specific, actionable suggestions for code improvement" | |
| - "Generate relevant test cases that cover edge cases" | |
| - "Maintain consistent focus on best practices" | |
| - "Produce a well-organized, comprehensive review report" | |
| - "Complete the entire workflow without human intervention" | |
| >The success criteria define what a successful code review should accomplish. | |
| >Each criterion should be measurable and verifiable. | |
| @target_audience "Software developers and code reviewers" | |
| >The primary users are software developers who want automated code reviews for their projects. | |
| >They need detailed, actionable feedback to improve their code quality and reliability. | |
| @developer_vision "Reliable, consistent code reviews that improve code quality" | |
| >The vision is to create a system that provides the same level of detail and insight as a human code reviewer, | |
| >but with greater consistency and without the limitations of human reviewers (fatigue, bias, etc.). | |
| """) | |
| # Create mco.features | |
| with open(features_file, "w") as f: | |
| f.write("""// MCO Features | |
| @feature "Static Analysis" | |
| >Perform static analysis of code to identify syntax errors, potential bugs, and code smells. | |
| >Use language-specific rules and best practices to evaluate code quality. | |
| @feature "Security Scanning" | |
| >Scan code for security vulnerabilities such as injection flaws, authentication issues, and data exposure risks. | |
| >Prioritize findings based on severity and potential impact. | |
| @feature "Performance Optimization" | |
| >Identify performance bottlenecks and inefficient algorithms or data structures. | |
| >Suggest optimizations that improve execution speed and resource usage. | |
| @feature "Code Style Enforcement" | |
| >Check adherence to coding standards and style guidelines. | |
| >Ensure consistent formatting, naming conventions, and documentation. | |
| @feature "Test Coverage Analysis" | |
| >Evaluate the completeness of test coverage for the codebase. | |
| >Identify untested code paths and suggest additional test cases. | |
| @feature "Refactoring Suggestions" | |
| >Recommend code refactoring to improve maintainability, readability, and extensibility. | |
| >Provide specific examples of refactored code. | |
| """) | |
| # Create mco.styles | |
| with open(styles_file, "w") as f: | |
| f.write("""// MCO Styles | |
| @style "Comprehensive" | |
| >Provide detailed analysis covering all aspects of the code, including syntax, semantics, style, and architecture. | |
| >Leave no stone unturned in the review process. | |
| @style "Actionable" | |
| >Focus on providing specific, actionable feedback that can be immediately implemented. | |
| >Include code examples and clear instructions for addressing issues. | |
| @style "Educational" | |
| >Explain the reasoning behind each suggestion to help developers learn and improve. | |
| >Reference relevant documentation, best practices, and design patterns. | |
| @style "Prioritized" | |
| >Organize findings by severity and impact to help developers focus on the most important issues first. | |
| >Clearly distinguish between critical issues and minor suggestions. | |
| @style "Balanced" | |
| >Acknowledge both strengths and weaknesses in the code to provide a balanced perspective. | |
| >Highlight well-implemented patterns and clever solutions alongside areas for improvement. | |
| @style "Collaborative" | |
| >Frame feedback in a collaborative, constructive manner rather than being overly critical. | |
| >Use language that encourages improvement rather than assigning blame. | |
| """) | |
| print("Sample SNLP files created") | |
| def setup_modal(): | |
| """Set up Modal for deployment""" | |
| if IS_HF_SPACE: | |
| print("Running in Hugging Face Space, skipping Modal setup") | |
| return | |
| try: | |
| import modal | |
| # Check if Modal is set up | |
| try: | |
| modal.Image.debian_slim() | |
| print("Modal is set up and ready to use") | |
| except Exception as e: | |
| print(f"Modal setup required: {str(e)}") | |
| print("Please run 'modal token new' to set up Modal") | |
| except ImportError: | |
| print("Modal not installed, installing...") | |
| subprocess.run( | |
| [sys.executable, "-m", "pip", "install", "modal"], | |
| check=True | |
| ) | |
| print("Modal installed, please restart the application") | |
| def main(): | |
| """Main entry point""" | |
| print("Starting MCO Hackathon project...") | |
| # Set up MCO server | |
| setup_mco_server() | |
| # Set up Modal | |
| setup_modal() | |
| # Create and launch Gradio UI | |
| app = create_ui() | |
| app.launch() | |
| if __name__ == "__main__": | |
| main() | |