@hybridlabor-api/bdb-antigravity-skills 1.0.0

package/skills/global_config/turborepo-caching/SKILL.md

@@ -0,0 +1,427 @@
+---
+name: turborepo-caching
+description: "Configure Turborepo for efficient monorepo builds with local and remote caching. Use when setting up Turborepo, optimizing build pipelines, or implementing distributed caching."
+risk: critical
+source: community
+date_added: "2026-02-27"
+---
+
+# Turborepo Caching
+
+Production patterns for Turborepo build optimization.
+
+## Do not use this skill when
+
+- The task is unrelated to turborepo caching
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Use this skill when
+
+- Setting up new Turborepo projects
+- Configuring build pipelines
+- Implementing remote caching
+- Optimizing CI/CD performance
+- Migrating from other monorepo tools
+- Debugging cache misses
+
+## Core Concepts
+
+### 1. Turborepo Architecture
+
+```
+Workspace Root/
+├── apps/
+│   ├── web/
+│   │   └── package.json
+│   └── docs/
+│       └── package.json
+├── packages/
+│   ├── ui/
+│   │   └── package.json
+│   └── config/
+│       └── package.json
+├── turbo.json
+└── package.json
+```
+
+### 2. Pipeline Concepts
+
+| Concept | Description |
+|---------|-------------|
+| **dependsOn** | Tasks that must complete first |
+| **cache** | Whether to cache outputs |
+| **outputs** | Files to cache |
+| **inputs** | Files that affect cache key |
+| **persistent** | Long-running tasks (dev servers) |
+
+## Templates
+
+### Template 1: turbo.json Configuration
+
+```json
+{
+  "$schema": "https://turbo.build/schema.json",
+  "globalDependencies": [
+    ".env",
+    ".env.local"
+  ],
+  "globalEnv": [
+    "NODE_ENV",
+    "VERCEL_URL"
+  ],
+  "pipeline": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": [
+        "dist/**",
+        ".next/**",
+        "!.next/cache/**"
+      ],
+      "env": [
+        "API_URL",
+        "NEXT_PUBLIC_*"
+      ]
+    },
+    "test": {
+      "dependsOn": ["build"],
+      "outputs": ["coverage/**"],
+      "inputs": [
+        "src/**/*.tsx",
+        "src/**/*.ts",
+        "test/**/*.ts"
+      ]
+    },
+    "lint": {
+      "outputs": [],
+      "cache": true
+    },
+    "typecheck": {
+      "dependsOn": ["^build"],
+      "outputs": []
+    },
+    "dev": {
+      "cache": false,
+      "persistent": true
+    },
+    "clean": {
+      "cache": false
+    }
+  }
+}
+```
+
+### Template 2: Package-Specific Pipeline
+
+```json
+// apps/web/turbo.json
+{
+  "$schema": "https://turbo.build/schema.json",
+  "extends": ["//"],
+  "pipeline": {
+    "build": {
+      "outputs": [".next/**", "!.next/cache/**"],
+      "env": [
+        "NEXT_PUBLIC_API_URL",
+        "NEXT_PUBLIC_ANALYTICS_ID"
+      ]
+    },
+    "test": {
+      "outputs": ["coverage/**"],
+      "inputs": [
+        "src/**",
+        "tests/**",
+        "jest.config.js"
+      ]
+    }
+  }
+}
+```
+
+### Template 3: Remote Caching with Vercel
+
+```bash
+# Login to Vercel
+npx turbo login
+
+# Link to Vercel project
+npx turbo link
+
+# Run with remote cache
+turbo build --remote-only
+
+# CI environment variables
+TURBO_TOKEN=your-token
+TURBO_TEAM=your-team
+```
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+env:
+  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+  TURBO_TEAM: ${{ vars.TURBO_TEAM }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npx turbo build --filter='...[origin/main]'
+
+      - name: Test
+        run: npx turbo test --filter='...[origin/main]'
+```
+
+### Template 4: Self-Hosted Remote Cache
+
+```typescript
+// Custom remote cache server (Express)
+import express from 'express';
+import { createReadStream, createWriteStream } from 'fs';
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+
+const app = express();
+const CACHE_DIR = './cache';
+
+// Get artifact
+app.get('/v8/artifacts/:hash', async (req, res) => {
+  const { hash } = req.params;
+  const team = req.query.teamId || 'default';
+  const filePath = join(CACHE_DIR, team, hash);
+
+  try {
+    const stream = createReadStream(filePath);
+    stream.pipe(res);
+  } catch {
+    res.status(404).send('Not found');
+  }
+});
+
+// Put artifact
+app.put('/v8/artifacts/:hash', async (req, res) => {
+  const { hash } = req.params;
+  const team = req.query.teamId || 'default';
+  const dir = join(CACHE_DIR, team);
+  const filePath = join(dir, hash);
+
+  await mkdir(dir, { recursive: true });
+
+  const stream = createWriteStream(filePath);
+  req.pipe(stream);
+
+  stream.on('finish', () => {
+    res.json({ urls: [`${req.protocol}://${req.get('host')}/v8/artifacts/${hash}`] });
+  });
+});
+
+// Check artifact exists
+app.head('/v8/artifacts/:hash', async (req, res) => {
+  const { hash } = req.params;
+  const team = req.query.teamId || 'default';
+  const filePath = join(CACHE_DIR, team, hash);
+
+  try {
+    await fs.access(filePath);
+    res.status(200).end();
+  } catch {
+    res.status(404).end();
+  }
+});
+
+app.listen(3000);
+```
+
+```json
+// turbo.json for self-hosted cache
+{
+  "remoteCache": {
+    "signature": false
+  }
+}
+```
+
+```bash
+# Use self-hosted cache
+turbo build --api="http://localhost:3000" --token="my-token" --team="my-team"
+```
+
+### Template 5: Filtering and Scoping
+
+```bash
+# Build specific package
+turbo build --filter=@myorg/web
+
+# Build package and its dependencies
+turbo build --filter=@myorg/web...
+
+# Build package and its dependents
+turbo build --filter=...@myorg/ui
+
+# Build changed packages since main
+turbo build --filter='...[origin/main]'
+
+# Build packages in directory
+turbo build --filter='./apps/*'
+
+# Combine filters
+turbo build --filter=@myorg/web --filter=@myorg/docs
+
+# Exclude package
+turbo build --filter='!@myorg/docs'
+
+# Include dependencies of changed
+turbo build --filter='...[HEAD^1]...'
+```
+
+### Template 6: Advanced Pipeline Configuration
+
+```json
+{
+  "$schema": "https://turbo.build/schema.json",
+  "pipeline": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": ["dist/**"],
+      "inputs": [
+        "$TURBO_DEFAULT$",
+        "!**/*.md",
+        "!**/*.test.*"
+      ]
+    },
+    "test": {
+      "dependsOn": ["^build"],
+      "outputs": ["coverage/**"],
+      "inputs": [
+        "src/**",
+        "tests/**",
+        "*.config.*"
+      ],
+      "env": ["CI", "NODE_ENV"]
+    },
+    "test:e2e": {
+      "dependsOn": ["build"],
+      "outputs": [],
+      "cache": false
+    },
+    "deploy": {
+      "dependsOn": ["build", "test", "lint"],
+      "outputs": [],
+      "cache": false
+    },
+    "db:generate": {
+      "cache": false
+    },
+    "db:push": {
+      "cache": false,
+      "dependsOn": ["db:generate"]
+    },
+    "@myorg/web#build": {
+      "dependsOn": ["^build", "@myorg/db#db:generate"],
+      "outputs": [".next/**"],
+      "env": ["NEXT_PUBLIC_*"]
+    }
+  }
+}
+```
+
+### Template 7: Root package.json Setup
+
+```json
+{
+  "name": "my-turborepo",
+  "private": true,
+  "workspaces": [
+    "apps/*",
+    "packages/*"
+  ],
+  "scripts": {
+    "build": "turbo build",
+    "dev": "turbo dev",
+    "lint": "turbo lint",
+    "test": "turbo test",
+    "clean": "turbo clean && rm -rf node_modules",
+    "format": "prettier --write \"**/*.{ts,tsx,md}\"",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "turbo build --filter=./packages/* && changeset publish"
+  },
+  "devDependencies": {
+    "turbo": "^1.10.0",
+    "prettier": "^3.0.0",
+    "@changesets/cli": "^2.26.0"
+  },
+  "packageManager": "npm@10.0.0"
+}
+```
+
+## Debugging Cache
+
+```bash
+# Dry run to see what would run
+turbo build --dry-run
+
+# Verbose output with hashes
+turbo build --verbosity=2
+
+# Show task graph
+turbo build --graph
+
+# Force no cache
+turbo build --force
+
+# Show cache status
+turbo build --summarize
+
+# Debug specific task
+TURBO_LOG_VERBOSITY=debug turbo build --filter=@myorg/web
+```
+
+## Best Practices
+
+### Do's
+- **Define explicit inputs** - Avoid cache invalidation
+- **Use workspace protocol** - `"@myorg/ui": "workspace:*"`
+- **Enable remote caching** - Share across CI and local
+- **Filter in CI** - Build only affected packages
+- **Cache build outputs** - Not source files
+
+### Don'ts
+- **Don't cache dev servers** - Use `persistent: true`
+- **Don't include secrets in env** - Use runtime env vars
+- **Don't ignore dependsOn** - Causes race conditions
+- **Don't over-filter** - May miss dependencies
+
+## Resources
+
+- [Turborepo Documentation](https://turbo.build/repo/docs)
+- [Caching Guide](https://turbo.build/repo/docs/core-concepts/caching)
+- [Remote Caching](https://turbo.build/repo/docs/core-concepts/remote-caching)
+
+## 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_config/typescript-pro/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: typescript-pro
+description: Master TypeScript with advanced types, generics, and strict type safety. Handles complex type systems, decorators, and enterprise-grade patterns.
+risk: safe
+source: community
+date_added: '2026-02-27'
+---
+You are a TypeScript expert specializing in advanced typing and enterprise-grade development.
+
+## Use this skill when
+
+- Designing TypeScript architectures or shared types
+- Solving complex typing, generics, or inference issues
+- Hardening type safety for production systems
+
+## Do not use this skill when
+
+- You only need JavaScript guidance
+- You cannot enforce TypeScript in the build pipeline
+- You need UI/UX design rather than type design
+
+## Instructions
+
+1. Define runtime targets and strictness requirements.
+2. Model types and contracts for critical surfaces.
+3. Implement with compiler and linting safeguards.
+4. Validate build performance and developer ergonomics.
+
+## Focus Areas
+- Advanced type systems (generics, conditional types, mapped types)
+- Strict TypeScript configuration and compiler options
+- Type inference optimization and utility types
+- Decorators and metadata programming
+- Module systems and namespace organization
+- Integration with modern frameworks (React, Node.js, Express)
+
+## Approach
+1. Leverage strict type checking with appropriate compiler flags
+2. Use generics and utility types for maximum type safety
+3. Prefer type inference over explicit annotations when clear
+4. Design robust interfaces and abstract classes
+5. Implement proper error boundaries with typed exceptions
+6. Optimize build times with incremental compilation
+
+## Output
+- Strongly-typed TypeScript with comprehensive interfaces
+- Generic functions and classes with proper constraints
+- Custom utility types and advanced type manipulations
+- Jest/Vitest tests with proper type assertions
+- TSConfig optimization for project requirements
+- Type declaration files (.d.ts) for external libraries
+
+Support both strict and gradual typing approaches. Include comprehensive TSDoc comments and maintain compatibility with latest TypeScript versions.
+
+## 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_config/ui-component/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: ui-component
+description: "Generate a new UI component that follows StyleSeed Toss conventions for structure, tokens, accessibility, and component ergonomics."
+category: design
+risk: safe
+source: community
+source_repo: bitjaru/styleseed
+source_type: community
+date_added: "2026-04-08"
+author: bitjaru
+tags: [ui, components, design-system, frontend, styleseed]
+tools: [claude, cursor, codex, gemini]
+---
+
+# UI Component
+
+## Overview
+
+Part of [StyleSeed](https://github.com/bitjaru/styleseed), this skill generates components that respect the Toss seed's design language instead of improvising ad hoc markup and styling. It emphasizes semantic tokens, predictable typing, reusable variants, and mobile-friendly accessibility defaults.
+
+## When to Use
+- Use when you need a new UI primitive or composed component inside a StyleSeed-based project
+- Use when you want a component to match the existing Toss seed conventions
+- Use when a component should be reusable, typed, and design-token driven
+- Use when the AI might otherwise invent spacing, colors, or interaction patterns
+
+## How It Works
+
+### Step 1: Read the Local Design Context
+
+Before generating code, inspect the seed's source of truth:
+- `CLAUDE.md` for conventions
+- `css/theme.css` for semantic tokens
+- at least one representative component from `components/ui/`
+
+If the user already has a better local example, follow the local codebase over a generic template.
+
+### Step 2: Choose the Correct Home
+
+Place the output where it belongs:
+- `src/components/ui/` for primitives and low-level building blocks
+- `src/components/patterns/` for composed sections or multi-part patterns
+
+Do not create a new primitive if an existing one can be extended safely.
+
+### Step 3: Follow the Structural Rules
+
+Use these defaults unless the host project strongly disagrees:
+- function declaration instead of a `const` component
+- `React.ComponentProps<>` or equivalent native prop typing
+- `className` passthrough support
+- `cn()` or the project's standard class merger
+- `data-slot` for component identification
+- CVA or equivalent only when variants are genuinely needed
+
+### Step 4: Use Semantic Tokens Only
+
+Do not hardcode visual values if the design system has a token for them.
+
+Preferred examples:
+- `bg-card`
+- `text-foreground`
+- `text-muted-foreground`
+- `border-border`
+- `shadow-[var(--shadow-card)]`
+
+### Step 5: Preserve StyleSeed Typography and Spacing
+
+- Use the scale already defined by the seed
+- Prefer multiples of 6px
+- Use logical spacing utilities where supported
+- Keep display and heading text tight, body text readable, captions restrained
+
+### Step 6: Bake in Accessibility
+
+- Touch targets should be at least 44x44px for interactive elements
+- Keyboard focus must be visible
+- Pass through `aria-*` attributes where appropriate
+- Respect reduced-motion preferences for nonessential motion
+
+## Output
+
+Provide:
+1. The generated component
+2. The target path
+3. Any required imports or dependencies
+4. Notes on variants, tokens, or follow-up integration work
+
+## Best Practices
+
+- Compose from existing primitives before inventing new ones
+- Keep the component API small and predictable
+- Prefer semantic layout classes over arbitrary values
+- Export named components unless the host project uses another standard consistently
+
+## Additional Resources
+
+- [StyleSeed repository](https://github.com/bitjaru/styleseed)
+- [Source skill](https://github.com/bitjaru/styleseed/blob/main/seeds/toss/.claude/skills/ui-component/SKILL.md)
+
+## 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_config/ui-page/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: ui-page
+description: "Scaffold a new mobile-first page using StyleSeed Toss layout patterns, section rhythm, and existing shell components."
+category: design
+risk: safe
+source: community
+source_repo: bitjaru/styleseed
+source_type: community
+date_added: "2026-04-08"
+author: bitjaru
+tags: [ui, page-design, mobile, layout, styleseed]
+tools: [claude, cursor, codex, gemini]
+---
+
+# UI Page
+
+## Overview
+
+Part of [StyleSeed](https://github.com/bitjaru/styleseed), this skill scaffolds a complete page or screen using the Toss seed's mobile-first composition rules. It keeps page structure consistent by building on the existing shell, top bar, bottom navigation, and card rhythm instead of producing disconnected sections.
+
+## When to Use
+- Use when you need a new page in a Toss-seed app
+- Use when you want a consistent page shell, spacing, and navigation structure
+- Use when you are adding a new product flow and need a solid starting layout
+- Use when you want to stay mobile-first even if the project later expands to larger breakpoints
+
+## How It Works
+
+### Step 1: Inspect the Existing Shell
+
+Read the current page scaffolding patterns first, especially:
+- page shell
+- top bar
+- bottom navigation
+- representative pages using the same route family
+
+### Step 2: Define the Page Purpose
+
+Clarify:
+- the page name
+- the primary user question the screen answers
+- the top one or two actions the user should take
+
+Every screen should have one dominant purpose.
+
+### Step 3: Use the Information Pyramid
+
+Lay out the page from highest importance to lowest:
+1. Hero or top summary
+2. KPI or key actions
+3. detail cards or supporting modules
+4. lists, history, or secondary content
+
+Avoid repeating the same section type mechanically from top to bottom.
+
+### Step 4: Apply the Toss Layout Rules
+
+Default layout choices:
+- mobile viewport width around `max-w-[430px]`
+- page background on `bg-background`
+- horizontal padding around `px-6`
+- section rhythm with `space-y-6`
+- generous bottom padding if a bottom nav is present
+- cards using semantic surface tokens, rounded corners, and light shadows
+
+### Step 5: Compose Instead of Rebuilding
+
+Use existing `ui/` and `patterns/` components wherever possible. New pages should primarily orchestrate existing building blocks, not recreate them.
+
+### Step 6: Account for Real Device Constraints
+
+- handle safe-area insets
+- avoid horizontal overflow
+- keep interactive clusters thumb-friendly
+- ensure long content scrolls cleanly without clipping the bottom navigation
+
+## Output
+
+Return:
+1. The page scaffold
+2. The chosen section structure
+3. Reused components and any newly required components
+4. Empty, loading, and error states that the page will need next
+
+## Best Practices
+
+- Keep the first version structurally correct before adding decoration
+- Use one strong hero instead of multiple competing highlights
+- Preserve navigation consistency across sibling screens
+- Prefer reusable section components when the page will likely repeat
+
+## Additional Resources
+
+- [StyleSeed repository](https://github.com/bitjaru/styleseed)
+- [Source skill](https://github.com/bitjaru/styleseed/blob/main/seeds/toss/.claude/skills/ui-page/SKILL.md)
+
+## 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.