@1aboveio/skills 0.0.0-stage → 1.0.0

package/skills/app-dev/prisma-setup/nextjs.md

@@ -0,0 +1,258 @@
+# Next.js + Prisma v7 Bootstrap
+
+Complete setup guide for Prisma v7 in a standalone Next.js App Router project.
+
+---
+
+## Setup Workflow
+
+### 1. Install Dependencies
+
+```bash
+npm install prisma tsx --save-dev
+npm install @prisma/adapter-pg @prisma/client dotenv
+```
+
+### 2. Initialize Prisma
+
+**Interactive command - run manually:**
+
+```bash
+npx prisma init --db --output ../app/generated/prisma
+```
+
+This creates:
+- `prisma/schema.prisma`
+- `prisma.config.ts`
+- `.env` with DATABASE_URL
+
+Ensure `.env` uses `postgres://` URL scheme.
+
+### 3. Update Schema
+
+```prisma
+generator client {
+  provider = "prisma-client"
+  output   = "../app/generated/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+### 4. Create Prisma Client
+
+```typescript
+// lib/prisma.ts
+import { PrismaClient } from "../app/generated/prisma/client"
+import { PrismaPg } from "@prisma/adapter-pg"
+
+const adapter = new PrismaPg({
+  connectionString: process.env.DATABASE_URL!,
+})
+
+const globalForPrisma = global as unknown as { prisma: PrismaClient }
+
+const prisma = globalForPrisma.prisma || new PrismaClient({ adapter })
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma
+
+export default prisma
+```
+
+### 5. Add NPM Scripts
+
+```json
+{
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "db:test": "tsx scripts/test-database.ts",
+    "db:studio": "prisma studio"
+  }
+}
+```
+
+### 6. Create Test Script
+
+```typescript
+// scripts/test-database.ts
+import "dotenv/config"
+import prisma from "../lib/prisma"
+
+async function testDatabase() {
+  console.log("Testing Prisma connection...\n")
+
+  try {
+    console.log("Connected!")
+
+    const user = await prisma.user.create({
+      data: { email: "test@example.com", name: "Test" },
+    })
+    console.log("Created:", user)
+
+    const users = await prisma.user.findMany()
+    console.log(`Found ${users.length} users`)
+
+    console.log("\nAll tests passed!")
+  } catch (error) {
+    console.error("Error:", error)
+    process.exit(1)
+  }
+}
+
+testDatabase()
+```
+
+### 7. Push Schema & Test
+
+```bash
+npx prisma db push
+npx prisma generate
+npm run db:test
+```
+
+---
+
+## API Route Example
+
+```typescript
+// app/api/users/route.ts
+import { NextRequest, NextResponse } from "next/server"
+import prisma from "../../../lib/prisma"
+
+export async function GET(request: NextRequest) {
+  try {
+    const users = await prisma.user.findMany()
+    return NextResponse.json(users)
+  } catch (error) {
+    console.error("Error fetching users:", error)
+    return NextResponse.json(
+      { error: "Failed to fetch users" },
+      { status: 500 }
+    )
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json()
+    const user = await prisma.user.create({
+      data: { email: body.email, name: body.name },
+    })
+    return NextResponse.json(user, { status: 201 })
+  } catch (error) {
+    console.error("Error creating user:", error)
+    return NextResponse.json(
+      { error: "Failed to create user" },
+      { status: 500 }
+    )
+  }
+}
+```
+
+---
+
+## Server Component Example
+
+```typescript
+// app/page.tsx
+import prisma from "../lib/prisma"
+
+export default async function Home() {
+  let users = []
+  let error = null
+
+  try {
+    users = await prisma.user.findMany({
+      orderBy: { createdAt: "desc" },
+    })
+  } catch (e) {
+    console.error("Error:", e)
+    error = "Failed to load users"
+  }
+
+  return (
+    <main className="p-8">
+      <h1>Users</h1>
+      {error ? (
+        <p className="text-red-500">{error}</p>
+      ) : users.length === 0 ? (
+        <p>No users yet</p>
+      ) : (
+        <ul>
+          {users.map((user) => (
+            <li key={user.id}>{user.name} ({user.email})</li>
+          ))}
+        </ul>
+      )}
+    </main>
+  )
+}
+```
+
+---
+
+## File Structure
+
+```
+project/
+├── app/
+│   ├── generated/
+│   │   └── prisma/        # Generated client
+│   ├── api/
+│   │   └── users/
+│   │       └── route.ts
+│   └── page.tsx
+├── lib/
+│   └── prisma.ts          # Singleton client
+├── prisma/
+│   ├── schema.prisma
+│   └── migrations/
+├── scripts/
+│   └── test-database.ts
+├── prisma.config.ts
+├── .env
+└── package.json
+```
+
+---
+
+## Troubleshooting
+
+### "Cannot find module"
+
+Check import path includes `/client`:
+```typescript
+// Correct
+import { PrismaClient } from "../app/generated/prisma/client"
+```
+
+### "DATABASE_URL not found"
+
+Ensure `import "dotenv/config"` is at top of:
+- `prisma.config.ts`
+- `scripts/test-database.ts`
+
+### "Connection refused"
+
+Verify DATABASE_URL uses TCP URL (`postgres://...`), not HTTP URL.
+
+### "prisma-client-js deprecated"
+
+Update generator:
+```prisma
+generator client {
+  provider = "prisma-client"  # Not "prisma-client-js"
+  output   = "../app/generated/prisma"
+}
+```

package/skills/app-dev/prisma-setup/release-check.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const WEEK_MS = 7 * DAY_MS;
+const here = dirname(fileURLToPath(import.meta.url));
+
+function readJson(path, fallback = {}) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return fallback; }
+}
+
+function frontmatterValue(text, key) {
+  const frontmatter = /^---\n([\s\S]*?)\n---/.exec(text)?.[1] ?? '';
+  const match = new RegExp('^' + key + ':\\s*([^\\n]+)$', 'm').exec(frontmatter);
+  return match?.[1].trim().replace(/^['"]|['"]$/g, '') ?? null;
+}
+
+function repositoryOf(source) {
+  const value = String(source ?? '').trim();
+  const match = /^(?:git@github\.com:|https:\/\/github\.com\/)?([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?$/.exec(value);
+  return match?.[1] ?? null;
+}
+
+function stableVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(String(value ?? '').trim());
+  return match ? match.slice(1).map(Number) : null;
+}
+
+function newer(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    if (left[index] !== right[index]) return left[index] > right[index];
+  }
+  return false;
+}
+
+function writeCache(path, value) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(value));
+  } catch { /* A read-only cache must not block skill use. */ }
+}
+
+function main(now = Date.now()) {
+  if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
+  const name = frontmatterValue(skill, 'name');
+  const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));
+  if (!name || !localVersion) return;
+
+  const lock = readJson(join(process.env.HOME || homedir(), '.agents', '.skill-lock.json'));
+  const entry = lock.skills?.[name];
+  const repository = repositoryOf(entry?.sourceUrl || entry?.source);
+  if (!repository) return;
+
+  const cacheRoot = process.env.XDG_CACHE_HOME || join(process.env.HOME || homedir(), '.cache');
+  const cachePath = join(cacheRoot, '1aboveio-skills', 'release-check.json');
+  const all = readJson(cachePath);
+  const cache = all[repository] && typeof all[repository] === 'object' ? all[repository] : {};
+
+  if (!cache.lastCheck || now - cache.lastCheck >= DAY_MS) {
+    const result = spawnSync('gh', ['api', 'repos/' + repository + '/releases/latest', '--jq', '.tag_name'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 1500,
+    });
+    cache.lastCheck = now;
+    if (result.status === 0 && stableVersion(result.stdout)) cache.latestTag = result.stdout.trim();
+    else delete cache.latestTag;
+    all[repository] = cache;
+    writeCache(cachePath, all);
+  }
+
+  const latestVersion = stableVersion(cache.latestTag);
+  if (!latestVersion || !newer(latestVersion, localVersion)) return;
+  if (cache.notifiedTag === cache.latestTag && cache.notifiedAt && now - cache.notifiedAt < WEEK_MS) return;
+
+  cache.notifiedTag = cache.latestTag;
+  cache.notifiedAt = now;
+  all[repository] = cache;
+  writeCache(cachePath, all);
+  const command = `npx skills@1.5.23 add '${repository}#${cache.latestTag}' --global --agent universal claude-code --skill ${name} --yes`;
+  process.stdout.write(
+    `UPDATE_AVAILABLE: A newer 1AboveIO skills release (${cache.latestTag}) is available; this skill is `
+      + `v${localVersion.join('.')}. Ask once whether to refresh ${name}. On approval run \`${command}\`. `
+      + 'The refreshed instructions apply next session. Either way, continue the current task and do not ask again this session.\n',
+  );
+}
+
+try { main(); } catch { /* Update checks are advisory and always fail silent. */ }

