@codyswann/lisa 1.48.0 → 1.50.0

package/plugins/lisa-nestjs/skills/skill-creator/scripts/quick_validate.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# This file is managed by Lisa.
+# Do not edit directly — changes will be overwritten on the next `lisa` run.
+"""
+Quick validation script for skills - minimal version
+"""
+
+import sys
+import os
+import re
+from pathlib import Path
+
+def validate_skill(skill_path):
+    """Basic validation of a skill"""
+    skill_path = Path(skill_path)
+    
+    # Check SKILL.md exists
+    skill_md = skill_path / 'SKILL.md'
+    if not skill_md.exists():
+        return False, "SKILL.md not found"
+    
+    # Read and validate frontmatter
+    content = skill_md.read_text()
+    if not content.startswith('---'):
+        return False, "No YAML frontmatter found"
+    
+    # Extract frontmatter
+    match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
+    if not match:
+        return False, "Invalid frontmatter format"
+    
+    frontmatter = match.group(1)
+    
+    # Check required fields
+    if 'name:' not in frontmatter:
+        return False, "Missing 'name' in frontmatter"
+    if 'description:' not in frontmatter:
+        return False, "Missing 'description' in frontmatter"
+    
+    # Extract name for validation
+    name_match = re.search(r'name:\s*(.+)', frontmatter)
+    if name_match:
+        name = name_match.group(1).strip()
+        # Check naming convention (hyphen-case: lowercase with hyphens)
+        if not re.match(r'^[a-z0-9-]+$', name):
+            return False, f"Name '{name}' should be hyphen-case (lowercase letters, digits, and hyphens only)"
+        if name.startswith('-') or name.endswith('-') or '--' in name:
+            return False, f"Name '{name}' cannot start/end with hyphen or contain consecutive hyphens"
+
+    # Extract and validate description
+    desc_match = re.search(r'description:\s*(.+)', frontmatter)
+    if desc_match:
+        description = desc_match.group(1).strip()
+        # Check for angle brackets
+        if '<' in description or '>' in description:
+            return False, "Description cannot contain angle brackets (< or >)"
+
+    return True, "Skill is valid!"
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python quick_validate.py <skill_directory>")
+        sys.exit(1)
+    
+    valid, message = validate_skill(sys.argv[1])
+    print(message)
+    sys.exit(0 if valid else 1)

package/plugins/lisa-nestjs/skills/sonarqube-check/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: sonarqube-check
+description: This skill should be used when checking why the last pull request failed SonarQube/SonarCloud quality gates. It uses the SonarQube MCP server to retrieve failure details and report the reasons.
+allowed-tools: ["mcp__sonarqube__*"]
+---
+
+# SonarQube Check
+
+Use the SonarQube MCP server to get the reason the last PR failed checks.
+
+Retrieve the quality gate status and report all failures with their details.

package/plugins/lisa-nestjs/skills/sonarqube-fix/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: sonarqube-fix
+description: This skill should be used when fixing SonarQube quality gate failures. It runs the sonarqube:check skill to identify failures, fixes the identified issues, and then commits the changes using the git:commit skill.
+---
+
+1. Run /sonarqube-check
+2. Fix the SonarQube quality gate failures identified in step 1
+3. Run /git-commit

package/plugins/lisa-nestjs/skills/tasks-load/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: tasks-load
+description: This skill should be used when loading tasks from a project directory into the current Claude Code session. It reads task JSON files from session subdirectories, recreates them in the current session, and sets the active project marker.
+allowed-tools: ["Read", "Bash", "TaskCreate", "TaskUpdate", "TaskList"]
+---
+
+# Load Project Tasks
+
+Load tasks from `projects/$ARGUMENTS/tasks/` into the current Claude Code session.
+
+Tasks are stored in session subdirectories to preserve history across `/clear` commands:
+```
+projects/$ARGUMENTS/tasks/
+├── {session-1-uuid}/
+│   ├── 1.json
+│   └── 2.json
+└── {session-2-uuid}/
+    ├── 1.json
+    └── 2.json
+```
+
+## Process
+
+### Step 1: Validate Project
+
+Check if the project exists and has task files:
+
+```bash
+find projects/$ARGUMENTS/tasks -name "*.json" 2>/dev/null | head -5
+```
+
+If no task files exist, report: "No tasks found in projects/$ARGUMENTS/tasks/"
+
+List available sessions:
+
+```bash
+ls -dt projects/$ARGUMENTS/tasks/*/ 2>/dev/null | head -10
+```
+
+### Step 2: Set Active Project
+
+Create the active project marker:
+
+```bash
+echo "$ARGUMENTS" > .claude-active-project
+```
+
+This ensures any new tasks created will sync back to this project.
+
+### Step 3: Load Tasks
+
+Find and load all task JSON files from ALL session directories:
+
+```bash
+find projects/$ARGUMENTS/tasks -name "*.json" -type f
+```
+
+For each JSON file found:
+
+1. Read the task JSON file
+2. Use TaskCreate to recreate the task with:
+   - subject from JSON
+   - description from JSON
+   - activeForm from JSON
+   - metadata: `{ "project": "$ARGUMENTS" }`
+3. If the task was already completed (status: "completed"), use TaskUpdate to mark it completed
+
+### Step 4: Report
+
+After loading all tasks, report:
+
+```
+Loaded X tasks from projects/$ARGUMENTS/tasks/
+- Sessions found: N
+- Pending: Y
+- Completed: Z
+
+Active project set to: $ARGUMENTS
+New tasks will automatically sync to this project.
+```
+
+## Notes
+
+- Tasks are recreated with new IDs in the current session
+- The original task IDs from the project are not preserved
+- Tasks from ALL sessions are loaded (full history)
+- Task dependencies (blocks/blockedBy) are NOT currently preserved across load/sync cycles
+- Use TaskList to see the loaded tasks

