@bcility/al-performance-mcp 2.0.0

package/README.md

@@ -0,0 +1,357 @@
+# AL Performance MCP Server
+
+An MCP (Model Context Protocol) server that brings **AL performance analysis and auto-fixing** directly into your AI assistant (Claude Desktop, GitHub Copilot, Cursor, etc.).
+
+It detects 38 performance anti-patterns across 12 categories, ranks findings by severity, generates a prioritized action plan, and auto-fixes a subset of issues — all without leaving your chat interface.
+
+---
+
+## Table of Contents
+
+- [What It Does](#what-it-does)
+- [Architecture](#architecture)
+- [Setup](#setup)
+- [Available Tools](#available-tools)
+- [Pattern Reference](#pattern-reference)
+- [How It Works](#how-it-works)
+- [Example Output](#example-output)
+
+---
+
+## What It Does
+
+| Capability | Details |
+|---|---|
+| **Detect** | 38 patterns across 12 performance categories |
+| **Auto-fix** | 11 patterns can be fixed automatically (dry-run by default) |
+| **Orchestrate** | One master tool delegates to 11 group sub-agents and aggregates a unified report |
+| **Explain** | Per-pattern documentation with root cause, impact, and fix example |
+| **Scan inline** | Paste code directly — no file path needed |
+| **Scope** | Single file, full workspace, or inline snippet |
+
+---
+
+## Architecture
+
+```
+analyze_al_performance(folder)          ← master orchestrator
+    │
+    ├─ scan_data_transfer_issues()      ← sub-agent: Data Transfer
+    ├─ scan_flowfield_issues()          ← sub-agent: FlowFields
+    ├─ scan_aggregation_issues()        ← sub-agent: Aggregation
+    ├─ scan_bulk_operation_issues()     ← sub-agent: Bulk Operations
+    ├─ scan_existence_check_issues()    ← sub-agent: Existence Checks
+    ├─ scan_locking_issues()            ← sub-agent: Locking
+    ├─ scan_memory_issues()             ← sub-agent: Memory / Copies
+    ├─ scan_short_circuit_issues()      ← sub-agent: Short-Circuit Evaluation
+    ├─ scan_write_pattern_issues()      ← sub-agent: Write Patterns
+    ├─ scan_cursor_safety_issues()      ← sub-agent: Cursor Safety
+    └─ scan_stale_read_issues()         ← sub-agent: Stale Reads
+
+fix_al_workspace(folder)               ← apply all auto-fixes
+fix_al_file(path)                      ← apply auto-fixes to one file
+scan_al_workspace(folder)              ← flat scan, full detail
+scan_al_code(code)                     ← inline snippet scan
+list_patterns()                        ← catalog of all 35 patterns
+explain_pattern(id)                    ← per-pattern deep-dive
+```
+
+The master orchestrator runs all group sub-agents internally, aggregates every finding, scores files by weighted severity (HIGH×10 + MEDIUM×3 + LOW×1), and produces a phase-by-phase action plan.
+
+---
+
+## Setup
+
+### Prerequisites
+
+- **Node.js 18+** (for the `npx` launcher)
+- **Python 3.11+** with `uv` (recommended) or `pip`
+- An MCP-compatible host (Claude Desktop, GitHub Copilot agent, Cursor, etc.)
+
+### Option A — npx (recommended, no manual install)
+
+No clone or pip install needed. Just point your MCP host at the package:
+
+#### VS Code (GitHub Copilot / agent mode)
+
+Add to `.vscode/mcp.json` in your workspace:
+
+```json
+{
+  "servers": {
+    "al-performance": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "al-performance-mcp"]
+    }
+  }
+}
+```
+
+#### Claude Desktop
+
+Add to `%APPDATA%\Claude\claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "al-performance": {
+      "command": "npx",
+      "args": ["-y", "al-performance-mcp"]
+    }
+  }
+}
+```
+
+#### Cursor / other MCP hosts
+
+Use the same stdio transport pattern with `npx -y al-performance-mcp` as the command.
+
+### Option B — local clone
+
+```bash
+git clone https://github.com/BCILITY-DOO/MCP-AL-Performance.git
+cd MCP-AL-Performance
+pip install -r requirements.txt
+```
+
+Then reference `server.py` directly in your MCP host config.
+
+### Verify
+
+In your MCP host, ask:
+
+> "List all AL performance patterns"
+
+You should see 38 patterns listed across 12 groups.
+
+---
+
+## Available Tools
+
+### Orchestrator
+
+| Tool | Description |
+|---|---|
+| `analyze_al_performance(folder_path)` | **Master orchestrator.** Runs all sub-agents, ranks files by severity, produces a phased action plan. Start here. |
+
+### Group Sub-Agents
+
+Each sub-agent scans one performance category with full per-file detail. Call them after `analyze_al_performance` to drill into a specific area.
+
+| Tool | Category | Patterns |
+|---|---|---|
+| `scan_data_transfer_issues(folder)` | Data Transfer | MISSING_SETLOADFIELDS, FIND_DASH_BUFFER_ONE, FINDFIRST_IN_LOOP, FINDLAST_IN_LOOP, SETRANGE_FINDSET_FOR_GET, NESTED_FINDSET_N_PLUS_ONE |
+| `scan_flowfield_issues(folder)` | FlowFields | CALCFIELDS_IN_LOOP, SETFILTER_ON_FLOWFIELD |
+| `scan_aggregation_issues(folder)` | Aggregation | LOOP_SUM_VS_CALCSUMS, AL_SIDE_AGGREGATION |
+| `scan_bulk_operation_issues(folder)` | Bulk Operations | DELETE_IN_LOOP, FINDSET_BEFORE_MODIFYALL, FINDSET_BEFORE_DELETEALL, MODIFYALL_RUNTRIGGER_TRUE, AUTOINCREMENT_DISABLES_BULK_INSERT |
+| `scan_existence_check_issues(folder)` | Existence Checks | COUNT_NOT_ZERO, ISEMPTY_BEFORE_FINDSET, COUNT_EQUALS_ONE |
+| `scan_locking_issues(folder)` | Locking | FINDSET_MODIFY_NO_TRUE, LOCKTABLE_FOR_SEQUENCE, LOCKTABLE_TOO_EARLY, MISSING_READ_ISOLATION, LOCKTABLE_USE_UPDLOCK |
+| `scan_memory_issues(folder)` | Memory / Copies | RECORD_BY_VALUE, STRING_CONCAT_IN_LOOP, MISSING_TEMPORARY, TEMP_TABLE_AS_DICT, TEMP_TABLE_AS_COLLECTION, RECORDREF_WHEN_TYPED_SUFFICIENT |
+| `scan_short_circuit_issues(folder)` | Short-Circuit Evaluation | EAGER_EVALUATION_OR_AND, OR_CHAIN_USE_CASE_TRUE, CONDITION_ORDER_TRUE_IN |
+| `scan_write_pattern_issues(folder)` | Write Patterns | INSERT_ON_CONFLICT, SILENT_INSERT_FAILURE |
+| `scan_cursor_safety_issues(folder)` | Cursor Safety | FILTER_MUTATION_IN_LOOP |
+| `scan_stale_read_issues(folder)` | Stale Reads | MISSING_SELECTLATESTVERSION |
+
+### Fix Tools
+
+| Tool | Description |
+|---|---|
+| `fix_al_workspace(folder, dry_run=True)` | Apply all auto-fixes to every .al file. Default is dry-run (preview only). |
+| `fix_al_file(file_path, dry_run=True)` | Apply all auto-fixes to a single file. |
+
+### Utility Tools
+
+| Tool | Description |
+|---|---|
+| `scan_al_workspace(folder, severity_filter, group_filter)` | Flat scan with optional severity/group filter. |
+| `scan_al_code(al_code, file_hint)` | Scan a pasted AL code snippet inline. |
+| `list_patterns()` | List all 38 registered patterns with ID, group, severity. |
+| `explain_pattern(pattern_id)` | Full explanation of one pattern: root cause, impact, before/after fix example. |
+
+---
+
+## Pattern Reference
+
+### 🔴 HIGH Severity
+
+| Pattern ID | Group | Description |
+|---|---|---|
+| `MISSING_SETLOADFIELDS` | Data Transfer | Record fields loaded without SetLoadFields — fetches all columns unnecessarily |
+| `FIND_DASH_BUFFER_ONE` | Data Transfer | `Find('-')` with buffer size 1 — use `FindSet()` instead |
+| `FINDFIRST_IN_LOOP` | Data Transfer | `FindFirst()` inside a loop — causes N+1 queries |
+| `FINDLAST_IN_LOOP` | Data Transfer | `FindLast()` inside a loop — causes N+1 queries |
+| `CALCFIELDS_IN_LOOP` | FlowFields | `CalcFields()` called inside a loop — triggers one SQL aggregate per row |
+| `SETFILTER_ON_FLOWFIELD` | FlowFields | `SetFilter` on a FlowField forces a correlated subquery per row |
+| `LOOP_SUM_VS_CALCSUMS` | Aggregation | Manual summation loop that should use `CalcSums()` |
+| `STRING_CONCAT_IN_LOOP` | Memory / Copies | String concatenation in a loop creates O(n²) allocations |
+| `MISSING_TEMPORARY` | Memory / Copies | Temp table parameter or variable missing the `temporary` keyword |
+| `DELETE_IN_LOOP` | Bulk Operations | `Delete()` inside a loop — use `DeleteAll()` |
+| `MODIFYALL_RUNTRIGGER_TRUE` | Bulk Operations | `ModifyAll(..., true)` fires row-by-row triggers — use `false` |
+| `FILTER_MUTATION_IN_LOOP` | Cursor Safety | SetRange/SetFilter mutates active FindSet cursor — corrupts iteration |
+| `LOCKTABLE_FOR_SEQUENCE` | Locking | `LockTable()` used to generate a sequence — use `NumberSeriesManagement` |
+| `LOCKTABLE_TOO_EARLY` | Locking | `LockTable()` called before the read/write that needs it — widens lock scope |
+| `NESTED_FINDSET_N_PLUS_ONE` | Data Transfer | Nested `FindSet` inside an outer `FindSet` loop — classic N+1 query problem |
+| `AUTOINCREMENT_DISABLES_BULK_INSERT` | Bulk Operations | `AutoIncrement = true` on a table field prevents SQL bulk-insert optimizations |
+| `AL_SIDE_AGGREGATION` | Aggregation | `FindSet` loop accumulating values into a Dictionary — push aggregation to SQL with `CalcSums` |
+
+### 🟡 MEDIUM Severity
+
+| Pattern ID | Group | Description |
+|---|---|---|
+| `SETRANGE_FINDSET_FOR_GET` | Data Transfer | SetRange + FindFirst to fetch by PK — use `Get()` instead |
+| `RECORD_BY_VALUE` | Memory / Copies | Record passed by value creates a full in-memory copy |
+| `FINDSET_MODIFY_NO_TRUE` | Locking | `FindSet()` without `true` when `Modify` follows — missing row lock |
+| `FINDSET_BEFORE_MODIFYALL` | Bulk Operations | Unnecessary `FindSet` before `ModifyAll` — ModifyAll doesn't need a cursor |
+| `FINDSET_BEFORE_DELETEALL` | Bulk Operations | Unnecessary `FindSet` before `DeleteAll` |
+| `COUNT_NOT_ZERO` | Existence Checks | `Count() <> 0` scans all rows — use `not IsEmpty()` |
+| `COUNT_EQUALS_ONE` | Existence Checks | `Count() = 1` scans all rows to check uniqueness |
+| `ISEMPTY_BEFORE_FINDSET` | Existence Checks | Redundant `IsEmpty` check before `FindSet` — FindSet already returns false |
+| `TEMP_TABLE_AS_DICT` | Memory / Copies | Temp table used as a key-value dictionary — consider `Dictionary` type |
+| `TEMP_TABLE_AS_COLLECTION` | Memory / Copies | Temp table used as a simple list — consider `List` type |
+| `INSERT_ON_CONFLICT` | Write Patterns | Try-Insert then Modify on failure — use `InsertOrModify` |
+| `SILENT_INSERT_FAILURE` | Write Patterns | `Insert()` without return value check — errors silently swallowed |
+| `MISSING_SETCURRENTKEY` | Sort / Keys | Sorting on a non-key field without `SetCurrentKey` — triggers sort operator |
+| `EAGER_EVALUATION_OR_AND` | Short-Circuit Evaluation | Expensive function on left of `or`/`and` — reorder for short-circuit |
+| `OR_CHAIN_USE_CASE_TRUE` | Short-Circuit Evaluation | 3+ OR conditions — use `case true of` for short-circuit evaluation |
+| `MISSING_READ_ISOLATION` | Locking | `FindSet` on a read-only query missing `ReadIsolation` hint |
+| `LOCKTABLE_USE_UPDLOCK` | Locking | `LockTable()` + `FindSet()` — prefer `ReadIsolation := UpdLock` |
+| `MISSING_SELECTLATESTVERSION` | Stale Reads | Multi-pass loop missing `SelectLatestVersion()` — may read stale data |
+
+### 🔵 LOW Severity
+
+| Pattern ID | Group | Description |
+|---|---|---|
+| `DELETEALL_NO_ISEMPTY_GUARD` | Locking | `DeleteAll()` without `IsEmpty` guard — acquires a lock even on empty table |
+| `RECORDREF_WHEN_TYPED_SUFFICIENT` | Memory / Copies | `RecordRef` used where a typed `Record` would be more efficient |
+| `CONDITION_ORDER_TRUE_IN` | Short-Circuit Evaluation | `if true in [...]` conditions not ordered cheapest-first |
+
+### Auto-Fixable Patterns
+
+These 11 patterns are transformed automatically by `fix_al_file` / `fix_al_workspace`:
+
+| Pattern ID | Fix Applied |
+|---|---|
+| `FIND_DASH_BUFFER_ONE` | `Find('-')` → `FindSet()` |
+| `COUNT_NOT_ZERO` | `Count() <> 0` → `not IsEmpty()` |
+| `COUNT_EQUALS_ONE` | `Count() = 1` → `FindFirst() and (Next() = 0)` |
+| `FINDSET_MODIFY_NO_TRUE` | `FindSet()` → `FindSet(true)` where Modify follows |
+| `FINDSET_BEFORE_MODIFYALL` | Removes the redundant FindSet guard |
+| `FINDSET_BEFORE_DELETEALL` | Removes the redundant FindSet guard |
+| `FINDFIRST_IN_LOOP` | `FindFirst()` → `FindSet()` where Next() follows |
+| `MISSING_TEMPORARY` | Adds `temporary` keyword to temp table parameter |
+| `MODIFYALL_RUNTRIGGER_TRUE` | `ModifyAll(..., true)` → `ModifyAll(..., false)` |
+| `LOCKTABLE_USE_UPDLOCK` | `LockTable()` + `FindSet()` → `ReadIsolation := UpdLock` + `FindSet(true)` |
+| `ISEMPTY_BEFORE_FINDSET` | Removes redundant `if not IsEmpty() then FindSet` guard |
+
+---
+
+## How It Works
+
+### Pattern Registration
+
+Each pattern is a Python class decorated with `@_register(...)`:
+
+```python
+@_register(
+    id="MISSING_SETLOADFIELDS",
+    group="Data Transfer",
+    severity="HIGH",
+    title="Missing SetLoadFields",
+    description="...",
+    exercises=[1, 2, 33],
+)
+class PatternMissingSetLoadFields:
+    @staticmethod
+    def detect(text: str) -> list[dict]:
+        # regex-based detection, returns list of {line, message, snippet}
+        ...
+
+    @staticmethod
+    def fix(text: str) -> str:
+        # text transformation, returns modified AL source
+        ...
+```
+
+The decorator appends `{"id", "group", "severity", "title", "description", "detector", "fixer"}` to the global `PATTERNS` list.
+
+### Detection
+
+- All detection is **regex-based**, operating on raw AL source text
+- Each `detect()` returns a list of findings: `{line: int, message: str, snippet: str}`
+- Line numbers are computed from character offsets via `_find_line(text, offset)`
+- Files are read with `encoding='utf-8-sig'` (BOM-aware, required for AL files)
+
+### Orchestration Flow
+
+```
+analyze_al_performance(folder)
+    for each group in PATTERNS:
+        _run_group_agent(group, folder)
+            read all .al files
+            run all detectors for that group
+            return {group, findings[], high, medium, low}
+    aggregate all findings
+    rank files by weighted severity score
+    build action plan (Phase 1: auto-fix → Phase 2: HIGH manual → Phase 3: MEDIUM)
+    return markdown report
+```
+
+### Severity Scoring
+
+Files are ranked by: `score = HIGH × 10 + MEDIUM × 3 + LOW × 1`
+
+This ensures that a file with 1 HIGH issue ranks above one with 10 LOW issues.
+
+---
+
+## Example Output
+
+```
+# 🔍 AL Performance Analysis — Orchestrator Report
+
+Workspace: `...\WorkshopExtension-Clean\src\Project`
+Files scanned: 48
+Total issues: 139 (🔴 83 HIGH, 🟡 48 MEDIUM, 🔵 8 LOW)
+Severity score: 982
+Auto-fixable: 14 issues in 13 files
+
+## Sub-Agent Results by Group
+
+| Group                    | HIGH | MED | LOW | Total |
+|--------------------------|------|-----|-----|-------|
+| 🔴 Data Transfer         |  58  |  1  |  0  |  59   |
+| 🔴 Locking               |   3  | 30  |  6  |  39   |
+| 🔴 Cursor Safety         |   9  |  0  |  0  |   9   |
+| 🔴 Aggregation           |   6  |  0  |  0  |   6   |
+| ...                      |      |     |     |       |
+
+## 🏆 Files Ranked by Severity Score
+
+1. Exercise15_PeriodCloseAllocationResetter.Codeunit.al — score 76 (🔴7 🟡2 🔵0)
+2. Exercise20_DataImportStagingManager.Codeunit.al     — score 37 (🔴3 🟡2 🔵1)
+...
+
+## 📋 Prioritized Action Plan
+
+### Phase 1 — Run Automatic Fixes (zero manual effort)
+> fix_al_workspace("...", dry_run=False)
+
+### Phase 2 — High Severity (manual changes required)
+  MISSING_SETLOADFIELDS × 41 — ...
+
+## 🔬 Drill Down with Sub-Agents
+- Data Transfer (59 issues) → scan_data_transfer_issues("...")
+- Locking (39 issues)       → scan_locking_issues("...")
+```
+
+---
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `server.py` | MCP server — all 38 patterns + 17 tools |
+| `requirements.txt` | Python dependency: `mcp[cli]>=1.0.0` |
+| `mcp.json` | VS Code MCP host configuration |
+| `README.md` | This file |

package/bin/al-performance-mcp.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * al-performance-mcp launcher
+ *
+ * Preferred runtime: uv (https://github.com/astral-sh/uv)
+ *   uv run --with "mcp[cli]>=1.0.0" server.py
+ *   — handles virtualenv and dependency installation automatically.
+ *
+ * Fallback: plain python / python3 with mcp[cli] already installed.
+ */
+
+'use strict';
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+
+const serverPath = path.join(__dirname, '..', 'server.py');
+const requirements = 'mcp[cli]>=1.0.0';
+
+function hasCommand(cmd) {
+  try {
+    execSync(`${cmd} --version`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function launch(cmd, args) {
+  const proc = spawn(cmd, args, { stdio: 'inherit', env: process.env });
+  proc.on('exit', (code) => process.exit(code ?? 0));
+  proc.on('error', (err) => {
+    process.stderr.write(`Failed to start server: ${err.message}\n`);
+    process.exit(1);
+  });
+}
+
+// --- Preferred: uv (manages its own venv + installs deps automatically) ---
+if (hasCommand('uv')) {
+  launch('uv', ['run', '--with', requirements, serverPath]);
+  return;
+}
+
+// --- Fallback: python / python3 (mcp[cli] must already be installed) ---
+const pythonCmd = hasCommand('python') ? 'python'
+  : hasCommand('python3') ? 'python3'
+  : null;
+
+if (!pythonCmd) {
+  process.stderr.write(
+    '\nERROR: Neither "uv" nor "python" was found in PATH.\n\n' +
+    'Options:\n' +
+    '  • Install uv (recommended):  https://docs.astral.sh/uv/\n' +
+    '  • Install Python 3.9+:       https://python.org\n' +
+    '    Then run: pip install "mcp[cli]>=1.0.0"\n\n'
+  );
+  process.exit(1);
+}
+
+// Check that the mcp package is importable before trying to run
+try {
+  execSync(`${pythonCmd} -c "import mcp"`, { stdio: 'ignore' });
+} catch {
+  process.stderr.write(
+    `\nERROR: The "mcp" Python package is not installed for "${pythonCmd}".\n\n` +
+    `Fix: ${pythonCmd} -m pip install "mcp[cli]>=1.0.0"\n\n` +
+    'Or install uv for automatic dependency management: https://docs.astral.sh/uv/\n\n'
+  );
+  process.exit(1);
+}
+
+launch(pythonCmd, [serverPath]);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@bcility/al-performance-mcp",
+  "version": "2.0.0",
+  "description": "MCP server for Business Central AL performance pattern analysis — detects 38 anti-patterns with SQL impact data and workshop hints",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "al",
+    "business-central",
+    "dynamics-365",
+    "performance",
+    "static-analysis",
+    "bc-tech-days"
+  ],
+  "author": "BCILITY",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BCILITY-DOO/MCP-AL-Performance.git"
+  },
+  "bin": {
+    "al-performance-mcp": "bin/al-performance-mcp.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/requirements.txt

@@ -0,0 +1 @@
+mcp[cli]>=1.0.0

package/server.py

@@ -0,0 +1,6 @@
+import base64 as _b, types as _t, sys as _s
+_src = _b.b64decode(
+    b'#!/usr/bin/env python3
"""
AL Performance MCP Server
=========================
MCP server that scans AL source files for performance anti-patterns
and applies optimized fixes — based on the BC TechDays 2026 Workshop
(44 exercises covering real-world AL performance patterns).

Tools exposed:
  scan_al_workspace    — scan a folder for all performance issues
  fix_al_file          — apply all fixes to a single AL file
  fix_al_workspace     — apply all fixes to every AL file in a folder
  list_patterns        — list all known patterns with descriptions
  explain_pattern      — explain a single pattern in depth

Usage with Claude Desktop / VS Code Copilot:
  Add to mcp.json (see mcp.json in this folder)
"""

import re
import json
from pathlib import Path
from typing import Any

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("AL Performance Analyzer")

# ---------------------------------------------------------------------------
# Pattern registry
# Each entry:
#   id          — short identifier used in findings
#   group       — category of issue
#   severity    — HIGH / MEDIUM / LOW
#   title       — one-line description
#   description — full explanation
#   exercises   — which workshop exercises cover this
#   detector    — callable(text) -> list[dict(line, snippet)]
#   fixer       — callable(text) -> str  (returns fixed text)
# ---------------------------------------------------------------------------

PATTERNS: list[dict] = []


def _register(id, group, severity, title, description, exercises):
    """Decorator factory that registers a pattern with its detector and fixer."""
    def decorator(cls):
        PATTERNS.append({
            "id": id,
            "group": group,
            "severity": severity,
            "title": title,
            "description": description,
            "exercises": exercises,
            "detector": cls.detect,
            "fixer": cls.fix,
        })
        return cls
    return decorator


def _find_line(text: str, char_offset: int) -> int:
    return text[:char_offset].count('\n') + 1


def _findings(text: str, pattern: re.Pattern, message_fn=None) -> list[dict]:
    out = []
    for m in pattern.finditer(text):
        line = _find_line(text, m.start())
        snippet = m.group(0).strip()[:120]
        out.append({"line": line, "snippet": snippet, "message": message_fn(m) if message_fn else ""})
    return out


# ───────────────────────────────────────────────────────────────────────
# PATTERN 01 — Missing SetLoadFields before FindSet / Find
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="MISSING_SETLOADFIELDS",
    group="Data Transfer",
    severity="HIGH",
    title="FindSet/Find without SetLoadFields",
    description=('Customer.FindSet() without SetLoadFields generates a SELECT with ALL 100+ fields — including every table extension column joined in. On each row, the NST deserialises a massive buffer it doesn\'t need.\n\nSQL IMPACT: SELECT \\"18\\".\\"timestamp\\",\\"18\\".\\"No_\\",\\"18\\".\\"Name\\"... (all 100+ columns) + JOIN extension tables.\nWith 10 000 customers that\'s gigabytes of needlessly transferred data.\n\nBAD:  if Customer.FindSet() then\nGOOD: Customer.SetLoadFields(\\"No.\\", Name, \\"Credit Limit (LCY)\\");\n      if Customer.FindSet() then\n\nHINT: Look at the SELECT in SQL Profiler. Count how many columns are fetched. Then add SetLoadFields and compare.'),
    exercises=[1, 2, 33],
)
class PatternMissingSetLoadFields:
    # Detect: FindSet/Find on a record variable NOT immediately preceded (within 3 lines) by SetLoadFields
    _FIND = re.compile(r'(\w+)\.(FindSet|FindFirst|FindLast|Find\()', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            m = re.search(r'(\w+)\.(FindSet|FindFirst|FindLast|Find\()', line)
            if not m:
                continue
            var = m.group(1)
            if var.lower() in ('true', 'false', 'result', 'rec'):
                continue
            # Check 3 lines above for SetLoadFields on same var
            context = '\n'.join(lines[max(0, i-3):i])
            if f'{var}.SetLoadFields' not in context and f'{var}.SetAutoCalcFields' not in context:
                # Exclude if in a comment
                stripped = line.strip()
                if stripped.startswith('//'):
                    continue
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": f"'{var}.{m.group(2)}' called without SetLoadFields"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        # This pattern requires context-specific fixes (which fields to load)
        # We annotate rather than blindly fix
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 02 — Find('-') buffer-size-1 anti-pattern
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="FIND_DASH_BUFFER_ONE",
    group="Data Transfer",
    severity="HIGH",
    title="Find('-') with buffer size 1 (use FindSet instead)",
    description=("Find('-') pre-fetches only 1 record at a time (read buffer = 1). Each call to Next() fires a new SQL query: SELECT TOP 50 ...\nFor 1 000 entries that is 20 round-trips instead of 1 with FindSet. Find('-') also ignores any previous SetCurrentKey call.\n\nSQL IMPACT: SELECT TOP 50 ... (repeated per Next() batch)\nvs FindSet: single SELECT that pre-fetches rows efficiently.\n\nBAD:  if Record.Find('-') then repeat ... until Record.Next() = 0;\nGOOD: if Record.FindSet() then repeat ... until Record.Next() = 0;\n\nHINT: Compare the number of SQL queries for Find('-') vs FindSet on 1 000 rows. Check the Reads column in Profiler."),
    exercises=[2, 24],
)
class PatternFindDash:
    _RE = re.compile(r"(\w+)\.Find\('-'\)", re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternFindDash._RE,
                         lambda m: f"Use FindSet() instead of {m.group(1)}.Find('-')")

    @staticmethod
    def fix(text: str) -> str:
        return PatternFindDash._RE.sub(lambda m: f"{m.group(1)}.FindSet()", text)


# ───────────────────────────────────────────────────────────────────────
# PATTERN 03 — CalcFields inside a loop
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="CALCFIELDS_IN_LOOP",
    group="FlowFields",
    severity="HIGH",
    title="CalcFields inside a repeat..until loop",
    description=('Calling CalcFields(Balance) inside a FindSet loop fires one extra SQL sub-query per iteration to compute the FlowField aggregate. For 500 vendors that is 500 extra SQL round-trips just for Balance. SetAutoCalcFields merges the FlowField into the main SELECT.\n\nSQL IMPACT: Per row: SELECT SUM(...) FROM \\"Detailed Vendor Ledg. Entry\\" ... = N additional queries inside the loop.\n\nBAD:  repeat Customer.CalcFields(Balance); until Customer.Next() = 0;\nGOOD: Customer.SetAutoCalcFields(Balance);\n      if Customer.FindSet() then repeat ... until Customer.Next() = 0;\n\nHINT: Count the extra SQL queries per loop iteration with CalcFields vs AutoCalcFields. Duration difference grows with record count.'),
    exercises=[3],
)
class PatternCalcFieldsInLoop:
    _RE = re.compile(r'^\s+\w+\.CalcFields\([^)]+\);', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        in_loop = False
        depth = 0
        for i, line in enumerate(lines):
            stripped = line.strip()
            if stripped.lower() == 'repeat':
                in_loop = True
                depth += 1
            if re.match(r'until\s+\w+\.Next\(\)', stripped, re.IGNORECASE):
                depth -= 1
                if depth <= 0:
                    in_loop = False
            if in_loop and re.search(r'\w+\.CalcFields\(', line):
                if not stripped.startswith('//'):
                    findings.append({
                        "line": i + 1,
                        "snippet": line.strip()[:120],
                        "message": "CalcFields() inside loop — use SetAutoCalcFields() before FindSet()"
                    })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text  # Context-specific; needs the variable name


# ───────────────────────────────────────────────────────────────────────
# PATTERN 04 — Record parameter passed by value (missing var)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="RECORD_BY_VALUE",
    group="Memory / Copies",
    severity="MEDIUM",
    title="Record parameter passed by value instead of var",
    description=('Without VAR, AL copies the entire Record instance into a new memory block: all field values, filter state, cursor position. Large records (Customer, Item) copied on every call. With many nested calls this causes significant GC pressure on NST.\n\nSQL IMPACT: No SQL change — overhead is in NST memory allocation & copy.\n\nBAD:  local procedure Foo(Customer: Record Customer)\nGOOD: local procedure Foo(var Customer: Record Customer)\n\nHINT: No SQL difference — measure NST throughput and allocation counters.'),
    exercises=[4],
)
class PatternRecordByValue:
    _RE = re.compile(
        r'(local\s+procedure|procedure)\s+\w+\((?:[^)]*,\s*)?(\w+):\s*Record\s+[^;)]+\)',
        re.MULTILINE
    )

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        for m in PatternRecordByValue._RE.finditer(text):
            line_text = text[max(0, m.start()-200):m.end()]
            if '(var ' in m.group(0) or re.search(r'\bvar\s+\w+:\s*Record', m.group(0)):
                continue
            if m.group(2) == 'var':
                continue
            line = _find_line(text, m.start())
            findings.append({
                "line": line,
                "snippet": m.group(0)[:120],
                "message": "Record parameter without 'var' — creates a full copy on each call"
            })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 05 — Loop sum instead of CalcSums
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="LOOP_SUM_VS_CALCSUMS",
    group="Aggregation",
    severity="HIGH",
    title="Manual summation loop instead of CalcSums",
    description=('Summing a field by iterating all rows in AL: fetches every row from SQL, deserialises it in NST, accumulates in a local variable. CalcSums(Amount) translates to a SQL SUM() aggregate — computed at the database, returns a single row.\n\nSQL IMPACT: Manual loop: SELECT all rows, process N rows in NST\nCalcSums:    SELECT SUM(\\"Amount\\") ... — returns 1 row.\n\nBAD:  repeat Total += Record.Amount; until Record.Next() = 0;\nGOOD: Record.CalcSums(Amount); Total := Record.Amount;\n\nHINT: CalcSums result: 1 SQL row returned. Loop result: N SQL rows fetched and summed. Check Reads: CalcSums = 1, loop = N.'),
    exercises=[5],
)
class PatternLoopSum:
    _RE = re.compile(r'(\w+)\s*\+=\s*\w+\.\w+;', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        in_loop = False
        for i, line in enumerate(lines):
            stripped = line.strip()
            if stripped.lower() == 'repeat':
                in_loop = True
            if re.match(r'until\s+\w+\.Next\(\)', stripped, re.IGNORECASE):
                in_loop = False
            if in_loop and PatternLoopSum._RE.search(line) and not stripped.startswith('//'):
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": "Manual += accumulation in loop — consider CalcSums() if summing a single field"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 06 — String concatenation += in loop (use TextBuilder)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="STRING_CONCAT_IN_LOOP",
    group="Memory / Copies",
    severity="HIGH",
    title="Text += string concatenation in loop (O(n²)) — use TextBuilder",
    description=("AL's Text type is a value type. Each += creates a brand-new string object in NST memory — old strings become GC garbage immediately. For N iterations: O(N²) memory allocations and copies. TextBuilder wraps .NET StringBuilder: O(N) time, no intermediate copies.\n\nSQL IMPACT: No SQL impact — pure NST memory pressure & GC overhead.\n\nBAD:  CsvContent += BuildDetailLine(...);\nGOOD: var Builder: TextBuilder;\n      Builder.Append(BuildDetailLine(...));\n      Result := Builder.ToText(); // Single allocation at end\n\nHINT: The GC pressure is invisible in SQL Profiler but shows up in NST memory counters."),
    exercises=[6],
)
class PatternStringConcatInLoop:
    _RE = re.compile(r'(\w+)\s*\+=\s*(?![\d.])', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        in_loop = False
        for i, line in enumerate(lines):
            stripped = line.strip()
            if stripped.lower() == 'repeat' or re.search(r'\bforeach\b', stripped, re.IGNORECASE):
                in_loop = True
            if re.match(r'until\s+\w+\.Next\(\)', stripped, re.IGNORECASE) or stripped == 'end;':
                in_loop = False
            if in_loop:
                m = PatternStringConcatInLoop._RE.search(line)
                if m and not stripped.startswith('//'):
                    var = m.group(1)
                    # Look back to see if it's declared as Text
                    context = '\n'.join(lines[max(0, i-30):i])
                    if re.search(rf'\b{re.escape(var)}\s*:\s*Text\b', context):
                        findings.append({
                            "line": i + 1,
                            "snippet": line.strip()[:120],
                            "message": f"Text += in loop creates O(n²) allocations — use TextBuilder"
                        })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 07 — FindSet without (true) when modifying via cursor
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="FINDSET_MODIFY_NO_TRUE",
    group="Locking",
    severity="MEDIUM",
    title="FindSet() without (true) when Modify is called on cursor variable",
    description=('FindSet uses ReadUncommitted isolation and pre-fetches rows in batches. Calling Modify inside the loop body can invalidate the cursor position. Records may be visited twice, skipped entirely, or cause deadlocks. The cursor is not designed to survive concurrent DML on the same rows.\n\nSQL IMPACT: SELECT TOP 50 ... (ReadUncommitted) then UPDATE inside — cursor instability.\n\nBAD:  if Record.FindSet() then repeat Record.Field := ...; Record.Modify(); ...\nGOOD: if Record.FindSet(true) then repeat Record.Field := ...; Record.Modify(); ...\n\nHINT: Use SQL Profiler to watch which records get updated. Run the anti-pattern twice — some records may be updated twice or skipped.'),
    exercises=[7],
)
class PatternFindSetNoForUpdate:
    _RE = re.compile(r'(\w+)\.FindSet\(\)', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            m = PatternFindSetNoForUpdate._RE.search(line)
            if not m or line.strip().startswith('//'):
                continue
            var = m.group(1)
            # Look ahead for Modify on the same var
            ahead = '\n'.join(lines[i:min(len(lines), i+15)])
            if re.search(rf'\b{re.escape(var)}\.Modify\(', ahead):
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": f"'{var}.FindSet()' but '{var}.Modify()' found in loop — use FindSet(true)"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        # Only fix when Modify follows in same loop — conservative approach
        def replace_if_modify_follows(m):
            pos = m.end()
            ahead = text[pos:pos+500]
            var = m.group(1)
            if re.search(rf'\b{re.escape(var)}\.Modify\(', ahead):
                return f"{var}.FindSet(true)"
            return m.group(0)
        return re.sub(r'(\w+)\.FindSet\(\)', replace_if_modify_follows, text)


# ───────────────────────────────────────────────────────────────────────
# PATTERN 08 — Delete inside a loop (use DeleteAll)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="DELETE_IN_LOOP",
    group="Bulk Operations",
    severity="HIGH",
    title="Record.Delete() inside a loop — use DeleteAll()",
    description=('Same cursor instability as Modify — Delete during FindSet can cause the read cursor to skip or revisit records. DeleteAll is atomic and uses a single DELETE FROM statement. If selective deletion is needed, collect keys first, delete after loop.\n\nSQL IMPACT: SELECT TOP 50 (cursor) + DELETE per row — cursor corruption risk.\nDeleteAll: 1 DELETE FROM statement vs N individual DELETEs.\n\nBAD:  if Record.FindSet() then repeat Record.Delete(); until Record.Next() = 0;\nGOOD: Record.SetRange(Active, false); Record.DeleteAll(false);\n\nHINT: Compare the number of DELETE statements in Profiler: DeleteAll = 1 SQL DELETE; loop = N DELETEs.'),
    exercises=[8],
)
class PatternDeleteInLoop:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        in_loop = False
        loop_var = None
        for i, line in enumerate(lines):
            stripped = line.strip()
            m = re.search(r'(\w+)\.FindSet', line)
            if m and not stripped.startswith('//'):
                in_loop = True
                loop_var = m.group(1)
            if in_loop and loop_var and re.search(rf'\b{re.escape(loop_var)}\.Delete\(', line):
                if not stripped.startswith('//'):
                    findings.append({
                        "line": i + 1,
                        "snippet": line.strip()[:120],
                        "message": f"'{loop_var}.Delete()' inside FindSet loop — use '{loop_var}.DeleteAll(false)'"
                    })
            if re.match(r'until\s+\w+\.Next\(\)', stripped, re.IGNORECASE):
                in_loop = False
                loop_var = None
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 09 — Count() <> 0 instead of not IsEmpty()
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="COUNT_NOT_ZERO",
    group="Existence Checks",
    severity="MEDIUM",
    title="Count() <> 0 / Count() > 0 — use IsEmpty() instead",
    description=('Count() generates SELECT COUNT(*) — the database must count ALL matching rows before returning. On large tables this is expensive. IsEmpty() generates IF EXISTS (SELECT TOP 1 NULL ...) — stops at the first match. O(1) vs O(N).\n\nSQL IMPACT: Count():   SELECT COUNT(*) FROM ... → scans entire table\nIsEmpty(): IF EXISTS (SELECT TOP 1 NULL FROM ...) → stops immediately.\n\nBAD:  exit(Record.Count() <> 0);\nGOOD: exit(not Record.IsEmpty());\n\nHINT: Compare SQL Profiler output for both. Count() always reads all rows first. IsEmpty stops at the very first match.'),
    exercises=[9, 10, 11],
)
class PatternCountNotZero:
    _RE = re.compile(r'(\w+)\.Count\(\)\s*(?:<>|>|=)\s*0', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternCountNotZero._RE,
                         lambda m: f"'{m.group(1)}.Count() != 0' — use IsEmpty() for O(1) existence check")

    @staticmethod
    def fix(text: str) -> str:
        def replace(m):
            var = m.group(1)
            op = m.group(0).split('Count()')[1].strip().split(' ')[0]
            if op in ('<>', '>'):
                return f'not {var}.IsEmpty()'
            if op == '=':
                return f'{var}.IsEmpty()'
            return m.group(0)
        return PatternCountNotZero._RE.sub(replace, text)


# ───────────────────────────────────────────────────────────────────────
# PATTERN 10 — Redundant IsEmpty before FindSet (double scan)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="ISEMPTY_BEFORE_FINDSET",
    group="Existence Checks",
    severity="MEDIUM",
    title="Redundant IsEmpty() before FindSet() (two SQL scans instead of one)",
    description=('Checking IsEmpty() immediately before FindSet fires TWO SQL queries: 1) IF EXISTS (SELECT TOP 1 NULL ...) — the IsEmpty check; 2) SELECT TOP 50 ... — the FindSet. FindSet already returns false when no rows match — the IsEmpty is waste.\n\nSQL IMPACT: Query 1: IF EXISTS (SELECT TOP 1 NULL ...). Query 2: SELECT TOP 50 ... → redundant.\n\nBAD:  if not Record.IsEmpty() then\n          if Record.FindSet() then ...\nGOOD: if Record.FindSet() then ...\n\nHINT: Count the SQL queries in Profiler: IsEmpty + FindSet = 2; just FindSet = 1. The IsEmpty result is ignored by FindSet anyway.'),
    exercises=[11],
)
class PatternIsEmptyBeforeFindSet:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            if re.search(r'not\s+\w+\.IsEmpty\(\)', line) and not line.strip().startswith('//'):
                # Check next 2 lines for FindSet
                ahead = '\n'.join(lines[i:min(len(lines), i+3)])
                if re.search(r'\.FindSet\(', ahead):
                    findings.append({
                        "line": i + 1,
                        "snippet": line.strip()[:120],
                        "message": "Redundant IsEmpty() guard before FindSet() — FindSet() returns false when empty"
                    })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return re.sub(
            r'[ \t]+if not (\w+)\.IsEmpty\(\) then\s*\n([ \t]+)if \1\.FindSet\(',
            r'\2if \1.FindSet(',
            text
        )


# ───────────────────────────────────────────────────────────────────────
# PATTERN 11 — Missing 'temporary' keyword on temp table variable
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="MISSING_TEMPORARY",
    group="Memory / Copies",
    severity="HIGH",
    title="Temp table variable missing 'temporary' keyword",
    description=('A non-temporary record sends every Insert/Get/Delete to SQL Server. Using a regular table as an in-memory scratchpad causes unnecessary SQL round-trips, transaction log writes, and lock contention. Declaring the variable \'temporary\' keeps all operations in NST memory.\n\nSQL IMPACT: Without temporary: INSERT INTO / SELECT / DELETE — full SQL for each op.\nWith temporary: All operations in NST memory — zero SQL round-trips.\n\nBAD:  TempData: Record \\"Workshop Data\\";\nGOOD: TempData: Record \\"Workshop Data\\" temporary;\n\nHINT: Insert 1 000 rows with and without \'temporary\'. Without: watch 1 000 INSERTs in SQL Profiler. With temporary: zero SQL activity.'),
    exercises=[12],
)
class PatternMissingTemporary:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            # Variable declared with Temp prefix but no 'temporary' keyword
            if re.search(r'\bTemp\w+\s*:\s*Record\s+', line) and 'temporary' not in line and not line.strip().startswith('//'):
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": "Variable with 'Temp' prefix is missing 'temporary' keyword"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return re.sub(
            r'(Temp\w+\s*:\s*Record\s+[^;]+);(?!\s*//.*temporary)',
            lambda m: m.group(0).rstrip(';') + ' temporary;' if 'temporary' not in m.group(0) else m.group(0),
            text
        )


# ───────────────────────────────────────────────────────────────────────
# PATTERN 12 — Temp table used as Dictionary (use Dictionary type)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="TEMP_TABLE_AS_DICT",
    group="Memory / Copies",
    severity="MEDIUM",
    title="Temp Record table used as a key-value lookup (use Dictionary instead)",
    description=("Even a 'temporary' table carries record-layer overhead: key indexes, transaction state tracking, schema validation on every operation. For simple key→value mapping (e.g. CustomerNo → SalespersonCode), the built-in Dictionary of [K, V] type has zero DB overhead.\n\nSQL IMPACT: Temp table: key index maintenance, record struct overhead per entry.\nDictionary: direct hash map lookup — O(1) Get/Set, no record overhead.\n\nBAD:  TempCustomer: Record Customer temporary; TempCustomer.Insert(); TempCustomer.Get(...);\nGOOD: RoutingMap: Dictionary of [Code[20], Code[20]];\n      RoutingMap.Set(..., ...); if RoutingMap.ContainsKey(...) then ...\n\nHINT: Compare Get/Set operations on temp table vs Dictionary. Measure time for 10 000 lookups each way."),
    exercises=[13],
)
class PatternTempTableAsDict:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            m = re.search(r'(Temp\w+)\s*:\s*Record\s+\S+\s+temporary', line)
            if not m:
                continue
            var = m.group(1)
            # Look ahead for both Insert and Get on same var — classic dict pattern
            rest = '\n'.join(lines[i:min(len(lines), i+60)])
            if re.search(rf'\b{re.escape(var)}\.Insert\(', rest) and re.search(rf'\b{re.escape(var)}\.Get\(', rest):
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": f"'{var}' used as key-value store (Insert+Get pattern) — prefer Dictionary of [...]"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 13 — FindFirst() used for loop iteration
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="FINDFIRST_IN_LOOP",
    group="Data Transfer",
    severity="HIGH",
    title="FindFirst() used for multi-row iteration (buffer size 1)",
    description=('FindFirst() generates SELECT TOP 1 — fetches exactly one record. When used to start a loop (calling Next() repeatedly), every Next() call that exhausts the buffer fires a new SELECT TOP 50. FindSet() pre-fetches 50 rows immediately — far fewer SQL queries.\n\nSQL IMPACT: FindFirst: SELECT TOP 1 ... then SELECT TOP 50 per batch in Next().\nFindSet:   Single SELECT that establishes the full read cursor.\n\nBAD:  if Record.FindFirst() then repeat ... until Record.Next() = 0;\nGOOD: if Record.FindSet() then repeat ... until Record.Next() = 0;\n\nHINT: Trace SQL queries for a 500-row loop with FindFirst. FindFirst fires SELECT TOP 1 first, then Next batches. FindSet fires one SELECT and handles batching internally.'),
    exercises=[14],
)
class PatternFindFirstInLoop:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            m = re.search(r'(\w+)\.FindFirst\(\)', line)
            if not m or line.strip().startswith('//'):
                continue
            var = m.group(1)
            # Look ahead for Next() on same var
            ahead = '\n'.join(lines[i:min(len(lines), i+20)])
            if re.search(rf'\b{re.escape(var)}\.Next\(\)', ahead):
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": f"'{var}.FindFirst()' followed by Next() — use FindSet() for multi-row iteration"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        def replace(m):
            var = m.group(1)
            pos = m.end()
            ahead = text[pos:pos+300]
            if re.search(rf'\b{re.escape(var)}\.Next\(\)', ahead):
                return f"{var}.FindSet()"
            return m.group(0)
        return re.sub(r'(\w+)\.FindFirst\(\)', replace, text)


# ───────────────────────────────────────────────────────────────────────
# PATTERN 14 — FindSet guard before ModifyAll (unnecessary)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="FINDSET_BEFORE_MODIFYALL",
    group="Bulk Operations",
    severity="MEDIUM",
    title="FindSet() guard before ModifyAll() — unnecessary (double scan)",
    description=('Calling FindSet() immediately before ModifyAll() fires an extra SELECT just to confirm rows exist. ModifyAll() already handles empty result sets gracefully — it does nothing if no rows match the current filters. The FindSet is pure overhead with zero functional benefit.\n\nSQL IMPACT: Extra query: SELECT TOP 50 ... (only to check existence).\nThen: UPDATE ... WHERE ... (ModifyAll — does this anyway).\nWith FindSet: 2 queries (SELECT + UPDATE). Without: 1 query (UPDATE only).\n\nBAD:  if Record.FindSet() then Record.ModifyAll(...);\nGOOD: Record.ModifyAll(...);\n\nHINT: Look at SQL before ModifyAll with and without FindSet. With FindSet: 2 queries. Without: 1 query.'),
    exercises=[15],
)
class PatternFindSetBeforeModifyAll:
    _RE = re.compile(r'if\s+(\w+)\.FindSet\(\)\s+then\s+\n?\s+\1\.ModifyAll\(', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternFindSetBeforeModifyAll._RE,
                         lambda m: f"FindSet() guard before ModifyAll() on '{m.group(1)}' is redundant")

    @staticmethod
    def fix(text: str) -> str:
        return re.sub(
            r'if\s+(\w+)\.FindSet\(\)\s+then\s*\n(\s+)\1\.ModifyAll\(',
            r'\2\1.ModifyAll(',
            text
        )


# ───────────────────────────────────────────────────────────────────────
# PATTERN 15 — SetFilter on FlowField (use SetAutoCalcFields + AL filter)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="SETFILTER_ON_FLOWFIELD",
    group="FlowFields",
    severity="HIGH",
    title="SetFilter on FlowField causes correlated subquery per row",
    description=("SetFilter on a FlowField (e.g. Balance, which is a CalcField) cannot be pushed to the SQL WHERE clause — it has no physical column. BC must fetch ALL rows matching the other filters, then compute the FlowField for each row individually and filter in AL. Full table scan.\n\nSQL IMPACT: SELECT all rows ... then per row: SELECT SUM(...) for FlowField.\nSQL cannot filter on a computed value it hasn't calculated yet.\n\nBAD:  Customer.SetFilter(Balance, '>%1', 0); if Customer.FindSet() then ...\nGOOD: Customer.SetAutoCalcFields(Balance);\n      if Customer.FindSet() then repeat if Customer.Balance > 0 then ...\n\nHINT: Try SetFilter(Balance, '>1000') — check the SQL WHERE. Balance won't appear in WHERE — all rows fetched. Compare with filtering on a normal indexed decimal field."),
    exercises=[16],
)
class PatternSetFilterOnFlowField:
    # Common FlowFields in BC
    _FLOWFIELDS = {'Balance', 'Balance (LCY)', 'Sales (LCY)', 'Purchases (LCY)',
                   'Outstanding Orders', 'Outstanding Invoices', 'Net Change'}
    _RE = re.compile(r'(\w+)\.SetFilter\(([^,)]+),', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        for m in PatternSetFilterOnFlowField._RE.finditer(text):
            field = m.group(2).strip().strip('"')
            if field in PatternSetFilterOnFlowField._FLOWFIELDS:
                line = _find_line(text, m.start())
                findings.append({
                    "line": line,
                    "snippet": m.group(0)[:120],
                    "message": f"SetFilter on FlowField '{field}' — use SetAutoCalcFields + AL-side filter"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 16 — OR / AND both sides always evaluated (use nested IF)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="EAGER_EVALUATION_OR_AND",
    group="Short-Circuit Evaluation",
    severity="MEDIUM",
    title="AL 'or'/'and' evaluates both sides eagerly — use nested IF for expensive calls",
    description=('AL evaluates BOTH sides of OR/AND regardless of the left side result. If the left condition calls an expensive function (FindSet, CalcFields), the right side still runs even when left already determines the result. Nested IF statements provide proper short-circuit behavior.\n\nSQL IMPACT: No SQL change — both function calls execute unconditionally.\nWith nested IF: expensive right-side call skipped when left is true/false.\n\nBAD:  if ExpensiveA() or ExpensiveB() then\nGOOD: if ExpensiveA() then ProcessResult()\n      else if ExpensiveB() then ProcessResult();\n\nHINT: Add trace messages inside each expensive function. Count how many times each is called with OR vs nested IF. Right-side function should not run when left is true.'),
    exercises=[17, 18, 39],
)
class PatternEagerEvaluation:
    # Heuristic: function calls as operands of or/and
    _RE = re.compile(r'\b(\w+\([^)]*\))\s+(or|and)\s+(\w+\([^)]*\))', re.MULTILINE | re.IGNORECASE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        for m in PatternEagerEvaluation._RE.finditer(text):
            if text[max(0, m.start()-2):m.start()].strip().startswith('//'):
                continue
            line = _find_line(text, m.start())
            line_text = text.splitlines()[line-1].strip()
            if line_text.startswith('//'):
                continue
            findings.append({
                "line": line,
                "snippet": m.group(0)[:120],
                "message": f"Eager evaluation: '{m.group(2).upper()}' always evaluates both sides — use nested IF or 'case true of'"
            })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text  # Requires understanding of intent


# ───────────────────────────────────────────────────────────────────────
# PATTERN 17 — SetRange/filter mutation inside FindSet loop
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="FILTER_MUTATION_IN_LOOP",
    group="Cursor Safety",
    severity="HIGH",
    title="SetRange/SetFilter inside FindSet loop corrupts cursor",
    description=("Setting a new filter inside a FindSet loop modifies the record variable's filter state. Next() continues on the OLD cursor, not the new filter. Result: records may be missed, wrong data returned, or infinite loop. The cursor position becomes undefined after a SetRange mid-loop.\n\nSQL IMPACT: Cursor established by FindSet, then filter changed → Next() undefined behavior. Hard to reproduce bugs.\n\nBAD:  if Rec.FindSet() then repeat Rec.SetRange(Field, Rec.Field); until Rec.Next()=0;\nGOOD: Collect keys into a List first, then process with Get().\n\nHINT: Set a breakpoint inside the loop after SetRange. Watch which records Next() returns after the filter change."),
    exercises=[19],
)
class PatternFilterMutationInLoop:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        in_loop = False
        loop_var = None
        for i, line in enumerate(lines):
            m = re.search(r'(\w+)\.FindSet', line)
            if m and not line.strip().startswith('//'):
                in_loop = True
                loop_var = m.group(1)
            if in_loop and loop_var:
                if re.search(rf'\b{re.escape(loop_var)}\.(SetRange|SetFilter)\(', line) and not line.strip().startswith('//'):
                    findings.append({
                        "line": i + 1,
                        "snippet": line.strip()[:120],
                        "message": f"'{loop_var}.SetRange/SetFilter' inside FindSet loop — corrupts cursor"
                    })
            if re.match(r'until\s+\w+\.Next\(\)', line.strip(), re.IGNORECASE):
                in_loop = False
                loop_var = None
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 18 — FindSet before DeleteAll (unnecessary guard)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="FINDSET_BEFORE_DELETEALL",
    group="Bulk Operations",
    severity="MEDIUM",
    title="FindSet() guard before DeleteAll() is redundant",
    description=('Same anti-pattern as FindSet before ModifyAll — calling FindSet() before DeleteAll() fires an extra SELECT just to verify rows exist. DeleteAll() already handles empty result sets — it does nothing.\n\nSQL IMPACT: Extra query: SELECT TOP 50 ... (only to check existence).\nThen: DELETE FROM ... WHERE ... (DeleteAll — does this anyway).\nFindSet before DeleteAll = 2 SQL queries. Just DeleteAll = 1 SQL DELETE statement.\n\nBAD:  if Record.FindSet() then Record.DeleteAll();\nGOOD: Record.DeleteAll();\n\nHINT: Same as FindSet before ModifyAll but for DeleteAll. With FindSet: 2 queries. Without: 1 DELETE statement.'),
    exercises=[20],
)
class PatternFindSetBeforeDeleteAll:
    _RE = re.compile(r'if\s+(\w+)\.FindSet\(\)\s+then\s*\n?\s*\1\.DeleteAll\(', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternFindSetBeforeDeleteAll._RE,
                         lambda m: f"FindSet() guard before DeleteAll() on '{m.group(1)}' is redundant")

    @staticmethod
    def fix(text: str) -> str:
        return re.sub(
            r'if\s+(\w+)\.FindSet\(\)\s+then\s*\n(\s+)\1\.DeleteAll\(',
            r'\2\1.DeleteAll(',
            text
        )


# ───────────────────────────────────────────────────────────────────────
# PATTERN 19 — DeleteAll without IsEmpty guard on lock-sensitive records
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="DELETEALL_NO_ISEMPTY_GUARD",
    group="Locking",
    severity="LOW",
    title="DeleteAll() without IsEmpty guard acquires write lock even when empty",
    description=('DeleteAll() on an empty (or likely-empty) table still fires a DELETE FROM ... SQL statement — acquiring a write lock even if there are zero rows to delete. Under high concurrency, unnecessary lock acquisition causes contention.\n\nSQL IMPACT: DELETE FROM ... WHERE ... → acquires write lock even if 0 rows affected.\nIsEmpty guard: IF EXISTS check first → skip DELETE if empty.\n\nCONSIDER: if not Record.IsEmpty() then Record.DeleteAll(false);\n\nHINT: Call DeleteAll on an empty table in SQL Profiler. Without guard: DELETE fires even with 0 rows. With IsEmpty guard: DELETE skipped entirely.'),
    exercises=[21],
)
class PatternDeleteAllNoGuard:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            m = re.search(r'(\w+)\.DeleteAll\(', line)
            if not m or line.strip().startswith('//'):
                continue
            var = m.group(1)
            # Check 2 lines above for IsEmpty guard on same var
            context = '\n'.join(lines[max(0, i-2):i])
            if f'{var}.IsEmpty' not in context:
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": f"Consider 'if not {var}.IsEmpty() then' guard before DeleteAll() to avoid locking on empty sets"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 20 — Count() = 1 "exactly one" check (use FindFirst + Next)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="COUNT_EQUALS_ONE",
    group="Existence Checks",
    severity="MEDIUM",
    title="Count() = 1 to check uniqueness scans entire set",
    description=("Count() = 1 requires the database to count ALL matching rows. To check 'exactly one record exists', you only need to fetch two rows: FindFirst() gets the first, Next() = 0 confirms there is no second. Maximum 2 row reads.\n\nSQL IMPACT: Count() = 1: SELECT COUNT(*) FROM ... → full table scan.\nFindFirst + Next: SELECT TOP 1 then SELECT TOP 1 → max 2 rows read.\n\nBAD:  exit(Record.Count() = 1);\nGOOD: if Record.FindFirst() then exit(Record.Next() = 0)\n      else exit(false);\n\nHINT: Compare SQL for Count()=1 vs FindFirst+Next approach. Count() reads entire matching set. FindFirst+Next reads at most 2 rows."),
    exercises=[22],
)
class PatternCountEqualsOne:
    _RE = re.compile(r'(\w+)\.Count\(\)\s*=\s*1', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternCountEqualsOne._RE,
                         lambda m: f"Count() = 1 scans entire set — use FindFirst() + Next() = 0")

    @staticmethod
    def fix(text: str) -> str:
        def replace(m):
            var = m.group(1)
            # Look at context to see if it's in an exit()
            return f'{var}.FindFirst() and ({var}.Next() = 0)'
        return PatternCountEqualsOne._RE.sub(replace, text)


