text: Title: Feature Proposal: Enhanced Single-File Execution in Any Directory Structure
  Body: #### **Current State**
  - nextpy's `run` command requires a predefined directory structure for execution.
  
  #### **Objective**
  - Enable users to execute individual files with `nextpy run`, regardless of the directory structure, similar to tools like Streamlit .
  
  #### **Proposal Details**
  
  **1. Command Enhancement:**
  - Modify `nextpy run` to primarily accept a file path:
    - `-f` or `--file`: Path to the target file (relative or absolute).
    - `-t` or `--theme`: Optional theme (defaults to standard if not provided).
  
  **2. Operational Logic:**
  - Ensure the file's existence at the given path.
  - Determine the file type (e.g., `.mdx`, `.py`) and execute accordingly.
  - For `.mdx` files, use the default MDX viewer, or apply the specified theme.
  - For `.py` files, execute the script in an isolated or appropriate environment.
  - Provide error messages and graceful exits for unsupported file types or execution errors.
  
  **3. Environment Independence:**
  - Eliminate dependency on a specific project structure.
  - Set up the necessary minimal environment based on the file type.
  - Allow environment variables or configurations to be specified via command line or external config files for flexibility.
  
  **4. Theme Integration and Default Viewer:**
  - Same as previously proposed.
  
  #### **Sample Usage:**
  
  **Run a File in Any Directory:**
  ```bash
  $ nextpy run -f /path/to/file.mdx
  $ nextpy run -f ./relative/path/to/script.py
  ```
  **With Custom Theme:**
  ```bash
  $ nextpy run -f /path/to/file.mdx -t bespoke_theme
  ```
  
  #### **Resultant Execution:**
  - Executing this command will focus on the specified file only, setting up a minimal environment as required.
  - The command will be independent of the directory structure, allowing flexibility in file organization.
  
  #### **Advantages:**
  - Streamlines the process of running individual files, making it more accessible and flexible.
  - Reduces the necessity for a comprehensive initial setup, facilitating quick testing and prototyping.
  - Enhances the user experience, particularly beneficial for new users and in educational contexts.
  
  #### **Implementation Considerations:**
  - Robust error handling and informative messaging for user guidance.
  - Extensive testing with various file locations and types to ensure reliability.
  - Documentation updates to guide users on new command usage and capabilities.
  
  #### **Potential Directory Structure Post-Execution:**
  ```bash
  .any_directory
  ├── executed_file.mdx (or .py, etc.)
  ├── .web (if necessary for execution)
  └── other_files_or_directories (unrelated to nextpy execution)
  ```
  
  # TODO
  
  ### Step 1: Requirements Analysis
  - [ ] Analyze the current functionality of the `nextpy run` command.
  - [ ] Identify the limitations with respect to directory structure dependence.
  
  ### Step 2: Design Command Enhancements
  - [ ] Design the new command line interface to accept a file path (`-f` or `--file`) and an optional theme (`-t` or `--theme`).
  - [ ] Plan how the command will handle different file types (e.g., `.mdx`, `.py`).
  
  ### Step 3: Update Command Line Interface
  - [ ] Modify the `run` command in Typer to accept the file path as a primary argument.
  - [ ] Implement the logic to parse and handle the optional theme argument.
  
  ### Step 4: Implement File Detection and Execution Logic
  - [ ] Develop a function to validate the existence of the specified file.
  - [ ] Create a function to determine the file type based on the file extension or content.
  - [ ] Implement the execution logic for `.mdx` files, including using the default MDX viewer or the specified theme.
  - [ ] Implement the execution logic for `.py` files, ensuring they run correctly irrespective of the directory structure.
  
  ### Step 5: Environment Setup
  - [ ] Establish a minimal environment setup required for the execution of the specified file.
  - [ ] Ensure environment variable or configuration can be set externally if required.
  
  ### Step 6: Testing and Quality Assurance
  - [ ] Conduct unit testing for new functionalities.
  - [ ] Perform integration testing to ensure the new command works seamlessly with existing features.
  - [ ] Test the command with various file types and in different directory structures.
  
  ### Step 7: Error Handling and User Feedback
  - [ ] Implement robust error handling for unsupported file types, missing files, and execution errors.
  - [ ] Develop user-friendly error messages and guidance for troubleshooting.
  
  ### Step 8: Documentation and Examples
  - [ ] Update the project documentation to include the new command usage.
  - [ ] Provide example use cases and command line inputs in the documentation.