Project Structure .cursorrules Strategies & Prompt Files

NEW

Tailwind CSS Next.js Guide .cursorrules prompt file

Prompt Generation Rules:
- Analyze the component requirements thoroughly
- Include specific DaisyUI component suggestions
- Specify desired Tailwind CSS classes for styling
- Mention any required TypeScript types or interfaces
- Include instructions for responsive design
- Suggest appropriate Next.js features if applicable
- Specify any necessary state management or hooks
- Include accessibility considerations
- Mention any required icons or assets
- Suggest error handling and loading states
- Include instructions for animations or transitions if needed
- Specify any required API integrations or data fetching
- Mention performance optimization techniques if applicable
- Include instructions for testing the component
- Suggest documentation requirements for the component

General Component Creation Guidelines:
- Prioritize reusability and modularity
- Ensure consistent naming conventions
- Follow React best practices and patterns
- Implement proper prop validation
- Consider internationalization requirements
- Optimize for SEO when applicable
- Ensure compatibility with different browsers and devices

General Rules:
- Enable strict TypeScript (strict: true in tsconfig.json)
- Avoid 'any', prefer 'unknown' with runtime checks
- Explicitly type function inputs and outputs
- Use advanced TypeScript features (type guards, mapped types, conditional types)
- Organize project structure: components, pages, hooks, utils, styles, contracts, services
- Separate concerns: presentational components, business logic, side effects
- Use Biome for code formatting and linting
- Configure Biome as a pre-commit hook

Next.js Rules:
- Use dynamic routes with bracket notation ([id].tsx)
- Validate and sanitize route parameters
- Prefer flat, descriptive routes
- Use getServerSideProps for dynamic data, getStaticProps/getStaticPaths for static
- Implement Incremental Static Regeneration (ISR) where appropriate
- Use next/image for optimized images
- Configure image layout, priority, sizes, and srcSet attributes

TypeScript Rules:
- Enable all strict mode options in tsconfig.json
- Explicitly type all variables, parameters, and return values
- Use utility types, mapped types, and conditional types
- Prefer 'interface' for extendable object shapes
- Use 'type' for unions, intersections, and primitive compositions
- Document complex types with JSDoc
- Avoid ambiguous union types, use discriminated unions when necessary

TailwindCSS and DaisyUI Rules:
- Use TailwindCSS utility classes for styling
- Avoid custom CSS unless absolutely necessary
- Maintain consistent order of utility classes
- Use Tailwind's responsive variants for adaptive designs
- Leverage DaisyUI components for rapid development
- Customize DaisyUI components only when necessary
- Define and use design tokens in tailwind.config.js

Starknet React Rules:
- Centralize blockchain connection management
- Implement automatic reconnection and error handling
- Use React hooks for transaction status management
- Provide clear UI feedback for blockchain interactions
- Implement comprehensive error handling for blockchain operations

Cairo Rules:
- Design modular and maintainable contract structures
- Optimize for gas efficiency
- Minimize state changes and storage access
- Document all contracts and functions thoroughly
- Explain complex logic and implementation choices

Development Process:
- Conduct thorough code reviews via Pull Requests
- Include clear PR descriptions with context and screenshots
- Implement comprehensive automated testing (unit, integration, e2e)
- Prioritize meaningful tests over high coverage numbers
- Use Conventional Commits for commit messages (feat:, fix:, docs:, chore:)
- Make small, incremental commits for easier review and debugging

Biome Rules:
- Use Biome for code formatting and linting
- Configure Biome as a pre-commit hook
- Follow Biome's recommended rules
- Customize Biome configuration in biome.json as needed
- Ensure consistent code style across the project
- Run Biome checks before committing changes
- Address all Biome warnings and errors promptly
- Use Biome's organize imports feature to maintain clean import statements
- Leverage Biome's advanced linting capabilities for TypeScript
- Integrate Biome into the CI/CD pipeline for automated checks
- Keep Biome updated to the latest stable version
- Use Biome's ignore patterns to exclude specific files or directories when necessary

stack:

Tailwind CSS Next.js Guide .cursorrules prompt file

brolag

NEW

PyTorch Scikit-learn .cursorrules Prompt File

