@elyracode/laravel 0.7.12

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## [0.7.12] - 2026-05-24
+
+### Added
+- `laravel_models` tool: map all Eloquent models with relationships, casts, scopes, and traits
+- `laravel_routes` tool: route listing with middleware, controllers, and request classes
+- `laravel_analyze` tool: project architecture analysis (stack, patterns, conventions)
+- `elyra-laravel` skill: Laravel conventions and best practices

package/README.md

@@ -0,0 +1,25 @@
+# @elyracode/laravel
+
+Deep Laravel project understanding for Elyra. Gives the agent x-ray vision into your models, routes, and architecture so it generates code that matches your project's conventions.
+
+## Install
+
+```bash
+elyra install npm:@elyracode/laravel
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `laravel_models` | Map all Eloquent models with relationships, casts, scopes, traits, and fillable fields |
+| `laravel_routes` | List routes with middleware, controllers, form requests, and resources |
+| `laravel_analyze` | Analyze project architecture: stack, patterns, auth, queue, conventions |
+
+## Why
+
+Other coding agents read Laravel files one at a time and guess at conventions. With these tools, the agent sees your entire data model and architecture before writing a single line — fewer wrong guesses, fewer wasted tokens, code that matches your project.
+
+## Included Skill
+
+The `elyra-laravel` skill provides deep knowledge of Laravel conventions, Eloquent patterns, common architectures, and best practices.

package/extensions/index.ts

@@ -0,0 +1,530 @@
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, join, relative } from "node:path";
+import type { ExtensionAPI } from "@elyracode/coding-agent";
+import { Type } from "typebox";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function isLaravelProject(cwd: string): boolean {
+	const composerPath = join(cwd, "composer.json");
+	if (!existsSync(composerPath)) return false;
+	try {
+		const composer = JSON.parse(readFileSync(composerPath, "utf-8")) as Record<string, unknown>;
+		const require = composer.require as Record<string, string> | undefined;
+		return Boolean(require?.["laravel/framework"]);
+	} catch {
+		return false;
+	}
+}
+
+function readPhpFile(filePath: string): string {
+	try {
+		return readFileSync(filePath, "utf-8");
+	} catch {
+		return "";
+	}
+}
+
+function findPhpFiles(dir: string, maxDepth = 5): string[] {
+	const results: string[] = [];
+	if (!existsSync(dir)) return results;
+
+	function walk(current: string, depth: number): void {
+		if (depth > maxDepth) return;
+		let entries: string[];
+		try {
+			entries = readdirSync(current);
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry.startsWith(".")) continue;
+			const full = join(current, entry);
+			try {
+				const stat = statSync(full);
+				if (stat.isDirectory()) {
+					walk(full, depth + 1);
+				} else if (entry.endsWith(".php")) {
+					results.push(full);
+				}
+			} catch {
+				// skip
+			}
+		}
+	}
+	walk(dir, 0);
+	return results;
+}
+
+function artisan(cwd: string, args: string, timeoutMs = 15_000): string {
+	try {
+		return execSync(`php artisan ${args}`, {
+			cwd,
+			encoding: "utf-8",
+			timeout: timeoutMs,
+			stdio: ["ignore", "pipe", "pipe"],
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+
+// ── Model Parser ────────────────────────────────────────────────────────────
+
+interface ModelInfo {
+	name: string;
+	path: string;
+	relationships: Array<{ type: string; related: string; method: string }>;
+	fillable: string[];
+	casts: string[];
+	scopes: string[];
+	traits: string[];
+	implements: string[];
+	useSoftDeletes: boolean;
+}
+
+function parseModel(filePath: string, cwd: string): ModelInfo | null {
+	const content = readPhpFile(filePath);
+	if (!content.includes("extends Model") && !content.includes("extends Authenticatable")) return null;
+
+	const nameMatch = content.match(/class\s+(\w+)\s+extends/);
+	if (!nameMatch) return null;
+
+	const name = nameMatch[1];
+	const relPath = relative(cwd, filePath);
+
+	// Relationships
+	const relationships: ModelInfo["relationships"] = [];
+	const relRegex =
+		/(?:public\s+)?function\s+(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{[^}]*\$this->(hasOne|hasMany|belongsTo|belongsToMany|hasManyThrough|hasOneThrough|morphOne|morphMany|morphToMany|morphTo|morphedByMany)\s*\(\s*(?:\\?[\w\\]*\\)?(\w+)::class/g;
+	let relMatch: RegExpExecArray | null = null;
+	while ((relMatch = relRegex.exec(content)) !== null) {
+		relationships.push({
+			method: relMatch[1],
+			type: relMatch[2],
+			related: relMatch[3],
+		});
+	}
+
+	// Fillable
+	const fillable: string[] = [];
+	const fillableMatch = content.match(/\$fillable\s*=\s*\[([\s\S]*?)\]/);
+	if (fillableMatch) {
+		const items = fillableMatch[1].match(/'([^']+)'/g);
+		if (items) {
+			for (const item of items) fillable.push(item.replace(/'/g, ""));
+		}
+	}
+
+	// Casts
+	const casts: string[] = [];
+	const castsMatch = content.match(/(?:protected\s+function\s+casts\s*\(\)[\s\S]*?return\s*\[([\s\S]*?)\]|\$casts\s*=\s*\[([\s\S]*?)\])/);
+	if (castsMatch) {
+		const castBlock = castsMatch[1] ?? castsMatch[2] ?? "";
+		const castItems = castBlock.match(/'(\w+)'\s*=>\s*'?([^',\]]+)/g);
+		if (castItems) {
+			for (const item of castItems) {
+				const parts = item.match(/'(\w+)'\s*=>\s*'?([^',\]]+)/);
+				if (parts) casts.push(`${parts[1]} (${parts[2].trim().replace(/'/g, "")})`);
+			}
+		}
+	}
+
+	// Scopes
+	const scopes: string[] = [];
+	const scopeRegex = /function\s+scope(\w+)\s*\(/g;
+	let scopeMatch: RegExpExecArray | null = null;
+	while ((scopeMatch = scopeRegex.exec(content)) !== null) {
+		scopes.push(scopeMatch[1].charAt(0).toLowerCase() + scopeMatch[1].slice(1));
+	}
+
+	// Traits
+	const traits: string[] = [];
+	const useRegex = /use\s+([\w\\]+(?:\s*,\s*[\w\\]+)*)\s*;/g;
+	let useMatch: RegExpExecArray | null = null;
+	while ((useMatch = useRegex.exec(content)) !== null) {
+		// Only traits inside the class body (after 'class X extends')
+		if (content.indexOf(useMatch[0]) > content.indexOf("extends")) {
+			const traitNames = useMatch[1].split(",").map((t) => {
+				const parts = t.trim().split("\\");
+				return parts[parts.length - 1];
+			});
+			traits.push(...traitNames);
+		}
+	}
+
+	const useSoftDeletes = traits.includes("SoftDeletes");
+
+	// Implements
+	const implMatch = content.match(/implements\s+([\w\\,\s]+)/);
+	const implements_: string[] = [];
+	if (implMatch) {
+		implements_.push(
+			...implMatch[1].split(",").map((i) => {
+				const parts = i.trim().split("\\");
+				return parts[parts.length - 1];
+			}),
+		);
+	}
+
+	return {
+		name,
+		path: relPath,
+		relationships,
+		fillable,
+		casts,
+		scopes,
+		traits: traits.filter((t) => t !== ""),
+		implements: implements_,
+		useSoftDeletes,
+	};
+}
+
+function formatModels(models: ModelInfo[]): string {
+	if (models.length === 0) return "No Eloquent models found.";
+
+	const lines: string[] = [`${models.length} Eloquent models found:\n`];
+
+	for (const model of models) {
+		lines.push(`${model.name} (${model.path})`);
+
+		if (model.relationships.length > 0) {
+			for (const rel of model.relationships) {
+				lines.push(`  ${rel.type}: ${rel.related} (via ${rel.method}())`);
+			}
+		}
+		if (model.fillable.length > 0) {
+			lines.push(`  fillable: ${model.fillable.join(", ")}`);
+		}
+		if (model.casts.length > 0) {
+			lines.push(`  casts: ${model.casts.join(", ")}`);
+		}
+		if (model.scopes.length > 0) {
+			lines.push(`  scopes: ${model.scopes.join(", ")}`);
+		}
+		if (model.traits.length > 0) {
+			lines.push(`  traits: ${model.traits.join(", ")}`);
+		}
+		if (model.implements.length > 0) {
+			lines.push(`  implements: ${model.implements.join(", ")}`);
+		}
+		lines.push("");
+	}
+
+	return lines.join("\n");
+}
+
+// ── Route Parser ────────────────────────────────────────────────────────────
+
+function parseRoutes(cwd: string, prefix?: string): string {
+	let args = "route:list --json";
+	if (prefix) args += ` --path=${prefix}`;
+
+	const output = artisan(cwd, args);
+	if (!output) return "Could not fetch routes. Is php artisan available?";
+
+	try {
+		const routes = JSON.parse(output) as Array<{
+			method: string;
+			uri: string;
+			name: string | null;
+			action: string;
+			middleware: string[] | string;
+		}>;
+
+		if (routes.length === 0) return prefix ? `No routes matching prefix "${prefix}".` : "No routes defined.";
+
+		const lines: string[] = [`${routes.length} routes:\n`];
+
+		for (const route of routes) {
+			const methods = route.method.toUpperCase();
+			const mw = Array.isArray(route.middleware)
+				? route.middleware.join(", ")
+				: route.middleware || "";
+
+			lines.push(`${methods} /${route.uri}`);
+			if (route.name) lines.push(`  name: ${route.name}`);
+			lines.push(`  action: ${route.action}`);
+			if (mw) lines.push(`  middleware: ${mw}`);
+			lines.push("");
+		}
+
+		return lines.join("\n");
+	} catch {
+		return "Could not parse route list output.";
+	}
+}
+
+// ── Project Analyzer ────────────────────────────────────────────────────────
+
+function analyzeProject(cwd: string, models: ModelInfo[]): string {
+	const lines: string[] = [];
+
+	// Laravel version
+	const composerLock = join(cwd, "composer.lock");
+	let laravelVersion = "unknown";
+	if (existsSync(composerLock)) {
+		try {
+			const lock = JSON.parse(readFileSync(composerLock, "utf-8")) as {
+				packages: Array<{ name: string; version: string }>;
+			};
+			const laravel = lock.packages.find((p) => p.name === "laravel/framework");
+			if (laravel) laravelVersion = laravel.version;
+		} catch {
+			// skip
+		}
+	}
+
+	// Detect stack
+	const composer = JSON.parse(readFileSync(join(cwd, "composer.json"), "utf-8")) as Record<string, unknown>;
+	const require = { ...(composer.require as Record<string, string> ?? {}), ...(composer["require-dev"] as Record<string, string> ?? {}) };
+	const packageJson = existsSync(join(cwd, "package.json"))
+		? (JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8")) as Record<string, unknown>)
+		: null;
+	const npmDeps = packageJson
+		? { ...(packageJson.dependencies as Record<string, string> ?? {}), ...(packageJson.devDependencies as Record<string, string> ?? {}) }
+		: {};
+
+	const stack: string[] = [`Laravel ${laravelVersion}`];
+	if (require["livewire/livewire"]) stack.push("Livewire");
+	if (require["inertiajs/inertia-laravel"]) stack.push("Inertia");
+	if (require["laravel/sanctum"]) stack.push("Sanctum");
+	if (require["laravel/passport"]) stack.push("Passport");
+	if (require["filament/filament"]) stack.push("Filament");
+	if (npmDeps.vue) stack.push("Vue");
+	if (npmDeps.react) stack.push("React");
+	if (npmDeps.svelte) stack.push("Svelte");
+	if (npmDeps.tailwindcss || npmDeps["@tailwindcss/vite"]) stack.push("Tailwind");
+	if (npmDeps.alpinejs) stack.push("Alpine.js");
+
+	lines.push(`Stack: ${stack.join(" + ")}`);
+
+	// Auth
+	if (require["laravel/sanctum"]) lines.push("Auth: Sanctum");
+	else if (require["laravel/passport"]) lines.push("Auth: Passport");
+	else if (require["laravel/fortify"]) lines.push("Auth: Fortify");
+	else if (require["laravel/breeze"]) lines.push("Auth: Breeze");
+	else if (require["laravel/jetstream"]) lines.push("Auth: Jetstream");
+
+	// Queue/Cache
+	const envPath = join(cwd, ".env");
+	if (existsSync(envPath)) {
+		const env = readFileSync(envPath, "utf-8");
+		const queueMatch = env.match(/QUEUE_CONNECTION=(\w+)/);
+		const cacheMatch = env.match(/CACHE_STORE=(\w+)/);
+		const dbMatch = env.match(/DB_CONNECTION=(\w+)/);
+		if (queueMatch) lines.push(`Queue: ${queueMatch[1]}`);
+		if (cacheMatch) lines.push(`Cache: ${cacheMatch[1]}`);
+		if (dbMatch) lines.push(`Database: ${dbMatch[1]}`);
+	}
+
+	// Patterns detection
+	const patterns: string[] = [];
+	if (existsSync(join(cwd, "app/Actions"))) patterns.push("Action classes (app/Actions/)");
+	if (existsSync(join(cwd, "app/Services"))) patterns.push("Service classes (app/Services/)");
+	if (existsSync(join(cwd, "app/Repositories"))) patterns.push("Repository pattern (app/Repositories/)");
+	if (existsSync(join(cwd, "app/DTOs")) || existsSync(join(cwd, "app/DataTransferObjects"))) patterns.push("DTOs");
+	if (existsSync(join(cwd, "app/Enums"))) patterns.push("Enums (app/Enums/)");
+	if (existsSync(join(cwd, "app/Observers"))) patterns.push("Observers (app/Observers/)");
+	if (existsSync(join(cwd, "app/Events"))) patterns.push("Events (app/Events/)");
+	if (existsSync(join(cwd, "app/Listeners"))) patterns.push("Listeners (app/Listeners/)");
+	if (existsSync(join(cwd, "app/Jobs"))) patterns.push("Jobs (app/Jobs/)");
+
+	if (patterns.length > 0) {
+		lines.push(`Patterns: ${patterns.join(", ")}`);
+	}
+
+	// Controller style
+	const controllerDir = join(cwd, "app/Http/Controllers");
+	if (existsSync(controllerDir)) {
+		const controllers = findPhpFiles(controllerDir, 2);
+		let invokable = 0;
+		let resource = 0;
+		for (const c of controllers.slice(0, 20)) {
+			const content = readPhpFile(c);
+			if (content.includes("__invoke")) invokable++;
+			if (content.includes("function index") && content.includes("function store")) resource++;
+		}
+		if (invokable > resource && invokable > 0) {
+			lines.push("Controllers: primarily invokable (single-action)");
+		} else if (resource > 0) {
+			lines.push("Controllers: primarily resource-style");
+		}
+	}
+
+	// Models summary
+	lines.push(`Models: ${models.length}`);
+
+	// Migrations
+	const migrationDir = join(cwd, "database/migrations");
+	if (existsSync(migrationDir)) {
+		try {
+			const migrations = readdirSync(migrationDir).filter((f) => f.endsWith(".php"));
+			lines.push(`Migrations: ${migrations.length}`);
+		} catch {
+			// skip
+		}
+	}
+
+	// Factories
+	const factoryDir = join(cwd, "database/factories");
+	if (existsSync(factoryDir)) {
+		try {
+			const factories = readdirSync(factoryDir).filter((f) => f.endsWith(".php"));
+			const modelsWithoutFactory = models.filter(
+				(m) => !factories.some((f) => f.includes(m.name)),
+			);
+			lines.push(`Factories: ${factories.length}`);
+			if (modelsWithoutFactory.length > 0) {
+				lines.push(`Missing factories: ${modelsWithoutFactory.map((m) => m.name).join(", ")}`);
+			}
+		} catch {
+			// skip
+		}
+	}
+
+	// Tests
+	const testDir = join(cwd, "tests");
+	if (existsSync(testDir)) {
+		const testFiles = findPhpFiles(testDir);
+		const usesPest = testFiles.some((f) => readPhpFile(f).includes("it(") || readPhpFile(f).includes("test("));
+		lines.push(`Tests: ${testFiles.length} files (${usesPest ? "Pest" : "PHPUnit"})`);
+	}
+
+	// Pending migrations
+	const pendingOutput = artisan(cwd, "migrate:status --no-interaction 2>&1");
+	if (pendingOutput) {
+		const pending = (pendingOutput.match(/Pending/gi) ?? []).length;
+		if (pending > 0) {
+			lines.push(`Pending migrations: ${pending}`);
+		}
+	}
+
+	return lines.join("\n");
+}
+
+// ── Extension ───────────────────────────────────────────────────────────────
+
+export default function (elyra: ExtensionAPI): void {
+	let cwd = "";
+	let toolsRegistered = false;
+
+	elyra.on("session_start", async (_event, ctx) => {
+		cwd = ctx.cwd;
+
+		// Only register tools when running inside a Laravel project
+		if (!toolsRegistered && isLaravelProject(getCwd())) {
+			toolsRegistered = true;
+			registerTools(elyra, () => cwd);
+		}
+	});
+}
+
+function registerTools(elyra: ExtensionAPI, getCwd: () => string): void {
+
+	// ── laravel_models ───────────────────────────────────────────────────
+
+	const modelsSchema = Type.Object({
+		filter: Type.Optional(
+			Type.String({ description: "Filter models by name (case-insensitive substring match)" }),
+		),
+	});
+
+	elyra.registerTool({
+		name: "laravel_models",
+		label: "Laravel Models",
+		description:
+			"Map all Eloquent models in the project with their relationships, fillable fields, casts, scopes, and traits. Returns a complete data model overview. Use this before generating code that involves database models.",
+		parameters: modelsSchema,
+		promptSnippet: "Map all Eloquent models with relationships and structure",
+		async execute(_toolCallId, params) {
+			if (!isLaravelProject(getCwd())) {
+				return { content: [{ type: "text", text: "Not a Laravel project (no laravel/framework in composer.json)" }], isError: true };
+			}
+
+			const modelDirs = [
+				join(getCwd(), "app/Models"),
+				join(getCwd(), "app"), // Laravel < 8 style
+			];
+
+			const allModels: ModelInfo[] = [];
+			const seen = new Set<string>();
+
+			for (const dir of modelDirs) {
+				const files = findPhpFiles(dir, 3);
+				for (const file of files) {
+					const model = parseModel(file, getCwd());
+					if (model && !seen.has(model.name)) {
+						seen.add(model.name);
+						if (!params.filter || model.name.toLowerCase().includes(params.filter.toLowerCase())) {
+							allModels.push(model);
+						}
+					}
+				}
+			}
+
+			allModels.sort((a, b) => a.name.localeCompare(b.name));
+			return { content: [{ type: "text", text: formatModels(allModels) }] };
+		},
+	});
+
+	// ── laravel_routes ───────────────────────────────────────────────────
+
+	const routesSchema = Type.Object({
+		prefix: Type.Optional(
+			Type.String({ description: "Filter routes by URI prefix (e.g. 'api', 'auth', 'admin')" }),
+		),
+	});
+
+	elyra.registerTool({
+		name: "laravel_routes",
+		label: "Laravel Routes",
+		description:
+			"List all registered routes with their HTTP methods, middleware, controller actions, and names. Requires php artisan to be available. Use this to understand the existing API surface before adding new routes.",
+		parameters: routesSchema,
+		promptSnippet: "List Laravel routes with middleware and controllers",
+		async execute(_toolCallId, params) {
+			if (!isLaravelProject(getCwd())) {
+				return { content: [{ type: "text", text: "Not a Laravel project" }], isError: true };
+			}
+			const result = parseRoutes(getCwd(), params.prefix);
+			return { content: [{ type: "text", text: result }] };
+		},
+	});
+
+	// ── laravel_analyze ──────────────────────────────────────────────────
+
+	const analyzeSchema = Type.Object({});
+
+	elyra.registerTool({
+		name: "laravel_analyze",
+		label: "Laravel Analyze",
+		description:
+			"Analyze the Laravel project architecture: framework version, stack (Livewire/Inertia/Vue/React), authentication method, patterns used (Actions/Services/Repositories), controller style, model count, test framework, and missing factories. Run this first when working on a Laravel project to understand conventions.",
+		parameters: analyzeSchema,
+		promptSnippet: "Analyze Laravel project architecture and conventions",
+		async execute() {
+			if (!isLaravelProject(getCwd())) {
+				return { content: [{ type: "text", text: "Not a Laravel project" }], isError: true };
+			}
+
+			// Parse models for the analysis
+			const modelDirs = [join(getCwd(), "app/Models"), join(getCwd(), "app")];
+			const allModels: ModelInfo[] = [];
+			const seen = new Set<string>();
+			for (const dir of modelDirs) {
+				for (const file of findPhpFiles(dir, 3)) {
+					const model = parseModel(file, getCwd());
+					if (model && !seen.has(model.name)) {
+						seen.add(model.name);
+						allModels.push(model);
+					}
+				}
+			}
+
+			const result = analyzeProject(getCwd(), allModels);
+			return { content: [{ type: "text", text: result }] };
+		},
+	});
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@elyracode/laravel",
+  "version": "0.7.12",
+  "description": "Deep Laravel project understanding for Elyra -- model relationships, route mapping, architecture analysis",
+  "type": "module",
+  "keywords": [
+    "elyra-package",
+    "laravel",
+    "eloquent",
+    "artisan",
+    "php"
+  ],
+  "license": "MIT",
+  "author": "Knut W. Horne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhorne/elyra.git",
+    "directory": "packages/laravel"
+  },
+  "elyra": {
+    "extensions": [
+      "./extensions/index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "peerDependencies": {
+    "@elyracode/coding-agent": "*",
+    "typebox": "*"
+  },
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'"
+  }
+}

