start-vibing-stacks 2.1.1 → 2.3.0

package/README.md

@@ -20,7 +20,7 @@ svs  # shortcut
 ## ✨ Features
 
 - **🔍 Auto-detection** — Scans your project files to suggest the right stack
-- **🐘 PHP 8.3+** — PHPStan, PHPUnit, Composer, Laravel/Octane, Symfony, Vanilla
+- **🐘 PHP 8.3+** — PHPStan, PHPUnit, Composer, Laravel/Octane
 - **📦 Node.js/TS** — Vitest, TypeScript, Bun, Next.js, Express
 - **🎯 Multi-framework** — Choose your framework, database, frontend, deploy target
 - **🤖 6 Universal Agents** — research, documenter, domain-updater, commit-manager, tester, compactor
@@ -33,7 +33,7 @@ svs  # shortcut
 
 | Stack | Status | Frameworks |
 |-------|--------|------------|
-| 🐘 PHP 8.3+ | ✅ Ready | Laravel, Laravel+Octane, Symfony, CodeIgniter, Vanilla |
+| 🐘 PHP 8.3+ | ✅ Ready | Laravel, Laravel+Octane |
 | 📦 Node.js/TS | ✅ Ready | Next.js, Nuxt, Astro, Express, Fastify |
 | 🐍 Python | 🔜 Soon | Django, FastAPI, Flask |
 | 🦀 Rust | 🔜 Soon | Actix, Axum |

package/dist/detector.js

