Skills by giuseppe-trisciuoglio

Provides comprehensive shadcn/ui component patterns, installation steps, and example code for Next.js/React projects. Contains explicit shell commands (`npx`, `npm`, `pnpm`), external registry URLs (e.g., `https://ui.shadcn.com`, `https://acme.com/registry/navbar.json`), and instructions to set `REGISTRY_TOKEN`/`COMPANY_TOKEN` environment variables.

Provides comprehensive Tailwind CSS utility-first styling patterns including responsive design, layout utilities, flexbox, grid, spacing, typography, colors, and modern CSS best practices. Use when styling React/Vue/Svelte components, building responsive layouts, implementing design systems, or optimizing CSS workflow.

Provides an expert React 19 patterns guide for Server Components, Actions, hooks, and TypeScript. The skill manifest requests broad tool access via `allowed-tools: Read, Write, Edit, Bash, Grep, Glob`, granting capabilities beyond its documentation purpose.

Generates TypeScript documentation, TypeDoc configuration, ADRs, and CI/CD workflows for docs generation and deployment. Includes shell commands (`npx typedoc`, `npm ci`, `git push`) and a deploy action using `secrets.GITHUB_TOKEN`, indicating purpose-aligned execution, network use, and credential access.

Provides comprehensive NestJS framework patterns with Drizzle ORM integration. Use when building NestJS applications, setting up APIs, implementing authentication, working with databases, or integrating Drizzle ORM. Covers controllers, providers, modules, middleware, guards, interceptors, testing, microservices, GraphQL, and database patterns.

Provides REST API design standards and Spring Boot examples for controllers, DTOs, error handling, pagination, and security headers. Includes a permissive CORS example (`configuration.setAllowedOriginPatterns(List.of("*"))`) and a Feign client (`@FeignClient(..., url = "${user.service.url}")`) that enables network calls.

This skill supplies Spring Boot JWT authentication and authorization patterns, example code, configuration, and a `./assets/generate-jwt-keys.sh` key-generation script. It includes local shell commands (`keytool`/`openssl`), uses secrets via env vars like `JWT_SECRET`/`GOOGLE_CLIENT_SECRET`, and configures external endpoints such as `https://auth.myapp.com/.well-known/jwks.json`.

Provides comprehensive testing patterns for Spring Boot applications including unit, integration, slice, and container-based testing with JUnit 5, Mockito, Testcontainers, and performance optimization. Use when implementing robust test suites for Spring Boot applications.

Provides a Spring Boot CRUD generator and templates for scaffolding feature-based services. The package includes a local scaffolding script `skills/spring-boot-crud-patterns/scripts/generate_crud_boilerplate.py` and usage examples invoking `python ...` (local execution); no secret exfiltration or external endpoints are instructed.

This skill provides Spring Data JPA patterns and extensive code examples for repositories, entities, queries, transactions, auditing, pagination, UUID keys, multi-database configuration, and indexing. It includes example credential properties like `users.datasource.password=password` and `products.datasource.password=postgres` and requests broad tools via `allowed-tools: Read, Write, Edit, Bash, Glob, Grep`.

Provides comprehensive chunking strategies, code examples, tooling recommendations, and visualization for RAG/document pipelines. Contains purpose-aligned instructions to run shell commands (e.g., `pip install`, `git clone`), call external APIs (e.g., `self.client.chat.completions.create`), and use API keys such as `openai_api_key`.

This skill documents prompt-engineering patterns and templates for few-shot learning, chain-of-thought, optimization, templates, and system-prompt design. It declares allowed tools including `Read`, `Write`, `Edit`, `Glob`, `Grep`, and `Bash`, which grants potential shell execution capability.

Provides dependency injection patterns for Spring Boot projects covering constructor-first patterns, optional collaborator handling, bean selection, and validation practices. Use when configuring beans, wiring dependencies, or troubleshooting injection issues.

This skill provides patterns to generate OpenAPI 3.0 documentation and integrate Swagger UI for Spring Boot 3.x. It references and instructs accessing endpoints such as `http://localhost:8080/v3/api-docs` and OAuth URLs like `https://auth.example.com/oauth/authorize`.

Dangerous skill: implements Spring AI MCP server patterns but enables dynamic code execution (`GROOVY_SCRIPT`), starts HTTP/STDI O transports (`/mcp` on port `8080`), and makes external calls to `https://api.weather.gov`. It also reads env vars like `OPENAI_API_KEY`/`ANTHROPIC_API_KEY` and includes permissive CORS (`*`).

This skill provides patterns and examples for JUnit 5 boundary and edge-case unit tests, covering numeric, string, collection, floating-point, date/time, array, and concurrency cases. No security-relevant behaviors detected.

