@elyracode/perf-tools 0.5.2

package/README.md

@@ -0,0 +1,29 @@
+# @elyracode/perf-tools
+
+Performance analysis for Elyra -- N+1 queries, slow queries, missing indexes.
+
+## Install
+
+```
+elyra install npm:@elyracode/perf-tools
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `analyze_queries` | Scan logs and code for N+1 patterns, repeated queries, missing eager loading, missing indexes |
+| `explain_query` | Run EXPLAIN on a SQL query to analyze execution plan |
+
+## Commands
+
+- `/perf` -- Run full performance analysis
+
+## Usage
+
+```
+> Analyze this project for N+1 queries
+> Find models that need eager loading
+> Explain this slow query: SELECT * FROM orders JOIN...
+/perf
+```

package/extensions/index.ts

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+import type { ExtensionAPI } from "@elyracode/coding-agent";
+import { Type } from "typebox";
+
+export default function (elyra: ExtensionAPI): void {
+
+	// ── Tool: analyze_queries ──
+	elyra.registerTool({
+		name: "analyze_queries",
+		label: "Analyze Database Queries",
+		description:
+			"Scan Laravel log files or source code for N+1 query patterns, " +
+			"repeated queries, and slow query candidates. " +
+			"Checks Eloquent models for missing eager loading, missing indexes, " +
+			"and common performance anti-patterns.",
+		parameters: Type.Object({
+			source: Type.Optional(
+				Type.Union([Type.Literal("logs"), Type.Literal("code"), Type.Literal("both")], {
+					description: "What to analyze: 'logs' (Laravel log file), 'code' (source scan), or 'both' (default)",
+				}),
+			),
+		}),
+		execute: async (_toolCallId, params) => {
+			try {
+				const cwd = process.cwd();
+				const source = params.source ?? "both";
+				const findings: string[] = ["# Query Performance Analysis", ""];
+
+				if (source === "logs" || source === "both") {
+					findings.push("## Log Analysis");
+					const logPath = join(cwd, "storage", "logs", "laravel.log");
+					if (existsSync(logPath)) {
+						const log = readFileSync(logPath, "utf-8");
+						const lastChunk = log.slice(-100000); // Last 100KB
+
+						// Find query patterns
+						const queryMatches = lastChunk.match(/\[\d{4}-.*?select.*?from/gi) ?? [];
+						const duplicates = findDuplicatePatterns(queryMatches);
+
+						if (duplicates.length > 0) {
+							findings.push(`Found ${duplicates.length} potentially repeated query patterns:`);
+							for (const dup of duplicates.slice(0, 10)) {
+								findings.push(`- ${dup.pattern} (${dup.count} times)`);
+							}
+						}
+
+						// Find slow queries (if debug bar data exists)
+						const slowMatches = lastChunk.match(/\[.*?\] .*?(\d+\.?\d*)ms.*?select/gi) ?? [];
+						const slowQueries = slowMatches.filter((m) => {
+							const ms = m.match(/(\d+\.?\d*)ms/)?.[1];
+							return ms && parseFloat(ms) > 100;
+						});
+						if (slowQueries.length > 0) {
+							findings.push("", `Slow queries (>100ms): ${slowQueries.length}`);
+							for (const q of slowQueries.slice(0, 5)) {
+								findings.push(`- ${q.slice(0, 200)}`);
+							}
+						}
+
+						if (duplicates.length === 0 && slowQueries.length === 0) {
+							findings.push("No obvious query issues found in logs.");
+						}
+					} else {
+						findings.push("Laravel log file not found at storage/logs/laravel.log");
+					}
+					findings.push("");
+				}
+
+				if (source === "code" || source === "both") {
+					findings.push("## Code Analysis");
+
+					// Scan for N+1 patterns
+					try {
+						const n1Patterns = execSync(
+							`grep -rn --include="*.php" -E "->\\w+\\b" app/ | grep -v vendor | grep -v "->where\\|->select\\|->join\\|->with\\|->load" | grep "foreach\\|each\\|map\\|->get()\\|->all()" | head -20`,
+							{ cwd, timeout: 15000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+						).trim();
+						if (n1Patterns) {
+							findings.push("### Potential N+1 Query Patterns");
+							findings.push("Files accessing relationships inside loops without eager loading:");
+							findings.push("```");
+							findings.push(n1Patterns);
+							findings.push("```");
+						}
+					} catch { /* no matches */ }
+
+					// Find models without $with or common relationship loading
+					try {
+						const models = execSync(
+							`grep -rl --include="*.php" "extends Model" app/ 2>/dev/null | head -20`,
+							{ cwd, timeout: 10000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+						).trim();
+						if (models) {
+							const modelFiles = models.split("\n").filter((l) => l.trim());
+							const missingWith: string[] = [];
+							for (const modelFile of modelFiles) {
+								const modelContent = readFileSync(join(cwd, modelFile), "utf-8");
+								const hasRelationships = /function\s+\w+\(\).*?(?:hasMany|belongsTo|hasOne|belongsToMany|morphTo|morphMany)/s.test(modelContent);
+								const hasDefaultWith = /\$with\s*=\s*\[/.test(modelContent);
+								if (hasRelationships && !hasDefaultWith) {
+									missingWith.push(modelFile);
+								}
+							}
+							if (missingWith.length > 0) {
+								findings.push("", "### Models with Relationships but no $with Default");
+								findings.push("Consider adding `protected $with = [...]` for commonly loaded relationships:");
+								for (const f of missingWith) {
+									findings.push(`- ${f}`);
+								}
+							}
+						}
+					} catch { /* ignore */ }
+
+					// Find missing indexes (check migrations for foreign keys without indexes)
+					try {
+						const migrations = execSync(
+							`grep -rn --include="*.php" "foreignId\\|->foreign\\|references(" database/migrations/ 2>/dev/null | head -20`,
+							{ cwd, timeout: 10000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+						).trim();
+						if (migrations) {
+							findings.push("", "### Foreign Keys (verify indexes exist)");
+							findings.push("These migrations define foreign keys -- ensure corresponding indexes exist:");
+							findings.push("```");
+							findings.push(migrations);
+							findings.push("```");
+						}
+					} catch { /* ignore */ }
+
+					findings.push("");
+				}
+
+				return {
+					content: [{ type: "text", text: findings.join("\n") }],
+					details: {},
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Performance analysis failed: ${msg}` }],
+					details: {},
+				};
+			}
+		},
+	});
+
+	// ── Tool: explain_query ──
+	elyra.registerTool({
+		name: "explain_query",
+		label: "Explain SQL Query",
+		description:
+			"Run EXPLAIN on a SQL query to analyze its execution plan. " +
+			"Shows whether indexes are used, estimated rows, and join types. " +
+			"Works with MySQL and SQLite. Requires db-tools to be installed for database access.",
+		parameters: Type.Object({
+			sql: Type.String({ description: "The SQL query to explain" }),
+			engine: Type.Optional(
+				Type.Union([Type.Literal("mysql"), Type.Literal("sqlite")], {
+					description: "Database engine (default: auto-detect from .env)",
+				}),
+			),
+		}),
+		execute: async (_toolCallId, params) => {
+			return {
+				content: [{
+					type: "text",
+					text: `Run EXPLAIN on this query and analyze the execution plan:\n\nEXPLAIN ${params.sql}\n\nLook for: full table scans (type=ALL), missing indexes, high row estimates, filesort, temporary tables.`,
+				}],
+				details: {},
+			};
+		},
+	});
+
+	// ── Commands ──
+	elyra.registerCommand("perf", {
+		description: "Analyze database query performance",
+		handler: async (_args, _ctx) => {
+			elyra.sendUserMessage("Analyze this project for database performance issues: N+1 queries, slow queries, missing indexes, and eager loading opportunities.");
+		},
+	});
+}
+
+interface DuplicatePattern {
+	pattern: string;
+	count: number;
+}
+
+function findDuplicatePatterns(queries: string[]): DuplicatePattern[] {
+	const normalized = queries.map((q) => q.replace(/\d+/g, "?").replace(/['"][^'"]*['"]/g, "?").slice(0, 100));
+	const counts = new Map<string, number>();
+	for (const q of normalized) {
+		counts.set(q, (counts.get(q) ?? 0) + 1);
+	}
+	return [...counts.entries()]
+		.filter(([_, count]) => count > 2)
+		.sort((a, b) => b[1] - a[1])
+		.map(([pattern, count]) => ({ pattern, count }));
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@elyracode/perf-tools",
+  "version": "0.5.2",
+  "description": "Elyra extension for performance analysis -- N+1 queries, slow queries, missing indexes",
+  "type": "module",
+  "keywords": ["elyra-package", "performance", "n+1", "queries", "optimization", "laravel"],
+  "license": "MIT",
+  "author": "Knut W. Horne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhorne/elyra.git",
+    "directory": "packages/perf-tools"
+  },
+  "elyra": { "extensions": ["./extensions/index.ts"] },
+  "peerDependencies": { "@elyracode/coding-agent": "*", "typebox": "*" },
+  "scripts": { "clean": "echo 'nothing to clean'", "build": "echo 'nothing to build'", "check": "echo 'nothing to check'" }
+}