@@ -11,7 +11,6 @@ const STACK_SIGNATURES = [
     { id: 'php', files: ['composer.json'], weight: 90, reason: 'composer.json detected' },
     { id: 'php', files: ['index.php'], weight: 60, reason: 'index.php detected' },
     { id: 'php', files: ['artisan'], weight: 95, reason: 'Laravel artisan detected' },
-    { id: 'php', files: ['symfony.lock'], weight: 95, reason: 'Symfony lock detected' },
     { id: 'php', files: ['public/index.php'], weight: 70, reason: 'public/index.php detected' },
     { id: 'php', files: ['.php-version'], weight: 80, reason: '.php-version detected' },
     // Node.js / TypeScript
@@ -79,12 +78,11 @@ export function detectProject(projectDir) {
  * Detect framework within a PHP project
  */
 export function detectPhpFramework(projectDir) {
-    if (existsSync(join(projectDir, 'artisan')))
+    if (existsSync(join(projectDir, 'artisan'))) {
+        if (existsSync(join(projectDir, 'rr.yaml')))
+            return 'laravel-octane';
         return 'laravel';
-    if (existsSync(join(projectDir, 'symfony.lock')))
-        return 'symfony';
-    if (existsSync(join(projectDir, 'spark')))
-        return 'codeigniter';
+    }
     return null;
 }
 /**

package/dist/index.js

@@ -14,6 +14,7 @@ import { detectProject, detectPhpFramework, detectNodeFramework, detectPythonFra
 import { autoInstall, installComposer, installClaudeCode } from './installer.js';
 import { loadStackConfig, setupProject } from './setup.js';
 import { selectMcpServers, installMcpServers } from './mcp.js';
+import { scanProjectStandards } from './scanner.js';
 // =============================================================================
 // CLI Arguments
 // =============================================================================
@@ -169,6 +170,7 @@ async function main() {
             })),
         },
     ]);
+    const selectedFramework = stackConfig.frameworks.find((f) => f.id === framework);
     // ─── Step 4: Select Database ───────────────────────────────────────────
     const { database } = await inquirer.prompt([
         {
@@ -182,12 +184,13 @@ async function main() {
         },
     ]);
     // ─── Step 5: Frontend ──────────────────────────────────────────────────
+    const compatibleFrontends = stackConfig.frontendOptions.filter((f) => !f.frameworks || f.frameworks.includes(framework));
     const { frontend } = await inquirer.prompt([
         {
             type: 'list',
             name: 'frontend',
             message: 'Frontend included?',
-            choices: stackConfig.frontendOptions.map((f) => ({
+            choices: compatibleFrontends.map((f) => ({
                 name: `${f.icon}  ${f.name}`,
                 value: f.id,
             })),
@@ -197,6 +200,54 @@ async function main() {
     const deploy = 'github';
     // ─── Step 6b: MCP Servers ────────────────────────────────────────────
     const selectedMcps = FLAGS.noMcp ? [] : await selectMcpServers(stackId, database);
+    // ─── Step 6c: Standards Review ──────────────────────────────────────────
+    let standardsReview;
+    const scanResults = scanProjectStandards(projectDir);
+    if (scanResults.patterns.length > 0) {
+        console.log('');
+        ui.header('📋 Standards Review');
+        ui.info(`Found ${scanResults.patterns.length} patterns from: ${scanResults.sources.join(', ')}`);
+        console.log('');
+        const categories = new Map();
+        for (const p of scanResults.patterns) {
+            const list = categories.get(p.category) || [];
+            list.push(p.name);
+            categories.set(p.category, list);
+        }
+        for (const [category, items] of categories) {
+            console.log(chalk.cyan(`  ${category}:`));
+            for (const item of items.slice(0, 3)) {
+                console.log(chalk.dim(`    • ${item}`));
+            }
+            if (items.length > 3) {
+                console.log(chalk.dim(`    ... and ${items.length - 3} more`));
+            }
+        }
+        console.log('');
+        const { adaptStandards } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'adaptStandards',
+                message: 'Adapt AI skills to match your project standards?',
+                choices: [
+                    {
+                        name: `🎯  Use my standards ${chalk.dim('— import patterns into AI context')}`,
+                        value: 'adapt',
+                    },
+                    {
+                        name: `📦  Use defaults ${chalk.dim('— start with plugin defaults')}`,
+                        value: 'defaults',
+                    },
+                ],
+            },
+        ]);
+        scanResults.status = adaptStandards === 'adapt' ? 'adapted' : 'defaults';
+        scanResults.userChoice = adaptStandards;
+        standardsReview = scanResults;
+        if (adaptStandards === 'adapt') {
+            ui.success(`${scanResults.patterns.length} patterns will be imported into AI context`);
+        }
+    }
     // ─── Step 7: Show Summary & Confirm ────────────────────────────────────
     const config = {
         name: projectName,
@@ -207,17 +258,27 @@ async function main() {
         deploy,
         path: projectDir,
         createdAt: new Date().toISOString(),
-        skills: [...stackConfig.skills],
+        skills: [
+            ...stackConfig.skills,
+            ...(selectedFramework?.skills ?? []),
+        ],
         qualityGates: `stacks/${stackId}/config/quality-gates.json`,
         cursorRules: detection.hasCursorRules,
         domains: {},
+        standardsReview,
     };
+    const standardsLabel = standardsReview
+        ? standardsReview.status === 'adapted'
+            ? `${standardsReview.patterns.length} patterns imported`
+            : 'Using defaults'
+        : 'No patterns found';
     ui.configSummary({
         'Stack': `${stackConfig.icon}  ${stackConfig.name} (${stackConfig.runtime})`,
         'Framework': framework,
         'Database': database,
         'Frontend': frontend,
         'Deploy': '🐙 GitHub (git push)',
+        'Standards': standardsLabel,
         'Agents': '6 universal',
         'Skills': `${stackConfig.skills.length} stack + shared`,
         'Hooks': 'stop-validator + prompt-inject',

package/dist/scanner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Start Vibing Stacks — Project Standards Scanner
+ *
+ * Scans existing project files to extract coding patterns
+ * and standards already in use.
+ */
+import type { StandardsReview } from './types.js';
+/**
+ * Run all scanners against a project directory.
+ * Returns combined results from all sources.
+ */
+export declare function scanProjectStandards(projectDir: string): StandardsReview;

package/dist/scanner.js

@@ -0,0 +1,480 @@
+/**
+ * Start Vibing Stacks — Project Standards Scanner
+ *
+ * Scans existing project files to extract coding patterns
+ * and standards already in use.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+// ─── PHP: Composer dependency map ──────────────────────────────────────────
+const COMPOSER_PACKAGES = {
+    'laravel/octane': { category: 'server', name: 'Laravel Octane (long-lived workers)' },
+    'laravel/sanctum': { category: 'auth', name: 'Laravel Sanctum for API token auth' },
+    'inertiajs/inertia-laravel': { category: 'frontend', name: 'Inertia.js (server-driven SPA)' },
+    'laravel/horizon': { category: 'queue', name: 'Laravel Horizon for queue monitoring' },
+    'laravel/telescope': { category: 'debug', name: 'Laravel Telescope for debugging' },
+    'laravel/cashier': { category: 'billing', name: 'Laravel Cashier for payments' },
+    'laravel/scout': { category: 'search', name: 'Laravel Scout for full-text search' },
+    'laravel/socialite': { category: 'auth', name: 'Laravel Socialite for OAuth' },
+    'spatie/laravel-permission': { category: 'auth', name: 'Spatie Permissions for RBAC' },
+    'spatie/laravel-medialibrary': { category: 'media', name: 'Spatie Media Library for file uploads' },
+    'spatie/laravel-activitylog': { category: 'audit', name: 'Spatie Activity Log for auditing' },
+    'tightenco/ziggy': { category: 'frontend', name: 'Ziggy for Laravel routes in JS' },
+    'predis/predis': { category: 'cache', name: 'Predis Redis client' },
+    'phpstan/phpstan': { category: 'quality', name: 'PHPStan static analysis' },
+    'friendsofphp/php-cs-fixer': { category: 'quality', name: 'PHP-CS-Fixer code style' },
+    'pestphp/pest': { category: 'testing', name: 'Pest PHP testing framework' },
+    'nunomaduro/larastan': { category: 'quality', name: 'Larastan (PHPStan for Laravel)' },
+};
+// ─── Node.js: npm/bun dependency map ───────────────────────────────────────
+const NPM_PACKAGES = {
+    // Frameworks
+    'next': { category: 'framework', name: 'Next.js framework' },
+    'nuxt': { category: 'framework', name: 'Nuxt framework' },
+    'astro': { category: 'framework', name: 'Astro framework' },
+    'express': { category: 'framework', name: 'Express.js server' },
+    'fastify': { category: 'framework', name: 'Fastify server' },
+    'hono': { category: 'framework', name: 'Hono lightweight framework' },
+    // Frontend
+    'react': { category: 'frontend', name: 'React library' },
+    'vue': { category: 'frontend', name: 'Vue.js framework' },
+    'svelte': { category: 'frontend', name: 'Svelte framework' },
+    '@sveltejs/kit': { category: 'frontend', name: 'SvelteKit framework' },
+    'tailwindcss': { category: 'frontend', name: 'TailwindCSS styling' },
+    '@tanstack/react-query': { category: 'data', name: 'TanStack Query for data fetching' },
+    'react-hook-form': { category: 'forms', name: 'React Hook Form' },
+    // UI
+    'sonner': { category: 'ui', name: 'Sonner toast notifications' },
+    'framer-motion': { category: 'ui', name: 'Framer Motion animations' },
+    'shadcn-ui': { category: 'ui', name: 'shadcn/ui components' },
+    '@radix-ui/react-dialog': { category: 'ui', name: 'Radix UI primitives' },
+    // API
+    '@trpc/server': { category: 'api', name: 'tRPC type-safe API' },
+    // Validation
+    'zod': { category: 'validation', name: 'Zod schema validation' },
+    // Database — MongoDB
+    'mongoose': { category: 'database', name: 'Mongoose (MongoDB)' },
+    // Database — PostgreSQL
+    'pg': { category: 'database', name: 'pg (PostgreSQL client)' },
+    '@neondatabase/serverless': { category: 'database', name: 'Neon serverless PostgreSQL' },
+    '@vercel/postgres': { category: 'database', name: 'Vercel Postgres' },
+    // Database — MySQL
+    'mysql2': { category: 'database', name: 'mysql2 (MySQL client)' },
+    '@planetscale/database': { category: 'database', name: 'PlanetScale MySQL' },
+    // Database — SQLite / Turso
+    'better-sqlite3': { category: 'database', name: 'better-sqlite3 (SQLite)' },
+    '@libsql/client': { category: 'database', name: 'libSQL / Turso client' },
+    // Database — ORMs
+    'prisma': { category: 'database', name: 'Prisma ORM' },
+    '@prisma/client': { category: 'database', name: 'Prisma Client' },
+    'drizzle-orm': { category: 'database', name: 'Drizzle ORM' },
+    'typeorm': { category: 'database', name: 'TypeORM' },
+    'sequelize': { category: 'database', name: 'Sequelize ORM' },
+    'kysely': { category: 'database', name: 'Kysely query builder' },
+    // Cache / Redis
+    'ioredis': { category: 'cache', name: 'Redis client (ioredis)' },
+    '@upstash/redis': { category: 'cache', name: 'Upstash Redis (serverless)' },
+    'redis': { category: 'cache', name: 'Redis client (node-redis)' },
+    // Auth
+    '@auth/core': { category: 'auth', name: 'Auth.js authentication' },
+    'next-auth': { category: 'auth', name: 'NextAuth.js authentication' },
+    'lucia': { category: 'auth', name: 'Lucia auth library' },
+    '@clerk/nextjs': { category: 'auth', name: 'Clerk authentication' },
+    // Testing
+    'vitest': { category: 'testing', name: 'Vitest testing framework' },
+    'jest': { category: 'testing', name: 'Jest testing framework' },
+    'playwright': { category: 'testing', name: 'Playwright E2E testing' },
+    '@playwright/test': { category: 'testing', name: 'Playwright test runner' },
+    'cypress': { category: 'testing', name: 'Cypress E2E testing' },
+    // Quality
+    'eslint': { category: 'quality', name: 'ESLint linting' },
+    'prettier': { category: 'quality', name: 'Prettier code formatting' },
+    'husky': { category: 'quality', name: 'Husky git hooks' },
+    'lint-staged': { category: 'quality', name: 'lint-staged pre-commit' },
+    // Billing
+    'stripe': { category: 'billing', name: 'Stripe payments' },
+    // Queue
+    'bullmq': { category: 'queue', name: 'BullMQ job queue' },
+    // Realtime
+    'socket.io': { category: 'realtime', name: 'Socket.IO realtime' },
+    'pusher': { category: 'realtime', name: 'Pusher realtime' },
+    'pusher-js': { category: 'realtime', name: 'Pusher JS client' },
+    // Media
+    'uploadthing': { category: 'media', name: 'UploadThing file uploads' },
+    'sharp': { category: 'media', name: 'Sharp image processing' },
+};
+function readFileIfExists(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function scanCursorRules(projectDir) {
+    const content = readFileIfExists(join(projectDir, '.cursorrules'));
+    if (!content)
+        return null;
+    const patterns = [];
+    const sectionRegex = /^##\s+(.+)/gm;
+    let match;
+    while ((match = sectionRegex.exec(content)) !== null) {
+        patterns.push({
+            category: 'coding-style',
+            name: `Cursor rule section: ${match[1].trim()}`,
+            confidence: 90,
+        });
+    }
+    if (/octane/i.test(content)) {
+        patterns.push({ category: 'server', name: 'Octane patterns defined in .cursorrules', confidence: 95 });
+    }
+    if (/inertia/i.test(content)) {
+        patterns.push({ category: 'frontend', name: 'Inertia.js patterns defined in .cursorrules', confidence: 95 });
+    }
+    if (/sanctum/i.test(content)) {
+        patterns.push({ category: 'auth', name: 'Sanctum auth patterns defined in .cursorrules', confidence: 95 });
+    }
+    if (/uuid/i.test(content)) {
+        patterns.push({ category: 'database', name: 'UUIDs as primary keys', confidence: 90 });
+    }
+    if (/snake_case/i.test(content) || /camelCase/i.test(content)) {
+        patterns.push({ category: 'coding-style', name: 'Naming conventions defined', confidence: 85 });
+    }
+    if (/tailwind/i.test(content)) {
+        patterns.push({ category: 'frontend', name: 'TailwindCSS styling', confidence: 90 });
+    }
+    if (/react/i.test(content)) {
+        patterns.push({ category: 'frontend', name: 'ReactJS frontend', confidence: 90 });
+    }
+    if (/migration/i.test(content) && /never|forbidden|fresh/i.test(content)) {
+        patterns.push({ category: 'database', name: 'Migration safety rules defined', confidence: 95 });
+    }
+    if (patterns.length === 0)
+        return null;
+    return { source: '.cursorrules', patterns };
+}
+function scanComposerJson(projectDir) {
+    const content = readFileIfExists(join(projectDir, 'composer.json'));
+    if (!content)
+        return null;
+    let composer;
+    try {
+        composer = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    const patterns = [];
+    const allDeps = { ...composer.require, ...composer['require-dev'] };
+    for (const [pkg, meta] of Object.entries(COMPOSER_PACKAGES)) {
+        if (allDeps[pkg]) {
+            patterns.push({
+                category: meta.category,
+                name: meta.name,
+                confidence: 100,
+                detail: `${pkg}: ${allDeps[pkg]}`,
+            });
+        }
+    }
+    const phpVersion = allDeps['php'];
+    if (phpVersion) {
+        patterns.push({
+            category: 'runtime',
+            name: `PHP version constraint: ${phpVersion}`,
+            confidence: 100,
+        });
+    }
+    if (patterns.length === 0)
+        return null;
+    return { source: 'composer.json', patterns };
+}
+function scanPhpStan(projectDir) {
+    const content = readFileIfExists(join(projectDir, 'phpstan.neon')) ||
+        readFileIfExists(join(projectDir, 'phpstan.neon.dist'));
+    if (!content)
+        return null;
+    const patterns = [];
+    const levelMatch = content.match(/level:\s*(\d+|max)/);
+    if (levelMatch) {
+        patterns.push({
+            category: 'quality',
+            name: `PHPStan level: ${levelMatch[1]}`,
+            confidence: 100,
+            detail: `level: ${levelMatch[1]}`,
+        });
+    }
+    const baselineMatch = content.match(/baseline/i);
+    if (baselineMatch) {
+        patterns.push({
+            category: 'quality',
+            name: 'PHPStan baseline in use',
+            confidence: 90,
+        });
+    }
+    if (patterns.length === 0)
+        return null;
+    return { source: 'phpstan.neon', patterns };
+}
+// ─── Node.js Scanners ──────────────────────────────────────────────────────
+function scanPackageJson(projectDir) {
+    const content = readFileIfExists(join(projectDir, 'package.json'));
+    if (!content)
+        return null;
+    let pkg;
+    try {
+        pkg = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    const patterns = [];
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const [dep, meta] of Object.entries(NPM_PACKAGES)) {
+        if (allDeps[dep]) {
+            patterns.push({
+                category: meta.category,
+                name: meta.name,
+                confidence: 100,
+                detail: `${dep}: ${allDeps[dep]}`,
+            });
+        }
+    }
+    const nodeVersion = pkg.engines?.['node'];
+    if (nodeVersion) {
+        patterns.push({
+            category: 'runtime',
+            name: `Node.js version constraint: ${nodeVersion}`,
+            confidence: 100,
+        });
+    }
+    const bunVersion = pkg.engines?.['bun'];
+    if (bunVersion) {
+        patterns.push({
+            category: 'runtime',
+            name: `Bun version constraint: ${bunVersion}`,
+            confidence: 100,
+        });
+    }
+    if (pkg.scripts) {
+        if (pkg.scripts['typecheck'] || pkg.scripts['type-check']) {
+            patterns.push({ category: 'quality', name: 'TypeScript type checking configured', confidence: 90 });
+        }
+        if (pkg.scripts['lint']) {
+            patterns.push({ category: 'quality', name: 'Lint script configured', confidence: 85 });
+        }
+        if (pkg.scripts['test']) {
+            patterns.push({ category: 'testing', name: 'Test script configured', confidence: 85 });
+        }
+    }
+    if (patterns.length === 0)
+        return null;
+    return { source: 'package.json', patterns };
+}
+function scanTsConfig(projectDir) {
+    const content = readFileIfExists(join(projectDir, 'tsconfig.json'));
+    if (!content)
+        return null;
+    const patterns = [];
+    if (/"strict"\s*:\s*true/i.test(content)) {
+        patterns.push({ category: 'quality', name: 'TypeScript strict mode enabled', confidence: 100 });
+    }
+    if (/"paths"\s*:/i.test(content)) {
+        patterns.push({ category: 'coding-style', name: 'Path aliases configured', confidence: 90 });
+    }
+    const targetMatch = content.match(/"target"\s*:\s*"(\w+)"/i);
+    if (targetMatch) {
+        patterns.push({
+            category: 'runtime',
+            name: `TypeScript target: ${targetMatch[1]}`,
+            confidence: 95,
+            detail: `target: ${targetMatch[1]}`,
+        });
+    }
+    if (/"noUncheckedIndexedAccess"\s*:\s*true/i.test(content)) {
+        patterns.push({ category: 'quality', name: 'Strict index access enabled', confidence: 95 });
+    }
+    if (patterns.length === 0)
+        return null;
+    return { source: 'tsconfig.json', patterns };
+}
+function scanEslintConfig(projectDir) {
+    const configFiles = [
+        'eslint.config.js', 'eslint.config.mjs', 'eslint.config.ts',
+        '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json', '.eslintrc.yml',
+    ];
+    let found = false;
+    for (const file of configFiles) {
+        if (existsSync(join(projectDir, file))) {
+            found = true;
+            break;
+        }
+    }
+    if (!found)
+        return null;
+    return {
+        source: 'eslint config',
+        patterns: [
+            { category: 'quality', name: 'ESLint config present', confidence: 100 },
+        ],
+    };
+}
+// ─── Shared Scanners ───────────────────────────────────────────────────────
+function scanProjectFiles(projectDir) {
+    const patterns = [];
+    if (existsSync(join(projectDir, 'rr.yaml')) || existsSync(join(projectDir, '.rr.yaml'))) {
+        patterns.push({ category: 'server', name: 'RoadRunner config present (Octane)', confidence: 100 });
+    }
+    const csFixerExists = existsSync(join(projectDir, '.php-cs-fixer.php')) ||
+        existsSync(join(projectDir, '.php-cs-fixer.dist.php'));
+    if (csFixerExists) {
+        patterns.push({ category: 'quality', name: 'PHP-CS-Fixer config present', confidence: 100 });
+    }
+    const phpunitExists = existsSync(join(projectDir, 'phpunit.xml')) ||
+        existsSync(join(projectDir, 'phpunit.xml.dist'));
+    if (phpunitExists) {
+        patterns.push({ category: 'testing', name: 'PHPUnit config present', confidence: 100 });
+    }
+    const dockerExists = existsSync(join(projectDir, 'docker-compose.yml')) ||
+        existsSync(join(projectDir, 'docker-compose.yaml'));
+    if (dockerExists) {
+        patterns.push({ category: 'deploy', name: 'Docker Compose setup present', confidence: 90 });
+    }
+    // ── Node.js: Framework configs ──
+    const nextConfigExists = existsSync(join(projectDir, 'next.config.js')) ||
+        existsSync(join(projectDir, 'next.config.mjs')) ||
+        existsSync(join(projectDir, 'next.config.ts'));
+    if (nextConfigExists) {
+        patterns.push({ category: 'framework', name: 'Next.js config present', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'nuxt.config.ts')) || existsSync(join(projectDir, 'nuxt.config.js'))) {
+        patterns.push({ category: 'framework', name: 'Nuxt config present', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'astro.config.mjs')) || existsSync(join(projectDir, 'astro.config.ts'))) {
+        patterns.push({ category: 'framework', name: 'Astro config present', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'svelte.config.js')) || existsSync(join(projectDir, 'svelte.config.ts'))) {
+        patterns.push({ category: 'framework', name: 'SvelteKit config present', confidence: 100 });
+    }
+    // ── Node.js: Frontend & UI ──
+    if (existsSync(join(projectDir, 'tailwind.config.ts')) || existsSync(join(projectDir, 'tailwind.config.js'))) {
+        patterns.push({ category: 'frontend', name: 'TailwindCSS config present', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'postcss.config.js')) || existsSync(join(projectDir, 'postcss.config.mjs'))) {
+        patterns.push({ category: 'frontend', name: 'PostCSS config present', confidence: 85 });
+    }
+    if (existsSync(join(projectDir, 'components.json'))) {
+        patterns.push({ category: 'ui', name: 'shadcn/ui components.json present', confidence: 95 });
+    }
+    // ── Node.js: Database configs ──
+    if (existsSync(join(projectDir, 'prisma/schema.prisma'))) {
+        patterns.push({ category: 'database', name: 'Prisma schema present', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'drizzle.config.ts')) || existsSync(join(projectDir, 'drizzle.config.js'))) {
+        patterns.push({ category: 'database', name: 'Drizzle config present', confidence: 100 });
+    }
+    // ── Node.js: Testing configs ──
+    if (existsSync(join(projectDir, 'vitest.config.ts')) || existsSync(join(projectDir, 'vitest.config.js'))) {
+        patterns.push({ category: 'testing', name: 'Vitest config present', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'playwright.config.ts'))) {
+        patterns.push({ category: 'testing', name: 'Playwright config present', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'cypress.config.ts')) || existsSync(join(projectDir, 'cypress.config.js'))) {
+        patterns.push({ category: 'testing', name: 'Cypress config present', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'jest.config.ts')) || existsSync(join(projectDir, 'jest.config.js'))) {
+        patterns.push({ category: 'testing', name: 'Jest config present', confidence: 100 });
+    }
+    // ── Node.js: Package manager ──
+    if (existsSync(join(projectDir, 'bun.lockb')) || existsSync(join(projectDir, 'bun.lock'))) {
+        patterns.push({ category: 'runtime', name: 'Bun package manager in use', confidence: 100 });
+    }
+    else if (existsSync(join(projectDir, 'pnpm-lock.yaml'))) {
+        patterns.push({ category: 'runtime', name: 'pnpm package manager in use', confidence: 100 });
+    }
+    else if (existsSync(join(projectDir, 'yarn.lock'))) {
+        patterns.push({ category: 'runtime', name: 'Yarn package manager in use', confidence: 100 });
+    }
+    // ── Deploy targets ──
+    if (existsSync(join(projectDir, 'vercel.json'))) {
+        patterns.push({ category: 'deploy', name: 'Vercel deployment config', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'netlify.toml'))) {
+        patterns.push({ category: 'deploy', name: 'Netlify deployment config', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'fly.toml'))) {
+        patterns.push({ category: 'deploy', name: 'Fly.io deployment config', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'railway.toml')) || existsSync(join(projectDir, 'railway.json'))) {
+        patterns.push({ category: 'deploy', name: 'Railway deployment config', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, 'Dockerfile'))) {
+        patterns.push({ category: 'deploy', name: 'Dockerfile present', confidence: 95 });
+    }
+    // ── Quality / Git hooks ──
+    if (existsSync(join(projectDir, '.husky'))) {
+        patterns.push({ category: 'quality', name: 'Husky git hooks configured', confidence: 100 });
+    }
+    if (existsSync(join(projectDir, '.lintstagedrc')) || existsSync(join(projectDir, '.lintstagedrc.json'))) {
+        patterns.push({ category: 'quality', name: 'lint-staged config present', confidence: 95 });
+    }
+    if (existsSync(join(projectDir, '.prettierrc')) || existsSync(join(projectDir, '.prettierrc.json')) || existsSync(join(projectDir, 'prettier.config.js'))) {
+        patterns.push({ category: 'quality', name: 'Prettier config present', confidence: 100 });
+    }
+    // Environment files (works for both PHP and Node.js projects)
+    const envContent = readFileIfExists(join(projectDir, '.env.example')) ||
+        readFileIfExists(join(projectDir, '.env'));
+    if (envContent) {
+        if (/REDIS_HOST|REDIS_URL/i.test(envContent)) {
+            patterns.push({ category: 'cache', name: 'Redis configured', confidence: 85 });
+        }
+        if (/PUSHER_|BROADCAST_|NEXT_PUBLIC_PUSHER/i.test(envContent)) {
+            patterns.push({ category: 'realtime', name: 'Broadcasting/Pusher configured', confidence: 80 });
+        }
+        if (/MAIL_MAILER|RESEND_API|SENDGRID/i.test(envContent)) {
+            patterns.push({ category: 'mail', name: 'Mail service configured', confidence: 75 });
+        }
+        if (/DATABASE_URL|DB_CONNECTION/i.test(envContent)) {
+            patterns.push({ category: 'database', name: 'Database connection configured', confidence: 80 });
+        }
+        if (/STRIPE_SECRET|STRIPE_KEY/i.test(envContent)) {
+            patterns.push({ category: 'billing', name: 'Stripe payments configured', confidence: 85 });
+        }
+    }
+    if (patterns.length === 0)
+        return null;
+    return { source: 'project files', patterns };
+}
+/**
+ * Run all scanners against a project directory.
+ * Returns combined results from all sources.
+ */
+export function scanProjectStandards(projectDir) {
+    const scanners = [
+        scanCursorRules,
+        scanComposerJson,
+        scanPhpStan,
+        scanPackageJson,
+        scanTsConfig,
+        scanEslintConfig,
+        scanProjectFiles,
+    ];
+    const results = [];
+    for (const scanner of scanners) {
+        const result = scanner(projectDir);
+        if (result) {
+            results.push(result);
+        }
+    }
+    const allPatterns = results.flatMap((r) => r.patterns);
+    const sources = results.map((r) => r.source);
+    return {
+        status: results.length > 0 ? 'pending' : 'defaults',
+        scannedAt: new Date().toISOString().split('T')[0],
+        sources,
+        patterns: allPatterns,
+        userChoice: 'pending',
+    };
+}