Provides patterns for unit testing service layer with Mockito. Validates business logic in isolation by mocking dependencies. Use when testing service behaviors and business logic without database or external services.

Provides patterns for unit testing external REST APIs using WireMock to mock HTTP endpoints. Use when testing service integrations with external APIs.

This skill documents Spring Data Neo4j integration patterns for building Neo4j-backed Spring applications. It includes explicit connection URIs such as `bolt://localhost:7687`/`neo4j+s://production.server:7687` and credential keys like `spring.neo4j.authentication.password`, indicating network connections and credential handling that are purpose-aligned.

This skill documents Spring Boot event-driven patterns and examples for publishing/consuming events with Kafka. It includes explicit network configuration such as `spring.kafka.bootstrap-servers=localhost:9092` and a Docker image reference `confluentinc/cp-kafka:7.5.0`; network usage is purpose-aligned.

Provides Retrieval-Augmented Generation (RAG) implementation patterns with LangChain4j. Handles document ingestion pipelines, embedding stores, vector search strategies, and knowledge-enhanced AI applications. Use when creating question-answering systems over document collections or AI assistants with external knowledge bases.

Provides patterns for unit testing REST controllers using MockMvc and @WebMvcTest. Validates request/response mapping, validation, and exception handling. Use when testing web layer endpoints in isolation.

This skill documents implementing the Saga Pattern for Spring Boot microservices using Kafka, Axon, and databases. It includes explicit configuration entries such as `spring.kafka.bootstrap-servers=localhost:9092` and `spring.datasource.password=orderpass` in examples, exposing endpoints/credentials in sample configs.

This skill documents patterns for enabling and operating the Spring Cache abstraction in Spring Boot. It contains explicit instructions to query local Actuator endpoints such as `GET http://localhost:8080/actuator/metrics` and references multiple external documentation URLs.

Provides tool and function calling patterns with LangChain4j. Handles defining tools, function calls, and LLM agent integration. Use when building agentic applications that interact with tools.

Provides guidance to configure Spring Boot Actuator for monitoring, health checks, and Micrometer metrics. The skill includes explicit network calls (e.g., `https://api.payment.com/health`, `http://zipkin:9411/api/v2/spans`), shell commands (`mvn spring-boot:run`, `curl ...`), and uses env vars like `${DATADOG_API_KEY}`.

Provides guidance to integrate Resilience4j patterns into Spring Boot applications. Includes code that calls `http://payment-api/process` and `http://product-api/products/` and recommends exposing management endpoints with `management.endpoints.web.exposure.include: '*'`.

Provides MCP server implementation patterns and templates for LangChain4j, including transports, tool/resource/prompt providers, and Spring Boot integration. Contains explicit instructions to run local commands (e.g., `List.of("npm", "exec", "@modelcontextprotocol/server-everything@0.6.2")`, `"/usr/local/bin/docker"`), configure `http://localhost:3001/sse`, and use the env var `GITHUB_TOKEN`.

Provides patterns for unit testing utility/helper classes and static methods. Validates pure functions and helper logic. Use when verifying utility code correctness.

Provides patterns for unit testing Spring Security with @PreAuthorize, @Secured, @RolesAllowed. Validates role-based access control and authorization policies. Use when testing security configurations and access control logic.

This skill, `unit-test-mapper-converter`, documents patterns and examples for unit testing MapStruct mappers and custom converters in Java. No security-relevant behaviors detected.

Provides patterns for unit testing caching behavior using Spring Cache annotations (@Cacheable, @CachePut, @CacheEvict). Use when validating cache configuration and cache hit/miss scenarios.

Provides patterns for unit testing @ExceptionHandler and @ControllerAdvice for global exception handling. Use when validating error response formatting and HTTP status codes.

This skill documents AWS SDK for Java v2 patterns for working with Amazon DynamoDB, including client setup, Enhanced Client usage, transactions, and Spring Boot integration. It demonstrates using `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` and shows network calls to AWS/LocalStack (e.g., `https://docs.aws.amazon.com/dynamodb/`, `localstack.getEndpointOverride(...)`).

Provides patterns for testing Spring application events (ApplicationEvent) with @EventListener and ApplicationEventPublisher. Handles event publishing, listening, and async event handling in Spring Boot applications. Use when validating event-driven workflows in your Spring Boot services.

This skill provides Amazon S3 patterns and Java SDK 2.x examples for bucket/object operations, presigned URLs, Transfer Manager, and Spring Boot integration. It explicitly handles credentials via `s3.access-key=${AWS_ACCESS_KEY}`/`s3.secret-key=${AWS_SECRET_KEY}` and makes network calls (e.g., `http://localhost:4566`, S3 API calls).

