@hybridlabor-api/bdb-antigravity-skills 1.0.0

package/skills/global_legacy/documentation/SKILL.md

@@ -0,0 +1,265 @@
+---
+name: documentation
+description: "Documentation generation workflow covering API docs, architecture docs, README files, code comments, and technical writing."
+category: workflow-bundle
+risk: safe
+source: personal
+date_added: "2026-02-27"
+---
+
+# Documentation Workflow Bundle
+
+## Overview
+
+Comprehensive documentation workflow for generating API documentation, architecture documentation, README files, code comments, and technical content from codebases.
+
+## When to Use This Workflow
+
+Use this workflow when:
+- Creating project documentation
+- Generating API documentation
+- Writing architecture docs
+- Documenting code
+- Creating user guides
+- Maintaining wikis
+
+## Workflow Phases
+
+### Phase 1: Documentation Planning
+
+#### Skills to Invoke
+- `docs-architect` - Documentation architecture
+- `documentation-templates` - Documentation templates
+
+#### Actions
+1. Identify documentation needs
+2. Choose documentation tools
+3. Plan documentation structure
+4. Define style guidelines
+5. Set up documentation site
+
+#### Copy-Paste Prompts
+```
+Use @docs-architect to plan documentation structure
+```
+
+```
+Use @documentation-templates to set up documentation
+```
+
+### Phase 2: API Documentation
+
+#### Skills to Invoke
+- `api-documenter` - API documentation
+- `api-documentation-generator` - Auto-generation
+- `openapi-spec-generation` - OpenAPI specs
+
+#### Actions
+1. Extract API endpoints
+2. Generate OpenAPI specs
+3. Create API reference
+4. Add usage examples
+5. Set up auto-generation
+
+#### Copy-Paste Prompts
+```
+Use @api-documenter to generate API documentation
+```
+
+```
+Use @openapi-spec-generation to create OpenAPI specs
+```
+
+### Phase 3: Architecture Documentation
+
+#### Skills to Invoke
+- `c4-architecture-c4-architecture` - C4 architecture
+- `c4-context` - Context diagrams
+- `c4-container` - Container diagrams
+- `c4-component` - Component diagrams
+- `c4-code` - Code diagrams
+- `mermaid-expert` - Mermaid diagrams
+
+#### Actions
+1. Create C4 diagrams
+2. Document architecture
+3. Generate sequence diagrams
+4. Document data flows
+5. Create deployment docs
+
+#### Copy-Paste Prompts
+```
+Use @c4-architecture-c4-architecture to create C4 diagrams
+```
+
+```
+Use @mermaid-expert to create architecture diagrams
+```
+
+### Phase 4: Code Documentation
+
+#### Skills to Invoke
+- `code-documentation-code-explain` - Code explanation
+- `code-documentation-doc-generate` - Doc generation
+- `documentation-generation-doc-generate` - Auto-generation
+
+#### Actions
+1. Extract code comments
+2. Generate JSDoc/TSDoc
+3. Create type documentation
+4. Document functions
+5. Add usage examples
+
+#### Copy-Paste Prompts
+```
+Use @code-documentation-code-explain to explain code
+```
+
+```
+Use @code-documentation-doc-generate to generate docs
+```
+
+### Phase 5: README and Getting Started
+
+#### Skills to Invoke
+- `readme` - README generation
+- `environment-setup-guide` - Setup guides
+- `tutorial-engineer` - Tutorial creation
+
+#### Actions
+1. Create README
+2. Write getting started guide
+3. Document installation
+4. Add usage examples
+5. Create troubleshooting guide
+
+#### Copy-Paste Prompts
+```
+Use @readme to create project README
+```
+
+```
+Use @tutorial-engineer to create tutorials
+```
+
+### Phase 6: Wiki and Knowledge Base
+
+#### Skills to Invoke
+- `wiki-architect` - Wiki architecture
+- `wiki-page-writer` - Wiki pages
+- `wiki-onboarding` - Onboarding docs
+- `wiki-qa` - Wiki Q&A
+- `wiki-researcher` - Wiki research
+- `wiki-vitepress` - VitePress wiki
+
+#### Actions
+1. Design wiki structure
+2. Create wiki pages
+3. Write onboarding guides
+4. Document processes
+5. Set up wiki site
+
+#### Copy-Paste Prompts
+```
+Use @wiki-architect to design wiki structure
+```
+
+```
+Use @wiki-page-writer to create wiki pages
+```
+
+```
+Use @wiki-onboarding to create onboarding docs
+```
+
+### Phase 7: Changelog and Release Notes
+
+#### Skills to Invoke
+- `changelog-automation` - Changelog generation
+- `wiki-changelog` - Changelog from git
+
+#### Actions
+1. Extract commit history
+2. Categorize changes
+3. Generate changelog
+4. Create release notes
+5. Publish updates
+
+#### Copy-Paste Prompts
+```
+Use @changelog-automation to generate changelog
+```
+
+```
+Use @wiki-changelog to create release notes
+```
+
+### Phase 8: Documentation Maintenance
+
+#### Skills to Invoke
+- `doc-coauthoring` - Collaborative writing
+- `reference-builder` - Reference docs
+
+#### Actions
+1. Review documentation
+2. Update outdated content
+3. Fix broken links
+4. Add new features
+5. Gather feedback
+
+#### Copy-Paste Prompts
+```
+Use @doc-coauthoring to collaborate on docs
+```
+
+## Documentation Types
+
+### Code-Level
+- JSDoc/TSDoc comments
+- Function documentation
+- Type definitions
+- Example code
+
+### API Documentation
+- Endpoint reference
+- Request/response schemas
+- Authentication guides
+- SDK documentation
+
+### Architecture Documentation
+- System overview
+- Component diagrams
+- Data flow diagrams
+- Deployment architecture
+
+### User Documentation
+- Getting started guides
+- User manuals
+- Tutorials
+- FAQs
+
+### Process Documentation
+- Runbooks
+- Onboarding guides
+- SOPs
+- Decision records
+
+## Quality Gates
+
+- [ ] All APIs documented
+- [ ] Architecture diagrams current
+- [ ] README up to date
+- [ ] Code comments helpful
+- [ ] Examples working
+- [ ] Links valid
+
+## Related Workflow Bundles
+
+- `development` - Development workflow
+- `testing-qa` - Documentation testing
+- `ai-ml` - AI documentation
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/skills/global_legacy/drizzle-orm-expert/SKILL.md

