claude-code-superkit 0.0.0-stage → 1.5.3

package/packages/core/settings.json

@@ -0,0 +1,229 @@
+{
+  "permissions": {
+    "allow": ["Bash", "Read", "Edit", "Write", "Glob", "Grep"],
+    "deny": [
+      "Bash(curl * | bash)",
+      "Bash(curl * | sh)",
+      "Bash(wget * | bash)",
+      "Bash(wget * | sh)",
+      "Bash(rm -rf /)",
+      "Bash(rm -rf /*)",
+      "Bash(mkfs *)",
+      "Bash(dd if=*)"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/block-dangerous-git.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/doc-check-on-commit.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/dev-required-on-commit.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/loop-guard.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/gateguard-pre-edit.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/gateguard-pre-edit.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/dev-marker-set.sh"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/audit-trail.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/edit-streak-check.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/plan-completion-gate.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "Grep|Read|Glob",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/gateguard-record-facts.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/audit-trail.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/dev-edit-counter.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/edit-streak-check.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/console-log-warning.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/migration-safety.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/bundle-import-check.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/config-protection.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/context-monitor.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/security-patterns.sh"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/dev-marker-set.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/user-intent-detect.sh"
+          },
+          {
+            "type": "command",
+            "command": "python3 \"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/intake-classifier.py"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/pre-compact-save.sh"
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/audit-settings-source.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/session-context-restore.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/evolve-check.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/superkit-update.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/compact-state-inject.sh"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/scripts/hooks/subagent-stop-validate.sh"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "Before finishing, verify: (1) All changed files pass stack-appropriate linters/compilers. (2) If logic/API/architecture changed — check that relevant docs were updated. Respond with {\"decision\": \"allow\"} if clean, or {\"decision\": \"block\", \"reason\": \"...\"} if issues.",
+            "model": "opus",
+            "timeout": 60,
+            "statusMessage": "Verifying session changes..."
+          }
+        ]
+      }
+    ]
+  },
+  "statusLine": "node \"$CLAUDE_PROJECT_DIR\"/.claude/scripts/statusline.cjs",
+  "enabledPlugins": {
+    "superpowers@claude-plugins-official": true,
+    "github@claude-plugins-official": true,
+    "context7@claude-plugins-official": true,
+    "code-review@claude-plugins-official": true
+  }
+}

package/packages/core/skills/drizzle-orm-expert/SKILL.md

