Fix code generation sandbox errors and add workspace utils template

- Fix database path in code_generation_assistant.py to use '/workspace/database/nasa_turbo.db'
- Make utils import conditional and only for RUL transformations
- Fix sys.path.append to use '/workspace' instead of '.'
- Add utils_template folder with pre-built RUL transformation utilities
- Update README with clear setup instructions for workspace utilities
- Addresses customer issues: ModuleNotFoundError for utils and mysql modules

Signed-off-by: Vineeth Kalluru <vikalluru@nvidia.com>

Author: vikalluru

industries/asset_lifecycle_management_agent/README.md

@@ -254,6 +254,41 @@ This ensures that:
 - Output files are organized within your project
 - Configuration remains portable across different machines
 
+#### Setting Up Workspace Utilities
+
+**IMPORTANT**: The code generation assistant requires a `utils` folder inside your `output_data` directory for RUL transformation tasks.
+
+**Setup Instructions:**
+
+1. Create the output_data directory (if it doesn't exist):
+```bash
+mkdir -p output_data
+```
+
+2. Copy the pre-built utility functions from the template:
+```bash
+cp -r utils_template output_data/utils
+```
+
+3. Verify the setup:
+```bash
+ls output_data/utils/
+# You should see: __init__.py  rul_utils.py
+```
+
+**What's included:**
+- `apply_piecewise_rul_transformation(df, maxlife=100)` - Transforms RUL data to create realistic "knee" patterns
+- `show_utilities()` - Display available utility functions
+
+These utilities are automatically available to the code generation assistant when running in the Docker sandbox (mapped as `/workspace/utils/`). The system will only import these utilities when specifically needed for RUL transformations, preventing unnecessary module loading errors (`ModuleNotFoundError: No module named 'utils'` will not occur).
+
+**How It Works:**
+- When you start the sandbox with `output_data/` as the mount point, the `utils/` folder becomes accessible at `/workspace/utils/`
+- The code generation assistant only imports utils when performing RUL transformations
+- For regular tasks (data retrieval, plotting, etc.), utils are not imported, avoiding module errors
+
+**Note**: If you move your `output_data` folder, make sure the `utils` subfolder comes with it, or copy it from `utils_template` again.
+
 ### 6. Vanna SQL Agent Training (Automatic)
 
 **Important**: The Vanna SQL agent training happens automatically when you start the workflow server. The `vanna_training_data.yaml` file contains pre-configured domain-specific knowledge that will be loaded automatically during server startup.

industries/asset_lifecycle_management_agent/src/asset_lifecycle_management_agent/plotting/code_generation_assistant.py

@@ -70,45 +70,26 @@ async def _generate_and_execute_code(
 OUTPUT ONLY THE CODE. NO COMMENTS. NO DOCSTRINGS. NO EXPLANATIONS.
 Generate only the code needed. Your response must contain ONLY executable Python code which will be DIRECTLY EXECUTED IN A SANDBOX.
 
-**UTILITIES AVAILABLE:**
-A 'utils' folder contains pre-built functions for Asset Lifecycle Management tasks (especially predictive maintenance):
-- utils.apply_piecewise_rul_transformation
-    - DESCRIPTION: Takes an input pandas DataFrame with time series data and create realistic "knee" patterns on the provided RUL column.
-    - INPUTS:
-    - df: pandas DataFrame with time series data
-    - maxlife: Maximum life threshold for the piecewise function (default: 100)
-    - time_col: Name of the time/cycle column (default: 'time_in_cycles')
-    - rul_col: Name of the RUL column to transform (default: 'RUL')
-   OUTPUTS:
-    - df - a pandas DataFrame with original data plus new 'transformed_RUL' column
+**DATABASE PATH:**
+For SQLite operations, the database file is located at: '/workspace/database/nasa_turbo.db'
+ALWAYS use this exact path when connecting to the database.
 
-- utils.show_utilities(): Show all available utilities if you need to see them
+**UTILITIES (OPTIONAL - ONLY FOR RUL TRANSFORMATIONS):**
+ONLY IF the task involves piecewise RUL transformation, you may use:
+- utils.apply_piecewise_rul_transformation(df, maxlife=100, time_col='time_in_cycles', rul_col='RUL')
+  Takes a pandas DataFrame and returns it with an added 'transformed_RUL' column using piecewise transformation.
 
-**CRITICAL REQUIREMENT: ALWAYS USE UTILITIES when available instead of writing custom implementations.**
-This ensures reliable, tested functionality and consistent results.
-
-To use utilities, start your code with:
+To use utilities (ONLY if needed for RUL transformation):
 ```python
 import sys
-sys.path.append(".")
+sys.path.append("/workspace")
 import utils
 
-<insert your code here>
-<insert your code here>
-<insert your code here>
-
-# Saving files to the current working directory.)
-print("Original RUL column name: ", rul column name)
-print("Transformed RUL column name: ", 'transformed_RUL')
-print("File saved to: filename.json")
+# Your code using the utility
+df_transformed = utils.apply_piecewise_rul_transformation(df, maxlife=100)
 ```
 
-**UTILITY USAGE GUIDELINES:**
-- Check if your task can be accomplished using the utility function
-- For RUL transformations: ALWAYS use utils.apply_piecewise_rul_transformation() instead of custom logic
-- The utility handles all error checking and provides detailed success messages
-- Use maxlife parameter to control the knee threshold (default: 100)
-- Capture the DataFrame returned by the utility function for further processing
+DO NOT import utils unless specifically needed for RUL transformation tasks.
 
 **CODE REQUIREMENTS:**
 1. Generate COMPLETE, SYNTACTICALLY CORRECT Python code
@@ -117,6 +98,7 @@ async def _generate_and_execute_code(
 4. NO comments, NO docstrings, NO explanations
 5. Use minimal variable names (df, fig, data, etc.)
 6. **CRITICAL FILE PATH RULE**: Use ONLY the filename directly (e.g., "filename.json"), NOT "output_data/filename.json"
+7. **DATABASE PATH RULE**: Use '/workspace/database/nasa_turbo.db' for SQLite connections
 8. **IF YOU STILL NEED TO SAVE FILES, THEN PRINT FILE NAMES TO STDOUT. (eg: print("Saved file to: filename.json"))**
 
 GENERATE CODE ONLY. NO COMMENTS. NO EXPLANATIONS."""
@@ -225,17 +207,20 @@ def is_code_incomplete(code):
 
                     fix_prompt_text = f"""The previous code needs to be fixed. Please analyze the issue and generate corrected Python code.
 
+ORIGINAL INSTRUCTIONS: {instructions}
+
 PREVIOUS CODE:
 {code}
 
 ISSUE TO FIX:
 {error_info}
 
 Please generate corrected Python code that fixes the problem. Follow all requirements:
-- Use utilities when available
+- Use '/workspace/database/nasa_turbo.db' for database connections
+- Only import utils if doing RUL transformations (use sys.path.append("/workspace"))
 - Generate only executable Python code
 - No comments or explanations
-- Handle file paths correctly
+- Handle file paths correctly (use only filename, not paths)
 - Complete all code blocks properly
 - Ensure the code is complete and not truncated
 

industries/asset_lifecycle_management_agent/utils_template/__init__.py

@@ -0,0 +1,11 @@
+"""
+Workspace utilities for Asset Lifecycle Management tasks.
+
+These pre-built utility functions provide reliable, tested implementations
+for common data processing tasks, particularly for predictive maintenance workflows.
+"""
+
+from .rul_utils import apply_piecewise_rul_transformation, show_utilities
+
+__all__ = ['apply_piecewise_rul_transformation', 'show_utilities']
+

industries/asset_lifecycle_management_agent/utils_template/rul_utils.py

@@ -0,0 +1,146 @@
+"""
+RUL (Remaining Useful Life) transformation utilities.
+
+Provides pre-built functions for transforming RUL data to create realistic patterns
+for Asset Lifecycle Management and predictive maintenance tasks.
+"""
+
+import pandas as pd
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def apply_piecewise_rul_transformation(
+    df: pd.DataFrame,
+    maxlife: int = 100,
+    time_col: str = 'time_in_cycles',
+    rul_col: str = 'RUL'
+) -> pd.DataFrame:
+    """
+    Transform RUL data to create realistic "knee" patterns.
+    
+    This function applies a piecewise transformation to RUL (Remaining Useful Life) values
+    to create a more realistic degradation pattern commonly seen in predictive maintenance:
+    - RUL stays constant at MAXLIFE until the remaining cycles drop below the threshold
+    - Then RUL decreases linearly to 0 as the equipment approaches failure
+    
+    This creates the characteristic "knee" pattern seen in actual equipment degradation.
+    
+    Args:
+        df: pandas DataFrame with time series data containing RUL values
+        maxlife: Maximum life threshold for the piecewise function (default: 100)
+                 RUL values above this will be capped at maxlife
+        time_col: Name of the time/cycle column (default: 'time_in_cycles')
+        rul_col: Name of the RUL column to transform (default: 'RUL')
+    
+    Returns:
+        pandas DataFrame with original data plus new 'transformed_RUL' column
+        
+    Raises:
+        ValueError: If required columns are missing from the DataFrame
+        
+    Example:
+        >>> df = pd.DataFrame({'time_in_cycles': [1, 2, 3], 'RUL': [150, 100, 50]})
+        >>> df_transformed = apply_piecewise_rul_transformation(df, maxlife=100)
+        >>> print(df_transformed['transformed_RUL'])
+        0    100
+        1    100
+        2     50
+        Name: transformed_RUL, dtype: int64
+    """
+    # Validate inputs
+    if not isinstance(df, pd.DataFrame):
+        raise ValueError(f"Expected pandas DataFrame, got {type(df)}")
+    
+    if rul_col not in df.columns:
+        raise ValueError(
+            f"RUL column '{rul_col}' not found in DataFrame. "
+            f"Available columns: {list(df.columns)}"
+        )
+    
+    if time_col not in df.columns:
+        logger.warning(
+            f"Time column '{time_col}' not found in DataFrame, but continuing anyway. "
+            f"Available columns: {list(df.columns)}"
+        )
+    
+    # Create a copy to avoid modifying the original
+    df_copy = df.copy()
+    
+    logger.info(f"Applying piecewise RUL transformation with maxlife={maxlife}")
+    logger.debug(f"Input RUL range: [{df_copy[rul_col].min()}, {df_copy[rul_col].max()}]")
+    
+    # Apply piecewise transformation
+    def transform_rul(rul_value):
+        """Apply the piecewise transformation to a single RUL value."""
+        if pd.isna(rul_value):
+            return rul_value  # Keep NaN values as NaN
+        if rul_value > maxlife:
+            return maxlife
+        return rul_value
+    
+    # Apply transformation to create new column
+    df_copy['transformed_RUL'] = df_copy[rul_col].apply(transform_rul)
+    
+    logger.info(
+        f"✅ Transformation complete! Added 'transformed_RUL' column. "
+        f"Output range: [{df_copy['transformed_RUL'].min()}, {df_copy['transformed_RUL'].max()}]"
+    )
+    logger.debug(f"Total rows processed: {len(df_copy)}")
+    
+    return df_copy
+
+
+def show_utilities():
+    """
+    Display available utility functions and their usage.
+    
+    Prints a formatted list of all available utilities in this workspace,
+    including descriptions and example usage.
+    """
+    utilities_info = """
+    ================================================================================
+    WORKSPACE UTILITIES - Asset Lifecycle Management
+    ================================================================================
+    
+    Available utility functions:
+    
+    1. apply_piecewise_rul_transformation(df, maxlife=100, time_col='time_in_cycles', rul_col='RUL')
+       
+       Description:
+         Transforms RUL (Remaining Useful Life) data to create realistic "knee" patterns
+         commonly seen in predictive maintenance scenarios.
+       
+       Parameters:
+         - df: pandas DataFrame with time series data
+         - maxlife: Maximum life threshold (default: 100)
+         - time_col: Name of time/cycle column (default: 'time_in_cycles')
+         - rul_col: Name of RUL column to transform (default: 'RUL')
+       
+       Returns:
+         DataFrame with original data plus new 'transformed_RUL' column
+       
+       Example:
+         df_transformed = utils.apply_piecewise_rul_transformation(df, maxlife=100)
+         print(df_transformed[['time_in_cycles', 'RUL', 'transformed_RUL']])
+    
+    2. show_utilities()
+       
+       Description:
+         Displays this help message with all available utilities.
+       
+       Example:
+         utils.show_utilities()
+    
+    ================================================================================
+    """
+    print(utilities_info)
+
+
+if __name__ == "__main__":
+    # Simple test
+    print("RUL Utilities Module")
+    print("=" * 50)
+    show_utilities()
+