Develop and test running sections, including testing running section-wise tasks

Author: neuromechanist

.gitignore

@@ -49,3 +49,9 @@ matlab_scripts/
 
 # Development files
 examples/matlab_scripts/section_test.m
+
+# Jupyter
+.ipynb_checkpoints/
+
+# DS_Store
+.DS_Store

examples/test_sections.py

@@ -0,0 +1,63 @@
+"""Test script for MATLAB section execution."""
+
+import asyncio
+from pathlib import Path
+
+from matlab_mcp.server import MatlabServer
+from matlab_mcp.utils.section_parser import get_section_info
+
+
+async def test_section_execution():
+    """Test section-based MATLAB script execution."""
+    print("Testing MATLAB Section Execution...")
+    
+    server = MatlabServer()
+    
+    # Test section parsing
+    print("\nTesting section parsing...")
+    script_path = Path("examples/matlab_scripts/section_test.m")
+    if not script_path.exists():
+        print(f"Error: Script not found at {script_path}")
+        return
+        
+    sections = get_section_info(script_path)
+    print(f"Found {len(sections)} sections:")
+    for section in sections:
+        print(f"- {section['title']} (lines {section['start_line']}-{section['end_line']})")
+        print(f"  Preview: {section['preview']}")
+    
+    # Test executing each section
+    print("\nExecuting sections one by one...")
+    for section in sections:
+        print(f"\nExecuting section: {section['title']}")
+        result = await server.engine.execute_section(
+            str(script_path),
+            (section['start_line'], section['end_line'])
+        )
+        
+        print("Output:")
+        print(result.output)
+        
+        print("Workspace variables:")
+        for var, value in result.workspace.items():
+            print(f"- {var}: {value}")
+            
+        if result.figures:
+            print(f"Generated {len(result.figures)} figures")
+            
+            # Save figures
+            output_dir = Path("test_output")
+            output_dir.mkdir(exist_ok=True)
+            
+            for i, fig_data in enumerate(result.figures):
+                output_path = output_dir / f"section_{section['start_line']}_figure_{i}.png"
+                output_path.write_bytes(fig_data)
+                print(f"Saved figure to: {output_path}")
+    
+    # Clean up
+    server.engine.cleanup()
+    print("\nTest completed successfully!")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_section_execution())

src/matlab_mcp/engine.py

@@ -9,6 +9,7 @@
 from mcp.server.fastmcp import Context
 
 from .models import ExecutionResult
+from .utils.section_parser import extract_section
 
 
 class MatlabEngine:
@@ -196,6 +197,49 @@ async def get_workspace(self) -> Dict[str, Any]:
 
         return workspace
 
+    async def execute_section(
+        self,
+        file_path: str,
+        section_range: tuple[int, int],
+        maintain_workspace: bool = True,
+        capture_plots: bool = True,
+        ctx: Optional[Context] = None
+    ) -> ExecutionResult:
+        """Execute a specific section of a MATLAB script.
+        
+        Args:
+            file_path: Path to the MATLAB script
+            section_range: Tuple of (start_line, end_line) for the section
+            maintain_workspace: Whether to maintain workspace between sections
+            capture_plots: Whether to capture generated plots
+            ctx: MCP context for progress reporting
+            
+        Returns:
+            ExecutionResult containing output, workspace state, and figures
+        """
+        script_path = Path(file_path)
+        if not script_path.exists():
+            raise FileNotFoundError(f"Script not found: {file_path}")
+            
+        # Extract the section code
+        section_code = extract_section(
+            script_path,
+            section_range[0],
+            section_range[1],
+            maintain_workspace
+        )
+        
+        if ctx:
+            ctx.info(f"Executing section (lines {section_range[0]}-{section_range[1]})")
+            
+        # Execute the section
+        return await self.execute(
+            section_code,
+            is_file=False,
+            capture_plots=capture_plots,
+            ctx=ctx
+        )
+
     def cleanup(self) -> None:
         """Clean up MATLAB engine and resources."""
         if self.eng is not None:

src/matlab_mcp/server.py

@@ -1,11 +1,12 @@
 """MATLAB MCP Server implementation."""
 
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 
 from mcp.server.fastmcp import FastMCP, Image, Context
 
 from .engine import MatlabEngine
+from .utils.section_parser import get_section_info
 
 
 class MatlabServer:
@@ -29,6 +30,71 @@ def __init__(self):
 
     def _setup_tools(self):
         """Set up MCP tools for MATLAB operations."""
