aiskillstore/marketplace / skills/10k-digital/lovable
lovable
UnverifiedIntegration skill for Lovable.dev projects. Activates when working with: - Lovable.dev projects with GitHub sync - Supabase Edge Functions that need deployment - Database migrations for Lovable Cloud - Projects with supabase/ directory structure - Any mention of "Lovable", "deploy edge function", "apply migration" Provides exact Lovable prompts for backend operations that can't be done via GitHub alone.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 11.0 KB |
| references/CLAUDE-template.md | markdown | 11.2 KB |
| references/codebase-map.md | markdown | 11.7 KB |
| references/prompts.md | markdown | 6.8 KB |
| references/secret-detection.md | markdown | 11.9 KB |
| skill-report.json | config | 189.3 KB |
references/codebase-map.md
View on GitHub# Codebase Map Generation Reference
This reference defines how to scan and generate a Project Structure Map for Lovable projects.
## Purpose
The codebase map helps Claude navigate user projects faster by providing:
- Directory structure with purposes
- Key files and their roles
- Component organization patterns
- Data flow overview
Target: ~60 lines, optimized for token efficiency while remaining useful.
---
## Scanning Algorithm
### Step 0: Detect Project Architecture
Before scanning, identify which architecture the project uses:
| Check | Result |
|-------|--------|
| `app.config.ts` exists at root | **TanStack Start** (new, SSR) |
| `vite.config.ts` exists at root | **Vite SPA** (legacy, CSR) |
Record the architecture type — it affects which directories to scan and what to document.
### Step 1: Scan Directory Structure
#### Vite SPA Projects (`vite.config.ts`)
Scan these directories in order:
```
1. src/ # Main source code
├── components/ # UI components
├── pages/ # Route pages
├── hooks/ # Custom React hooks
├── lib/ # Utilities and helpers
├── utils/ # Alternative utilities location
├── services/ # API services
├── contexts/ # React contexts
├── stores/ # State management (zustand, etc.)
├── types/ # TypeScript definitions
├── integrations/ # External service integrations
│ └── supabase/ # Supabase client and types
└── assets/ # Static assets
2. supabase/ # Backend
├── functions/ # Supabase Edge Functions
└── migrations/ # Database migrations
3. public/ # Static files
4. Root config files # vite.config.ts, tailwind.config, etc.
```
#### TanStack Start Projects (`app.config.ts`)
Scan these directories in order:
```
1. app/ # Main source code (replaces src/)
├── routes/ # File-based route pages
├── components/ # UI components
├── lib/ # Utilities and helpers
├── utils/ # Alternative utilities location
├── services/ # API services
├── contexts/ # React contexts
├── stores/ # State management
├── types/ # TypeScript definitions
├── integrations/ # External service integrations
│ └── supabase/ # Supabase client and types
└── *.server.ts # TanStack server functions (auto-deploy)
2. supabase/ # Backend
├── functions/ # Supabase Edge Functions (need deployment)
└── migrations/ # Database migrations
3. public/ # Static files
4. Root config files # app.config.ts, tailwind.config, etc.
```
### Step 2: Detect Component Organization Pattern
Check `src/components/` structure:
**Flat Pattern** (all components at same level):
```
components/
├── Button.tsx
├── Card.tsx
├── Modal.tsx
└── ...
```
**Feature-Based Pattern** (grouped by feature):
```
components/
├── auth/
│ ├── LoginForm.tsx
│ └── SignupForm.tsx
├── dashboard/
│ ├── StatsCard.tsx
│ └── ActivityFeed.tsx
└── ui/ # shadcn/ui primitives
```
**Atomic Pattern** (atoms/molecules/organisms):
```
components/
├── atoms/
├── molecules/
└── organisms/
```
### Step 3: Identify Key Files
Scan for these important files based on architecture:
#### Vite SPA Key Files
| Pattern | Purpose |
|---------|---------|
| `src/App.tsx` | Main app entry, routing |
| `src/main.tsx` | React DOM entry point |
| `src/index.tsx` | Alternative entry point |
| `src/lib/utils.ts` | Shared utilities (cn helper) |
| `src/lib/supabase.ts` | Supabase client |
| `src/integrations/supabase/client.ts` | Supabase client (Lovable default) |
| `src/hooks/use*.ts` | Custom hooks |
| `src/contexts/*Context.tsx` | React contexts |
| `src/types/*.ts` | Type definitions |
| `vite.config.ts` | Vite configuration |
| `tailwind.config.js` | Tailwind configuration |
| `tsconfig.json` | TypeScript configuration |
#### TanStack Start Key Files
| Pattern | Purpose |
|---------|---------|
| `app/routes/__root.tsx` | Root layout (wraps all pages) |
| `app/routes/index.tsx` | Home page (/) |
| `app/routes/*.tsx` | Route pages (file = route) |
| `app/lib/utils.ts` | Shared utilities (cn helper) |
| `app/integrations/supabase/client.ts` | Supabase client |
| `app/**/*.server.ts` | TanStack server functions (server-only) |
| `app.config.ts` | TanStack Start configuration |
| `tailwind.config.js` | Tailwind configuration |
| `tsconfig.json` | TypeScript configuration |
### Step 4: Detect Routing Structure
Check for routing patterns based on architecture:
**Vite SPA — React Router** (check `src/App.tsx`):
- Look for `<Routes>`, `<Route>`, `<BrowserRouter>`
- Extract route paths and their components
**TanStack Start — File-based routing** (check `app/routes/`):
- Each `.tsx` file in `app/routes/` is a route
- `__root.tsx` = root layout
- `index.tsx` = `/`
- `about.tsx` = `/about`
- `$id.tsx` = dynamic segment (e.g., `/post/$id`)
- Nested folders = nested routes
### Step 5: Detect State Management
Check for state management patterns:
| Pattern | Detection |
|---------|-----------|
| React Context | `createContext`, `useContext` in `src/contexts/` |
| Zustand | `create` from 'zustand' in `src/stores/` |
| Redux | `configureStore`, `createSlice` |
| TanStack Query | `useQuery`, `useMutation` usage |
### Step 6: Detect Data Flow
Build simplified data flow based on imports:
```
Pages → Components → Hooks → Services/Integrations → Supabase/API
```
Check for:
- Supabase client usage in hooks
- API service files
- Edge function invocations
---
## Map Template
Generate this structure (~60 lines). Use the appropriate template based on detected architecture.
### Template: Vite SPA (legacy)
```markdown
## Project Structure Map
> Architecture: Vite SPA (CSR) — Quick navigation guide - run `/lovable:map --update` to refresh
### Directory Layout
```
src/
├── components/ # [COMPONENT_PATTERN] UI components
│ └── ui/ # shadcn/ui primitives (Button, Card, Dialog, etc.)
├── pages/ # Route pages ([PAGE_COUNT] pages)
├── hooks/ # Custom React hooks ([HOOK_COUNT] hooks)
├── lib/ # Utilities and helpers
├── integrations/ # External integrations
│ └── supabase/ # Supabase client and generated types
└── [OTHER_DIRS] # [PURPOSE]
supabase/
├── functions/ # Supabase Edge Functions ([FUNCTION_COUNT] functions) — needs deploy
└── migrations/ # Database migrations ([MIGRATION_COUNT] migrations)
```
### Key Files
| File | Purpose |
|------|---------|
| `src/App.tsx` | [DETECTED_PURPOSE] |
| `src/lib/utils.ts` | Shared utilities (cn, formatters) |
| `src/integrations/supabase/client.ts` | Supabase client configuration |
| [OTHER_KEY_FILES] | [PURPOSE] |
### Patterns
- **Components**: [COMPONENT_PATTERN_DESCRIPTION]
- **State**: [STATE_MANAGEMENT_PATTERN]
- **Data Flow**: Pages → Hooks → Supabase Client → Edge Functions
### Quick Lookup
| Looking for... | Check here |
|----------------|------------|
| UI components | `src/components/ui/` |
| Page routes | `src/pages/` or `src/App.tsx` |
| API calls | `src/hooks/` or `src/integrations/` |
| Types | `src/types/` or `src/integrations/supabase/types.ts` |
| Edge functions | `supabase/functions/[name]/index.ts` |
*Last updated: [TIMESTAMP]*
```
### Template: TanStack Start (new)
```markdown
## Project Structure Map
> Architecture: TanStack Start (SSR) — Quick navigation guide - run `/lovable:map --update` to refresh
### Directory Layout
```
app/
├── routes/ # File-based routes ([ROUTE_COUNT] routes)
│ ├── __root.tsx # Root layout
│ └── *.tsx # Page routes (filename = URL path)
├── components/ # [COMPONENT_PATTERN] UI components
│ └── ui/ # shadcn/ui primitives
├── lib/ # Utilities and helpers
├── integrations/ # External integrations
│ └── supabase/ # Supabase client and generated types
└── [OTHER_DIRS] # [PURPOSE]
supabase/
├── functions/ # Supabase Edge Functions ([FUNCTION_COUNT] functions) — needs deploy
└── migrations/ # Database migrations ([MIGRATION_COUNT] migrations)
```
### Key Files
| File | Purpose |
|------|---------|
| `app/routes/__root.tsx` | Root layout (wraps all pages) |
| `app/routes/index.tsx` | Home page (/) |
| `app/lib/utils.ts` | Shared utilities (cn, formatters) |
| `app/integrations/supabase/client.ts` | Supabase client configuration |
| `app.config.ts` | TanStack Start configuration |
| [OTHER_KEY_FILES] | [PURPOSE] |
### Patterns
- **Architecture**: SSR — pages render as HTML on the server before browser
- **Routing**: File-based (app/routes/*.tsx files = URL routes)
- **Server functions**: `*.server.ts` files auto-deploy via GitHub (no Lovable prompt needed)
- **Components**: [COMPONENT_PATTERN_DESCRIPTION]
- **State**: [STATE_MANAGEMENT_PATTERN]
- **Data Flow**: Routes (loaders) → Supabase Client → Edge Functions
### Quick Lookup
| Looking for... | Check here |
|----------------|------------|
| UI components | `app/components/ui/` |
| Page routes | `app/routes/` (file = route) |
| Root layout | `app/routes/__root.tsx` |
| Server functions | `app/**/*.server.ts` |
| API calls | `app/lib/` or `app/integrations/` |
| Types | `app/types/` or `app/integrations/supabase/types.ts` |
| Supabase Edge functions | `supabase/functions/[name]/index.ts` |
*Last updated: [TIMESTAMP]*
```
---
## Edge Cases
### Missing Directories
If a standard directory doesn't exist, omit it from the map. Don't show empty directories.
### Non-Standard Structures
If structure doesn't match Lovable/React patterns:
1. List top-level directories with best-guess purposes
2. Identify entry point (package.json main/module field)
3. Note: "Non-standard structure - map may be incomplete"
### Large Projects
If > 50 components or > 20 pages:
- Group by subdirectory instead of listing all
- Show counts: "components/ (45 components in 8 categories)"
### Monorepo Detection
If `packages/` or `apps/` directory exists:
- Note monorepo structure
- Focus map on the primary app (usually `apps/web/` or `packages/app/`)
---
## Integration Points
### With /lovable:init
Add Question 8.5:
```
Would you like me to generate a Project Structure Map?
This helps me navigate your codebase faster by documenting:
- Directory structure and purposes
- Key files and their roles
- Component organization patterns
Generate map? (yes/no)
Default: yes (recommended)
```
### With /lovable:sync
Add `--refresh-map` flag:
- If map section exists in CLAUDE.md, optionally refresh it
- Detect if structure changed significantly since last generation
- Skip if no major changes to avoid unnecessary updates
### With /lovable:map command
Standalone command options:
```
/lovable:map # Generate and display map
/lovable:map --update # Update CLAUDE.md with new map
/lovable:map --verbose # Show detailed scanning output
```
---
## Token Efficiency Guidelines
1. **Use tree format** - More compact than prose descriptions
2. **Counts over lists** - "12 components" not listing all 12
3. **Tables for key info** - Scannable, compact
4. **Skip obvious files** - Don't document package.json, .gitignore
5. **Merge similar items** - "hooks/" not "hooks/useAuth.ts, hooks/useData.ts..."
6. **Purpose over description** - "Auth handling" not "This file handles authentication..."
Target: Map should be quickly scannable in 10 seconds to find what you need.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |