Custom Feature Agent - AI-Powered Feature Generation

User Request
    │
    ▼
┌─────────────────────────────────────┐
│      Custom Feature Agent           │
│  ┌─────────────────────────────┐   │
│  │  1. Validate Requirements   │   │
│  │  2. Research Best Practices │   │
│  │  3. Check Existing Files    │   │
│  │  4. Create Git Branch       │   │
│  └─────────────────────────────┘   │
└─────────────────┬───────────────────┘
                  │
                  ▼
┌─────────────────────────────────────┐
│       Claude Code SDK               │
│  ┌─────────────────────────────┐   │
│  │  • Reads codebase structure │   │
│  │  • Applies unified template │   │
│  │  • Generates compliant code │   │
│  │  • Creates test files       │   │
│  │  • Writes documentation     │   │
│  └─────────────────────────────┘   │
└─────────────────┬───────────────────┘
                  │
                  ▼
┌─────────────────────────────────────┐
│        Generated Components         │
│  • lobster/agents/*_expert.py       │
│  • lobster/services/{category}/*.py │
│  • tests/unit/services/{category}/* │
│  • wiki/*.md                        │
└─────────────────────────────────────┘

lobster/services/
├── analysis/           # Statistical analysis, clustering, DE, differential
├── data_access/        # External APIs, databases, GEO, content fetching
├── data_management/    # Modality CRUD, concatenation, storage
├── metadata/           # Standardization, validation, ID mapping
├── ml/                 # Machine learning, embeddings, predictions
├── orchestration/      # Workflow coordination, pipeline execution
├── quality/            # QC, preprocessing, filtering
└── visualization/      # Plotting, charts, visualization services

lobster chat

Create a new metabolomics analysis service that:
- Loads and normalizes metabolomics data from various formats
- Performs pathway enrichment analysis
- Generates volcano plots and heatmaps
- Integrates with existing bulk RNA-seq data

create_new_feature(
    feature_type="agent_with_service",
    feature_name="metabolomics",
    requirements="""
    Create a metabolomics analysis agent that:
    - Supports LC-MS and GC-MS data formats
    - Performs feature detection and alignment
    - Calculates metabolite abundances
    - Integrates with pathway databases (KEGG, MetaCyc)
    """
)

class MetabolomicsService:
    """Stateless service for metabolomics analysis."""

    def analyze(
        self,
        adata: AnnData,
        **params
    ) -> Tuple[AnnData, Dict[str, Any], AnalysisStep]:
        """
        Perform metabolomics analysis.

        Returns:
            Tuple of (processed_adata, stats_dict, ir)
        """
        # Processing logic
        processed = adata.copy()
        # ... analysis code ...

        stats = {
            "n_metabolites": processed.n_vars,
            "n_samples": processed.n_obs,
            # ... other statistics ...
        }

        ir = self._create_ir(**params)

        return processed, stats, ir

    def _create_ir(self, **params) -> AnalysisStep:
        """Create W3C-PROV compliant intermediate representation."""
        return AnalysisStep(
            operation="metabolomics.analyze",
            tool_name="analyze",
            description="Metabolomics analysis",
            library="lobster",
            code_template="""
# Metabolomics analysis
service = MetabolomicsService()
result, stats, ir = service.analyze(adata, **{{ params }})
""",
            imports=["from lobster.services.analysis.metabolomics_service import MetabolomicsService"],
            parameters=params,
            parameter_schema={...}
        )

@tool
def analyze_metabolomics(
    modality_name: str,
    normalization: str = "median"
) -> str:
    """Perform metabolomics analysis on the specified modality."""
    try:
        # 1. Validate modality exists
        if modality_name not in data_manager.list_modalities():
            raise ModalityNotFoundError(f"Modality '{modality_name}' not found")

        adata = data_manager.get_modality(modality_name)

        # 2. Call stateless service
        result, stats, ir = service.analyze(adata, normalization=normalization)

        # 3. Store result with descriptive naming
        new_name = f"{modality_name}_metabolomics_analyzed"
        data_manager.modalities[new_name] = result

        # 4. Log with IR for provenance
        data_manager.log_tool_usage(
            "analyze_metabolomics",
            {"normalization": normalization},
            stats,
            ir=ir  # IR is mandatory
        )

        return format_response(stats, new_name)

    except Exception as e:
        logger.error(f"Analysis failed: {e}")
        return f"Analysis failed: {str(e)}"

from lobster.core.interfaces.download_service import IDownloadService

class MyDatabaseDownloadService(IDownloadService):
    """Download service for MyDatabase."""

    def supports_database(self, database: str) -> bool:
        return database.lower() in ["mydatabase", "mydb"]

    def download_dataset(
        self,
        queue_entry: DownloadQueueEntry,
        strategy_override: Optional[Dict] = None
    ) -> Tuple[AnnData, Dict[str, Any], AnalysisStep]:
        """Download and process dataset from MyDatabase."""
        # Implementation
        pass

    def validate_strategy_params(
        self,
        params: Dict[str, Any]
    ) -> Tuple[bool, Optional[str]]:
        """Validate download strategy parameters."""
        pass

    def get_supported_strategies(self) -> List[str]:
        """Return list of supported download strategies."""
        return ["default", "parallel", "streaming"]

from lobster.services.data_management.modality_management_service import ModalityManagementService

class MyModalityService:
    """Service with modality management capabilities."""

    def __init__(self, data_manager: DataManagerV2):
        self.modality_service = ModalityManagementService(data_manager)

    def load_data(self, path: str, name: str) -> Tuple[AnnData, Dict, AnalysisStep]:
        """Load data using the standardized modality service."""
        return self.modality_service.load_modality(
            modality_name=name,
            file_path=path,
            adapter="csv",
            dataset_type="metabolomics",
            validate=True
        )

spatial_transcriptomics
metabolomics_v2
gene2vec
rna_velocity

SpatialTranscriptomics  # PascalCase
spatial-transcriptomics # hyphens
10x_genomics            # starts with number
spatial_                # trailing underscore

geo_gse12345                      # Original data
├── geo_gse12345_quality_assessed # After QC
├── geo_gse12345_filtered         # After filtering
├── geo_gse12345_normalized       # After normalization
├── geo_gse12345_clustered        # After clustering
└── geo_gse12345_annotated        # After annotation

# In your agent module: lobster/agents/metabolomics_expert.py
from lobster.core.registry import AgentRegistryConfig

AGENT_CONFIG = AgentRegistryConfig(
    name='metabolomics_expert_agent',
    display_name='Metabolomics Expert',
    description='Handles metabolomics analysis including pathway enrichment',
    factory_function='lobster.agents.metabolomics_expert:metabolomics_expert',
    tier_requirement='free',
    handoff_tool_name='handoff_to_metabolomics_expert_agent',
    handoff_tool_description='Hand off metabolomics analysis tasks'
)

[project.entry-points."lobster.agents"]
metabolomics_expert_agent = "lobster.agents.metabolomics_expert:AGENT_CONFIG"

# Add to lobster/config/agent_config.py
"metabolomics_expert_agent": "claude-4-sonnet",

# On feature branch (auto-created)
make test              # Run tests
make lint              # Check linting
make type-check        # Type checking

git add .
git commit -m "feat: Add metabolomics analysis service"
git push origin feature/metabolomics_241126

# Run all custom feature agent tests
pytest tests/unit/agents/test_custom_feature_agent.py -v

# Run specific test class
pytest tests/unit/agents/test_custom_feature_agent.py::TestFeatureNameValidation -v

git checkout -b test/custom-feature-test
# Run agent to create test feature
# Verify generated code
git checkout main
git branch -D test/custom-feature-test

create_new_feature(
    feature_type="service",
    feature_name="test_feature",
    requirements="...",
    debug=True  # Enable verbose output
)

# Good
Create a spatial transcriptomics service that:
- Handles Visium and Slide-seq data formats
- Performs neighborhood analysis using squidpy
- Calculates Moran's I for spatial autocorrelation
- Generates spatial scatter plots with cluster overlays
- Supports integration with histology images

# Bad
Create a spatial service

Requirements should use:
- squidpy for spatial analysis
- scanpy for preprocessing
- matplotlib/plotly for visualization