+
+        @self.mcp.tool()
+        async def get_script_sections(
+            script_name: str,
+            ctx: Context = None
+        ) -> List[dict]:
+            """Get information about sections in a MATLAB script.
+            
+            Args:
+                script_name: Name of the script (without .m extension)
+                ctx: MCP context for progress reporting
+            
+            Returns:
+                List of dictionaries containing section information
+            """
+            script_path = self.scripts_dir / f"{script_name}.m"
+            if not script_path.exists():
+                raise FileNotFoundError(f"Script {script_name}.m not found")
+                
+            if ctx:
+                ctx.info(f"Getting sections for script: {script_name}")
+                
+            return get_section_info(script_path)
+
+        @self.mcp.tool()
+        async def execute_script_section(
+            script_name: str,
+            section_range: tuple[int, int],
+            maintain_workspace: bool = True,
+            ctx: Context = None
+        ) -> Dict[str, Any]:
+            """Execute a specific section of a MATLAB script.
+            
+            Args:
+                script_name: Name of the script (without .m extension)
+                section_range: Tuple of (start_line, end_line) for the section
+                maintain_workspace: Whether to maintain workspace between sections
+                ctx: MCP context for progress reporting
+            
+            Returns:
+                Dictionary containing execution results
+            """
+            script_path = self.scripts_dir / f"{script_name}.m"
+            if not script_path.exists():
+                raise FileNotFoundError(f"Script {script_name}.m not found")
+                
+            result = await self.engine.execute_section(
+                str(script_path),
+                section_range,
+                maintain_workspace=maintain_workspace,
+                ctx=ctx
+            )
+            
+            # Convert raw bytes to MCP Image objects
+            figures = [
+                Image(data=fig_data, format='png')
+                for fig_data in result.figures
+            ]
+            
+            return {
+                "output": result.output,
+                "error": result.error,
+                "workspace": result.workspace,
+                "figures": figures
+            }
 
         @self.mcp.tool()
         async def execute_script(

src/matlab_mcp/utils/section_parser.py

@@ -0,0 +1,114 @@
+"""Utility functions for parsing and executing MATLAB script sections."""
+
+from pathlib import Path
+from typing import List, Tuple
+
+
+def parse_sections(file_path: Path) -> List[Tuple[int, int, str]]:
+    """Parse a MATLAB script into sections.
+    
+    Args:
+        file_path: Path to the MATLAB script
+        
+    Returns:
+        List of tuples containing (start_line, end_line, section_title)
+        for each section in the script. If no sections are found, returns
+        a single section spanning the entire file.
+    """
+    sections = []
+    current_start = 0
+    current_title = "Main"
+    
+    with open(file_path) as f:
+        lines = f.readlines()
+        
+    for i, line in enumerate(lines):
+        if line.startswith('%%'):
+            # If we found a section marker, end the previous section
+            if current_start < i:
+                sections.append((current_start, i - 1, current_title))
+            
+            # Start a new section
+            current_start = i
+            # Extract section title (everything after %% on the same line)
+            current_title = line[2:].strip()
+    
+    # Add the final section
+    if current_start < len(lines):
+        sections.append((current_start, len(lines) - 1, current_title))
+    
+    # If no sections were found, treat the entire file as one section
+    if not sections:
+        sections = [(0, len(lines) - 1, "Main")]
+    
+    return sections
+
+
+def extract_section(
+    file_path: Path,
+    start_line: int,
+    end_line: int,
+    maintain_workspace: bool = True
+) -> str:
+    """Extract a section of MATLAB code from a file.
+    
+    Args:
+        file_path: Path to the MATLAB script
+        start_line: Starting line number (0-based)
+        end_line: Ending line number (0-based)
+        maintain_workspace: Whether to maintain workspace variables
+        
+    Returns:
+        MATLAB code for the specified section
+    """
+    with open(file_path) as f:
+        lines = f.readlines()
+    
+    # Extract the section lines
+    section_lines = lines[start_line:end_line + 1]
+    
+    # If not maintaining workspace, add clear command at the start
+    if not maintain_workspace:
+        section_lines.insert(0, 'clear;\n')
+    
+    return ''.join(section_lines)
+
+
+def get_section_info(file_path: Path) -> List[dict]:
+    """Get information about sections in a MATLAB script.
+    
+    Args:
+        file_path: Path to the MATLAB script
+        
+    Returns:
+        List of dictionaries containing section information:
+        {
+            'title': section title,
+            'start_line': starting line number,
+            'end_line': ending line number,
+            'preview': first non-comment line of the section
+        }
+    """
+    sections = parse_sections(file_path)
+    section_info = []
+    
+    with open(file_path) as f:
+        lines = f.readlines()
+    
+    for start, end, title in sections:
+        # Find first non-comment line for preview
+        preview = ""
+        for line in lines[start:end + 1]:
+            stripped = line.strip()
+            if stripped and not stripped.startswith('%'):
+                preview = stripped
+                break
+        
+        section_info.append({
+            'title': title,
+            'start_line': start,
+            'end_line': end,
+            'preview': preview
+        })
+    
+    return section_info