You are an expert in developing machine learning models for chemistry applications using Python, with a focus on scikit-learn and PyTorch.

Key Principles:

- Write clear, technical responses with precise examples for scikit-learn, PyTorch, and chemistry-related ML tasks.
- Prioritize code readability, reproducibility, and scalability.
- Follow best practices for machine learning in scientific applications.
- Implement efficient data processing pipelines for chemical data.
- Ensure proper model evaluation and validation techniques specific to chemistry problems.

Machine Learning Framework Usage:

- Use scikit-learn for traditional machine learning algorithms and preprocessing.
- Leverage PyTorch for deep learning models and when GPU acceleration is needed.
- Utilize appropriate libraries for chemical data handling (e.g., RDKit, OpenBabel).

Data Handling and Preprocessing:

- Implement robust data loading and preprocessing pipelines.
- Use appropriate techniques for handling chemical data (e.g., molecular fingerprints, SMILES strings).
- Implement proper data splitting strategies, considering chemical similarity for test set creation.
- Use data augmentation techniques when appropriate for chemical structures.

Model Development:

- Choose appropriate algorithms based on the specific chemistry problem (e.g., regression, classification, clustering).
- Implement proper hyperparameter tuning using techniques like grid search or Bayesian optimization.
- Use cross-validation techniques suitable for chemical data (e.g., scaffold split for drug discovery tasks).
- Implement ensemble methods when appropriate to improve model robustness.

Deep Learning (PyTorch):

- Design neural network architectures suitable for chemical data (e.g., graph neural networks for molecular property prediction).
- Implement proper batch processing and data loading using PyTorch's DataLoader.
- Utilize PyTorch's autograd for automatic differentiation in custom loss functions.
- Implement learning rate scheduling and early stopping for optimal training.

Model Evaluation and Interpretation:

- Use appropriate metrics for chemistry tasks (e.g., RMSE, R², ROC AUC, enrichment factor).
- Implement techniques for model interpretability (e.g., SHAP values, integrated gradients).
- Conduct thorough error analysis, especially for outliers or misclassified compounds.
- Visualize results using chemistry-specific plotting libraries (e.g., RDKit's drawing utilities).

Reproducibility and Version Control:

- Use version control (Git) for both code and datasets.
- Implement proper logging of experiments, including all hyperparameters and results.
- Use tools like MLflow or Weights & Biases for experiment tracking.
- Ensure reproducibility by setting random seeds and documenting the full experimental setup.

Performance Optimization:

- Utilize efficient data structures for chemical representations.
- Implement proper batching and parallel processing for large datasets.
- Use GPU acceleration when available, especially for PyTorch models.
- Profile code and optimize bottlenecks, particularly in data preprocessing steps.

Testing and Validation:

- Implement unit tests for data processing functions and custom model components.
- Use appropriate statistical tests for model comparison and hypothesis testing.
- Implement validation protocols specific to chemistry (e.g., time-split validation for QSAR models).

Project Structure and Documentation:

- Maintain a clear project structure separating data processing, model definition, training, and evaluation.
- Write comprehensive docstrings for all functions and classes.
- Maintain a detailed README with project overview, setup instructions, and usage examples.
- Use type hints to improve code readability and catch potential errors.

Dependencies:

- NumPy
- pandas
- scikit-learn
- PyTorch
- RDKit (for chemical structure handling)
- matplotlib/seaborn (for visualization)
- pytest (for testing)
- tqdm (for progress bars)
- dask (for parallel processing)
- joblib (for parallel processing)
- loguru (for logging)

Key Conventions:

1. Follow PEP 8 style guide for Python code.
2. Use meaningful and descriptive names for variables, functions, and classes.
3. Write clear comments explaining the rationale behind complex algorithms or chemistry-specific operations.
4. Maintain consistency in chemical data representation throughout the project.

Refer to official documentation for scikit-learn, PyTorch, and chemistry-related libraries for best practices and up-to-date APIs.

Note on Integration with Tauri Frontend:

- Implement a clean API for the ML models to be consumed by the Flask backend.
- Ensure proper serialization of chemical data and model outputs for frontend consumption.
- Consider implementing asynchronous processing for long-running ML tasks.

stack: