@vetala/vetala 0.1.0-beta

package/skill/jetbrains-vmoptions/references/prerequisite-check.md

@@ -0,0 +1,65 @@
+# Prerequisite Check Guide
+
+This document defines the **mandatory input validation logic** before generating any vmoptions.
+
+## Required Input
+
+| Field | Required | Why |
+|-------|----------|-----|
+| **IDE version** | ✅ BLOCKING | Determines JDK version (17 vs 21), available GC options, and compatible flags |
+
+## Optional Input
+
+| Field | Why |
+|-------|-----|
+| **System RAM** | Heap size (`-Xmx`) recommendation |
+| **CPU cores** | GC thread count (`-XX:ParallelGCThreads`, `-XX:ConcGCThreads`) tuning |
+| **OS** | Platform-specific optimizations (e.g., large pages support) |
+| **Primary goal** | Filter relevant options (latency vs throughput vs memory) |
+| **GC preference** | Skip GC selection if user already decided |
+
+### IDE Version Format Examples
+
+- `IntelliJ IDEA 2024.1` → version 241.x → JDK 21
+- `WebStorm 2023.3` → version 233.x → JDK 17
+- `PyCharm 243.21565` → version 243.x → JDK 21
+
+### Version to JDK Mapping
+
+| IDE Version Range | Build Number | JDK |
+|-------------------|--------------|-----|
+| 2022.2 – 2024.2   | 222 – 242    | 17  |
+| 2024.3+           | 243+         | 21  |
+
+## Prompt Templates
+
+### When IDE version is missing
+
+```
+I need your JetBrains IDE version to provide accurate vmoptions.
+
+Please tell me:
+- **IDE name and version** (e.g., IntelliJ IDEA 2024.1, WebStorm 2023.3)
+
+This is required because different IDE versions use different JDK versions (17 vs 21), which affects available GC options and compatible flags.
+```
+
+### After collecting IDE version
+
+```
+Got it. [IDE version] uses JDK [17/21].
+
+For better recommendations, you can also share:
+- **System info** — RAM size, CPU cores, OS (macOS/Windows/Linux)
+- **Primary goal** — e.g., reduce freezes, faster indexing, large project support
+- **GC preference** — G1GC, ZGC, Generational ZGC, Shenandoah
+
+Or I can use sensible defaults. What would you like?
+```
+
+## Validation Rules
+
+1. **Never assume IDE version** — Always ask if not explicitly provided
+2. **Never generate vmoptions without IDE version** — This is a blocking requirement
+3. **Accept partial version info** — If user says "latest IntelliJ", ask for specific version number
+4. **Version number is sufficient** — "243.21565" alone is enough to determine JDK version