Provides patterns for unit testing JSON serialization/deserialization with Jackson and @JsonTest. Use when validating JSON mapping, custom serializers, and date format handling.

Provides patterns for unit testing @ConfigurationProperties classes with @ConfigurationPropertiesTest. Use when validating application configuration binding and validation.

Provides configuration patterns for LangChain4J vector stores in RAG applications. Use when building semantic search, integrating vector databases (PostgreSQL/pgvector, Pinecone, MongoDB, Milvus, Neo4j), implementing embedding storage/retrieval, setting up hybrid search, or optimizing vector database performance for production AI applications.

Provides parameterized testing patterns with @ParameterizedTest, @ValueSource, @CsvSource. Enables running a single test method with multiple input combinations. Use when testing multiple scenarios with similar logic.

Provides patterns for unit testing scheduled and async tasks using @Scheduled and @Async. Handles mocking task execution and timing. Use when validating asynchronous operations and scheduling behavior.

Provides testing strategies for LangChain4J applications, covering unit mocks, Testcontainers integration, RAG, streaming, and performance tests. Examples start containers via `GenericContainer`/`DockerImageName.parse(...)`, use `System.getenv("OPENAI_API_KEY")`, and list `allowed-tools: Read, Write, Edit, Bash, Glob, Grep`.

Provides patterns to configure AWS RDS (Aurora, MySQL, PostgreSQL) with Spring Boot applications. Use when setting up datasources, connection pooling, security, and production-ready database configuration.

This skill documents LangChain4j AI Services patterns for Java — interfaces, annotations, memory, tools, RAG, and streaming. It includes code that reads the `OPENAI_API_KEY` env var and configures `OpenAiChatModel`/`OpenAiEmbeddingModel`, which will make external API calls.

Provides integration patterns for LangChain4j with Spring Boot. Handles auto-configuration, dependency injection, and Spring ecosystem integration. Use when embedding LangChain4j into Spring Boot applications.

This skill documents AWS SDK for Java 2.x configuration, authentication, HTTP client setup, and testing. It references credential sources like `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `~/.aws/credentials`, includes setup commands such as `aws sso login`, and uses endpoints like `http://localhost:4566` and `http://proxy:8080`.

Provides AWS messaging patterns using AWS SDK for Java 2.x for SQS queues and SNS topics. Handles sending/receiving messages, FIFO queues, DLQ, subscriptions, and pub/sub patterns. Use when implementing messaging with SQS or SNS.

Provides AWS RDS (Relational Database Service) management patterns using AWS SDK for Java 2.x. Use when creating, modifying, monitoring, or managing Amazon RDS database instances, snapshots, parameter groups, and configurations.

Provides AWS Key Management Service (KMS) patterns using AWS SDK for Java 2.x. Use when creating/managing encryption keys, encrypting/decrypting data, generating data keys, digital signing, key rotation, or integrating encryption into Spring Boot applications.

This skill provides AWS Secrets Manager patterns and Java/Spring Boot examples for storing, retrieving, caching, and rotating secrets. It includes explicit credential usage (`AwsBasicCredentials.create("${aws.accessKeyId}", "${aws.secretKey}")`), shell debug commands (e.g., `aws secretsmanager get-secret-value --secret-id my-secret`), and network calls to `https://api.example.com`.

This skill provides Amazon Bedrock Java SDK patterns and examples for model discovery, invocation, streaming, embeddings, and Spring Boot integration. It requests `allowed-tools: Read, Write, Edit, Bash, Glob, Grep`, uses credential providers like `StaticCredentialsProvider.create(new AwsBasicCredentialsAccessKey("test", "test"))`, and calls `https://api.open-meteo.com/v1/forecast`.

Provides AWS Lambda Java SDK examples and patterns for creating, invoking, and managing Lambda functions. Uses network calls via `LambdaClient.invoke` and standard SDK credential providers such as `DefaultCredentialsProvider.create()`.

Provides patterns for unit testing Jakarta Bean Validation (@Valid, @NotNull, @Min, @Max, etc.) with custom validators and constraint violations. Validates logic without Spring context. Use when ensuring data integrity and validation rules are correct.

This skill provides patterns and example code for building Retrieval-Augmented Generation (RAG) systems with vector databases and embedding models. It instructs use of environment variables such as `OPENAI_API_KEY` and `PINECONE_API_KEY` and references network endpoints like `https://api.openai.com/v1` and `http://localhost:8080`.

Provides Qdrant vector database integration patterns with LangChain4j. Handles embedding storage, similarity search, and vector management for Java applications. Use when implementing vector-based retrieval for RAG systems, semantic search, or recommendation engines.