package/skills/app-dev/prisma-setup/turborepo.md

@@ -0,0 +1,301 @@
+# Turborepo + Prisma v7 Setup
+
+Monorepo setup with shared Prisma package across multiple apps.
+
+---
+
+## Monorepo Layout
+
+```
+repo/
+├── apps/
+│   ├── web/                # Next.js app
+│   └── admin/              # Another Next app
+├── packages/
+│   ├── db/                 # Prisma package
+│   └── ui/                 # Shared UI
+├── turbo.json
+├── package.json
+└── .env
+```
+
+**Key rule:** Prisma lives in `packages/db`, not inside an app.
+
+---
+
+## Package Structure: packages/db
+
+```
+packages/db/
+├── prisma/
+│   ├── schema.prisma
+│   └── migrations/
+├── src/
+│   ├── generated/
+│   │   └── prisma/         # Generated client
+│   ├── client.ts           # Singleton
+│   └── index.ts            # Exports
+├── scripts/
+│   └── test-database.ts
+├── prisma.config.ts
+└── package.json
+```
+
+---
+
+## Schema Configuration
+
+```prisma
+// packages/db/prisma/schema.prisma
+generator client {
+  provider = "prisma-client"
+  output   = "../src/generated/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+---
+
+## Prisma Config
+
+```typescript
+// packages/db/prisma.config.ts
+import "dotenv/config"
+import { defineConfig, env } from "prisma/config"
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    path: "prisma/migrations",
+  },
+  datasource: {
+    url: env("DATABASE_URL"),
+  },
+})
+```
+
+---
+
+## Client Singleton
+
+```typescript
+// packages/db/src/client.ts
+import { PrismaClient } from "./generated/prisma/client"
+import { PrismaPg } from "@prisma/adapter-pg"
+
+const adapter = new PrismaPg({
+  connectionString: process.env.DATABASE_URL!,
+})
+
+const globalForPrisma = globalThis as unknown as {
+  prisma?: PrismaClient
+}
+
+export const prisma =
+  globalForPrisma.prisma ?? new PrismaClient({ adapter })
+
+if (process.env.NODE_ENV !== "production") {
+  globalForPrisma.prisma = prisma
+}
+
+export default prisma
+```
+
+---
+
+## Package Exports
+
+```typescript
+// packages/db/src/index.ts
+export { prisma } from "./client"
+export * from "./generated/prisma"
+```
+
+```json
+// packages/db/package.json
+{
+  "name": "@repo/db",
+  "private": true,
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "scripts": {
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push",
+    "db:migrate": "prisma migrate dev",
+    "db:studio": "prisma studio",
+    "db:test": "tsx scripts/test-database.ts"
+  }
+}
+```
+
+---
+
+## Turbo Configuration
+
+```json
+// turbo.json
+{
+  "globalEnv": ["DATABASE_URL"],
+  "tasks": {
+    "dev": {
+      "cache": false,
+      "persistent": true,
+      "dependsOn": ["^db:generate"]
+    },
+    "build": {
+      "dependsOn": ["^db:generate"],
+      "outputs": [".next/**", "dist/**"]
+    },
+    "db:generate": {
+      "cache": false
+    },
+    "db:migrate": {
+      "cache": false
+    },
+    "db:studio": {
+      "cache": false
+    },
+    "db:test": {
+      "cache": false,
+      "dependsOn": ["db:generate"]
+    }
+  }
+}
+```
+
+---
+
+## Root Scripts
+
+```json
+// package.json (root)
+{
+  "scripts": {
+    "dev": "turbo dev",
+    "build": "turbo build",
+    "db:generate": "turbo run db:generate",
+    "db:push": "turbo run db:push",
+    "db:migrate": "turbo run db:migrate",
+    "db:studio": "turbo run db:studio",
+    "db:test": "turbo run db:test"
+  }
+}
+```
+
+---
+
+## Using in Apps
+
+### Add Dependency
+
+```json
+// apps/web/package.json
+{
+  "dependencies": {
+    "@repo/db": "*"
+  }
+}
+```
+
+### Import in Server Code
+
+```typescript
+// apps/web/app/api/users/route.ts
+import { prisma } from "@repo/db"
+import { NextResponse } from "next/server"
+
+export async function GET() {
+  try {
+    const users = await prisma.user.findMany()
+    return NextResponse.json(users)
+  } catch (e) {
+    console.error(e)
+    return NextResponse.json({ error: "Failed" }, { status: 500 })
+  }
+}
+```
+
+---
+
+## Test Script
+
+```typescript
+// packages/db/scripts/test-database.ts
+import "dotenv/config"
+import prisma from "../src/client"
+
+async function testDatabase() {
+  console.log("Testing connection...\n")
+
+  try {
+    console.log("Connected!")
+
+    const user = await prisma.user.create({
+      data: { email: "demo@example.com", name: "Demo" }
+    })
+    console.log("Created:", user)
+
+    const users = await prisma.user.findMany()
+    console.log(`Found ${users.length} users`)
+
+    console.log("\nAll tests passed!")
+  } catch (error) {
+    console.error("Error:", error)
+    process.exit(1)
+  } finally {
+    await prisma.$disconnect()
+  }
+}
+
+testDatabase()
+```
+
+---
+
+## Setup Workflow
+
+1. Create Turborepo or use existing
+2. Add `packages/db`, install Prisma v7 deps
+3. Initialize Prisma in packages/db:
+   ```bash
+   cd packages/db
+   npx prisma init
+   ```
+4. Update `prisma.config.ts` with `import "dotenv/config"`
+5. Update schema with v7 generator + output
+6. Create `src/client.ts` singleton
+7. Wire Turbo tasks in `turbo.json`
+8. Add `.env` at root and/or `packages/db/.env`
+9. Push schema:
+   ```bash
+   npm run db:push
+   ```
+10. Test:
+    ```bash
+    npm run db:test
+    ```
+
+---
+
+## Verification Checklist
+
+1. `provider = "prisma-client"`?
+2. `output = "../src/generated/prisma"` in packages/db?
+3. All Prisma files in `packages/db`?
+4. Client imports from generated path or `@repo/db`?
+5. `import "dotenv/config"` in prisma.config.ts?
+6. Turbo tasks depend on `db:generate`?
+7. `DATABASE_URL` in `globalEnv`?
+8. All DB ops wrapped in try/catch?
+9. Test script exists in packages/db?

package/skills/app-dev/pyspark/LICENSE

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) 2026 1AboveIO