package/skill/kysely-converter/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: kysely-converter
+description: Capable of converting raw SQL queries into type-safe Kysely TypeScript code. Knows how to handle various SQL dialects and complex query structures.
+---
+
+# Kysely Converter Capabilities
+
+This agent is capable of transforming SQL queries into idiomatic Kysely TypeScript code. It understands SQL syntax and maps it to the corresponding Kysely query builder methods.
+
+## Core Capabilities
+
+- **SQL Parsing**: Understands raw SQL structure including CTEs, subqueries, and complex clauses.
+- **Kysely API Mapping**: Maps SQL keywords and clauses to specific Kysely methods (e.g., `SELECT` -> `.select()`, `WHERE` -> `.where()`).
+- **Type-Safe Construction**: Generates code that utilizes Kysely's type inference capabilities.
+- **Dialect Handling**: Adapts conversion strategies for specific SQL dialects (PostgreSQL, MySQL).
+
+## Supported Query Types
+
+### SELECT Queries
+- **Column Selection**: Capable of selecting specific columns, all columns (`*`), and handling table prefixes.
+- **Aliasing**: Handles column and table aliases using `as` syntax.
+- **Distinct**: Supports `DISTINCT` and PostgreSQL-specific `DISTINCT ON`.
+- **Joins**: Converts `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, and other join types with complex `ON` conditions.
+- **Filtering**:
+  - Handles basic comparison operators (`=`, `>`, `<`, etc.).
+  - Supports complex boolean logic (`AND`, `OR`) using expression builders.
+  - Manages `NULL` checks (`IS NULL`, `IS NOT NULL`).
+  - Handles `IN` clauses and pattern matching (`LIKE`).
+- **Aggregation**: Converts `GROUP BY` and `HAVING` clauses with aggregate functions (`COUNT`, `SUM`, `AVG`, `MAX`, `MIN`).
+- **Ordering & Pagination**: Maps `ORDER BY` (asc/desc), `LIMIT`, and `OFFSET`.
+
+### INSERT Operations
+- **Single & Batch Insert**: Can convert single-row and multi-row value insertions.
+- **Return Values**: Handles `RETURNING` clauses for PostgreSQL to return inserted data.
+
+### UPDATE Operations
+- **Set Clauses**: Converts `SET` assignments for simple values and expressions (e.g., incrementing a counter).
+- **Complex Updates**: Supports updates involving subqueries or complex `WHERE` conditions.
+
+### DELETE Operations
+- **Basic Deletion**: Maps standard `DELETE FROM` statements with conditions.
+- **Return Values**: Handles `RETURNING` clauses for deleted rows (PostgreSQL).
+
+## Advanced Features
+
+### Window Functions
+- **Ranking Functions**: `ROW_NUMBER`, `RANK`, `DENSE_RANK`, `NTILE`, `PERCENT_RANK`, `CUME_DIST`.
+- **Value Functions**: `LAG`, `LEAD`, `FIRST_VALUE`, `LAST_VALUE`, `NTH_VALUE`.
+- **Aggregate Windows**: Windowed versions of `AVG`, `COUNT`, `MAX`, `MIN`, `SUM`.
+- **Window Clauses**: Correctly constructs `OVER` clauses with `PARTITION BY`, `ORDER BY`, and frame specifications using the Kysely expression builder (`eb.fn.agg`).
+
+### Expressions & Logic
+- **CASE Statements**: Converts `CASE WHEN ... THEN ... ELSE` logic into Kysely's `eb.case()` chain.
+- **Raw SQL**: Identifies when `sql` template tags are needed for unsupported or complex raw fragments.
+
+## Reference Patterns
+The agent applies specific patterns found in the `references/` directory:
+- `select.md`: Query structure and clause mapping.
+- `insert.md`: Insertion patterns and return value handling.
+- `update.md`: Update logic and assignment expressions.
+- `delete.md`: Deletion mapping.
+- `window_function.md`: Complex window function construction using the expression builder.

package/skill/kysely-converter/references/delete.md

@@ -0,0 +1,323 @@
+# Kysely DELETE Reference
+
+## Basic DELETE
+```sql
+DELETE FROM person WHERE id = 1
+```
+```ts
+db.deleteFrom('person')
+  .where('id', '=', 1)
+  .execute()
+```
+
+## Delete with Result
+```sql
+DELETE FROM person WHERE id = 1
+```
+```ts
+const result = await db
+  .deleteFrom('person')
+  .where('id', '=', 1)
+  .executeTakeFirst()
+
+console.log(result.numDeletedRows)
+```
+
+## DELETE with RETURNING (PostgreSQL)
+```sql
+DELETE FROM person WHERE id = 1 RETURNING id, first_name
+```
+```ts
+const deleted = await db
+  .deleteFrom('person')
+  .where('id', '=', 1)
+  .returning(['id', 'first_name'])
+  .executeTakeFirstOrThrow()
+```
+
+### RETURNING All Columns
+```sql
+DELETE FROM person WHERE id = 1 RETURNING *
+```
+```ts
+db.deleteFrom('person')
+  .where('id', '=', 1)
+  .returningAll()
+  .executeTakeFirstOrThrow()
+```
+
+### RETURNING from Specific Table
+```sql
+DELETE FROM toy USING pet, person
+WHERE toy.pet_id = pet.id AND pet.owner_id = person.id AND person.first_name = 'Bob'
+RETURNING pet.*
+```
+```ts
+db.deleteFrom('toy')
+  .using(['pet', 'person'])
+  .whereRef('toy.pet_id', '=', 'pet.id')
+  .whereRef('pet.owner_id', '=', 'person.id')
+  .where('person.first_name', '=', 'Bob')
+  .returningAll('pet')
+  .execute()
+```
+
+## WHERE Conditions
+
+### Simple Comparison
+```sql
+DELETE FROM person WHERE status = 'inactive'
+```
+```ts
+db.deleteFrom('person')
+  .where('status', '=', 'inactive')
+  .execute()
+```
+
+### Multiple Conditions
+```sql
+DELETE FROM person WHERE status = 'inactive' AND age > 18
+```
+```ts
+db.deleteFrom('person')
+  .where('status', '=', 'inactive')
+  .where('age', '>', 18)
+  .execute()
+```
+
+### IN Operator
+```sql
+DELETE FROM person WHERE id IN (1, 2, 3)
+```
+```ts
+db.deleteFrom('person')
+  .where('id', 'in', [1, 2, 3])
+  .execute()
+```
+
+### NOT IN Operator
+```sql
+DELETE FROM person WHERE id NOT IN (1, 2, 3)
+```
+```ts
+db.deleteFrom('person')
+  .where('id', 'not in', [1, 2, 3])
+  .execute()
+```
+
+### IS NULL / IS NOT NULL
+```sql
+DELETE FROM person WHERE deleted_at IS NOT NULL
+```
+```ts
+db.deleteFrom('person')
+  .where('deleted_at', 'is not', null)
+  .execute()
+```
+
+### LIKE
+```sql
+DELETE FROM person WHERE name LIKE 'test%'
+```
+```ts
+db.deleteFrom('person')
+  .where('name', 'like', 'test%')
+  .execute()
+```
+
+### Complex WHERE (OR/AND)
+```sql
+DELETE FROM person
+WHERE (status = 'deleted' AND type = 'a') OR (status = 'archived' AND type = 'b')
+```
+```ts
+db.deleteFrom('person')
+  .where((eb) =>
+    eb.or([
+      eb.and([
+        eb('status', '=', 'deleted'),
+        eb('type', '=', 'a')
+      ]),
+      eb.and([
+        eb('status', '=', 'archived'),
+        eb('type', '=', 'b')
+      ])
+    ])
+  )
+  .execute()
+```
+
+### Column to Column Comparison (whereRef)
+```sql
+DELETE FROM person WHERE expires_at < created_at
+```
+```ts
+db.deleteFrom('person')
+  .whereRef('expires_at', '<', 'created_at')
+  .execute()
+```
+
+### Subquery in WHERE
+```sql
+DELETE FROM person WHERE id IN (SELECT owner_id FROM pet WHERE species = 'cat')
+```
+```ts
+db.deleteFrom('person')
+  .where('id', 'in', (eb) => eb
+    .selectFrom('pet')
+    .where('species', '=', 'cat')
+    .select('owner_id')
+  )
+  .execute()
+```
+
+### EXISTS Subquery
+```sql
+DELETE FROM person WHERE EXISTS (SELECT 1 FROM pet WHERE pet.owner_id = person.id)
+```
+```ts
+db.deleteFrom('person')
+  .where((eb) =>
+    eb.exists(
+      eb.selectFrom('pet')
+        .whereRef('pet.owner_id', '=', 'person.id')
+        .select(sql.lit(1))
+    )
+  )
+  .execute()
+```
+
+## DELETE with USING (PostgreSQL)
+```sql
+DELETE FROM pet USING person
+WHERE pet.owner_id = person.id AND person.first_name = 'Bob'
+```
+```ts
+db.deleteFrom('pet')
+  .using('person')
+  .whereRef('pet.owner_id', '=', 'person.id')
+  .where('person.first_name', '=', 'Bob')
+  .execute()
+```
+
+### USING with Multiple Tables
+```sql
+DELETE FROM toy USING pet, person
+WHERE toy.pet_id = pet.id AND pet.owner_id = person.id AND person.first_name = 'Bob'
+```
+```ts
+db.deleteFrom('toy')
+  .using(['pet', 'person'])
+  .whereRef('toy.pet_id', '=', 'pet.id')
+  .whereRef('pet.owner_id', '=', 'person.id')
+  .where('person.first_name', '=', 'Bob')
+  .execute()
+```
+
+## DELETE with JOIN (MySQL)
+```sql
+DELETE FROM pet USING pet
+LEFT JOIN person ON person.id = pet.owner_id
+WHERE person.first_name = 'Bob'
+```
+```ts
+db.deleteFrom('pet')
+  .using('pet')
+  .leftJoin('person', 'person.id', 'pet.owner_id')
+  .where('person.first_name', '=', 'Bob')
+  .execute()
+```
+
+### INNER JOIN
+```ts
+db.deleteFrom('pet')
+  .using('pet')
+  .innerJoin('person', 'person.id', 'pet.owner_id')
+  .where('person.first_name', '=', 'Bob')
+  .execute()
+```
+
+## DELETE with LIMIT (MySQL)
+```sql
+DELETE FROM person WHERE status = 'inactive' LIMIT 10
+```
+```ts
+db.deleteFrom('person')
+  .where('status', '=', 'inactive')
+  .limit(10)
+  .execute()
+```
+
+## DELETE with ORDER BY + LIMIT (MySQL)
+```sql
+DELETE FROM person ORDER BY created_at ASC LIMIT 5
+```
+```ts
+db.deleteFrom('person')
+  .orderBy('created_at', 'asc')
+  .limit(5)
+  .execute()
+```
+
+## WITH CTE + DELETE
+```sql
+WITH old_records AS (
+  SELECT id FROM person WHERE created_at < '2020-01-01'
+)
+DELETE FROM person WHERE id IN (SELECT id FROM old_records)
+```
+```ts
+db.with('old_records', (db) => db
+    .selectFrom('person')
+    .where('created_at', '<', '2020-01-01')
+    .select('id')
+  )
+  .deleteFrom('person')
+  .where('id', 'in', (eb) => eb.selectFrom('old_records').select('id'))
+  .execute()
+```
+
+## Conditional Delete ($if)
+```ts
+async function deletePerson(id: number, returnDeleted: boolean) {
+  return await db
+    .deleteFrom('person')
+    .where('id', '=', id)
+    .$if(returnDeleted, (qb) => qb.returningAll())
+    .execute()
+}
+```
+
+## Clear WHERE Clause
+```ts
+db.deleteFrom('person')
+  .where('id', '=', 1)
+  .clearWhere()  // Removes the WHERE clause
+  .where('id', '=', 2)  // Add new condition
+  .execute()
+```
+
+## Clear LIMIT Clause
+```ts
+db.deleteFrom('person')
+  .where('status', '=', 'inactive')
+  .limit(10)
+  .clearLimit()  // Removes the LIMIT clause
+  .execute()
+```
+
+
+## Dialect Differences
+
+### MySQL
+- Uses backticks for identifiers: \`table\`.\`column\`
+- Supports `DELETE ... LIMIT`
+- Supports `DELETE ... ORDER BY ... LIMIT`
+- For JOIN in DELETE, use `USING table` + JOIN clause
+- No `RETURNING` clause - `numDeletedRows` available in result
+
+### PostgreSQL
+- Uses double quotes for identifiers: "table"."column"
+- Supports `DELETE ... USING` for joining tables
+- Supports `DELETE ... RETURNING` clause
+- Does not support `LIMIT` in DELETE