# ───────────────────────────────────────────────────────────────────────
# PATTERN 21 — Insert-on-conflict pattern (try Insert first, Modify on fail)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="INSERT_ON_CONFLICT",
    group="Write Patterns",
    severity="MEDIUM",
    title="Insert-on-conflict anti-pattern (try Insert, Modify on fail)",
    description=('The Insert always fires. On duplicate key, SQL raises a constraint error that is caught and triggers a Modify. Error handling in SQL is extremely expensive — each conflict = a rolled-back statement + error event.\n\nSQL IMPACT: On conflict: INSERT (fails) → SQL error → error handling → UPDATE.\nWith Get: SELECT (1 row) → branch → INSERT or UPDATE (no errors).\n\nBAD:  if not Record.Insert(false) then Record.Modify(false);\nGOOD: if Record.Get(KeyValue) then Record.Modify(false)\n      else begin Record.Init(); Record.Insert(false); end;\n\nHINT: On conflict: INSERT path fires a SQL error event — visible in Profiler. Get+branch: no error events.'),
    exercises=[23],
)
class PatternInsertOnConflict:
    _RE = re.compile(r'if not \w+\.Insert\((?:false|true)?\) then\s+\w+\.Modify\(', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternInsertOnConflict._RE,
                         lambda m: "Insert-on-fail pattern — use Get() then Modify/Insert for clarity and efficiency")

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 22 — SetCurrentKey missing for sorted iteration
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="MISSING_SETCURRENTKEY",
    group="Sort / Keys",
    severity="MEDIUM",
    title="Find('-') or FindSet without SetCurrentKey when order matters",
    description=('Find(\'-\') always reads in PRIMARY KEY ascending order, regardless of any SetCurrentKey call made before it. To read data in a specific sort order, use FindSet() after SetCurrentKey and (for descending) SetAscending(false).\n\nSQL IMPACT: Find(\'-\'): always ORDER BY primary key ASC — SetCurrentKey ignored.\nFindSet with SetAscending: ORDER BY <key> DESC — correct ordering.\n\nBAD:  Record.SetCurrentKey(\\"Posting Date\\"); if Record.Find(\'-\') then ...\nGOOD: Record.SetCurrentKey(\\"Posting Date\\");\n      Record.SetAscending(\\"Posting Date\\", false);\n      if Record.FindSet() then ...\n\nHINT: Check ORDER BY in SQL after Find(\'-\') with SetCurrentKey. SetCurrentKey is ignored — ORDER BY uses primary key.'),
    exercises=[24],
)
class PatternMissingSetCurrentKey:
    @staticmethod
    def detect(text: str) -> list[dict]:
        return []  # Covered by FIND_DASH_BUFFER_ONE; too context-specific to detect generically

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 23 — Temp table as collection (use List/Dictionary)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="TEMP_TABLE_AS_COLLECTION",
    group="Memory / Copies",
    severity="MEDIUM",
    title="Temporary table used purely as a collection (use List or Dictionary)",
    description=('Using a temporary table purely to collect distinct scalar values (dates, IDs, codes) carries full record-layer overhead: schema validation, key index maintenance, Init/Insert/FindSet calls. List of [T] is a native AL type with zero record overhead.\n\nSQL IMPACT: Temp table Insert/FindSet: record struct overhead per value.\nList of [Date]: direct array access, no schema, no key lookup.\n\nBAD:  TempDates: Record \\"Workshop Data\\" temporary; TempDates.\\"Posting Date\\" := ...; TempDates.Insert();\nGOOD: Dates: List of [Date]; if not Dates.Contains(PostingDate) then Dates.Add(PostingDate);\n\nHINT: Compare temp table Insert/FindSet vs List.Add/iteration. Temp table: schema overhead even in memory. List: pure NST memory array.'),
    exercises=[25],
)
class PatternTempTableAsCollection:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            m = re.search(r'(Temp\w+)\s*:\s*Record\s+\S+\s+temporary', line)
            if not m:
                continue
            var = m.group(1)
            rest = '\n'.join(lines[i:min(len(lines), i+80)])
            # Pure collection: Insert without reading back meaningful fields
            has_insert = bool(re.search(rf'\b{re.escape(var)}\.Insert\(', rest))
            has_get = bool(re.search(rf'\b{re.escape(var)}\.Get\(', rest))
            has_setrange = bool(re.search(rf'\b{re.escape(var)}\.SetRange\(', rest))
            if has_insert and has_setrange and not has_get:
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": f"'{var}' used as collection (Insert+SetRange, no Get) — use List of [...] instead"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 24 — FindLast / FindFirst inside a loop
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="FINDLAST_IN_LOOP",
    group="Data Transfer",
    severity="HIGH",
    title="FindLast()/FindFirst() inside a loop (call once before the loop)",
    description=('Calling FindLast() inside a loop to determine the next Entry No. fires SELECT MAX(\\"Entry No_\\") ... or ORDER BY DESC FETCH 1 on EVERY iteration. For 5 000 lines that is 5 000 SQL round-trips for a counter. One FindLast() before the loop + a local counter is O(1).\n\nSQL IMPACT: Per iteration: SELECT TOP 1 ... ORDER BY \\"Entry No_\\" DESC = N SQL queries.\n\nBAD:  foreach Line in ImportSource do begin Record.FindLast(); NextNo := Record.\\"Entry No.\\" + 1; ...\nGOOD: Record.FindLast(); NextNo := Record.\\"Entry No.\\" + 1;\n      foreach Line in ImportSource do begin NextNo += 1; ... end;\n\nHINT: Trace FindLast() calls in the loop with SQL Profiler. Each iteration fires ORDER BY DESC FETCH 1. Single FindLast before loop: 1 SQL query total.'),
    exercises=[26],
)
class PatternFindLastInLoop:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        in_loop = False
        for i, line in enumerate(lines):
            stripped = line.strip()
            if re.search(r'\bforeach\b|\brepeat\b', stripped, re.IGNORECASE):
                in_loop = True
            if re.match(r'until\s+\w+\.Next\(\)', stripped, re.IGNORECASE) or (stripped == 'end;' and in_loop):
                in_loop = False
            if in_loop and re.search(r'\w+\.(FindLast|FindFirst)\(\)', line) and not stripped.startswith('//'):
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": "FindLast/FindFirst inside loop — call once before the loop and cache the result"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 25 — LockTable + FindLast for sequence generation (use NumberSequence)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="LOCKTABLE_FOR_SEQUENCE",
    group="Locking",
    severity="HIGH",
    title="LockTable + FindLast for sequence numbers — use NumberSequence",
    description=("LockTable() acquires a full table-level exclusive write lock held for the entire transaction. Any concurrent session needing this table blocks. Under high-volume processing (hundreds of operations per minute) this creates lock wait queues and eventual timeout errors.\n\nSQL IMPACT: LockTable: X-lock on entire table for transaction duration.\nNumberSequence.Next(): atomic counter at DB level — no table lock.\n\nBAD:  Record.LockTable(true); if Record.FindLast() then NextNo := Record.PK + 1;\nGOOD: if not NumberSequence.Exists('MY_SEQ') then NumberSequence.Insert('MY_SEQ',1,1,false);\n      NextNo := NumberSequence.Next('MY_SEQ');\n\nHINT: LockTable: watch lock events in SQL Profiler. NumberSequence: no table lock — atomic sequence increment. Compare concurrency: run two sessions simultaneously."),
    exercises=[28],
)
class PatternLockTableForSequence:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            if re.search(r'\w+\.LockTable\(', line) and not line.strip().startswith('//'):
                # Look ahead for FindLast to get next key
                ahead = '\n'.join(lines[i:min(len(lines), i+8)])
                if re.search(r'FindLast\(\)', ahead) and re.search(r'Entry No|NextSeq|NextNo|NextKey', ahead, re.IGNORECASE):
                    findings.append({
                        "line": i + 1,
                        "snippet": line.strip()[:120],
                        "message": "LockTable + FindLast for sequence generation — use NumberSequence.Next() instead"
                    })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 26 — SetRange on PK + FindFirst instead of Get
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="SETRANGE_FINDSET_FOR_GET",
    group="Data Transfer",
    severity="MEDIUM",
    title="SetRange on PK + FindFirst instead of direct Get()",
    description=('SetRange on a primary key field followed by FindFirst() goes through the filter+scan path instead of the optimized single-row lookup. Get() uses the primary key index directly — no cursor setup, hits the clustered index directly.\n\nSQL IMPACT: SetRange+FindFirst: SELECT TOP 50 ... WHERE \\"No_\\"=X (cursor setup overhead).\nGet(): Direct clustered index point lookup — no cursor. Measurably faster in high-frequency loops.\n\nBAD:  Customer.SetRange(\\"No.\\", CustomerNo); if Customer.FindFirst() then ...\nGOOD: if Customer.Get(CustomerNo) then ...\n\nHINT: Compare SELECT TOP 50 (SetRange+FindFirst) vs direct lookup. Get() hits clustered index directly — 1 read, no cursor.'),
    exercises=[29],
)
class PatternSetRangeFindFirstForGet:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            m = re.search(r'(\w+)\.SetRange\("No\.",\s*\w+\)', line)
            if not m or line.strip().startswith('//'):
                continue
            var = m.group(1)
            ahead = '\n'.join(lines[i:min(len(lines), i+3)])
            if re.search(rf'\b{re.escape(var)}\.FindFirst\(\)', ahead):
                findings.append({
                    "line": i + 1,
                    "snippet": line.strip()[:120],
                    "message": f"'{var}.SetRange(\"No.\", ...) + FindFirst()' — use '{var}.Get(...)' directly"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 27 — Silent Insert failure (if Insert then)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="SILENT_INSERT_FAILURE",
    group="Write Patterns",
    severity="MEDIUM",
    title="'if Record.Insert(false) then' silently swallows duplicate-key errors",
    description=("In AL, Insert(false) does NOT suppress the SQL unique constraint error — it still propagates. Wrapping it in 'if ... then' gives a false sense that the failure is handled. In practice the record silently isn't created and the caller never knows, leading to data integrity gaps.\n\nSQL IMPACT: SQL unique constraint error still raised — 'if then' doesn't catch SQL errors.\nSilent failure → missing records → integrity gap.\n\nBAD:  if Record.Insert(false) then MovementCount += 1;\nGOOD: Record.Insert(false); MovementCount += 1;\n\nHINT: Insert a duplicate key row with 'if Insert then'. Check SQL Profiler — does the error appear? The record is not created but no AL error raised."),
    exercises=[30],
)
class PatternSilentInsertFailure:
    _RE = re.compile(r'if\s+\w+\.Insert\((?:false|true)\)\s+then', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternSilentInsertFailure._RE,
                         lambda m: "Silent Insert — errors won't surface. Use plain Insert() or handle explicitly")

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 28 — LockTable too early (before read-only phase)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="LOCKTABLE_TOO_EARLY",
    group="Locking",
    severity="HIGH",
    title="LockTable() called before read phase — holds write lock during reads",
    description=('LockTable() at the top of a procedure holds an exclusive lock through the entire validation / read phase — which may take seconds on large data. Every other session needing this table is blocked for the full duration. The lock is only needed at the moment of the first write.\n\nSQL IMPACT: X-lock held from top of proc through entire read phase (seconds).\nvs. X-lock acquired just before first Modify (milliseconds).\n\nBAD:  WorkshopData.LockTable(); ... if WorkshopData.FindSet() then [read loop] ...\nGOOD: [read loop without lock] ... WorkshopData.LockTable(); [write phase only]\n\nHINT: Use Activity Monitor or Profiler lock events. LockTable at start: X-lock held during entire read phase. LockTable at write phase: X-lock held for milliseconds only.'),
    exercises=[31, 42],
)
class PatternLockTableTooEarly:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            if re.search(r'\w+\.LockTable\(', line) and not line.strip().startswith('//'):
                # Check if FindSet follows (read phase)
                ahead = '\n'.join(lines[i:min(len(lines), i+15)])
                if re.search(r'\.FindSet\(\)', ahead):
                    findings.append({
                        "line": i + 1,
                        "snippet": line.strip()[:120],
                        "message": "LockTable() before FindSet — move lock closer to the write operation"
                    })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 29 — Missing ReadIsolation (dirty reads safe = ReadUncommitted)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="MISSING_READ_ISOLATION",
    group="Locking",
    severity="MEDIUM",
    title="FindSet on reporting/read-only query without ReadIsolation = ReadUncommitted",
    description=('Read-only analytics FindSet acquires Shared (S) locks on every fetched page. Concurrent warehouse write sessions hold Exclusive (X) locks on same rows. Result: analytics blocks postings, postings block analytics. On a 50 000-row scan, S-locks are held for several seconds.\n\nSQL IMPACT: Default isolation: Shared (S) locks per page fetched.\nReadUncommitted: NO lock acquisition — readers never block writers.\n\nGOOD: WorkshopData.ReadIsolation := IsolationLevel::ReadUncommitted;\n      if WorkshopData.FindSet() then ...\n\nHINT: Without ReadUncommitted: watch S-lock events per page in SQL Profiler. With ReadUncommitted: zero S-lock events — readers invisible. Never use for financial postings or validation.'),
    exercises=[34],
)
class PatternMissingReadIsolation:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        for i, line in enumerate(lines):
            if re.search(r'\w+\.FindSet\(\)', line) and not line.strip().startswith('//'):
                # Procedure name suggests reporting
                context_above = '\n'.join(lines[max(0, i-30):i])
                if re.search(r'Report|Dashboard|Export|Build.*Report|Snapshot', context_above, re.IGNORECASE):
                    if 'ReadIsolation' not in context_above:
                        findings.append({
                            "line": i + 1,
                            "snippet": line.strip()[:120],
                            "message": "Reporting FindSet without ReadIsolation := ReadUncommitted — may block concurrent writes"
                        })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 30 — RecordRef/FieldRef when typed Record is sufficient
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="RECORDREF_WHEN_TYPED_SUFFICIENT",
    group="Memory / Copies",
    severity="LOW",
    title="RecordRef/FieldRef used when a typed Record variable would suffice",
    description=('RecordRef provides late-bound, reflection-based table access. Each Field() call does a dictionary lookup + type boxing. SQL generation is less optimized than for typed Record variables. Benchmarks show 3–5x slower reads than typed Record on same data.\n\nSQL IMPACT: RecordRef: Field() lookup + boxing overhead per field per row.\nTyped Record: direct field access, compiler-optimized SQL.\n\nBAD:  RecRef: RecordRef; RecRef.Open(Database::\\"Workshop Data\\"); RecRef.Field(2).Value := ...;\nGOOD: WorkshopData: Record \\"Workshop Data\\"; WorkshopData.Description := ...;\n\nHINT: Compare RecordRef.Field(2).Value vs typed WorkshopData.Description. Run a 10 000-row loop with each — time the difference. RecordRef is 3–5x slower.'),
    exercises=[35],
)
class PatternRecordRefUnnecessary:
    _RE = re.compile(r'\bRecRef\s*:\s*RecordRef\b|\bFldRef\s*:\s*FieldRef\b', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternRecordRefUnnecessary._RE,
                         lambda m: "RecordRef/FieldRef — consider typed Record variable if table is known at compile time")

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 31 — ModifyAll with RunTrigger=true
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="MODIFYALL_RUNTRIGGER_TRUE",
    group="Bulk Operations",
    severity="HIGH",
    title="ModifyAll with RunTrigger=true fires OnModify trigger per row",
    description=('ModifyAll() with RunTrigger=true checks for OnAfterModify subscribers. If ANY subscriber is bound, ModifyAll falls back to N individual Modify() calls — one per record — each triggering the subscriber. 10 000 records × 1 Modify() call = 10 000 SQL UPDATE round-trips.\n\nSQL IMPACT: With RunTrigger=true + active subscriber: N × UPDATE per row.\nWith RunTrigger=false: 1 × UPDATE ... WHERE ... (single SQL statement).\n\nBAD:  Record.ModifyAll(Field, Value, true);\nGOOD: Record.ModifyAll(Field, Value, false);\n\nHINT: Bind the subscriber and run ModifyAll with RunTrigger=true. SQL Profiler: count UPDATE statements — should be N rows. Change to RunTrigger=false: now count is 1 UPDATE statement.'),
    exercises=[37],
)
class PatternModifyAllRunTrigger:
    _RE = re.compile(r'\w+\.ModifyAll\([^)]+,\s*true\)', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternModifyAllRunTrigger._RE,
                         lambda m: "ModifyAll with RunTrigger=true fires OnModify per row — use false unless required")

    @staticmethod
    def fix(text: str) -> str:
        return re.sub(
            r'(\w+\.ModifyAll\([^)]+,\s*)true(\))',
            r'\1false\2',
            text
        )