@@ -0,0 +1,368 @@
+---
+name: drizzle-orm-expert
+description: "Expert in Drizzle ORM for TypeScript — schema design, relational queries, migrations, and serverless database integration. Use when building type-safe database layers with Drizzle."
+risk: safe
+source: community
+date_added: "2026-03-04"
+---
+
+# Drizzle ORM Expert
+
+You are a production-grade Drizzle ORM expert. You help developers build type-safe, performant database layers using Drizzle ORM with TypeScript. You know schema design, the relational query API, Drizzle Kit migrations, and integrations with Next.js, tRPC, and serverless databases (Neon, PlanetScale, Turso, Supabase).
+
+## When to Use This Skill
+
+- Use when the user asks to set up Drizzle ORM in a new or existing project
+- Use when designing database schemas with Drizzle's TypeScript-first approach
+- Use when writing complex relational queries (joins, subqueries, aggregations)
+- Use when setting up or troubleshooting Drizzle Kit migrations
+- Use when integrating Drizzle with Next.js App Router, tRPC, or Hono
+- Use when optimizing database performance (prepared statements, batching, connection pooling)
+- Use when migrating from Prisma, TypeORM, or Knex to Drizzle
+
+## Core Concepts
+
+### Why Drizzle
+
+Drizzle ORM is a TypeScript-first ORM that generates zero runtime overhead. Unlike Prisma (which uses a query engine binary), Drizzle compiles to raw SQL — making it ideal for edge runtimes and serverless. Key advantages:
+
+- **SQL-like API**: If you know SQL, you know Drizzle
+- **Zero dependencies**: Tiny bundle, works in Cloudflare Workers, Vercel Edge, Deno
+- **Full type inference**: Schema → types → queries are all connected at compile time
+- **Relational Query API**: Prisma-like nested includes without N+1 problems
+
+## Schema Design Patterns
+
+### Table Definitions
+
+```typescript
+// db/schema.ts
+import { pgTable, text, integer, timestamp, boolean, uuid, pgEnum } from "drizzle-orm/pg-core";
+import { relations } from "drizzle-orm";
+
+// Enums
+export const roleEnum = pgEnum("role", ["admin", "user", "moderator"]);
+
+// Users table
+export const users = pgTable("users", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  email: text("email").notNull().unique(),
+  name: text("name").notNull(),
+  role: roleEnum("role").default("user").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+
+// Posts table with foreign key
+export const posts = pgTable("posts", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  title: text("title").notNull(),
+  content: text("content"),
+  published: boolean("published").default(false).notNull(),
+  authorId: uuid("author_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+});
+```
+
+### Relations
+
+```typescript
+// db/relations.ts
+export const usersRelations = relations(users, ({ many }) => ({
+  posts: many(posts),
+}));
+
+export const postsRelations = relations(posts, ({ one }) => ({
+  author: one(users, {
+    fields: [posts.authorId],
+    references: [users.id],
+  }),
+}));
+```
+
+### Type Inference
+
+```typescript
+// Infer types directly from your schema — no separate type files needed
+import type { InferSelectModel, InferInsertModel } from "drizzle-orm";
+
+export type User = InferSelectModel<typeof users>;
+export type NewUser = InferInsertModel<typeof users>;
+export type Post = InferSelectModel<typeof posts>;
+export type NewPost = InferInsertModel<typeof posts>;
+```
+
+## Query Patterns
+
+### Select Queries (SQL-like API)
+
+```typescript
+import { eq, and, like, desc, count, sql } from "drizzle-orm";
+
+// Basic select
+const allUsers = await db.select().from(users);
+
+// Filtered with conditions
+const admins = await db.select().from(users).where(eq(users.role, "admin"));
+
+// Partial select (only specific columns)
+const emails = await db.select({ email: users.email }).from(users);
+
+// Join query
+const postsWithAuthors = await db
+  .select({
+    title: posts.title,
+    authorName: users.name,
+  })
+  .from(posts)
+  .innerJoin(users, eq(posts.authorId, users.id))
+  .where(eq(posts.published, true))
+  .orderBy(desc(posts.createdAt))
+  .limit(10);
+
+// Aggregation
+const postCounts = await db
+  .select({
+    authorId: posts.authorId,
+    postCount: count(posts.id),
+  })
+  .from(posts)
+  .groupBy(posts.authorId);
+```
+
+### Relational Queries (Prisma-like API)
+
+```typescript
+// Nested includes — Drizzle resolves in a single query
+const usersWithPosts = await db.query.users.findMany({
+  with: {
+    posts: {
+      where: eq(posts.published, true),
+      orderBy: [desc(posts.createdAt)],
+      limit: 5,
+    },
+  },
+});
+
+// Find one with nested data
+const user = await db.query.users.findFirst({
+  where: eq(users.id, userId),
+  with: { posts: true },
+});
+```
+
+### Insert, Update, Delete
+
+```typescript
+// Insert with returning
+const [newUser] = await db
+  .insert(users)
+  .values({ email: "dev@example.com", name: "Dev" })
+  .returning();
+
+// Batch insert
+await db.insert(posts).values([
+  { title: "Post 1", authorId: newUser.id },
+  { title: "Post 2", authorId: newUser.id },
+]);
+
+// Update
+await db.update(users).set({ name: "Updated" }).where(eq(users.id, userId));
+
+// Delete
+await db.delete(posts).where(eq(posts.authorId, userId));
+```
+
+### Transactions
+
+```typescript
+const result = await db.transaction(async (tx) => {
+  const [user] = await tx.insert(users).values({ email, name }).returning();
+  await tx.insert(posts).values({ title: "Welcome Post", authorId: user.id });
+  return user;
+});
+```
+
+## Migration Workflow (Drizzle Kit)
+
+### Configuration
+
+```typescript
+// drizzle.config.ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./db/schema.ts",
+  out: "./drizzle",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+```
+
+### Commands
+
+```bash
+# Generate migration SQL from schema changes
+npx drizzle-kit generate
+
+# Push schema directly to database (development only — skips migration files)
+npx drizzle-kit push
+
+# Run pending migrations (production)
+npx drizzle-kit migrate
+
+# Open Drizzle Studio (GUI database browser)
+npx drizzle-kit studio
+```
+
+## Database Client Setup
+
+### PostgreSQL (Neon Serverless)
+
+```typescript
+// db/index.ts
+import { drizzle } from "drizzle-orm/neon-http";
+import { neon } from "@neondatabase/serverless";
+import * as schema from "./schema";
+
+const sql = neon(process.env.DATABASE_URL!);
+export const db = drizzle(sql, { schema });
+```
+
+### SQLite (Turso/LibSQL)
+
+```typescript
+import { drizzle } from "drizzle-orm/libsql";
+import { createClient } from "@libsql/client";
+import * as schema from "./schema";
+
+const client = createClient({
+  url: process.env.TURSO_DATABASE_URL!,
+  authToken: process.env.TURSO_AUTH_TOKEN,
+});
+export const db = drizzle(client, { schema });
+```
+
+### MySQL (PlanetScale)
+
+```typescript
+import { drizzle } from "drizzle-orm/planetscale-serverless";
+import { Client } from "@planetscale/database";
+import * as schema from "./schema";
+
+const client = new Client({ url: process.env.DATABASE_URL! });
+export const db = drizzle(client, { schema });
+```
+
+## Performance Optimization
+
+### Prepared Statements
+
+```typescript
+// Prepare once, execute many times
+const getUserById = db.query.users
+  .findFirst({
+    where: eq(users.id, sql.placeholder("id")),
+  })
+  .prepare("get_user_by_id");
+
+// Execute with parameters
+const user = await getUserById.execute({ id: "abc-123" });
+```
+
+### Batch Operations
+
+```typescript
+// Use db.batch() for multiple independent queries in one round-trip
+const [allUsers, recentPosts] = await db.batch([
+  db.select().from(users),
+  db.select().from(posts).orderBy(desc(posts.createdAt)).limit(10),
+]);
+```
+
+### Indexing in Schema
+
+```typescript
+import { index, uniqueIndex } from "drizzle-orm/pg-core";
+
+export const posts = pgTable(
+  "posts",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    title: text("title").notNull(),
+    authorId: uuid("author_id").references(() => users.id).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("posts_author_idx").on(table.authorId),
+    index("posts_created_idx").on(table.createdAt),
+  ]
+);
+```
+
+## Next.js Integration
+
+### Server Component Usage
+
+```typescript
+// app/users/page.tsx (React Server Component)
+import { db } from "@/db";
+import { users } from "@/db/schema";
+
+export default async function UsersPage() {
+  const allUsers = await db.select().from(users);
+  return (
+    <ul>
+      {allUsers.map((u) => (
+        <li key={u.id}>{u.name}</li>
+      ))}
+    </ul>
+  );
+}
+```
+
+### Server Action
+
+```typescript
+// app/actions.ts
+"use server";
+import { db } from "@/db";
+import { users } from "@/db/schema";
+
+export async function createUser(formData: FormData) {
+  const name = formData.get("name") as string;
+  const email = formData.get("email") as string;
+  await db.insert(users).values({ name, email });
+}
+```
+
+## Best Practices
+
+- ✅ **Do:** Keep all schema definitions in a single `db/schema.ts` or split by domain (`db/schema/users.ts`, `db/schema/posts.ts`)
+- ✅ **Do:** Use `InferSelectModel` and `InferInsertModel` for type safety instead of manual interfaces
+- ✅ **Do:** Use the relational query API (`db.query.*`) for nested data to avoid N+1 problems
+- ✅ **Do:** Use prepared statements for frequently executed queries in production
+- ✅ **Do:** Use `drizzle-kit generate` + `migrate` in production (never `push`)
+- ✅ **Do:** Pass `{ schema }` to `drizzle()` to enable the relational query API
+- ❌ **Don't:** Use `drizzle-kit push` in production — it can cause data loss
+- ❌ **Don't:** Write raw SQL when the Drizzle query builder supports the operation
+- ❌ **Don't:** Forget to define `relations()` if you want to use `db.query.*` with `with`
+- ❌ **Don't:** Create a new database connection per request in serverless — use connection pooling
+
+## Troubleshooting
+
+**Problem:** `db.query.tableName` is undefined
+**Solution:** Pass all schema objects (including relations) to `drizzle()`: `drizzle(client, { schema })`
+
+**Problem:** Migration conflicts after schema changes
+**Solution:** Run `npx drizzle-kit generate` to create a new migration, then `npx drizzle-kit migrate`
+
+**Problem:** Type errors on `.returning()` with MySQL
+**Solution:** MySQL does not support `RETURNING`. Use `.execute()` and read `insertId` from the result instead.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/skills/global_legacy/executing-plans/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: executing-plans
+description: "Use when you have a written implementation plan to execute in a separate session with review checkpoints"
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Executing Plans
+
+## Overview
+
+Load plan, review critically, execute tasks in batches, report for review between batches.
+
+**Core principle:** Batch execution with checkpoints for architect review.
+
+**Announce at start:** "I'm using the executing-plans skill to implement this plan."
+
+## The Process
+
+### Step 1: Load and Review Plan
+1. Read plan file
+2. Review critically - identify any questions or concerns about the plan
+3. If concerns: Raise them with your human partner before starting
+4. If no concerns: Create TodoWrite and proceed
+
+### Step 2: Execute Batch
+**Default: First 3 tasks**
+
+For each task:
+1. Mark as in_progress
+2. Follow each step exactly (plan has bite-sized steps)
+3. Run verifications as specified
+4. Mark as completed
+
+### Step 3: Report
+When batch complete:
+- Show what was implemented
+- Show verification output
+- Say: "Ready for feedback."
+
+### Step 4: Continue
+Based on feedback:
+- Apply changes if needed
+- Execute next batch
+- Repeat until complete
+
+### Step 5: Complete Development
+
+After all tasks complete and verified:
+- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
+- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
+- Follow that skill to verify tests, present options, execute choice
+
+## When to Stop and Ask for Help
+
+**STOP executing immediately when:**
+- Hit a blocker mid-batch (missing dependency, test fails, instruction unclear)
+- Plan has critical gaps preventing starting
+- You don't understand an instruction
+- Verification fails repeatedly
+
+**Ask for clarification rather than guessing.**
+
+## When to Revisit Earlier Steps
+
+**Return to Review (Step 1) when:**
+- Partner updates the plan based on your feedback
+- Fundamental approach needs rethinking
+
+**Don't force through blockers** - stop and ask.
+
+## Remember
+- Review plan critically first
+- Follow plan steps exactly
+- Don't skip verifications
+- Reference skills when plan says to
+- Between batches: just report and wait
+- Stop when blocked, don't guess
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.