package/plugins/lisa-nestjs/skills/tasks-sync/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: tasks-sync
+description: This skill should be used when syncing current session tasks to a project directory. It exports all tasks from the current Claude Code session to JSON files in the project's tasks directory, enabling persistence across sessions.
+allowed-tools: ["Read", "Write", "Bash", "TaskList", "TaskGet"]
+---
+
+# Sync Tasks to Project
+
+Sync all tasks from the current session to `projects/$ARGUMENTS/tasks/{session-id}/`.
+
+This skill is for manual syncing when work started without setting an active project. Once synced, the automatic hook handles future task updates.
+
+## Process
+
+### Step 1: Validate Project
+
+Check if the project directory exists:
+
+```bash
+ls -d projects/$ARGUMENTS 2>/dev/null
+```
+
+If the project doesn't exist, ask: "Project '$ARGUMENTS' doesn't exist. Create it?"
+
+If yes, create the project structure:
+
+```bash
+mkdir -p projects/$ARGUMENTS/tasks
+```
+
+### Step 2: Determine Session ID
+
+Find the current session by looking for the most recently modified task directory:
+
+```bash
+ls -dt ~/.claude/tasks/*/ 2>/dev/null | head -1 | xargs basename
+```
+
+If no session found, use a timestamp-based identifier:
+
+```bash
+echo "manual-$(date +%Y%m%d-%H%M%S)"
+```
+
+Store the session ID for use in subsequent steps.
+
+### Step 3: Set Active Project
+
+Create/update the active project marker:
+
+```bash
+echo "$ARGUMENTS" > .claude-active-project
+```
+
+### Step 4: Get Current Tasks
+
+Use TaskList to get all tasks in the current session.
+
+### Step 5: Sync Each Task
+
+For each task from TaskList:
+
+1. Use TaskGet to get full task details
+2. Create the session directory:
+
+```bash
+mkdir -p projects/$ARGUMENTS/tasks/{session-id}
+```
+
+3. Create a JSON file with the task data:
+
+```json
+{
+  "id": "<task-id>",
+  "subject": "<subject>",
+  "description": "<description>",
+  "activeForm": "<activeForm>",
+  "status": "<status>",
+  "blocks": [],
+  "blockedBy": []
+}
+```
+
+4. Write to `projects/$ARGUMENTS/tasks/{session-id}/<id>.json`
+
+### Step 6: Stage for Git
+
+```bash
+git add projects/$ARGUMENTS/tasks/{session-id}/*.json
+```
+
+### Step 7: Report
+
+```
+Synced X tasks to projects/$ARGUMENTS/tasks/{session-id}/
+- Pending: Y
+- In Progress: Z
+- Completed: W
+
+Files staged for commit. Run /git-commit when ready.
+```
+
+## Notes
+
+- This skill manually syncs all current tasks to a project
+- Use this when work started without a project context
+- After syncing, the active project is set so future tasks auto-sync via the hook
+- Each sync creates a new session directory to preserve history

package/plugins/lisa-nestjs/skills/typeorm-patterns/SKILL.md