package/skills/elyra-laravel/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: elyra-laravel
+description: Laravel project understanding. Use when the project has a composer.json with laravel/framework, or when the user asks about Eloquent models, routes, migrations, controllers, or any Laravel-specific topic.
+---
+
+# Laravel Development
+
+## When to Use
+
+Use Laravel tools when:
+- The project has `composer.json` with `laravel/framework`
+- The user asks about models, relationships, migrations, or database structure
+- The user wants to add a feature that touches multiple layers (model, controller, routes, tests)
+- You need to understand the existing architecture before generating code
+
+## Available Tools
+
+| Tool | Use when |
+|------|----------|
+| `laravel_models` | Understanding data model, relationships, and model structure before generating code |
+| `laravel_routes` | Understanding existing routes, middleware, and controllers before adding new endpoints |
+| `laravel_analyze` | Understanding project conventions and patterns before writing any code |
+
+## Key Principle
+
+Run `laravel_analyze` or `laravel_models` BEFORE generating Laravel code. Match the project's existing patterns — if it uses Actions, don't create Services. If controllers are invokable, don't create resource controllers.
+
+## Common Laravel Patterns
+
+| Pattern | Files | When used |
+|---------|-------|-----------|
+| Action classes | `app/Actions/` | Single-purpose business logic |
+| Service classes | `app/Services/` | Complex business logic |
+| Repository pattern | `app/Repositories/` | Database abstraction |
+| Form Requests | `app/Http/Requests/` | Input validation |
+| API Resources | `app/Http/Resources/` | Response transformation |
+| Policies | `app/Policies/` | Authorization |
+| Observers | `app/Observers/` | Model event hooks |
+| Enums | `app/Enums/` | Type-safe constants (PHP 8.1+) |
+
+## Eloquent Relationship Methods
+
+| Method | Meaning |
+|--------|---------|
+| `hasOne` | One-to-one (parent side) |
+| `belongsTo` | One-to-one/many inverse (child side) |
+| `hasMany` | One-to-many (parent side) |
+| `belongsToMany` | Many-to-many (either side, uses pivot table) |
+| `hasOneThrough` | One-to-one through intermediate model |
+| `hasManyThrough` | One-to-many through intermediate model |
+| `morphOne` | Polymorphic one-to-one |
+| `morphMany` | Polymorphic one-to-many |
+| `morphToMany` | Polymorphic many-to-many |
+| `morphTo` | Polymorphic inverse |
+
+## Migration Best Practices
+
+- Always create a migration with a new model
+- Use `$table->foreignId('user_id')->constrained()->cascadeOnDelete()`
+- Use `$table->timestamps()` on every table
+- Name pivot tables alphabetically: `post_tag` not `tag_post`
+- Add indexes on frequently queried columns
+
+## Testing Conventions
+
+- Use Pest for new Laravel 11+ projects
+- One test file per feature or model
+- Use factories for test data, never manual inserts
+- Name test methods descriptively: `it('creates a post with valid data')`
+
+## Feature Generation Checklist
+
+When adding a new feature, generate in this order:
+1. Migration
+2. Model (with relationships, casts, fillable)
+3. Factory
+4. Form Request (validation)
+5. Controller or Action
+6. API Resource (if API)
+7. Routes
+8. Policy (authorization)
+9. Tests