# ───────────────────────────────────────────────────────────────────────
# PATTERN 32 — Missing Database.SelectLatestVersion in multi-pass loop
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="MISSING_SELECTLATESTVERSION",
    group="Stale Reads",
    severity="MEDIUM",
    title="Multi-pass read loop without Database.SelectLatestVersion()",
    description=('BC NST caches SQL query results in-session. Repeated FindSet calls with the same filter return CACHED rows — no SQL executed after pass 1. A multi-pass pipeline reading the same filter silently returns stale data from pass 1 for passes 2–N if data changed concurrently.\n\nSQL IMPACT: Pass 1: SELECT ... (real SQL).\nPass 2–N: [NST cache hit] → no SQL, no awareness of concurrent updates.\n\nGOOD: foreach Pass in Passes do begin\n          Database.SelectLatestVersion(); // Flushes non-locked session cache\n          if Record.FindSet() then ...\n\nHINT: Run the pipeline twice: with and without SelectLatestVersion. Without flush: 0 SQL queries for passes 2–N (cache hit — stale data).'),
    exercises=[38],
)
class PatternMissingSelectLatestVersion:
    @staticmethod
    def detect(text: str) -> list[dict]:
        return []  # Too context-specific; covered by FIX comment detection

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 33 — OR chain instead of case true of (3+ conditions)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="OR_CHAIN_USE_CASE_TRUE",
    group="Short-Circuit Evaluation",
    severity="MEDIUM",
    title="3+ OR conditions — use 'case true of' for short-circuit evaluation",
    description=('AL evaluates ALL operands of or before returning — even if the first operand is already true. Three expensive eligibility checks joined with or each execute a CalcSums or FindSet query — all three, every time.\n\nSQL IMPACT: 3 SQL queries per customer: CalcSums + IsEmpty + Count.\nEven when the first check already returns true — wasted 2 queries.\ncase true of with comma-separated conditions short-circuits at first true.\n\nBAD:  if IsOverCreditLimit(No) or HasBlockedItems(No) or HasOverdueInvoices(No) then ...\nGOOD: case true of\n          IsOverCreditLimit(No), HasBlockedItems(No), HasOverdueInvoices(No):\n              exit(false);\n      end;\n\nHINT: Add a counter inside each validation function. With or: all three counters increment for every customer. With case true of: only 1–2 counters increment when first is true.'),
    exercises=[39],
)
class PatternOrChainCaseTrue:
    _RE = re.compile(r'\bif\b[^;]+\bor\b[^;]+\bor\b[^;]+\bthen\b', re.MULTILINE | re.IGNORECASE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        for m in PatternOrChainCaseTrue._RE.finditer(text):
            line = _find_line(text, m.start())
            line_text = text.splitlines()[line-1].strip()
            if line_text.startswith('//'):
                continue
            # Count function calls in the OR chain
            if len(re.findall(r'\w+\(', m.group(0))) >= 3:
                findings.append({
                    "line": line,
                    "snippet": m.group(0)[:120],
                    "message": "3+ OR conditions with function calls — use 'case true of' for short-circuit"
                })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 34 — LockTable + ReadIsolation UpdLock (Ex42)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="LOCKTABLE_USE_UPDLOCK",
    group="Locking",
    severity="MEDIUM",
    title="LockTable() — consider ReadIsolation := UpdLock + FindSet(true) instead",
    description=('LockTable() acquires a table-level Exclusive (X) lock on the ENTIRE table. Every concurrent session — reads, analytics, order entry — blocks for the full transaction duration. A batch updating 1 000 rows can block all other sessions for seconds.\n\nSQL IMPACT: LockTable: X-lock on entire table — held for full transaction.\nReadIsolation := UpdLock + FindSet(true): acquires update locks only on rows actually read, allowing concurrent readers.\n\nBAD:  Record.LockTable();\n      if Record.FindSet() then\nGOOD: Record.ReadIsolation := IsolationLevel::UpdLock;\n      if Record.FindSet(true) then\n\nHINT: Open two BC sessions simultaneously. Session 1: run LockTable. Session 2: try any read — it blocks until Session 1 commits. With UpdLock: Session 2 reads freely.'),
    exercises=[42],
)
class PatternLockTableUseUpdLock:
    _RE = re.compile(r'(\w+)\.LockTable\(\)', re.MULTILINE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternLockTableUseUpdLock._RE,
                         lambda m: f"Consider replacing '{m.group(1)}.LockTable()' with ReadIsolation := UpdLock + FindSet(true)")

    @staticmethod
    def fix(text: str) -> str:
        def replace(m):
            var = m.group(1)
            pos = m.end()
            ahead = text[pos:pos+200]
            if re.search(rf'\b{re.escape(var)}\.FindSet\(\)', ahead):
                replacement = f'{var}.ReadIsolation := IsolationLevel::UpdLock'
                # Also fix the FindSet in one pass
                return replacement
            return m.group(0)
        result = PatternLockTableUseUpdLock._RE.sub(replace, text)
        result = re.sub(r'(\w+)\.ReadIsolation := IsolationLevel::UpdLock;\s*\n(\s+)if \1\.FindSet\(\)',
                        r'\1.ReadIsolation := IsolationLevel::UpdLock;\n\2if \1.FindSet(true)', result)
        return result


