start-vibing-stacks 1.8.1 → 1.9.1

package/dist/index.js

@@ -45,11 +45,9 @@ if (FLAGS.help) {
     --version, -v     Show version
 
   ${chalk.bold('Supported Stacks:')}
-    🐘 PHP 8.3+       Laravel, Symfony, CodeIgniter, Vanilla
+    🐘 PHP 8.3+       Laravel 12 + Octane + Inertia.js (React)
     📦 Node.js/TS     Next.js, Nuxt, Express, Fastify
-    🐍 Python         Django, FastAPI, Flask (coming soon)
-    🦀 Rust           (coming soon)
-    🐹 Go             (coming soon)
+    🐍 Python 3.12+   FastAPI, Django, Flask
   `);
     process.exit(0);
 }

package/dist/ui.js

@@ -2,7 +2,7 @@
  * Start Vibing Stacks — Terminal UI
  */
 import chalk from 'chalk';
-const VERSION = '1.8.1';
+const VERSION = '1.9.1';
 const gradient = (text) => {
     const colors = [chalk.hex('#FF6B6B'), chalk.hex('#FF8E53'), chalk.hex('#FFBD2E'), chalk.hex('#48BB78'), chalk.hex('#4299E1'), chalk.hex('#9F7AEA')];
     return text.split('').map((c, i) => colors[i % colors.length](c)).join('');
@@ -12,7 +12,7 @@ ${chalk.hex('#9F7AEA')('    ╔════════════════
 ${chalk.hex('#9F7AEA')('    ║')}                                                 ${chalk.hex('#9F7AEA')('║')}
 ${chalk.hex('#9F7AEA')('    ║')}   ${chalk.hex('#FF6B6B').bold('⚡')} ${chalk.bold.white('S T A R T')}   ${chalk.bold.white('V I B I N G')}   ${chalk.bold.white('S T A C K S')} ${chalk.hex('#FF6B6B').bold('⚡')}  ${chalk.hex('#9F7AEA')('║')}
 ${chalk.hex('#9F7AEA')('    ║')}                                                 ${chalk.hex('#9F7AEA')('║')}
-${chalk.hex('#9F7AEA')('    ║')}   ${chalk.hex('#FF8E53')('🐘 PHP')}  ${chalk.hex('#48BB78')('📦 Node')}  ${chalk.hex('#4299E1')('🐍 Python')}  ${chalk.hex('#FF6B6B')('🦀 Rust')}  ${chalk.hex('#FFBD2E')('🐹 Go')}   ${chalk.hex('#9F7AEA')('║')}
+${chalk.hex('#9F7AEA')('    ║')}      ${chalk.hex('#FF8E53')('🐘 PHP')}    ${chalk.hex('#48BB78')('📦 Node.js')}    ${chalk.hex('#4299E1')('🐍 Python')}      ${chalk.hex('#9F7AEA')('║')}
 ${chalk.hex('#9F7AEA')('    ║')}                                                 ${chalk.hex('#9F7AEA')('║')}
 ${chalk.hex('#9F7AEA')('    ║')}   ${chalk.dim('AI-powered dev workflow  ·  33 skills  ·  v' + VERSION)}   ${chalk.hex('#9F7AEA')('║')}
 ${chalk.hex('#9F7AEA')('    ║')}                                                 ${chalk.hex('#9F7AEA')('║')}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-vibing-stacks",
-  "version": "1.8.1",
+  "version": "1.9.1",
   "description": "AI-powered multi-stack dev workflow for Claude Code. Supports PHP, Node.js, Python and more.",
   "type": "module",
   "bin": {

package/stacks/php/skills/inertia-react/SKILL.md

@@ -0,0 +1,198 @@
+# Inertia.js + React — Laravel Frontend
+
+**ALWAYS invoke when writing Inertia.js pages, components, or shared data.**
+
+## How Inertia Works
+
+```
+Browser ←→ Inertia.js ←→ Laravel Controller
+           (no API needed)
+
+- First request: full HTML (SSR or SPA)
+- Subsequent: XHR with JSON props → React re-renders
+- No API routes needed — controllers return Inertia::render()
+```
+
+## Controller Pattern
+
+```php
+use Inertia\Inertia;
+
+class UserController extends Controller
+{
+    public function index(): \Inertia\Response
+    {
+        return Inertia::render('Users/Index', [
+            'users' => User::query()
+                ->select('id', 'name', 'email', 'created_at')
+                ->orderByDesc('created_at')
+                ->paginate(20),
+            'filters' => request()->only(['search', 'role']),
+        ]);
+    }
+
+    public function store(StoreUserRequest $request): \Illuminate\Http\RedirectResponse
+    {
+        User::create($request->validated());
+        return redirect()->route('users.index')
+            ->with('success', 'User created.');
+    }
+}
+```
+
+## React Page Component
+
+```tsx
+// resources/js/Pages/Users/Index.tsx
+import { Head, Link, router } from '@inertiajs/react';
+import { PageProps, User, PaginatedData } from '@/types';
+
+interface Props extends PageProps {
+  users: PaginatedData<User>;
+  filters: { search?: string; role?: string };
+}
+
+export default function UsersIndex({ users, filters }: Props) {
+  return (
+    <>
+      <Head title="Users" />
+
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+        {/* Search */}
+        <input
+          defaultValue={filters.search}
+          onChange={(e) => router.get('/users', { search: e.target.value }, {
+            preserveState: true,
+            replace: true,
+          })}
+          placeholder="Search..."
+          className="border rounded-lg px-4 py-2"
+        />
+
+        {/* List */}
+        {users.data.map((user) => (
+          <div key={user.id} className="p-4 border-b">
+            <Link href={`/users/${user.id}`} className="text-blue-600 hover:underline">
+              {user.name}
+            </Link>
+          </div>
+        ))}
+
+        {/* Pagination */}
+        {users.links.map((link, i) => (
+          <Link key={i} href={link.url ?? ''} className={link.active ? 'font-bold' : ''}>
+            <span dangerouslySetInnerHTML={{ __html: link.label }} />
+          </Link>
+        ))}
+      </div>
+    </>
+  );
+}
+```
+
+## Shared Data (Layout Props)
+
+```php
+// app/Http/Middleware/HandleInertiaRequests.php
+public function share(Request $request): array
+{
+    return [
+        ...parent::share($request),
+        'auth' => [
+            'user' => $request->user()?->only('id', 'name', 'email', 'avatar'),
+        ],
+        'flash' => [
+            'success' => session('success'),
+            'error' => session('error'),
+        ],
+    ];
+}
+```
+
+```tsx
+// Access in any component
+import { usePage } from '@inertiajs/react';
+
+const { auth, flash } = usePage().props;
+```
+
+## Forms (useForm hook)
+
+```tsx
+import { useForm } from '@inertiajs/react';
+
+export default function CreateUser() {
+  const { data, setData, post, processing, errors } = useForm({
+    name: '',
+    email: '',
+    password: '',
+  });
+
+  const submit = (e: React.FormEvent) => {
+    e.preventDefault();
+    post('/users');
+  };
+
+  return (
+    <form onSubmit={submit}>
+      <input value={data.name} onChange={e => setData('name', e.target.value)} />
+      {errors.name && <span className="text-red-500 text-sm">{errors.name}</span>}
+
+      <input value={data.email} onChange={e => setData('email', e.target.value)} />
+      {errors.email && <span className="text-red-500 text-sm">{errors.email}</span>}
+
+      <button type="submit" disabled={processing} className="bg-blue-600 text-white px-4 py-2 rounded-lg disabled:opacity-50">
+        {processing ? 'Saving...' : 'Create'}
+      </button>
+    </form>
+  );
+}
+```
+
+## TypeScript Types
+
+```tsx
+// resources/js/types/index.d.ts
+export interface PageProps {
+  auth: { user: User | null };
+  flash: { success?: string; error?: string };
+}
+
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+  avatar?: string;
+  created_at: string;
+}
+
+export interface PaginatedData<T> {
+  data: T[];
+  links: { url: string | null; label: string; active: boolean }[];
+  current_page: number;
+  last_page: number;
+  per_page: number;
+  total: number;
+}
+```
+
+## TailwindCSS 4 Setup
+
+```css
+/* resources/css/app.css */
+@import "tailwindcss";
+
+@theme {
+  --color-primary: #3b82f6;
+  --color-primary-foreground: #ffffff;
+  --font-sans: 'Inter', sans-serif;
+}
+```
+
+## FORBIDDEN
+
+1. **API routes for Inertia pages** — use `Inertia::render()` in controllers
+2. **`window.location` for navigation** — use `router.visit()` or `<Link>`
+3. **Fetching data in useEffect** — pass as props from controller
+4. **Duplicating validation** — validate in FormRequest, show errors from `useForm`
+5. **`any` types for page props** — always type with `interface Props extends PageProps`

package/stacks/php/skills/mariadb-octane/SKILL.md

@@ -0,0 +1,385 @@
+# MariaDB + Octane — Database Patterns for Persistent Workers
+
+**ALWAYS invoke when writing queries, migrations, models, or DB config in Laravel Octane.**
+
+## Why Octane Changes Everything
+
+```
+Traditional PHP:           Octane (RoadRunner):
+┌──────────┐              ┌──────────────────────┐
+│ Request → │              │ Worker boots ONCE     │
+│ Boot app  │              │   ↓                   │
+│ DB connect│              │ Request 1 → process   │
+│ Process   │              │ Request 2 → process   │  ← SAME connection
+│ DB close  │              │ Request 3 → process   │  ← SAME state
+│ Die       │              │ ...500 requests...    │
+└──────────┘              │ Worker restarts       │
+                          └──────────────────────┘
+
+Problems in Octane:
+- Connection stays open → stale connections, gone away errors
+- Transaction leaks → uncommitted TX bleeds to next request
+- Query builder state → leftover bindings
+- String truncation → silent data loss in strict mode OFF
+```
+
+## Connection Configuration
+
+```php
+// config/database.php
+'mysql' => [
+    'driver' => 'mysql',
+    'host' => env('DB_HOST', '127.0.0.1'),
+    'port' => env('DB_PORT', '3306'),
+    'database' => env('DB_DATABASE'),
+    'username' => env('DB_USERNAME'),
+    'password' => env('DB_PASSWORD'),
+    'charset' => 'utf8mb4',
+    'collation' => 'utf8mb4_unicode_ci',
+    'prefix' => '',
+    'strict' => true,                    // ← MANDATORY
+    'engine' => 'InnoDB',
+    'options' => [
+        PDO::ATTR_PERSISTENT => true,    // ← Octane reuses connections
+        PDO::ATTR_EMULATE_PREPARES => false,  // ← Real prepared statements
+        PDO::ATTR_STRINGIFY_FETCHES => false,  // ← Preserve int/float types
+        PDO::MYSQL_ATTR_FOUND_ROWS => true,    // ← Accurate affected rows
+    ],
+    'modes' => [
+        'STRICT_TRANS_TABLES',           // ← Errors instead of truncation
+        'NO_ZERO_IN_DATE',               // ← No 0000-00-00 dates
+        'NO_ZERO_DATE',
+        'ERROR_FOR_DIVISION_BY_ZERO',
+        'NO_ENGINE_SUBSTITUTION',
+        'ONLY_FULL_GROUP_BY',            // ← Force explicit GROUP BY
+    ],
+],
+```
+
+### Why `strict => true` + SQL Modes
+
+```
+strict: false (DEFAULT MariaDB):
+INSERT INTO users (name) VALUES ('This is a very long name that exceeds the column limit')
+→ Silently TRUNCATES to column length! No error! DATA LOST!
+
+strict: true (OUR STANDARD):
+→ ERROR 1406: Data too long for column 'name'
+→ You KNOW the problem immediately
+```
+
+**Rule:** `strict => true` is NON-NEGOTIABLE. Every silent truncation is a bug waiting to explode.
+
+## Octane Connection Flush (MANDATORY)
+
+```php
+// app/Providers/AppServiceProvider.php
+use Laravel\Octane\Facades\Octane;
+
+public function boot(): void
+{
+    // Flush stale connections between requests
+    Octane::prepare(function ($sandbox) {
+        $sandbox->flushDatabaseConnections();
+    });
+
+    // Also flush on tick (long-running operations)
+    Octane::tick('db-health', function () {
+        try {
+            DB::connection()->getPdo();
+        } catch (\Exception $e) {
+            DB::reconnect();
+        }
+    })->seconds(30);
+}
+```
+
+## Migration Patterns
+
+### Column Definitions — Be Explicit
+
+```php
+// ✅ ALWAYS define exact lengths — no surprises with strict mode
+Schema::create('leads', function (Blueprint $table) {
+    $table->uuid('id')->primary();
+
+    // Strings: ALWAYS define max length
+    $table->string('name', 255);                // varchar(255)
+    $table->string('email', 320);               // RFC 5321 max email
+    $table->string('phone', 20);                // E.164 max
+    $table->string('status', 30);               // enum-like but flexible
+    $table->string('country_code', 3);          // ISO 3166-1 alpha-2/3
+    $table->string('currency', 3);              // ISO 4217
+
+    // Use text() for unbounded content
+    $table->text('notes');                       // 64KB
+    $table->mediumText('description');           // 16MB
+    $table->longText('raw_payload');             // 4GB
+
+    // Decimals: ALWAYS precision + scale
+    $table->decimal('price', 10, 2);            // 99,999,999.99
+    $table->decimal('commission_rate', 5, 4);   // 0.0000 to 9.9999
+    $table->unsignedBigInteger('impressions')->default(0);
+
+    // Dates
+    $table->timestamp('converted_at')->nullable();
+    $table->timestamps();                        // created_at, updated_at
+    $table->softDeletes();                       // deleted_at
+
+    // JSON (MariaDB 10.2+)
+    $table->json('metadata')->nullable();
+
+    // Indexes
+    $table->index('status');
+    $table->index(['status', 'created_at']);     // Composite for common queries
+    $table->unique('email');
+});
+```
+
+### Index Strategy for MariaDB
+
+```php
+// ✅ Composite indexes — leftmost prefix rule
+$table->index(['user_id', 'status', 'created_at']);
+// Covers: WHERE user_id = ? 
+// Covers: WHERE user_id = ? AND status = ?
+// Covers: WHERE user_id = ? AND status = ? ORDER BY created_at
+// Does NOT cover: WHERE status = ? (user_id not in query)
+
+// ✅ Covering index for frequent queries
+$table->index(['domain_id', 'status', 'created_at', 'id'], 'idx_leads_dashboard');
+
+// ✅ Partial-like with generated column (MariaDB 10.2+)
+// For: WHERE JSON_EXTRACT(metadata, '$.source') = 'google'
+$table->string('metadata_source', 50)->virtualAs("JSON_UNQUOTE(JSON_EXTRACT(metadata, '$.source'))");
+$table->index('metadata_source');
+```
+
+## Eloquent Patterns for Octane
+
+### Scoped Queries (avoid stale state)
+
+```php
+class Lead extends Model
+{
+    use HasUuids;
+
+    // ✅ Scopes — reusable, composable
+    public function scopeActive(Builder $query): Builder
+    {
+        return $query->where('status', 'active');
+    }
+
+    public function scopeForUser(Builder $query, string $userId): Builder
+    {
+        return $query->where('user_id', $userId);
+    }
+
+    public function scopeCreatedBetween(Builder $query, Carbon $from, Carbon $to): Builder
+    {
+        return $query->whereBetween('created_at', [$from, $to]);
+    }
+}
+
+// Usage (always fresh query, no state leaks):
+Lead::query()
+    ->active()
+    ->forUser($request->user()->id)
+    ->createdBetween(now()->subDays(30), now())
+    ->paginate(20);
+```
+
+### N+1 Prevention
+
+```php
+// ✅ ALWAYS eager load relationships
+class LeadController extends Controller
+{
+    public function index(Request $request): JsonResponse
+    {
+        $leads = Lead::query()
+            ->with(['domain:id,name', 'user:id,name,email'])  // Select only needed columns
+            ->select('id', 'name', 'email', 'status', 'domain_id', 'user_id', 'created_at')
+            ->forUser($request->user()->id)
+            ->latest()
+            ->paginate(20);
+
+        return LeadResource::collection($leads);
+    }
+}
+
+// ❌ NEVER in Octane (N+1 with persistent connections = compounding slowness)
+foreach ($leads as $lead) {
+    echo $lead->domain->name;  // N+1 query PER lead, PER request, ALL DAY
+}
+```
+
+### Bulk Operations (Octane-safe)
+
+```php
+// ✅ Chunked processing — controls memory in long-lived worker
+Lead::query()
+    ->where('status', 'pending')
+    ->chunkById(500, function ($leads) {
+        foreach ($leads as $lead) {
+            ProcessLeadJob::dispatch($lead);
+        }
+    });
+
+// ✅ Bulk insert (single query)
+Lead::insert(
+    collect($rows)->map(fn ($row) => [
+        'id' => Str::uuid()->toString(),
+        'name' => $row['name'],
+        'email' => $row['email'],
+        'created_at' => now(),
+        'updated_at' => now(),
+    ])->toArray()
+);
+
+// ✅ Bulk update
+Lead::query()
+    ->whereIn('id', $ids)
+    ->update(['status' => 'processed', 'processed_at' => now()]);
+
+// ❌ NEVER in Octane (memory grows with each request)
+$allLeads = Lead::all();  // Loads EVERYTHING into worker memory
+```
+
+### Transaction Safety in Octane
+
+```php
+// ✅ Always explicit transactions with try/catch
+// In Octane, an uncaught exception leaves the TX open for the NEXT request!
+try {
+    DB::beginTransaction();
+
+    $lead = Lead::create($validated);
+    $lead->attempts()->create(['status' => 'new']);
+    ConversionService::fire($lead);
+
+    DB::commit();
+} catch (\Throwable $e) {
+    DB::rollBack();  // ← CRITICAL in Octane — prevents TX leak
+    report($e);
+    throw $e;
+}
+
+// ✅ Or use the closure syntax (auto-rollback on exception)
+$lead = DB::transaction(function () use ($validated) {
+    $lead = Lead::create($validated);
+    $lead->attempts()->create(['status' => 'new']);
+    return $lead;
+}, attempts: 3);  // Retry on deadlock
+```
+
+## Query Performance
+
+### Explain Before Deploy
+
+```php
+// In Tinker or test:
+DB::enableQueryLog();
+$leads = Lead::query()->active()->forUser($userId)->paginate(20);
+$queries = DB::getQueryLog();
+
+// Check for full table scans:
+// EXPLAIN SELECT * FROM leads WHERE user_id = ? AND status = 'active'
+// Look for: type=ref or type=range (GOOD), type=ALL (BAD — full scan)
+```
+
+### Pagination (NEVER offset for large tables)
+
+```php
+// ✅ Cursor pagination (fast on large tables)
+$leads = Lead::query()
+    ->where('user_id', $userId)
+    ->orderBy('id')
+    ->cursorPaginate(20);
+
+// ✅ Standard pagination (OK for admin panels)
+$leads = Lead::query()->paginate(20);
+
+// ❌ NEVER manual offset on large tables
+Lead::query()->offset(100000)->limit(20)->get();
+// Full scan of 100,000 rows just to skip them!
+```
+
+### Count Optimization
+
+```php
+// ❌ SLOW on large tables
+$total = Lead::count();  // Full table scan
+
+// ✅ Approximate count (MariaDB)
+$total = DB::selectOne("SELECT TABLE_ROWS FROM information_schema.TABLES WHERE TABLE_NAME = 'leads'")->TABLE_ROWS;
+
+// ✅ Exact count with cache
+$total = Cache::remember("leads:count:{$userId}", 60, function () use ($userId) {
+    return Lead::where('user_id', $userId)->count();
+});
+```
+
+## Model Casts (Strict Types)
+
+```php
+class Lead extends Model
+{
+    protected $casts = [
+        'metadata' => 'array',              // JSON → array (auto encode/decode)
+        'price' => 'decimal:2',             // Always 2 decimal places
+        'is_active' => 'boolean',           // 1/0 → true/false
+        'converted_at' => 'immutable_datetime',  // Carbon Immutable (Octane-safe)
+        'impressions' => 'integer',         // String → int
+        'status' => LeadStatus::class,      // Backed enum
+    ];
+}
+
+// ✅ Backed enums for status columns
+enum LeadStatus: string
+{
+    case Pending = 'pending';
+    case Active = 'active';
+    case Converted = 'converted';
+    case Rejected = 'rejected';
+}
+```
+
+## Health Check
+
+```php
+// routes/web.php — Octane worker health
+Route::get('/health', function () {
+    try {
+        DB::connection()->getPdo();
+        $dbOk = true;
+    } catch (\Exception $e) {
+        DB::reconnect();
+        $dbOk = false;
+    }
+
+    return response()->json([
+        'status' => $dbOk ? 'healthy' : 'degraded',
+        'db' => $dbOk,
+        'worker_memory' => memory_get_usage(true) / 1024 / 1024 . ' MB',
+        'worker_peak' => memory_get_peak_usage(true) / 1024 / 1024 . ' MB',
+    ], $dbOk ? 200 : 503);
+});
+```
+
+## FORBIDDEN
+
+| ❌ Don't | ✅ Do |
+|---|---|
+| `strict => false` | `strict => true` + SQL modes |
+| `$table->string('name')` (no length) | `$table->string('name', 255)` |
+| `Lead::all()` in Octane | `Lead::query()->paginate()` or `chunkById()` |
+| Uncaught exception in transaction | `DB::transaction()` closure or explicit rollBack |
+| `$_GET`, `$_POST` | `$request->input()` |
+| `static $cache = []` | Instance property or Redis cache |
+| `offset()` on large tables | `cursorPaginate()` |
+| `migrate:fresh`, `db:wipe` | Incremental migrations only |
+| No index on WHERE/ORDER columns | Composite indexes matching query patterns |
+| `Lead::count()` on millions of rows | Cached count or approximate count |
+| `'metadata' => 'json'` cast | `'metadata' => 'array'` (auto decode) |
+| `datetime` cast | `immutable_datetime` (Octane-safe, no mutation) |

package/stacks/php/stack.json

@@ -1,159 +1,66 @@
 {
   "id": "php",
   "name": "PHP",
-  "icon": "\ud83d\udc18",
+  "icon": "🐘",
   "runtime": "PHP 8.3+",
   "minVersion": "8.3.0",
   "packageManager": "composer",
-  "extensions": [
-    ".php",
-    ".blade.php",
-    ".twig",
-    ".phtml"
-  ],
-  "testExtensions": [
-    "*Test.php",
-    "*_test.php"
-  ],
-  "detectFiles": [
-    "composer.json",
-    "index.php",
-    "artisan",
-    "public/index.php"
-  ],
+  "extensions": [".php", ".blade.php"],
+  "testExtensions": ["*Test.php", "*_test.php"],
+  "detectFiles": ["composer.json", "artisan", "public/index.php"],
   "commands": {
     "test": "vendor/bin/phpunit",
     "lint": "vendor/bin/phpstan analyse --level=6",
     "format": "vendor/bin/php-cs-fixer fix",
-    "serve": "php -S localhost:8000 -t public/",
-    "build": null
+    "serve": "php artisan octane:start --watch",
+    "build": "npm run build"
   },
   "qualityGates": [
-    {
-      "name": "PHPStan",
-      "command": "vendor/bin/phpstan analyse --level=6",
-      "required": true,
-      "order": 1
-    },
-    {
-      "name": "PHPUnit",
-      "command": "vendor/bin/phpunit",
-      "required": true,
-      "order": 2
-    },
-    {
-      "name": "CS Fixer",
-      "command": "vendor/bin/php-cs-fixer fix --dry-run --diff",
-      "required": false,
-      "order": 3
-    }
+    { "name": "PHPStan", "command": "vendor/bin/phpstan analyse --level=6", "required": true, "order": 1 },
+    { "name": "PHPUnit", "command": "vendor/bin/phpunit", "required": true, "order": 2 },
+    { "name": "TypeCheck", "command": "npx tsc --noEmit", "required": true, "order": 3 },
+    { "name": "Lint", "command": "npx eslint resources/js/", "required": false, "order": 4 }
   ],
   "frameworks": [
-    {
-      "id": "laravel",
-      "name": "Laravel",
-      "icon": "\ud83c\udfd7\ufe0f",
-      "detectFiles": [
-        "artisan",
-        "bootstrap/app.php"
-      ]
-    },
     {
       "id": "laravel-octane",
-      "name": "Laravel + Octane (RoadRunner)",
-      "icon": "\ud83d\ude80",
-      "detectFiles": [
-        "artisan",
-        "rr.yaml"
-      ]
-    },
-    {
-      "id": "symfony",
-      "name": "Symfony",
-      "icon": "\ud83c\udfb5",
-      "detectFiles": [
-        "symfony.lock"
-      ]
+      "name": "Laravel 12 + Octane (RoadRunner) + Inertia.js",
+      "icon": "🚀",
+      "detectFiles": ["artisan", "rr.yaml"],
+      "default": true
     },
     {
-      "id": "codeigniter",
-      "name": "CodeIgniter",
-      "icon": "\ud83e\udde9",
-      "detectFiles": [
-        "spark"
-      ]
-    },
-    {
-      "id": "vanilla",
-      "name": "Vanilla PHP",
-      "icon": "\ud83d\udcc4"
+      "id": "laravel",
+      "name": "Laravel 12 (standard)",
+      "icon": "🏗️",
+      "detectFiles": ["artisan", "bootstrap/app.php"]
     }
   ],
   "databases": [
-    {
-      "id": "mysql",
-      "name": "MySQL / MariaDB",
-      "icon": "\ud83d\udc2c"
-    },
-    {
-      "id": "postgresql",
-      "name": "PostgreSQL",
-      "icon": "\ud83d\udc18"
-    },
-    {
-      "id": "mongodb",
-      "name": "MongoDB",
-      "icon": "\ud83c\udf43"
-    },
-    {
-      "id": "sqlite",
-      "name": "SQLite",
-      "icon": "\ud83d\udcc1"
-    },
-    {
-      "id": "none",
-      "name": "None",
-      "icon": "\u274c"
-    }
+    { "id": "mysql", "name": "MySQL / MariaDB", "icon": "🐬" },
+    { "id": "postgresql", "name": "PostgreSQL", "icon": "🐘" },
+    { "id": "sqlite", "name": "SQLite", "icon": "📁" }
   ],
   "frontendOptions": [
     {
-      "id": "react-tailwind",
-      "name": "ReactJS 19+ / TailwindCSS 4+",
-      "icon": "\u269b\ufe0f"
-    },
-    {
-      "id": "tailwind-vanilla",
-      "name": "TailwindCSS 4+ / Vanilla JS",
-      "icon": "\ud83c\udfa8"
+      "id": "react-inertia",
+      "name": "ReactJS 19 + Inertia.js + TailwindCSS 4",
+      "icon": "⚛️",
+      "default": true
     },
     {
       "id": "blade",
-      "name": "Blade Templates (Laravel)",
-      "icon": "\ud83d\uddbc\ufe0f"
-    },
-    {
-      "id": "livewire",
-      "name": "Livewire + Alpine.js",
-      "icon": "\u26a1"
-    },
-    {
-      "id": "twig",
-      "name": "Twig Templates (Symfony)",
-      "icon": "\ud83c\udf3f"
+      "name": "Blade + TailwindCSS 4",
+      "icon": "🖼️"
     },
     {
       "id": "none",
-      "name": "API only \u2014 no frontend",
-      "icon": "\u274c"
+      "name": "API only — no frontend",
+      "icon": "🔌"
     }
   ],
   "deployTargets": [
-    {
-      "id": "github",
-      "name": "GitHub (git push)",
-      "icon": "\ud83d\udc19"
-    }
+    { "id": "github", "name": "GitHub (git push)", "icon": "🐙" }
   ],
   "skills": [
     "php-patterns",
@@ -192,10 +99,10 @@
       "name": "Node.js",
       "command": "node",
       "versionFlag": "--version",
-      "minVersion": "18.0.0",
+      "minVersion": "20.0.0",
       "installCommand": {
         "macos": "brew install node",
-        "linux": "curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - && sudo apt install -y nodejs"
+        "linux": "curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - && sudo apt install -y nodejs"
       },
       "versionRegex": "v?(\\d+\\.\\d+\\.\\d+)"
     }