@c0x12c/ai-toolkit 1.15.0

package/skills/content-engine/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: content-engine
+description: Turn one idea into platform-native content for X, LinkedIn, TikTok, YouTube, newsletters. Use when the user wants social posts, threads, scripts, or content calendars.
+allowed_tools:
+  - Read
+  - Write
+  - WebSearch
+---
+
+# Content Engine
+
+Turn one idea into strong content for each platform. Don't cross-post the same thing.
+
+## When to Use
+
+- Writing X posts or threads
+- LinkedIn posts or launch updates
+- Short-form video scripts
+- Turning articles or demos into social content
+- Building a content plan around a launch
+
+> See `examples.md` for platform-specific post examples showing the same idea adapted for X, LinkedIn, and newsletter.
+
+## First Questions
+
+Ask:
+- Source: What are we working from?
+- Audience: Builders, investors, customers, or general?
+- Platform: X, LinkedIn, TikTok, YouTube, newsletter, or all?
+- Goal: Awareness, conversion, recruiting, or engagement?
+
+## Setup
+
+If the user runs this skill often, store preferences in a `content-config.json`:
+
+```json
+{
+  "defaultPlatforms": ["x", "linkedin"],
+  "brandVoice": "direct and technical",
+  "audience": "developers and technical founders",
+  "avoidWords": ["excited", "thrilled", "game-changer"],
+  "hashtagPolicy": "max 2 per post"
+}
+```
+
+Read this config at the start of every content session. Skip the "First Questions" step for any field that's already configured.
+
+## Rules
+
+1. Adapt for each platform. Don't copy-paste.
+2. Hooks matter more than summaries.
+3. One clear idea per post.
+4. Use specifics, not slogans.
+5. Keep the ask small and clear.
+
+## Platform Tips
+
+### X
+- Open fast
+- One idea per tweet
+- Keep links out of the body
+- No hashtag spam
+
+### LinkedIn
+- Strong first line
+- Short paragraphs
+- More framing around lessons and results
+
+### TikTok / Short Video
+- First 3 seconds must grab attention
+- Script around visuals
+- One demo, one claim, one CTA
+
+### YouTube
+- Show the result early
+- Structure by chapters
+- New visual every 20-30 seconds
+
+### Newsletter
+- One clear theme
+- Skimmable section titles
+- Opening paragraph does real work
+
+## Repurposing Flow
+
+1. Start with one anchor piece (article, video, demo)
+2. Pull out 3-7 separate ideas
+3. Write platform-native version of each
+4. Cut overlap between posts
+5. Match CTAs to each platform
+
+## Interaction Style
+
+**No BS. Honest feedback only.**
+
+This is a two-way talk:
+- I ask you questions → you answer
+- You ask me questions → I think hard, give you options, then answer
+
+**When I ask you a question, I always:**
+1. Think about it first
+2. Give you 2-3 options with my honest take on each
+3. Tell you which one I'd pick and why
+4. Then ask what you think
+
+**When you ask me something:**
+- I give you a straight answer
+- I tell you if a hook is weak or a post won't land
+- I push for platform-native content, not lazy cross-posts
+
+**Never:**
+- Ask a question without giving options
+- Write generic hooks like "Here's what I learned..."
+- Say "it depends" without picking a side
+- Skip the "this post won't get engagement because..." feedback
+- Let hype language into social content
+
+## Gotchas
+
+- **Cross-posting is lazy and it shows.** A LinkedIn post copy-pasted to X looks like spam. Every platform has different norms — adapt the format, length, and hook.
+- **Weak hooks sink good content.** "Here's what I learned about X" is invisible on any feed. Open with tension, a number, or a contrarian take.
+- **Corporate-speak kills engagement.** "We're excited to announce" gets zero engagement. Say what you did, what happened, and why it matters.
+- **Too many CTAs = no action.** Pick one CTA per post. "Like, share, comment, and sign up" is noise. One clear ask.
+- **Hashtag spam on LinkedIn and X is counterproductive.** 1-3 relevant hashtags max. A wall of hashtags signals low-quality content.
+
+## Before You Deliver
+
+- Each draft fits its platform
+- Hooks are specific, not generic
+- No hype language
+- CTAs match the content and audience

package/skills/content-engine/examples.md

@@ -0,0 +1,72 @@
+# Content Engine — Platform Examples
+
+> Read these examples to understand what platform-native content looks like. Same idea, different format per platform.
+
+## Source Idea
+**"We shipped a feature that reduced API response time from 800ms to 120ms by adding a Redis cache layer."**
+
+---
+
+## X (Twitter) — Single Post
+> We cut our API response time from 800ms to 120ms.
+>
+> The fix: Redis cache in front of our heaviest query.
+>
+> Took 2 hours to implement. Should've done it 6 months ago.
+
+**Why this works:** Specific numbers. Self-deprecating honesty. No hashtags.
+
+### Bad Version
+> 🚀 Excited to share that we've optimized our API performance! By leveraging Redis caching, we've achieved significant improvements in response times. #DevOps #Performance #Redis #Optimization
+
+**Why this fails:** Emoji rocket, "excited to share", vague ("significant"), hashtag spam.
+
+---
+
+## X (Twitter) — Thread
+> **1/** Our API was taking 800ms per request. Users were complaining. Here's the 2-hour fix that got us to 120ms.
+>
+> **2/** The problem: our /dashboard endpoint hits 6 tables, joins 3 of them, and runs a GROUP BY. On every. single. request.
+>
+> **3/** The fix: Redis cache with 60-second TTL. Dashboard data doesn't change that often. Users don't need real-time accuracy on a summary screen.
+>
+> **4/** Results after 1 week:
+> - p99 latency: 800ms → 120ms
+> - DB CPU: 78% → 31%
+> - User complaints about "slow dashboard": 0
+>
+> **5/** Should we have done this earlier? Obviously. But we were busy building features nobody used. That's a different thread.
+
+---
+
+## LinkedIn Post
+> Last week I spent 2 hours on a fix that should've happened 6 months ago.
+>
+> Our API dashboard endpoint was taking 800ms. Users were complaining, but we kept prioritizing new features.
+>
+> The fix was embarrassingly simple: Redis cache with a 60-second TTL.
+>
+> Results:
+> → Response time: 800ms → 120ms
+> → Database CPU: 78% → 31%
+> → User complaints: gone
+>
+> The lesson isn't about Redis. It's about how easy it is to ignore performance problems when you're "too busy building."
+>
+> Sometimes the most impactful work is the boring work.
+
+**Why this works:** Personal story, specific numbers, lesson at the end, short paragraphs.
+
+### Bad Version
+> 🎉 Thrilled to announce that our engineering team has achieved a remarkable 85% improvement in API performance! This milestone demonstrates our commitment to delivering exceptional user experiences. We leveraged cutting-edge caching technology to optimize our infrastructure. #Engineering #Innovation #TechLeadership
+
+**Why this fails:** "Thrilled to announce", "remarkable", "commitment to delivering", hashtags, no specifics.
+
+---
+
+## Newsletter Blurb
+> **This week's win: 2-hour fix, 6x faster API**
+>
+> Our dashboard was slow (800ms). Turned out the endpoint was hitting 6 tables on every request. Added a Redis cache with a 60-second TTL. Now it's 120ms.
+>
+> Lesson: before you build the next feature, check if the last one actually works well.

package/skills/database-patterns/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: database-patterns
+description: Database design patterns including schema design, migrations, soft deletes, and Exposed ORM. Use when creating tables, writing migrations, or implementing repositories.
+allowed_tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+---
+
+# Database Patterns — Quick Reference
+
+## Hard Rules
+
+| Rule | Do | Don't |
+|------|------|-------|
+| Data types | TEXT | VARCHAR |
+| Primary keys | UUID | SERIAL, BIGINT |
+| Soft delete | deleted_at TIMESTAMP | DELETE FROM |
+| Foreign keys | App-level validation | REFERENCES, ON DELETE CASCADE |
+| Standard columns | id, created_at, updated_at, deleted_at | Skip any of these |
+
+## Migration Template
+
+SQL migration with table, trigger, and partial indexes for soft delete.
+
+> See code-templates.md for the complete SQL template.
+
+## Exposed Table Object
+
+Extend `UUIDTable`, use `text()` not `varchar()`, add standard timestamp columns.
+
+> See code-templates.md for the complete template.
+
+## Entity Data Class
+
+Implement `Entity<Instant>`, include all business fields + `createdAt`, `updatedAt`, `deletedAt`.
+
+> See code-templates.md for the complete template.
+
+## Repository Pattern
+
+Interface + `Default*` implementation. Reads on `db.replica`, writes on `db.primary`. Soft delete via `deletedAt` update. `convert()` method maps `ResultRow` to entity.
+
+> See code-templates.md for the full interface + implementation code.
+
+## When Creating a New Table
+
+Full checklist:
+1. SQL migration file (next number in sequence)
+2. Table object in `module-repository/table/`
+3. Entity data class in `module-repository/entity/`
+4. Enum/constants in `module-repository/constant/` (if needed)
+5. Repository interface + implementation
+6. Factory bean for repository
+7. Repository tests
+
+## Flyway Rules
+
+- NEVER add a migration that fills a gap in deployed sequence
+- NEVER rename an already-deployed migration file
+- Migration numbers must be sequential from the latest
+- Keep migrations simple and focused (one table per migration)
+
+## Gotchas
+
+- **Only `id` uses `.value` -- everything else is direct.** `row[Table.id].value` gives UUID, but `row[Table.projectId]` already returns UUID. Adding `.value` to non-id columns causes compile errors.
+- **`gen_random_uuid()` vs `uuid_generate_v4()` -- pick one per project.** Mixing them works but confuses code review. Check existing migrations for which one the project uses.
+- **Don't re-declare `createdAt`, `updatedAt`, `deletedAt` if extending SoftDeleteTable.** They're inherited. Declaring them again causes duplicate column errors.
+- **Forgetting `WHERE deleted_at IS NULL` on indexes wastes space.** Every index on a soft-delete table should be partial. Full indexes include dead records nobody queries.
+- **Text columns that hold JSON should still use `text()` in Exposed.** JSONB in Postgres, `text()` in Kotlin, serialize/deserialize in the entity layer.

package/skills/database-patterns/code-templates.md

@@ -0,0 +1,114 @@
+# Database Patterns — Code Templates
+
+> This file is referenced by SKILL.md. Read it when writing migrations, table objects, entities, or repositories.
+
+## SQL Migration Template
+
+```sql
+CREATE TABLE {table_name} (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  -- business columns here, always TEXT not VARCHAR
+  name TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'active',
+  description TEXT,
+  -- standard columns (required on ALL tables)
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  deleted_at TIMESTAMP
+);
+
+-- Updated_at trigger (required)
+CREATE TRIGGER set_{table_name}_updated_at
+  BEFORE UPDATE ON {table_name}
+  FOR EACH ROW
+  EXECUTE FUNCTION update_updated_at_column();
+
+-- Indexes (include deleted_at IS NULL for soft delete)
+CREATE INDEX idx_{table_name}_status
+  ON {table_name} (status)
+  WHERE deleted_at IS NULL;
+```
+
+## Exposed Table Object
+
+```kotlin
+object EmployeesTable : UUIDTable("employees") {
+  val name = text("name")
+  val email = text("email")
+  val status = text("status").default(EmployeeStatus.ACTIVE.value)
+  val description = text("description").nullable()
+  val createdAt = timestamp("created_at")
+  val updatedAt = timestamp("updated_at").nullable()
+  val deletedAt = timestamp("deleted_at").nullable()
+}
+```
+
+## Entity Data Class
+
+```kotlin
+data class EmployeeEntity(
+  override val id: UUID = UUID.randomUUID(),
+  val name: String,
+  val email: String,
+  val status: String,
+  val description: String?,
+  override val createdAt: Instant,
+  override val updatedAt: Instant?,
+  override val deletedAt: Instant?
+) : Entity<Instant>
+```
+
+## Repository Pattern
+
+```kotlin
+interface EmployeeRepository {
+  fun insert(entity: EmployeeEntity): EmployeeEntity
+  fun update(id: UUID, name: String?, status: String?): EmployeeEntity?
+  fun byId(id: UUID): EmployeeEntity?
+  fun byIds(ids: List<UUID>): List<EmployeeEntity>
+  fun deleteById(id: UUID): EmployeeEntity?
+}
+
+class DefaultEmployeeRepository(
+  private val db: DatabaseContext
+) : EmployeeRepository {
+
+  override fun byId(id: UUID): EmployeeEntity? {
+    return transaction(db.replica) {
+      EmployeesTable
+        .selectAll()
+        .where { (EmployeesTable.id eq id) and EmployeesTable.deletedAt.isNull() }
+        .singleOrNull()
+        ?.let { convert(it) }
+    }
+  }
+
+  override fun deleteById(id: UUID): EmployeeEntity? {
+    return transaction(db.primary) {
+      EmployeesTable.update(
+        where = { (EmployeesTable.id eq id) and EmployeesTable.deletedAt.isNull() }
+      ) {
+        it[deletedAt] = Instant.now()
+        it[updatedAt] = Instant.now()
+      }
+      // Return the soft-deleted entity
+      EmployeesTable
+        .selectAll()
+        .where { EmployeesTable.id eq id }
+        .singleOrNull()
+        ?.let { convert(it) }
+    }
+  }
+
+  private fun convert(row: ResultRow) = EmployeeEntity(
+    id = row[EmployeesTable.id].value,
+    name = row[EmployeesTable.name],
+    email = row[EmployeesTable.email],
+    status = row[EmployeesTable.status],
+    description = row[EmployeesTable.description],
+    createdAt = row[EmployeesTable.createdAt],
+    updatedAt = row[EmployeesTable.updatedAt],
+    deletedAt = row[EmployeesTable.deletedAt]
+  )
+}
+```

package/skills/database-table-creator/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: database-table-creator
+description: Creates database table with full Kotlin synchronization (SQL migration → Table → Entity → Repository → Tests). Use when adding new database tables or entities.
+allowed_tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+---
+
+# Database Table Creator Skill
+
+Creates complete database table implementation with SQL migration, Kotlin code, and comprehensive tests.
+
+## What This Skill Does
+
+Generates:
+1. **SQL Migration** - PostgreSQL table with soft deletes, indexes, triggers
+2. **Kotlin Table Object** - Exposed ORM table definition (extends UUIDTable)
+3. **Entity Data Class** - Kotlin entity implementing Entity<Instant>
+4. **Repository Interface + Implementation** - CRUD operations with soft delete
+5. **Repository Tests** - Comprehensive test coverage (7+ tests)
+6. **Factory Bean** - Dependency injection registration
+
+## Critical Rules
+
+### Database Design (rules/database/SCHEMA.md)
+
+**SQL Requirements**:
+- ❌ NO foreign key constraints (NEVER use REFERENCES or FOREIGN KEY)
+- ✅ Use TEXT for strings (NOT VARCHAR)
+- ✅ Include: id (UUID), created_at, updated_at, deleted_at
+- ✅ ALL indexes MUST have `WHERE deleted_at IS NULL`
+- ✅ Add soft delete index: `WHERE deleted_at IS NOT NULL`
+- ✅ Add update trigger for updated_at
+
+**Kotlin Requirements**:
+- ✅ Table MUST extend `UUIDTable` (NOT `Table`)
+- ✅ Entity MUST implement `Entity<Instant>`
+- ✅ ALL queries MUST filter `deletedAt.isNull()`
+- ❌ NO `!!` operators (forbidden by pre-commit hooks)
+- ✅ Soft delete only (set deletedAt, never hard delete)
+
+## Workflow
+
+### Step 1: Create SQL Migration
+
+Location: `database-migration/sql/{number}-{description}.sql`
+
+```sql
+-- ============================================================================
+-- Description: [Describe what this migration does]
+-- Table: {table_name}
+-- ============================================================================
+
+CREATE TABLE {table_name} (
+    -- Primary key (REQUIRED)
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+
+    -- Business columns
+    name TEXT NOT NULL,
+    email TEXT,
+    status TEXT DEFAULT 'active',
+    user_id UUID,
+    count INTEGER DEFAULT 0,
+    is_active BOOLEAN DEFAULT true,
+    metadata JSONB,
+
+    -- Standard timestamps (REQUIRED)
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+-- Unique index (allows duplicate soft-deleted records)
+CREATE UNIQUE INDEX idx_{table_name}_email_unique
+    ON {table_name}(email) WHERE deleted_at IS NULL;
+
+-- Foreign key index (NO FK constraint, just index)
+CREATE INDEX idx_{table_name}_user_id
+    ON {table_name}(user_id) WHERE deleted_at IS NULL;
+
+-- Soft delete index (REQUIRED)
+CREATE INDEX idx_{table_name}_deleted_at
+    ON {table_name}(deleted_at) WHERE deleted_at IS NOT NULL;
+
+-- Update trigger (REQUIRED)
+CREATE TRIGGER update_{table_name}_updated_at
+BEFORE UPDATE ON {table_name}
+FOR EACH ROW
+EXECUTE FUNCTION update_updated_at();
+```
+
+**Critical**:
+- Use TEXT not VARCHAR
+- NO REFERENCES or FOREIGN KEY
+- ALL indexes have WHERE clause
+- Soft delete index required
+- Update trigger required
+
+### Step 2: Run Migration
+
+```bash
+./gradlew :app:module-repository:flywayMigrate
+```
+
+Verify success before proceeding.
+
+### Steps 3-10: Kotlin Implementation
+
+> See `kotlin-templates.md` for all Kotlin code templates (Table, Entity, Repository, Factory Bean, Tests).
+
+Follow this order:
+1. **Step 3** — Table object (extends `UUIDTable`, use `text()` not `varchar()`)
+2. **Step 4** — Entity data class (implements `Entity<Instant>`)
+3. **Step 5** — Constants/Enums (if needed)
+4. **Step 6** — Repository interface
+5. **Step 7** — Repository implementation (`db.primary` for writes, `db.replica` for reads, ALWAYS filter `deletedAt.isNull()`)
+6. **Step 8** — Factory bean registration
+7. **Step 9** — Repository tests (minimum 7 tests, must include soft delete verification)
+8. **Step 10** — Run tests: `./gradlew test`
+
+## Common Mistakes to Avoid
+
+> See `examples.md` for common mistakes and anti-patterns.
+
+## Success Criteria
+
+✅ SQL migration runs successfully
+✅ Uses TEXT (not VARCHAR)
+✅ NO foreign key constraints
+✅ All indexes have WHERE clause
+✅ Kotlin Table extends UUIDTable
+✅ Entity implements Entity<Instant>
+✅ All queries filter deletedAt.isNull()
+✅ No !! operators
+✅ Soft delete only (no hard delete)
+✅ Factory bean registered
+✅ All 7+ tests pass