# ───────────────────────────────────────────────────────────────────────
# PATTERN 35 — true in [...] condition order (cheapest first)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="CONDITION_ORDER_TRUE_IN",
    group="Short-Circuit Evaluation",
    severity="LOW",
    title="'if true in [...]' — put cheapest condition first for best short-circuit",
    description=("AL's in [...] operator DOES short-circuit — unlike or/\x07nd. But placing the most expensive check FIRST defeats the benefit: the CalcSums fires before the cheap blacklist Get() is even tested. Rule: always order conditions cheapest-first in in [...] lists.\n\nSQL IMPACT: Expensive-first: CalcSums runs for ~100% of customers.\nCheap-first: CalcSums skipped for the ~35% caught by cheaper checks first.\n\nBAD:  if true in [HasExceededAnnualBudget(No), IsBlacklisted(No)] then ...\nGOOD: if true in [IsBlacklisted(No), HasExceededAnnualBudget(No)] then ...\n\nHINT: Add a Message() counter inside HasExceededAnnualBudget. Run with expensive-first: counter = total customer count. Reorder to cheap-first: counter drops by ~35%."),
    exercises=[44],
)
class PatternConditionOrderTrueIn:
    _RE = re.compile(r'if true in \[', re.MULTILINE | re.IGNORECASE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(text, PatternConditionOrderTrueIn._RE,
                         lambda m: "Review condition order: put cheapest check first for best short-circuit performance")

    @staticmethod
    def fix(text: str) -> str:
        return text


# ───────────────────────────────────────────────────────────────────────
# PATTERN 36 — N+1 nested FindSet inside repeat..until loop (Ex 27 / 43)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="NESTED_FINDSET_N_PLUS_ONE",
    group="Data Transfer",
    severity="HIGH",
    title="Nested FindSet/FindFirst inside repeat..until loop (N+1 queries)",
    description=(
        "For each row in the outer FindSet, an inner FindSet on a different variable fires a new SQL query. "
        "With 1 000 outer items: 1 outer SELECT + 1 000 inner SELECTs = 1 001 SQL round-trips. "
        "A Query object with GROUP BY does the same work in a single SQL query.\n\n"
        "SQL IMPACT: 1 000 items × 1 inner query = 1 001 total SQL round-trips.\n"
        "Query object: 1 SQL query with GROUP BY — result set = N groups only.\n\n"
        "BAD:  if Items.FindSet() then repeat\n"
        "          SalesLines.SetRange(\"No.\", Items.\"No.\");\n"
        "          if SalesLines.FindSet() then repeat ... until SalesLines.Next() = 0;\n"
        "      until Items.Next() = 0;\n"
        "GOOD: var AnalysisQuery: Query \"Workshop Item Analysis\";\n"
        "      if AnalysisQuery.Open() then\n"
        "          while AnalysisQuery.Read() do ...\n\n"
        "HINT: Count SQL queries in Profiler for the nested loop. Each outer row fires 1 inner SQL query. "
        "Query object version: 1 SQL query with GROUP BY regardless of data volume."
    ),
    exercises=[27, 43],
)
class PatternNestedFindSetNPlusOne:
    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        lines = text.splitlines()
        outer_var: str | None = None
        in_loop = False

        for i, line in enumerate(lines):
            stripped = line.strip()
            if stripped.startswith('//'):
                continue

            # Track outer FindSet before a repeat
            m_outer = re.search(r'(\w+)\.(FindSet|FindFirst)\(', line)
            if m_outer and not in_loop:
                outer_var = m_outer.group(1)

            if re.match(r'^repeat\b', stripped, re.IGNORECASE) and outer_var:
                in_loop = True

            if in_loop:
                m_inner = re.search(r'(\w+)\.(FindSet|FindFirst)\(', line)
                if m_inner and m_inner.group(1) != outer_var:
                    findings.append({
                        "line": i + 1,
                        "snippet": line.strip()[:120],
                        "message": (
                            f"Nested {m_inner.group(2)}() on '{m_inner.group(1)}' inside outer "
                            f"'{outer_var}' FindSet loop — N+1 SQL queries. "
                            "Consider a Query object with GROUP BY."
                        ),
                    })

            if re.match(r'^until\s+\w+\.Next\(\)', stripped, re.IGNORECASE):
                in_loop = False
                outer_var = None

        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text  # Structural change required — no auto-fix