@@ -0,0 +1,275 @@
+---
+name: typeorm-patterns
+description: Enforces TypeORM implementation patterns for this NestJS backend project. This skill should be used when creating or modifying TypeORM entities, repositories, database configuration, migrations, or any database-related code. It covers configuration patterns (TypeOrmModule.forRootAsync, replication, naming strategy), entity patterns (base entity, comments, indexes), and observability (X-Ray logging).
+---
+
+# TypeORM Patterns
+
+## Overview
+
+This skill enforces TypeORM implementation patterns for the NestJS backend project. It ensures consistent database configuration, entity design, repository patterns, and observability across the codebase.
+
+## Core Requirements
+
+### Configuration Requirements
+
+| Requirement | Details |
+|-------------|---------|
+| **Module Pattern** | `TypeOrmModule.forRootAsync()` with `dataSourceFactory` |
+| **Naming Strategy** | `SnakeNamingStrategy` from `typeorm-naming-strategies` |
+| **Synchronize** | Always `false` - migrations only, no auto-sync |
+| **Entity Loading** | Explicit entity exports via index.ts (esbuild compatibility) |
+| **Database** | PostgreSQL (local Docker, AWS Aurora Serverless v2 production) |
+
+### Environment-Based Configuration
+
+| Environment | Connection Type | Authentication |
+|-------------|-----------------|----------------|
+| **Local** | Direct connection | Environment variables |
+| **Production** | Read-write replication | AWS RDS Signer (IAM) |
+
+### Entity Requirements
+
+| Requirement | Details |
+|-------------|---------|
+| **Abstract Base** | All entities extend `TimestampedEntity` (NOT TypeORM's `BaseEntity`) |
+| **Primary Key** | UUID via `@PrimaryGeneratedColumn("uuid")` |
+| **Column Comments** | Required on all columns via `@Column({ comment: "..." })` |
+| **Foreign Keys** | Must be indexed via `@Index()` decorator |
+| **Cascade Deletes** | Use `orphanedRowAction: "delete"` on OneToMany relations |
+
+**Note**: We use `TimestampedEntity` to avoid confusion with TypeORM's built-in `BaseEntity` class which provides Active Record pattern methods. Our abstract class only provides column inheritance.
+
+### Observability Requirements
+
+| Requirement | Details |
+|-------------|---------|
+| **Logger** | Custom `TypeOrmXRayLogger` for distributed tracing |
+| **Graceful Degradation** | Logger must work locally without X-Ray SDK |
+| **Query Tracking** | Extract query type and table name for metrics |
+
+## Quick Reference
+
+### Database Module Setup
+
+Use the standard NestJS `TypeOrmModule.forRootAsync()` with `dataSourceFactory` for full control:
+
+```typescript
+import { Module } from "@nestjs/common";
+import { TypeOrmModule } from "@nestjs/typeorm";
+import { DataSource } from "typeorm";
+import { createTypeOrmOptions } from "./database.config";
+
+/**
+ * Database module using official NestJS TypeORM integration.
+ *
+ * @remarks
+ * Uses forRootAsync with dataSourceFactory for:
+ * - Async configuration (environment-based)
+ * - Custom DataSource initialization
+ * - Replication support with dynamic passwords
+ */
+@Module({
+  imports: [
+    TypeOrmModule.forRootAsync({
+      useFactory: createTypeOrmOptions,
+      dataSourceFactory: async (options) => {
+        const dataSource = new DataSource(options);
+        return dataSource.initialize();
+      },
+    }),
+  ],
+})
+export class DatabaseModule {}
+```
+
+### Creating a New Entity
+
+```typescript
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from "typeorm";
+import { TimestampedEntity } from "./timestamped.entity";
+
+/**
+ * Represents a user in the system.
+ *
+ * @remarks
+ * Users belong to organizations and can have multiple watchlists.
+ */
+@Entity({ comment: "Application users with organization membership" })
+export class User extends TimestampedEntity {
+  @Column({ comment: "User email address for authentication" })
+  @Index()
+  email: string;
+
+  @Column({ comment: "User display name", nullable: true })
+  name: string | null;
+
+  @Column({ comment: "Foreign key to organization", type: "uuid" })
+  @Index()
+  organizationId: string;
+
+  @ManyToOne(() => Organization, { onDelete: "SET NULL", nullable: true })
+  @JoinColumn()
+  organization: Organization;
+
+  @OneToMany(() => Watchlist, w => w.user, { orphanedRowAction: "delete" })
+  watchlists: Watchlist[];
+}
+```
+
+**Important**: The abstract `TimestampedEntity` does NOT have an `@Entity()` decorator - only concrete child entities get this decorator.
+
+### Adding Entity to Exports
+
+After creating any entity, add it to `src/database/entities/index.ts`:
+
+```typescript
+export { User } from "./user.entity";
+export { Organization } from "./organization.entity";
+// Add new entity here
+```
+
+### Using Repository Injection
+
+With `TypeOrmModule`, use `@InjectRepository()` for standard repository access:
+
+```typescript
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+import { User } from "../entities/user.entity";
+
+@Injectable()
+export class UserService {
+  constructor(
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>
+  ) {}
+
+  async findByEmail(email: string): Promise<User | null> {
+    return this.userRepository.findOne({ where: { email } });
+  }
+}
+```
+
+### Creating a Custom Repository (When Needed)
+
+Only create custom repositories when you need reusable query methods:
+
+```typescript
+import { Injectable } from "@nestjs/common";
+import { DataSource, Repository } from "typeorm";
+import { User } from "../entities/user.entity";
+
+/**
+ * Custom repository for complex User queries.
+ */
+@Injectable()
+export class UserRepository extends Repository<User> {
+  constructor(private readonly dataSource: DataSource) {
+    super(User, dataSource.createEntityManager());
+  }
+
+  /**
+   * Find users with full-text search.
+   */
+  async searchByName(query: string): Promise<User[]> {
+    return this.createQueryBuilder("user")
+      .where("user.name ILIKE :query", { query: `%${query}%` })
+      .getMany();
+  }
+}
+```
+
+### Custom Repositories in Transactions
+
+**Critical**: Class-based repositories extending `Repository<T>` do NOT work correctly inside transactions. Per [TypeORM documentation](https://typeorm.io/docs/working-with-entity-manager/custom-repository/), you must use `withRepository()`:
+
+```typescript
+// WRONG - repository uses wrong EntityManager, won't be transactional
+async transferFunds(fromId: string, toId: string, amount: number): Promise<void> {
+  await this.dataSource.transaction(async manager => {
+    const from = await this.accountRepository.findOne({ where: { id: fromId } });
+    // This query runs OUTSIDE the transaction!
+  });
+}
+
+// CORRECT - use withRepository() for transactional operations
+async transferFunds(fromId: string, toId: string, amount: number): Promise<void> {
+  await this.dataSource.transaction(async manager => {
+    const accountRepo = manager.withRepository(this.accountRepository);
+    const from = await accountRepo.findOne({ where: { id: fromId } });
+    // This query runs INSIDE the transaction
+  });
+}
+```
+
+## Read-Write Routing
+
+TypeORM automatically routes queries based on operation type when replication is configured:
+
+| Operation | Endpoint | Method Examples |
+|-----------|----------|-----------------|
+| **Read** | Slave (read replica) | `find()`, `findOne()`, `query()` with SELECT |
+| **Write** | Master | `save()`, `insert()`, `update()`, `delete()` |
+
+To force a specific connection:
+
+```typescript
+// Force master for reads (when consistency required)
+await this.userRepository.manager.transaction(async manager => {
+  const user = await manager.findOne(User, { where: { id } });
+  // This read uses master connection
+});
+
+// QueryRunner for explicit control
+const queryRunner = dataSource.createQueryRunner("master");
+try {
+  await queryRunner.query("SELECT * FROM users WHERE id = $1", [id]);
+} finally {
+  await queryRunner.release();
+}
+```
+
+## Migration Workflow
+
+Always use the migration scripts - never modify migration files directly:
+
+```bash
+# Generate migration from entity changes
+bun migration:generate --name=AddUserEmailIndex
+
+# Run pending migrations
+bun migration:run
+
+# Revert last migration
+bun migration:revert
+```
+
+## File Structure
+
+```
+src/database/
+├── database.module.ts          # NestJS module with TypeOrmModule.forRootAsync
+├── database.config.ts          # Configuration factory
+├── typeorm-xray-logger.ts      # Custom X-Ray logger
+├── entities/
+│   ├── index.ts                # Explicit entity exports
+│   ├── timestamped.entity.ts   # Abstract base entity (no @Entity decorator)
+│   ├── user.entity.ts
+│   └── ...
+├── repositories/               # Only if custom repositories needed
+│   ├── index.ts
+│   ├── user.repository.ts
+│   └── ...
+└── migrations/
+    └── {timestamp}-{name}.ts
+```
+
+## Detailed References
+
+For comprehensive implementation details, see:
+
+- **[references/configuration-patterns.md](references/configuration-patterns.md)** - TypeOrmModule setup, replication, environment configuration
+- **[references/entity-patterns.md](references/entity-patterns.md)** - Base entity, relationships, indexes, enums, views
+- **[references/observability-patterns.md](references/observability-patterns.md)** - X-Ray logger implementation with graceful degradation