@@ -0,0 +1,260 @@
+---
+name: drizzle-orm-expert
+description: Expert in Drizzle ORM for TypeScript — schema design, relational queries, migrations, serverless DB integration. Use when building type-safe database layers with Drizzle, migrating from Prisma, or optimizing edge runtime DB access
+tokens: 1960
+user-invocable: false
+---
+
+# Drizzle ORM Expert
+
+TypeScript-first ORM that compiles to raw SQL with zero runtime overhead. Ideal for edge runtimes and serverless. Two complementary APIs: SQL-like query builder and Prisma-style relational queries.
+
+## Use this skill when
+
+- Setting up Drizzle ORM in a new or existing project
+- Designing database schemas with Drizzle's TypeScript-first approach
+- Writing complex relational queries (joins, subqueries, aggregations)
+- Setting up or troubleshooting Drizzle Kit migrations
+- Integrating Drizzle with Next.js App Router, tRPC, or Hono
+- Optimizing performance (prepared statements, batching, pooling)
+- Migrating from Prisma, TypeORM, or Knex
+
+## Do not use this skill when
+
+- The DB layer uses Prisma, TypeORM, or raw SQL exclusively
+- You need a database-agnostic ORM guide
+- The task is about DB server configuration (use `postgresql-optimization`)
+
+## Hard Rules
+
+- NEVER run `drizzle-kit push` in production — it can drop columns and lose data. Use `generate` → review SQL → `migrate`.
+- ALWAYS pass `{ schema }` to `drizzle()` — without it `db.query.*` is `undefined`.
+- ALWAYS define and export `relations()` before using `db.query.*` with `with`.
+- ALWAYS use connection pooling (pgBouncer, Neon serverless, or node-pg `Pool`).
+- Use the query builder rather than raw SQL whenever it supports the operation.
+- MySQL has no `.returning()` — read `insertId` from the result instead.
+
+## Workflow
+
+1. Identify the DB driver (PostgreSQL, SQLite, MySQL) and pick the adapter (see Adapters table).
+2. Define schema in `db/schema.ts` (or domain-split `db/schema/users.ts`).
+3. Define `relations()` separately and export them so `db.query.*` with `with` resolves.
+4. Initialize the client with `{ schema }`.
+5. Derive row types with `InferSelectModel` / `InferInsertModel` — never hand-write interfaces.
+6. For production schema changes: `drizzle-kit generate` → review the SQL → `drizzle-kit migrate` (never `push`).
+
+## Core Architecture
+
+No runtime query-engine binary (unlike Prisma), so Drizzle runs on edge runtimes — Cloudflare Workers, Vercel Edge Functions, Deno Deploy. The two APIs:
+
+- **SQL-like builder**: `db.select().from().where().join().orderBy()` — close to SQL semantics
+- **Relational query API**: `db.query.users.findMany({ with: { posts: true } })` — Prisma-style nested fetching
+
+## Schema Design
+
+```typescript
+import { pgTable, uuid, text, boolean, timestamp, pgEnum, index, uniqueIndex } from 'drizzle-orm/pg-core';
+
+export const roleEnum = pgEnum('role', ['admin', 'user', 'guest']);
+
+export const users = pgTable('users', {
+  id: uuid('id').defaultRandom().primaryKey(),
+  email: text('email').notNull().unique(),
+  role: roleEnum('role').default('user').notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => ({
+  emailIdx: uniqueIndex('users_email_idx').on(table.email),
+  createdIdx: index('users_created_idx').on(table.createdAt),
+}));
+
+export const posts = pgTable('posts', {
+  id: uuid('id').defaultRandom().primaryKey(),
+  userId: uuid('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+  title: text('title').notNull(),
+  published: boolean('published').default(false).notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+});
+```
+
+Every column the query examples below read (`posts.published`, `posts.createdAt`) is defined here.
+
+## Relations API
+
+```typescript
+import { relations } from 'drizzle-orm';
+
+export const usersRelations = relations(users, ({ many }) => ({
+  posts: many(posts),
+}));
+
+export const postsRelations = relations(posts, ({ one }) => ({
+  author: one(users, { fields: [posts.userId], references: [users.id] }),
+}));
+
+// Initialize client WITH schema so db.query.* works:
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import * as schema from './schema';
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+export const db = drizzle(pool, { schema });
+```
+
+Many-to-many requires an explicit junction table — Drizzle has no implicit join tables.
+
+## Queries
+
+### SQL-like builder
+```typescript
+import { eq, and, desc } from 'drizzle-orm';
+
+const recent = await db
+  .select({ id: posts.id, title: posts.title, author: users.email })
+  .from(posts)
+  .innerJoin(users, eq(users.id, posts.userId))
+  .where(and(eq(users.role, 'user'), eq(posts.published, true)))
+  .orderBy(desc(posts.createdAt))
+  .limit(20);
+```
+
+### Relational
+
+Prefer the callback form `(table, { eq }) => ...` — it avoids importing and shadowing the schema's table symbols:
+
+```typescript
+const activeUsers = await db.query.users.findMany({
+  where: (user, { eq }) => eq(user.role, 'user'),
+  orderBy: (user, { desc }) => desc(user.createdAt),
+  with: {
+    posts: {
+      where: (post, { eq }) => eq(post.published, true),
+      limit: 5,
+    },
+  },
+  limit: 20,
+});
+```
+
+## Mutations
+
+```typescript
+// Insert + returning (Postgres only)
+const [inserted] = await db.insert(users).values({ email: 'a@b.c' }).returning();
+
+// Batch
+await db.insert(users).values([{ email: 'x@x' }, { email: 'y@y' }]);
+
+// Update
+await db.update(users).set({ role: 'admin' }).where(eq(users.id, id));
+
+// Delete
+await db.delete(posts).where(eq(posts.userId, id));
+
+// Upsert
+await db.insert(users)
+  .values({ id, email })
+  .onConflictDoUpdate({ target: users.id, set: { email } });
+```
+
+## Transactions
+
+```typescript
+import { sql } from 'drizzle-orm';
+
+await db.transaction(async (tx) => {
+  const [author] = await tx.insert(users).values({ email: 'A@B.C' }).returning();
+  await tx.update(users)
+    .set({ email: sql`lower(${users.email})` })   // sql`` escape hatch, columns interpolate safely
+    .where(eq(users.id, author.id));
+  // any throw → rollback
+});
+```
+
+## Drizzle Kit
+
+```bash
+drizzle-kit generate    # write SQL migration files (review them)
+drizzle-kit migrate     # apply pending migrations — production
+drizzle-kit push        # sync schema directly — DEV ONLY, NEVER prod
+drizzle-kit studio      # GUI database browser
+```
+
+`drizzle.config.ts`:
+```typescript
+import type { Config } from 'drizzle-kit';
+export default {
+  schema: './db/schema.ts',
+  out: './db/migrations',
+  dialect: 'postgresql',
+  dbCredentials: { url: process.env.DATABASE_URL! },
+} satisfies Config;
+```
+
+## Adapters
+
+| DB | Adapter |
+|---|---|
+| Postgres (Neon) | `drizzle-orm/neon-http` |
+| Postgres (node-pg) | `drizzle-orm/node-postgres` |
+| Postgres (postgres.js) | `drizzle-orm/postgres-js` |
+| SQLite (Turso) | `drizzle-orm/libsql` |
+| SQLite (local) | `drizzle-orm/better-sqlite3` |
+| MySQL (PlanetScale) | `drizzle-orm/planetscale-serverless` |
+| MySQL (mysql2) | `drizzle-orm/mysql2` |
+
+## Type Inference
+
+```typescript
+import type { InferSelectModel, InferInsertModel } from 'drizzle-orm';
+type User = InferSelectModel<typeof users>;
+type NewUser = InferInsertModel<typeof users>;
+```
+
+Never write manual TS interfaces for DB rows — schema is the source of truth.
+
+## Performance
+
+- **Prepared statements** for hot paths: `.prepare('getUser')` once, execute many times
+- **Partial select**: choose only needed columns
+- **Batch**: `db.batch([...])` for many independent queries in one round-trip (libsql / d1 only)
+- **Indexes**: declare `index()` / `uniqueIndex()` inside the table builder
+
+## Next.js Integration
+
+```typescript
+// app/dashboard/page.tsx — Server Component
+import { db } from '@/db';
+
+export default async function Dashboard() {
+  const allUsers = await db.query.users.findMany({ limit: 20 });
+  return <UsersList users={allUsers} />;
+}
+```
+
+```typescript
+// Server Action
+'use server';
+import { db } from '@/db';
+import { users } from '@/db/schema';
+export async function createUser(formData: FormData) {
+  await db.insert(users).values({ email: formData.get('email') as string });
+}
+```
+
+## Common Issues
+
+| Symptom | Cause | Fix |
+|---------|-------|-----|
+| `db.query.users` is undefined | `{ schema }` not passed to `drizzle()` | Pass schema |
+| Migration conflict | Out-of-sync DB state | `generate` new migration, review SQL, `migrate` |
+| Type error on `relations` | Forgot to `export const usersRelations = relations(...)` | Add export |
+| Slow query in Edge runtime | New connection per request | Use a serverless adapter (Neon, PlanetScale) or HTTP-based driver |
+
+## Recap — non-negotiables
+
+- Never `drizzle-kit push` in production; `generate` → review SQL → `migrate`.
+- Pass `{ schema }` to `drizzle()` and export `relations()`, or `db.query.*` breaks.
+- Always pool connections; prefer the query builder over raw SQL.
+- MySQL has no `.returning()` — read `insertId` instead.
+
+Adapted from VKirill/codex-starter-kit (Apache 2.0 community skill).