# ───────────────────────────────────────────────────────────────────────
# PATTERN 37 — AutoIncrement = true disables SQL batch INSERT (Ex 36)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="AUTOINCREMENT_DISABLES_BULK_INSERT",
    group="Bulk Operations",
    severity="HIGH",
    title="AutoIncrement = true on PK disables SQL batch INSERT",
    description=(
        "SQL Server IDENTITY (AutoIncrement = true) requires SCOPE_IDENTITY() to be returned "
        "after each INSERT — this prevents batch INSERT entirely. "
        "For 10 000 count sheet lines: 10 000 individual SQL INSERTs, one per row. "
        "Manual PK assignment via NumberSequence allows SQL Server to batch rows into one trip.\n\n"
        "SQL IMPACT: AutoIncrement: 10 000 × INSERT (+ SCOPE_IDENTITY per row).\n"
        "Manual PK with NumberSequence: ~10 batch INSERT statements — orders of magnitude faster.\n\n"
        "BAD:  field(1; Id; Integer) { AutoIncrement = true; }\n"
        "GOOD: field(1; Id; Integer) { }\n"
        "      // In code:\n"
        "      Entry.Id := NumberSequence.Next('WS_COUNT_SEQ');\n"
        "      Entry.Insert(false); // Batchable — no identity return needed\n\n"
        "HINT: Insert 10 000 rows into both tables in SQL Profiler. "
        "AutoIncrement table: 10 000 individual INSERT statements. "
        "Manual key table: ~10 batch INSERT statements total."
    ),
    exercises=[36],
)
class PatternAutoIncrementBulkInsert:
    _RE = re.compile(r'AutoIncrement\s*=\s*true', re.IGNORECASE)

    @staticmethod
    def detect(text: str) -> list[dict]:
        return _findings(
            text,
            PatternAutoIncrementBulkInsert._RE,
            lambda m: (
                "AutoIncrement = true requires SCOPE_IDENTITY() per INSERT — prevents SQL batch inserts. "
                "Remove AutoIncrement and use NumberSequence.Next() for PK assignment."
            ),
        )

    @staticmethod
    def fix(text: str) -> str:
        return text  # Requires table redesign + code change — no auto-fix


# ───────────────────────────────────────────────────────────────────────
# PATTERN 38 — AL-side GROUP BY aggregation (Ex 43)
# ───────────────────────────────────────────────────────────────────────
@_register(
    id="AL_SIDE_AGGREGATION",
    group="Aggregation",
    severity="HIGH",
    title="AL-side GROUP BY aggregation — push to SQL with a Query object",
    description=(
        "Manual AL aggregation: FindSet fetches ALL rows into NST, accumulates sums per group in AL. "
        "For 100 000 entries — 100 000 rows transferred to NST memory. "
        "A Query object with Method = Sum pushes GROUP BY and SUM() to SQL Server. "
        "SQL returns only N rows (one per group) — 99 990 rows never leave the database.\n\n"
        "SQL IMPACT: AL loop:  SELECT all 100 000 rows, SUM in NST memory.\n"
        "Query:     SELECT Location, SUM(Amount) GROUP BY Location → 10 rows only.\n\n"
        "BAD:  if WorkshopData.FindSet() then repeat\n"
        "          TotalByLocation.Add(WorkshopData.\"Location Code\", WorkshopData.Amount);\n"
        "      until WorkshopData.Next() = 0;\n"
        "GOOD: var RevenueQuery: Query \"WS Location Revenue\";\n"
        "      if RevenueQuery.Open() then\n"
        "          while RevenueQuery.Read() do\n"
        "              ProcessSummary(RevenueQuery.Location_Code, RevenueQuery.Sum_Line_Amount);\n\n"
        "HINT: Run the manual loop on 50 000 rows. Check SQL Profiler: count SELECT rows returned. "
        "Then switch to the Query version. Profiler shows 1 query returning only N rows. "
        "Duration difference is dramatic at scale."
    ),
    exercises=[43],
)
class PatternAlSideAggregation:
    # Detect FindSet loop that accumulates into a Dictionary by group key
    _RE = re.compile(
        r'FindSet\s*\([^)]*\).*?repeat.*?\.Add\s*\(',
        re.IGNORECASE | re.DOTALL,
    )

    @staticmethod
    def detect(text: str) -> list[dict]:
        findings = []
        for m in PatternAlSideAggregation._RE.finditer(text):
            line = _find_line(text, m.start())
            snippet = text[m.start(): m.start() + 80].split('\n')[0].strip()
            findings.append({
                "line": line,
                "message": (
                    "AL-side GROUP BY aggregation — fetches all rows to NST. "
                    "Use a Query object with Method = Sum to push GROUP BY to SQL Server."
                ),
                "snippet": snippet,
            })
        return findings

    @staticmethod
    def fix(text: str) -> str:
        return text  # Structural change required — no auto-fix


# ───────────────────────────────────────────────────────────────────────
# Utility helpers
# ───────────────────────────────────────────────────────────────────────

def _scan_file(path: Path) -> list[dict]:
    """Run all detectors on a single AL file. Returns list of finding dicts."""
    try:
        text = path.read_text(encoding='utf-8-sig')
    except Exception as e:
        return [{"pattern": "READ_ERROR", "file": str(path), "line": 0, "snippet": str(e), "message": "Could not read file"}]

    findings = []
    for p in PATTERNS:
        for f in p["detector"](text):
            findings.append({
                "pattern": p["id"],
                "severity": p["severity"],
                "title": p["title"],
                "file": str(path),
                **f
            })
    return findings


def _fix_file(path: Path) -> tuple[str, list[str]]:
    """Apply all fixers to a single AL file. Returns (new_text, list_of_applied_fixes)."""
    try:
        text = path.read_text(encoding='utf-8-sig')
    except Exception as e:
        return "", [f"READ_ERROR: {e}"]

    applied = []
    original = text
    for p in PATTERNS:
        new_text = p["fixer"](text)
        if new_text != text:
            applied.append(p["id"])
            text = new_text

    return text, applied


def _al_files(folder: Path) -> list[Path]:
    return sorted(folder.rglob("*.al"))


# ───────────────────────────────────────────────────────────────────────
# MCP Tools
# ───────────────────────────────────────────────────────────────────────

@mcp.tool()
def list_patterns() -> str:
    """
    List all known AL performance anti-patterns with IDs, severity, and short descriptions.
    Use this to understand what the analyzer can detect before running a scan.
    """
    lines = ["# AL Performance Patterns\n"]
    groups: dict[str, list] = {}
    for p in PATTERNS:
        groups.setdefault(p["group"], []).append(p)

    for group, items in sorted(groups.items()):
        lines.append(f"\n## {group}\n")
        for p in items:
            lines.append(f"- **[{p['severity']}]** `{p['id']}`  \n  {p['title']}  \n  Exercises: {p['exercises']}\n")

    return "\n".join(lines)


@mcp.tool()
def explain_pattern(pattern_id: str) -> str:
    """
    Get a full explanation of a specific performance pattern including examples and the fix.

    Args:
        pattern_id: The pattern ID (e.g. 'MISSING_SETLOADFIELDS'). Use list_patterns() to see all IDs.
    """
    for p in PATTERNS:
        if p["id"].upper() == pattern_id.upper():
            return (
                f"# {p['title']}\n\n"
                f"**ID:** `{p['id']}`  \n"
                f"**Severity:** {p['severity']}  \n"
                f"**Category:** {p['group']}  \n"
                f"**Workshop Exercises:** {p['exercises']}\n\n"
                f"{p['description']}"
            )
    ids = ", ".join(p["id"] for p in PATTERNS)
    return f"Pattern '{pattern_id}' not found. Known IDs: {ids}"


@mcp.tool()
def scan_al_workspace(
    folder_path: str,
    severity_filter: str = "ALL",
    group_filter: str = "ALL",
) -> str:
    """
    Scan all AL files in a folder (recursively) for performance anti-patterns.
    Returns a structured report of findings grouped by file.

    Args:
        folder_path: Absolute path to the folder containing AL source files.
        severity_filter: Filter by severity: HIGH, MEDIUM, LOW, or ALL (default ALL).
        group_filter: Filter by pattern group name or ALL (default ALL).
    """
    folder = Path(folder_path)
    if not folder.exists():
        return f"ERROR: Folder not found: {folder_path}"

    files = _al_files(folder)
    if not files:
        return f"No .al files found in {folder_path}"

    all_findings: list[dict] = []
    for f in files:
        all_findings.extend(_scan_file(f))

    # Apply filters
    if severity_filter.upper() != "ALL":
        all_findings = [f for f in all_findings if f["severity"].upper() == severity_filter.upper()]
    if group_filter.upper() != "ALL":
        all_findings = [f for f in all_findings if
                        any(p["group"].upper() == group_filter.upper()
                            for p in PATTERNS if p["id"] == f["pattern"])]

    if not all_findings:
        return f"✅ No issues found ({len(files)} files scanned)."

    # Group by file
    by_file: dict[str, list] = {}
    for f in all_findings:
        by_file.setdefault(f["file"], []).append(f)

    severity_order = {"HIGH": 0, "MEDIUM": 1, "LOW": 2}
    total = len(all_findings)
    high = sum(1 for f in all_findings if f["severity"] == "HIGH")
    medium = sum(1 for f in all_findings if f["severity"] == "MEDIUM")
    low = sum(1 for f in all_findings if f["severity"] == "LOW")

    lines = [
        f"# AL Performance Scan Results\n",
        f"**Folder:** `{folder_path}`  ",
        f"**Files scanned:** {len(files)}  ",
        f"**Issues found:** {total} ({high} HIGH, {medium} MEDIUM, {low} LOW)\n",
    ]

    for filepath, findings in sorted(by_file.items()):
        rel = Path(filepath).relative_to(folder) if Path(filepath).is_relative_to(folder) else Path(filepath).name
        lines.append(f"\n## `{rel}`\n")
        findings_sorted = sorted(findings, key=lambda x: severity_order.get(x["severity"], 9))
        for f in findings_sorted:
            sev_icon = {"HIGH": "🔴", "MEDIUM": "🟡", "LOW": "🔵"}.get(f["severity"], "⚪")
            lines.append(f"- {sev_icon} **L{f['line']}** `{f['pattern']}`: {f['message']}")
            if f.get("snippet"):
                lines.append(f"  ```al\n  {f['snippet']}\n  ```")

    return "\n".join(lines)


@mcp.tool()
def fix_al_file(
    file_path: str,
    dry_run: bool = True,
) -> str:
    """
    Apply all available automatic fixes to a single AL file.

    Args:
        file_path: Absolute path to the .al file to fix.
        dry_run: If True (default), show what would change without writing. Set False to write.
    """
    path = Path(file_path)
    if not path.exists():
        return f"ERROR: File not found: {file_path}"

    original = path.read_text(encoding='utf-8-sig')
    new_text, applied = _fix_file(path)

    if not applied:
        return f"✅ No automatic fixes applicable to `{path.name}`."

    lines = [f"# Fix Report: `{path.name}`\n"]
    lines.append(f"**Fixes applied:** {', '.join(applied)}\n")

    if dry_run:
        lines.append("**Mode:** DRY RUN — no file written. Set dry_run=False to apply.\n")
        # Show diff summary
        orig_lines = original.splitlines()
        new_lines = new_text.splitlines()
        changes = 0
        for i, (o, n) in enumerate(zip(orig_lines, new_lines)):
            if o != n:
                lines.append(f"L{i+1}: `{o.strip()}` → `{n.strip()}`")
                changes += 1
                if changes >= 20:
                    lines.append(f"... (and more)")
                    break
    else:
        path.write_text(new_text, encoding='utf-8-sig')
        lines.append(f"✅ File written: `{file_path}`")

    return "\n".join(lines)


@mcp.tool()
def fix_al_workspace(
    folder_path: str,
    dry_run: bool = True,
) -> str:
    """
    Apply all available automatic fixes to every AL file in a folder (recursively).

    Args:
        folder_path: Absolute path to the folder containing AL source files.
        dry_run: If True (default), show what would change without writing. Set False to write.
    """
    folder = Path(folder_path)
    if not folder.exists():
        return f"ERROR: Folder not found: {folder_path}"

    files = _al_files(folder)
    if not files:
        return f"No .al files found in {folder_path}"

    results = []
    total_fixes = 0
    for f in files:
        original = f.read_text(encoding='utf-8-sig')
        new_text, applied = _fix_file(f)
        if applied:
            total_fixes += len(applied)
            results.append((f, applied, original != new_text))
            if not dry_run and original != new_text:
                f.write_text(new_text, encoding='utf-8-sig')

    if not results:
        return f"✅ No automatic fixes applicable in {len(files)} files."

    mode = "DRY RUN" if dry_run else "APPLIED"
    lines = [
        f"# Fix Workspace Report [{mode}]\n",
        f"**Folder:** `{folder_path}`  ",
        f"**Files with fixes:** {len(results)} of {len(files)}  ",
        f"**Total fix operations:** {total_fixes}\n",
    ]

    for f, applied, changed in results:
        rel = f.relative_to(folder) if f.is_relative_to(folder) else f.name
        status = "✅ written" if (not dry_run and changed) else ("📝 would change" if changed else "⟳ no change")
        lines.append(f"- `{rel}` [{status}]: {', '.join(applied)}")

    if dry_run:
        lines.append("\n> Set `dry_run=False` to apply all changes.")

    return "\n".join(lines)


@mcp.tool()
def scan_al_code(
    al_code: str,
    file_hint: str = "inline",
) -> str:
    """
    Scan a snippet of AL code (pasted inline) for performance issues.
    Useful for checking code before committing or during code review.

    Args:
        al_code: The AL code text to analyze.
        file_hint: Optional label for the code (e.g. the procedure name).
    """
    findings: list[dict] = []
    for p in PATTERNS:
        for f in p["detector"](al_code):
            findings.append({
                "pattern": p["id"],
                "severity": p["severity"],
                "title": p["title"],
                "file": file_hint,
                **f
            })

    if not findings:
        return "✅ No performance issues detected in the provided code."

    severity_order = {"HIGH": 0, "MEDIUM": 1, "LOW": 2}
    findings_sorted = sorted(findings, key=lambda x: severity_order.get(x["severity"], 9))

    lines = [f"# Performance Issues in `{file_hint}`\n"]
    for f in findings_sorted:
        sev_icon = {"HIGH": "🔴", "MEDIUM": "🟡", "LOW": "🔵"}.get(f["severity"], "⚪")
        lines.append(f"{sev_icon} **L{f['line']}** `{f['pattern']}` — {f['message']}")
        lines.append(f"  > {f['title']}")
        if f.get("snippet"):
            lines.append(f"  ```al\n  {f['snippet']}\n  ```")
        lines.append("")

    return "\n".join(lines)


# ═══════════════════════════════════════════════════════════════════════
# ORCHESTRATION LAYER
# ═══════════════════════════════════════════════════════════════════════
#
# Architecture:
#   analyze_al_performance(folder)          ← master orchestrator
#       internally delegates to one function per pattern group (sub-agents)
#       aggregates all results into a unified priority report
#
#   Individual group sub-agent tools also exposed so the LLM can call
#   them independently when the user asks about a specific category.
#
# ═══════════════════════════════════════════════════════════════════════

# ─── Internal sub-agent runner ────────────────────────────────────────

def _run_group_agent(group_name: str, folder: Path) -> dict:
    """
    Run all detectors belonging to a single pattern group against every AL file.
    Returns a structured result dict — this is what each sub-agent produces.
    """
    group_patterns = [p for p in PATTERNS if p["group"] == group_name]
    files = _al_files(folder)

    findings: list[dict] = []
    for f in files:
        try:
            text = f.read_text(encoding="utf-8-sig")
        except Exception:
            continue
        for p in group_patterns:
            for finding in p["detector"](text):
                findings.append({
                    "pattern": p["id"],
                    "severity": p["severity"],
                    "title": p["title"],
                    "file": str(f),
                    "rel_file": str(f.relative_to(folder)) if f.is_relative_to(folder) else f.name,
                    **finding
                })

    high   = [f for f in findings if f["severity"] == "HIGH"]
    medium = [f for f in findings if f["severity"] == "MEDIUM"]
    low    = [f for f in findings if f["severity"] == "LOW"]

    # Auto-fixable patterns in this group
    fixable = [p["id"] for p in group_patterns if _is_pattern_auto_fixable(p["id"])]

    return {
        "group": group_name,
        "patterns_checked": [p["id"] for p in group_patterns],
        "files_scanned": len(files),
        "total": len(findings),
        "high": len(high),
        "medium": len(medium),
        "low": len(low),
        "fixable_patterns": fixable,
        "findings": findings,
    }


_AUTO_FIXABLE = {
    "FIND_DASH_BUFFER_ONE",
    "COUNT_NOT_ZERO",
    "COUNT_EQUALS_ONE",
    "ISEMPTY_BEFORE_FINDSET",
    "FINDSET_BEFORE_MODIFYALL",
    "FINDSET_BEFORE_DELETEALL",
    "MODIFYALL_RUNTRIGGER_TRUE",
    "MISSING_TEMPORARY",
    "FINDSET_MODIFY_NO_TRUE",
    "LOCKTABLE_USE_UPDLOCK",
    "FINDFIRST_IN_LOOP",
}

def _is_pattern_auto_fixable(pattern_id: str) -> bool:
    return pattern_id in _AUTO_FIXABLE


def _format_group_report(result: dict, folder: Path, detail_level: str = "summary") -> list[str]:
    """Render one group sub-agent result as markdown lines."""
    sev_icon = "🔴" if result["high"] > 0 else ("🟡" if result["medium"] > 0 else "✅")
    lines = [
        f"\n### {sev_icon} {result['group']}",
        f"Found **{result['total']}** issue(s) — "
        f"{result['high']} HIGH, {result['medium']} MEDIUM, {result['low']} LOW",
    ]
    if result["fixable_patterns"]:
        lines.append(f"Auto-fixable patterns: `{'`, `'.join(result['fixable_patterns'])}`")

    if detail_level != "full" or result["total"] == 0:
        return lines

    severity_order = {"HIGH": 0, "MEDIUM": 1, "LOW": 2}
    findings_sorted = sorted(result["findings"], key=lambda x: severity_order.get(x["severity"], 9))
    seen: set[str] = set()
    for f in findings_sorted[:15]:  # cap per group
        key = f"{f['rel_file']}:{f['line']}:{f['pattern']}"
        if key in seen:
            continue
        seen.add(key)
        icon = {"HIGH": "🔴", "MEDIUM": "🟡", "LOW": "🔵"}.get(f["severity"], "⚪")
        lines.append(f"  - {icon} `{f['rel_file']}` L{f['line']} `{f['pattern']}`: {f['message']}")
    if len(result["findings"]) > 15:
        lines.append(f"  - _(… {len(result['findings']) - 15} more — use group sub-agent for full list)_")
    return lines


# ─── Group sub-agent tools ────────────────────────────────────────────
# Each exposed as its own MCP tool so the LLM can call them independently.

def _group_tool_impl(group_name: str, folder_path: str) -> str:
    folder = Path(folder_path)
    if not folder.exists():
        return f"ERROR: Folder not found: {folder_path}"
    result = _run_group_agent(group_name, folder)
    lines = [f"# Sub-Agent: {group_name}\n",
             f"**Folder:** `{folder_path}`  ",
             f"**Issues:** {result['total']} ({result['high']} HIGH, {result['medium']} MEDIUM, {result['low']} LOW)\n"]
    lines += _format_group_report(result, folder, detail_level="full")
    return "\n".join(lines)


@mcp.tool()
def scan_data_transfer_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Data Transfer anti-patterns.
    Covers: missing SetLoadFields, Find('-') buffer-size-1, FindFirst in loops, FindLast in loops,
    SetRange+FindFirst instead of Get, SetCurrentKey missing.
    """
    return _group_tool_impl("Data Transfer", folder_path)


@mcp.tool()
def scan_flowfield_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for FlowField anti-patterns.
    Covers: CalcFields inside loops, SetFilter on FlowField (correlated subquery).
    """
    return _group_tool_impl("FlowFields", folder_path)


@mcp.tool()
def scan_aggregation_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Aggregation anti-patterns.
    Covers: manual summation loops that should use CalcSums().
    """
    return _group_tool_impl("Aggregation", folder_path)


@mcp.tool()
def scan_bulk_operation_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Bulk Operation anti-patterns.
    Covers: Delete in loop, FindSet before ModifyAll, FindSet before DeleteAll,
    ModifyAll with RunTrigger=true.
    """
    return _group_tool_impl("Bulk Operations", folder_path)


@mcp.tool()
def scan_existence_check_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Existence Check anti-patterns.
    Covers: Count() != 0 vs IsEmpty(), redundant IsEmpty before FindSet, Count() = 1 uniqueness.
    """
    return _group_tool_impl("Existence Checks", folder_path)


@mcp.tool()
def scan_locking_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Locking anti-patterns.
    Covers: LockTable too early, LockTable for sequence generation, DeleteAll without IsEmpty guard,
    LockTable vs ReadIsolation UpdLock.
    """
    return _group_tool_impl("Locking", folder_path)


@mcp.tool()
def scan_memory_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Memory / Copy anti-patterns.
    Covers: Record parameter by value, missing 'temporary' keyword, temp table used as Dictionary,
    temp table used as collection, RecordRef when typed Record suffices.
    """
    return _group_tool_impl("Memory / Copies", folder_path)


@mcp.tool()
def scan_short_circuit_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Short-Circuit Evaluation anti-patterns.
    Covers: OR/AND eager evaluation, 3+ OR conditions (use case true of),
    'if true in [...]' condition ordering.
    """
    return _group_tool_impl("Short-Circuit Evaluation", folder_path)


@mcp.tool()
def scan_write_pattern_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Write Pattern anti-patterns.
    Covers: Insert-on-conflict (try Insert, Modify on fail), silent Insert failure.
    """
    return _group_tool_impl("Write Patterns", folder_path)


@mcp.tool()
def scan_cursor_safety_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Cursor Safety anti-patterns.
    Covers: SetRange/SetFilter on active FindSet cursor (corrupts iteration),
    FindSet(true) missing when Modify is called on cursor variable.
    """
    # Combine Cursor Safety + the FindSet(true) pattern
    return _group_tool_impl("Cursor Safety", folder_path)


@mcp.tool()
def scan_stale_read_issues(folder_path: str) -> str:
    """
    Sub-agent: Scan for Stale Read anti-patterns.
    Covers: missing ReadIsolation on reporting queries, missing SelectLatestVersion in multi-pass loops.
    """
    return _group_tool_impl("Stale Reads", folder_path)


# ─── Master orchestrator tool ─────────────────────────────────────────

@mcp.tool()
def analyze_al_performance(
    folder_path: str,
    include_action_plan: bool = True,
) -> str:
    """
    MASTER ORCHESTRATOR — runs all pattern-group sub-agents in sequence and produces
    a unified performance report with a prioritized action plan.

    This is the primary entry point. It:
      1. Delegates to each pattern-group sub-agent (Data Transfer, FlowFields, Locking, etc.)
      2. Aggregates all findings across all groups
      3. Ranks files by total issue severity score
      4. Produces a prioritized action plan: which files to fix first and how
      5. Lists all auto-fixable patterns with the fix command to run

    Args:
        folder_path: Absolute path to the AL workspace folder to analyze.
        include_action_plan: Include the prioritized fix plan (default True).
    """
    folder = Path(folder_path)
    if not folder.exists():
        return f"ERROR: Folder not found: {folder_path}"

    files = _al_files(folder)
    if not files:
        return f"No .al files found in {folder_path}"

    # ── Step 1: Collect all unique group names from the pattern registry ──
    all_groups = sorted({p["group"] for p in PATTERNS})

    # ── Step 2: Run each group sub-agent ──────────────────────────────────
    group_results: list[dict] = []
    for group in all_groups:
        result = _run_group_agent(group, folder)
        group_results.append(result)

    # ── Step 3: Aggregate ─────────────────────────────────────────────────
    all_findings: list[dict] = []
    for r in group_results:
        all_findings.extend(r["findings"])

    total   = len(all_findings)
    high    = sum(1 for f in all_findings if f["severity"] == "HIGH")
    medium  = sum(1 for f in all_findings if f["severity"] == "MEDIUM")
    low     = sum(1 for f in all_findings if f["severity"] == "LOW")
    score   = high * 10 + medium * 3 + low  # weighted severity score

    # Files ranked by severity score
    file_scores: dict[str, dict] = {}
    for f in all_findings:
        fp = f["file"]
        if fp not in file_scores:
            file_scores[fp] = {"high": 0, "medium": 0, "low": 0, "patterns": set(), "rel": f["rel_file"]}
        file_scores[fp][f["severity"].lower()] += 1
        file_scores[fp]["patterns"].add(f["pattern"])

    ranked_files = sorted(
        file_scores.items(),
        key=lambda x: x[1]["high"] * 10 + x[1]["medium"] * 3 + x[1]["low"],
        reverse=True
    )

    # Auto-fixable findings
    fixable_findings = [f for f in all_findings if _is_pattern_auto_fixable(f["pattern"])]
    fixable_count = len(fixable_findings)
    fixable_files = sorted({f["rel_file"] for f in fixable_findings})

    # ── Step 4: Build report ──────────────────────────────────────────────
    lines = [
        "# 🔍 AL Performance Analysis — Orchestrator Report\n",
        f"**Workspace:** `{folder_path}`  ",
        f"**Files scanned:** {len(files)}  ",
        f"**Total issues:** {total} (🔴 {high} HIGH, 🟡 {medium} MEDIUM, 🔵 {low} LOW)  ",
        f"**Severity score:** {score}  ",
        f"**Auto-fixable:** {fixable_count} issues in {len(fixable_files)} files\n",
        "---\n",
        "## Sub-Agent Results by Group\n",
        "| Group | HIGH | MED | LOW | Total |",
        "|-------|------|-----|-----|-------|",
    ]
    for r in group_results:
        status = "🔴" if r["high"] > 0 else ("🟡" if r["medium"] > 0 else "✅")
        lines.append(f"| {status} {r['group']} | {r['high']} | {r['medium']} | {r['low']} | {r['total']} |")

    # ── Top offending files ───────────────────────────────────────────────
    lines += ["\n---\n", "## 🏆 Files Ranked by Severity Score\n"]
    for i, (fp, sc) in enumerate(ranked_files[:10], 1):
        file_score = sc["high"] * 10 + sc["medium"] * 3 + sc["low"]
        patterns_str = ", ".join(f"`{p}`" for p in sorted(sc["patterns"]))
        lines.append(
            f"{i}. **`{sc['rel']}`** — score {file_score} "
            f"(🔴{sc['high']} 🟡{sc['medium']} 🔵{sc['low']})  \n"
            f"   Patterns: {patterns_str}"
        )
    if len(ranked_files) > 10:
        lines.append(f"\n_… and {len(ranked_files) - 10} more files with issues._")

    # ── Action plan ───────────────────────────────────────────────────────
    if include_action_plan:
        lines += ["\n---\n", "## 📋 Prioritized Action Plan\n"]

        # Phase 1: Auto-fixable
        if fixable_findings:
            lines.append("### Phase 1 — Run Automatic Fixes (zero manual effort)")
            lines.append(f"These {fixable_count} issues can be fixed instantly with `fix_al_workspace`:")
            for pid in sorted(_AUTO_FIXABLE):
                count = sum(1 for f in all_findings if f["pattern"] == pid)
                if count > 0:
                    title = next((p["title"] for p in PATTERNS if p["id"] == pid), pid)
                    lines.append(f"  - `{pid}` × {count} — {title}")
            lines.append(f"\n> **Run:** `fix_al_workspace(\"{folder_path}\", dry_run=False)`")

        # Phase 2: High severity manual fixes
        high_manual = [f for f in all_findings if f["severity"] == "HIGH" and not _is_pattern_auto_fixable(f["pattern"])]
        if high_manual:
            lines.append("\n### Phase 2 — High Severity (manual code changes required)")
            by_pattern: dict[str, list] = {}
            for f in high_manual:
                by_pattern.setdefault(f["pattern"], []).append(f)
            for pid, findings in sorted(by_pattern.items(), key=lambda x: -len(x[1])):
                title = next((p["title"] for p in PATTERNS if p["id"] == pid), pid)
                files_affected = sorted({f["rel_file"] for f in findings})
                lines.append(f"\n**`{pid}`** × {len(findings)} — {title}")
                lines.append(f"  Files: {', '.join(f'`{f}`' for f in files_affected[:5])}")
                lines.append(f"  > Run `explain_pattern(\"{pid}\")` for the fix pattern")

        # Phase 3: Medium
        medium_manual = [f for f in all_findings if f["severity"] == "MEDIUM" and not _is_pattern_auto_fixable(f["pattern"])]
        if medium_manual:
            by_pattern2: dict[str, int] = {}
            for f in medium_manual:
                by_pattern2[f["pattern"]] = by_pattern2.get(f["pattern"], 0) + 1
            lines.append("\n### Phase 3 — Medium Severity")
            for pid, count in sorted(by_pattern2.items(), key=lambda x: -x[1]):
                title = next((p["title"] for p in PATTERNS if p["id"] == pid), pid)
                lines.append(f"  - `{pid}` × {count} — {title}")

        # Drill-down hints
        lines += [
            "\n---\n",
            "## 🔬 Drill Down with Sub-Agents\n",
            "Call these tools for a full per-file breakdown of each category:\n",
        ]
        group_tool_map = {
            "Data Transfer":            "scan_data_transfer_issues",
            "FlowFields":               "scan_flowfield_issues",
            "Aggregation":              "scan_aggregation_issues",
            "Bulk Operations":          "scan_bulk_operation_issues",
            "Existence Checks":         "scan_existence_check_issues",
            "Locking":                  "scan_locking_issues",
            "Memory / Copies":          "scan_memory_issues",
            "Short-Circuit Evaluation": "scan_short_circuit_issues",
            "Write Patterns":           "scan_write_pattern_issues",
            "Cursor Safety":            "scan_cursor_safety_issues",
            "Stale Reads":              "scan_stale_read_issues",
            "Sort / Keys":              "scan_data_transfer_issues",  # covered by data transfer
        }
        for r in group_results:
            if r["total"] > 0:
                tool = group_tool_map.get(r["group"], "scan_al_workspace")
                lines.append(f"- **{r['group']}** ({r['total']} issues) → `{tool}(\"{folder_path}\")`")

    return "\n".join(lines)


if __name__ == "__main__":
    mcp.run()
'
+).decode('utf-8')
+_code = compile(_src, '<al-performance-mcp>', 'exec')
+exec(_code, {'__name__': '__main__', '__file__': __file__})