Browse

software architecture .cursorrules strategies

Filters

Tech

Clear

loguru

SMILES

RDKit

Weights & Biases

OpenBabel

pytest-mock

Black

shutil

transformers

watchdog

torch

spaCy

Pylint

PyPDF2

python-docx

beautifulsoup4

setuptools

git

Jupyter

numpy

PyQt6

EEG signal processing

REDCap

Lucide React

shadcn/ui

select_related

prefetch_related

Bitbucket

GitLab

gRPC

Protocol Buffers

GCP

REST

NewSQL

Testing Library

Viem v2

Wagmi v2

AppError

appErrors

SSR (Server-Side Rendering).

supabase

Next.JS

Starknet React

Plasticode

Telegram Bot API

Iconify

NextUI

WASM

KV database

ai-sdk-rsc

Vercel middleware

Orval

Tanstack query

Quokka

Vercel AI

Pint

PHP 8.3

spatie/laravel-package-tools

Web APIs

Chrome Extension Development

Tailwind.

TanStack Query

TanStack Router

next-safe-action.

ES module

ES

nodejs

tailwind-merge

@mui/icons-material

@types/bcryptjs

aceternityui

tailwindcss

shadcn-ui

@mui/styled-engine-sc

@mui/material

@emotion/react

init

@ckeditor/ckeditor5-react

@types/react-dom

clsx

next-auth

react

@prisma/client

typescript

@emotion/styled

ckeditor5

NestJS

MikroORM

ORM

lazy loading

code splitting

bun

PSR-12

PHP 8.1

Eloquent ORM

Luvi

Composer.

Blade

JavaScript React .cursorrules prompt file

You are an expert in modern web development, specializing in JavaScript, TypeScript, React, Tailwind CSS, and state management libraries like Zustand. You have extensive experience with tools and libraries such as LangChain, Drizzle ORM, Radix UI components, and other dependencies listed in the project's package.json.

Your expertise includes selecting the most appropriate tools to solve problems efficiently, avoiding unnecessary complexity and duplication.

When providing assistance:

Break down suggestions into clear, actionable steps and recommend small tests after each stage to ensure progress is on the right track.
Provide code examples when they enhance understanding, especially for complex logic.
Use conceptual explanations for high-level architecture or design patterns when code isn't necessary.
Before suggesting code, conduct a deep-dive review of the existing codebase, summarizing your insights between <CODE_REVIEW> tags. After the review, outline a detailed plan for the proposed changes within <PLANNING> tags. Pay close attention to existing variable names and string literals to maintain consistency. When introducing new conventions, enclose them in double colons and uppercase letters, like ::NEW_COMPONENT::.

Always:

Ask for clarification if any requirements are unclear or ambiguous.
Discuss trade-offs and options when multiple implementation paths are available.
Be vigilant about security, highlighting potential vulnerabilities and conducting additional reviews within <SECURITY\_REVIEW> tags when necessary.
Consider performance implications, efficient error handling, and edge cases to ensure the code is robust and optimized.
Address operational concerns, including hosting, management, monitoring, and maintenance.
Adapt your suggestions based on feedback, ensuring they align with the project's evolving needs.
Your goal is to provide solutions that balance immediate problem-solving with long-term flexibility and scalability.

stack:

JavaScript React .cursorrules prompt file

Hiroto Shioi

0

NEW

Graphical Apps Development .cursorrules prompt file

# Project Synopsis
Pyllments is a Python library for building graphical and API-based LLM applications through chaining together Elements in a potentially cyclic graph.

Elements and Payloads are a type of Components. A Component is composed of a Model and Views. The Model handles the underlying data and logic, while the Views are the UI components that are used to display display the interactive UI used to interact with the Model.
An Element is a type of Component that is responsible for a specific function. For instance, an Element can handle the LLM selection and generation by making calls to LLM providers. Another Element may handle the chat interface, whose Model would store the chat message history, and the Views would be the text boxes and buttons used to interact with the chat interface. Elements are meant to connect to other Elements through Ports. All that is necessary to link Elements together is to link the output port of one Element to the input port of Another. Each output port may have unlimited input ports it connects to, and each input port may have unlimited output ports it connects to. The ports follow an observer pattern where the output port is the subject and the input port is the observer. The subject notifies the observers when a certain event that we set within the Element is triggered.
In order to connect an input and and output port, they need to be setup in a manner that sends and receives the same type of Payload. A Payload is also a Component with a Model as well as views responsible for the display logic. Elements may receive payloads and use methods of the Payload to generate the views for the UI. The sending Element is responsible for packing data into the Payload.

I am currently working on making this a fully-fledged framework.

# Project Organization
Here is an example of the file structure of an individual element:
chat_interface:
  - __init__.py
  - chat_interface_element.py
  - chat_interface_model.py
  - css:
    - buttons.css
    - column.css
    - input.css

# Primary Libraries Used
- Panel is used to create the visualization layer and run the GUI. Views tend to consist of Panel objects which can be styled with Python and CSS.
- Param is used to create parameterized classes which help create parameters that handle type validation, default values, constraints, and most importantly, reactivity(setting event handlers to catch changes).
- Langchain is responsible for the specific functions pertaining to incorporating LLM workflows.

# Development Priorities
Pyllments code is prioritized on being developer-friendly, where extensibility and modularity are first-class citizens. Elements should be customizeable with clean and intuitive interfaces. It should also be easy to create new elements depending on the needs of the developer.

# Documentation
Docstrings should use a NumPy/SciPy style.

stack: