mostajs-orm-validator 0.2.0

package/README.md

@@ -0,0 +1,90 @@
+# @mostajs/orm — ORMConceptValidator (VSCode Extension)
+
+> **v0.1.0** — Plug-in VSCode pour le [`ORMConceptValidator`](https://www.npmjs.com/package/@mostajs/orm) de `@mostajs/orm`. Détecte 18 anomalies conceptuelles dans vos `EntitySchema` avec squiggles inline et quick-fix.
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+
+## Installation
+
+### Depuis le Marketplace *(quand publié)*
+
+```
+ext install apolocine.mostajs-orm-validator
+```
+
+### Depuis source *(développement)*
+
+```bash
+git clone https://github.com/apolocine/mosta-orm-vscode
+cd mosta-orm-vscode
+npm install
+npm run compile
+# Ouvrir le dossier dans VSCode, F5 pour lancer un Extension Development Host
+```
+
+## Pré-requis
+
+Le workspace doit avoir :
+- `@mostajs/orm@^1.15.0` *(le validator CLI doit être accessible via `npx mostajs-orm-validator`)*
+- Un dossier de schémas *(default `./schemas`, configurable)*
+
+## Configuration
+
+Paramètres dans VSCode *(File > Preferences > Settings, chercher "mostajs orm")* :
+
+| Paramètre | Default | Description |
+|---|---|---|
+| `mostajsOrmValidator.enabled` | `true` | Active/désactive l'extension pour le workspace |
+| `mostajsOrmValidator.schemasDir` | `./schemas` | Dossier des fichiers `*.schema.ts` |
+| `mostajsOrmValidator.sourceRoot` | `./lib` | Dossier source pour règles cross-file *(R005, R007, R008, R011, R012, R014, R015)* |
+| `mostajsOrmValidator.ignore` | `[]` | Règles à ignorer *(ex: `["R015", "R017"]`)* |
+| `mostajsOrmValidator.runOnSave` | `true` | Relancer à chaque save d'un `*.schema.ts` |
+
+## Commandes *(Ctrl+Shift+P)*
+
+| Commande | Description |
+|---|---|
+| **ORMValidator: Validate current workspace** | Lance le validator sur tout le workspace |
+| **ORMValidator: Apply all auto-fixes** | Applique `--fix` pour toutes les règles fixables *(V3-A V2)* |
+| **ORMValidator: Rollback last --fix (restore .bak)** | Restaure les `.bak` du dernier `--fix` |
+
+## Fonctionnement
+
+À l'ouverture d'un fichier TypeScript, l'extension :
+1. Lance `npx mostajs-orm-validator <schemasDir> --src <sourceRoot> --format json`
+2. Parse les findings JSON
+3. Affiche chaque finding comme un **Diagnostic VSCode** *(squiggle inline)* :
+   - 🔴 `error` → squiggle rouge
+   - 🟡 `warning` → squiggle jaune
+   - ℹ️ `info` → squiggle bleu
+   - 💡 `hint` → soulignement gris
+4. Le code de la règle *(ex: R001-EMPTY-RELATIONS)* apparaît dans le tooltip + dans la barre Problems
+5. Sur sauvegarde *(si `runOnSave: true`)*, relance la validation
+
+## Quick-fix V3-C V1 *(limité)*
+
+V0.1.0 propose des suggestions textuelles dans les tooltips. Les quick-fix
+automatiques *(via VSCode Code Actions)* arrivent en V3-C V2 — pour l'instant
+utiliser le CLI :
+
+```bash
+npx mostajs-orm-validator ./schemas --src ./lib --fix-dry-run    # preview
+npx mostajs-orm-validator ./schemas --src ./lib --fix             # apply
+npx mostajs-orm-validator ./schemas --rollback-fix                # undo
+```
+
+## Limites V0.1.0
+
+- Quick-fix VSCode Code Action : non implémenté *(V3-C V2)* — utiliser CLI pour appliquer
+- LSP server dédié : pas encore *(V3-C V3, performance optimale)* — utilise le CLI via spawn
+- Marketplace publish : pas encore *(décision utilisateur — nécessite PAT Azure DevOps)*
+
+## Roadmap
+
+- **V3-C V2** : LSP server natif *(perf, sans spawn CLI)* + Code Actions VSCode pour les quick-fix
+- **V3-C V3** : Publish sur VSCode Marketplace + JetBrains Marketplace *(IntelliJ/WebStorm)*
+- **V4** : Intégration GitHub Actions / preview dans PR
+
+## Licence
+
+AGPL-3.0-or-later

package/llms.txt

@@ -0,0 +1,66 @@
+# mostajs-orm-validator (extension VSCode) — fiche LLM
+> Linter algorithmique des schémas @mostajs/orm — 18 anomalies conceptuelles avec squiggles + quick-fix.
+
+- Version: 0.2.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
+- Chemin: mostajs/mosta-orm-vscode · Statut audit: partiel (src/ + manifest VSCode ; out/ compilé)
+
+## RÔLE
+Extension Visual Studio Code (publisher `apolocine`). Analyse en continu les fichiers
+`*.schema.ts` d'un projet @mostajs/orm et signale 18 anomalies conceptuelles (règles
+R001-R018) directement dans l'éditeur, avec quick-fix pour les règles auto-corrigibles.
+Importe @mostajs/orm/validator en-process (plus de spawn CLI), validation à la sauvegarde
+(debounced) et au démarrage. Ce n'est pas un paquet npm importable mais une extension VSIX.
+
+## INSTALLATION
+Installer le `.vsix` (commande `vsce package` puis VSCode → Install from VSIX),
+ou publier via `vsce publish`. Requiert VSCode ^1.80.0.
+
+## EXPORTS
+Aucun export de bibliothèque. L'extension expose des commandes et des réglages VSCode.
+Point d'entrée : `./out/extension.js` — fonction `activate(context)`.
+Activation : onLanguage:typescript, onLanguage:typescriptreact.
+
+## API — COMMANDES VSCODE
+- `mostajsOrmValidator.validate` — « ORMValidator: Validate current workspace »
+- `mostajsOrmValidator.fixAll`  — « ORMValidator: Apply all auto-fixes »
+- `mostajsOrmValidator.fixOne`  — « ORMValidator: Apply this fix » (quick-fix ciblé)
+- `mostajsOrmValidator.rollback` — « ORMValidator: Rollback last --fix (restore .bak) »
+
+## RÉGLAGES (settings.json)
+- `mostajsOrmValidator.enabled` (boolean, def true) — activer le validator
+- `mostajsOrmValidator.schemasDir` (string, def `./schemas`) — dossier des `*.schema.ts`
+- `mostajsOrmValidator.sourceRoot` (string, def `./lib`) — racine des sources ;
+  active les règles cross-file R005, R007, R008, R011, R012, R014, R015
+- `mostajsOrmValidator.ignore` (string[], def []) — règles à ignorer, ex `['R015','R017']`
+- `mostajsOrmValidator.runOnSave` (boolean, def true) — revalider à chaque sauvegarde
+
+## TYPES CLÉS
+Sans objet — extension VSCode, pas de surface de types publique.
+
+## PATTERN
+```jsonc
+// .vscode/settings.json du projet @mostajs/orm
+{
+  "mostajsOrmValidator.schemasDir": "./src/schemas",
+  "mostajsOrmValidator.sourceRoot": "./src",
+  "mostajsOrmValidator.ignore": ["R015"]
+}
+```
+Ouvrir un fichier `*.schema.ts` : les findings apparaissent en squiggles ;
+Ctrl+. propose les quick-fix sur les règles fixables.
+
+## DÉPEND DE
+- @mostajs/orm (dependency — utilise le sous-chemin `@mostajs/orm/validator` en-process)
+- jiti (chargement des modules schéma TypeScript à la volée)
+
+## PIÈGES
+- Les règles cross-file (R005, R007, R008, R011, R012, R014, R015) ne s'activent que si
+  `sourceRoot` est correctement renseigné — sinon elles sont silencieusement inactives.
+- `rollback` restaure les `.bak` créés par le dernier `--fix` ; idempotent (no-op sans `.bak`).
+- Validation déclenchée uniquement sur fichiers `.ts`/`.tsx` et si `runOnSave` est actif
+  (debounce 300 ms).
+- Le linter partage le moteur de @mostajs/orm/validator — version des règles liée à la
+  version de @mostajs/orm installée.
+
+## RÉFÉRENCES
+- README.md · (règles documentées dans mosta-orm/docs/ORMConceptValidator.md)

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "mostajs-orm-validator",
+  "displayName": "@mostajs/orm — ORMConceptValidator",
+  "description": "Algorithmic linter for @mostajs/orm schemas. Detects 18 conceptual anomalies with inline squiggles + quick-fix.",
+  "version": "0.2.0",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "license": "AGPL-3.0-or-later",
+  "publisher": "apolocine",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apolocine/mosta-orm-vscode"
+  },
+  "engines": {
+    "vscode": "^1.80.0"
+  },
+  "categories": [
+    "Linters",
+    "Other"
+  ],
+  "keywords": [
+    "orm",
+    "validator",
+    "linter",
+    "mostajs",
+    "schema"
+  ],
+  "main": "./out/extension.js",
+  "activationEvents": [
+    "onLanguage:typescript",
+    "onLanguage:typescriptreact"
+  ],
+  "contributes": {
+    "configuration": {
+      "title": "@mostajs/orm — ORMConceptValidator",
+      "properties": {
+        "mostajsOrmValidator.enabled": {
+          "type": "boolean",
+          "default": true,
+          "description": "Activer/désactiver le validator pour ce workspace."
+        },
+        "mostajsOrmValidator.schemasDir": {
+          "type": "string",
+          "default": "./schemas",
+          "description": "Chemin relatif vers le dossier contenant les fichiers *.schema.ts."
+        },
+        "mostajsOrmValidator.sourceRoot": {
+          "type": "string",
+          "default": "./lib",
+          "description": "Chemin relatif vers les sources (active les règles cross-file R005, R007, R008, R011, R012, R014, R015)."
+        },
+        "mostajsOrmValidator.ignore": {
+          "type": "array",
+          "default": [],
+          "items": {
+            "type": "string"
+          },
+          "description": "Liste des règles à ignorer (ex: ['R015', 'R017'])."
+        },
+        "mostajsOrmValidator.runOnSave": {
+          "type": "boolean",
+          "default": true,
+          "description": "Relancer la validation à chaque sauvegarde d'un schema."
+        }
+      }
+    },
+    "commands": [
+      {
+        "command": "mostajsOrmValidator.validate",
+        "title": "ORMValidator: Validate current workspace",
+        "category": "@mostajs/orm"
+      },
+      {
+        "command": "mostajsOrmValidator.fixAll",
+        "title": "ORMValidator: Apply all auto-fixes",
+        "category": "@mostajs/orm"
+      },
+      {
+        "command": "mostajsOrmValidator.fixOne",
+        "title": "ORMValidator: Apply this fix",
+        "category": "@mostajs/orm"
+      },
+      {
+        "command": "mostajsOrmValidator.rollback",
+        "title": "ORMValidator: Rollback last --fix (restore .bak)",
+        "category": "@mostajs/orm"
+      }
+    ]
+  },
+  "dependencies": {
+    "@mostajs/orm": "^1.16.0",
+    "jiti": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.80.0",
+    "@types/node": "^22.0.0",
+    "@vscode/vsce": "^3.0.0",
+    "typescript": "^5.6.0"
+  },
+  "scripts": {
+    "compile": "tsc",
+    "watch": "tsc --watch",
+    "vscode:prepublish": "npm run compile",
+    "package": "vsce package"
+  }
+}

package/src/extension.ts

@@ -0,0 +1,365 @@
+// @mostajs/orm — VSCode extension v0.2.0 (V3-C V2)
+// Author: Dr Hamid MADANI <drmdh@msn.com>
+//
+// V3-C V2 — Améliorations vs V0.1.0 :
+//   - Import direct @mostajs/orm/validator (plus de spawn CLI)
+//   - Code Actions (quick-fix) pour les findings fixables
+//   - Hot reload sur change (debounced)
+//   - Performance : in-process, partagé entre fichiers
+
+import * as vscode from 'vscode'
+import * as path from 'node:path'
+import * as fs from 'node:fs'
+
+let diagnosticCollection: vscode.DiagnosticCollection
+let outputChannel: vscode.OutputChannel
+let lastReport: any = null
+let debounceHandle: NodeJS.Timeout | null = null
+
+const DEBOUNCE_MS = 300
+
+export async function activate(context: vscode.ExtensionContext) {
+  outputChannel = vscode.window.createOutputChannel('ORMConceptValidator')
+  diagnosticCollection = vscode.languages.createDiagnosticCollection('mostajsOrmValidator')
+  context.subscriptions.push(diagnosticCollection, outputChannel)
+
+  // Commands
+  context.subscriptions.push(
+    vscode.commands.registerCommand('mostajsOrmValidator.validate', runValidation),
+    vscode.commands.registerCommand('mostajsOrmValidator.fixAll', runFixAll),
+    vscode.commands.registerCommand('mostajsOrmValidator.fixOne', runFixOne),
+    vscode.commands.registerCommand('mostajsOrmValidator.rollback', runRollback),
+  )
+
+  // Trigger : on save (debounced)
+  context.subscriptions.push(
+    vscode.workspace.onDidSaveTextDocument((doc) => {
+      if (!isEnabled()) return
+      if (!doc.fileName.endsWith('.ts') && !doc.fileName.endsWith('.tsx')) return
+      const cfg = vscode.workspace.getConfiguration('mostajsOrmValidator')
+      if (!cfg.get<boolean>('runOnSave', true)) return
+      scheduleValidation()
+    }),
+  )
+
+  // Code Action provider — propose quick-fix sur les findings fixables
+  context.subscriptions.push(
+    vscode.languages.registerCodeActionsProvider(
+      { language: 'typescript' },
+      new ValidatorCodeActionProvider(),
+      { providedCodeActionKinds: [vscode.CodeActionKind.QuickFix] },
+    ),
+    vscode.languages.registerCodeActionsProvider(
+      { language: 'typescriptreact' },
+      new ValidatorCodeActionProvider(),
+      { providedCodeActionKinds: [vscode.CodeActionKind.QuickFix] },
+    ),
+  )
+
+  // Validation initiale au démarrage
+  if (isEnabled() && hasSchemasDir()) {
+    await runValidation()
+  }
+
+  outputChannel.appendLine('ORMConceptValidator V3-C V2 activated.')
+}
+
+export function deactivate() {
+  if (debounceHandle) clearTimeout(debounceHandle)
+  diagnosticCollection?.dispose()
+  outputChannel?.dispose()
+}
+
+function scheduleValidation() {
+  if (debounceHandle) clearTimeout(debounceHandle)
+  debounceHandle = setTimeout(() => { void runValidation() }, DEBOUNCE_MS)
+}
+
+// ─── Validation ─────────────────────────────────────────────────
+
+async function runValidation() {
+  const workspace = vscode.workspace.workspaceFolders?.[0]
+  if (!workspace) return
+
+  const cfg = vscode.workspace.getConfiguration('mostajsOrmValidator')
+  const schemasDir = path.join(workspace.uri.fsPath, cfg.get<string>('schemasDir') ?? './schemas')
+  const sourceRoot = path.join(workspace.uri.fsPath, cfg.get<string>('sourceRoot') ?? './lib')
+  const ignore = cfg.get<string[]>('ignore') ?? []
+
+  if (!fs.existsSync(schemasDir)) {
+    outputChannel.appendLine(`Skip : schemasDir introuvable (${schemasDir})`)
+    return
+  }
+
+  try {
+    // Import direct (in-process). Lazy load car @mostajs/orm/validator + ts-morph
+    // est lourd (~2 MB) — on ne le charge qu'à la 1ère validation.
+    const validator = await import('@mostajs/orm/validator')
+    const { createJiti } = await import('jiti')
+
+    // Charge les schemas via jiti (TS direct)
+    const jiti = createJiti(require.main?.filename ?? __filename, { interopDefault: true, fsCache: false })
+    const byName = new Map<string, any>()
+    walkSchemas(schemasDir, async (filePath) => {
+      try {
+        const mod: any = await jiti.import(filePath)
+        for (const exp of Object.values(mod)) {
+          if (isEntitySchema(exp)) {
+            const s = exp as any
+            if (!byName.has(s.name)) byName.set(s.name, s)
+          }
+        }
+      } catch (e) {
+        outputChannel.appendLine(`Skip ${filePath}: ${(e as Error).message}`)
+      }
+    })
+    const schemas = [...byName.values()]
+    if (schemas.length === 0) {
+      outputChannel.appendLine(`Aucun schéma trouvé dans ${schemasDir}`)
+      diagnosticCollection.clear()
+      return
+    }
+
+    const report = await validator.validateSchemas(schemas, {
+      sourceRoot: fs.existsSync(sourceRoot) ? sourceRoot : undefined,
+      ignore,
+    })
+    lastReport = report
+
+    // Push diagnostics
+    diagnosticCollection.clear()
+    const findingsByFile = new Map<string, any[]>()
+    for (const f of report.findings) {
+      const file = locateFindingFile(f, schemasDir, workspace.uri.fsPath)
+      if (!file) continue
+      if (!findingsByFile.has(file)) findingsByFile.set(file, [])
+      findingsByFile.get(file)!.push(f)
+    }
+
+    for (const [file, findings] of findingsByFile) {
+      const diagnostics: vscode.Diagnostic[] = []
+      for (const f of findings) {
+        const range = computeRange(file, f)
+        const diag = new vscode.Diagnostic(range, `[${f.ruleId}] ${f.message}`, severityToVSCode(f.severity))
+        diag.source = '@mostajs/orm-validator'
+        diag.code = f.ruleId
+        // Stockage payload pour Code Action récupérer ensuite
+        ;(diag as any).fixableData = f
+        diagnostics.push(diag)
+      }
+      diagnosticCollection.set(vscode.Uri.file(file), diagnostics)
+    }
+
+    outputChannel.appendLine(`✓ ${report.findings.length} findings (${report.countBySeverity.warning} warnings, ${report.countBySeverity.info} infos, ${report.countBySeverity.hint} hints) sur ${schemas.length} schémas — ${report.durationMs}ms`)
+  } catch (e) {
+    outputChannel.appendLine(`Error: ${(e as Error).stack ?? (e as Error).message}`)
+  }
+}
+
+// ─── Code Actions provider (quick-fix) ──────────────────────────
+
+class ValidatorCodeActionProvider implements vscode.CodeActionProvider {
+  provideCodeActions(
+    document: vscode.TextDocument,
+    range: vscode.Range,
+    context: vscode.CodeActionContext,
+  ): vscode.CodeAction[] {
+    const actions: vscode.CodeAction[] = []
+    for (const diag of context.diagnostics) {
+      if (diag.source !== '@mostajs/orm-validator') continue
+      const finding = (diag as any).fixableData
+      if (!finding?.fixable) continue
+      const action = new vscode.CodeAction(
+        `⚙ Auto-fix [${finding.ruleId}] ${finding.location.schema}${finding.location.field ? '.' + finding.location.field : ''}`,
+        vscode.CodeActionKind.QuickFix,
+      )
+      action.command = {
+        title: 'Auto-fix',
+        command: 'mostajsOrmValidator.fixOne',
+        arguments: [finding],
+      }
+      action.diagnostics = [diag]
+      action.isPreferred = true
+      actions.push(action)
+    }
+    return actions
+  }
+}
+
+async function runFixOne(finding: any) {
+  if (!lastReport) {
+    vscode.window.showWarningMessage('Aucun rapport en mémoire — lance "Validate" d\'abord.')
+    return
+  }
+  await applyFixesFiltered([finding])
+}
+
+async function runFixAll() {
+  if (!lastReport) {
+    vscode.window.showWarningMessage('Aucun rapport en mémoire — lance "Validate" d\'abord.')
+    return
+  }
+  const fixable = lastReport.findings.filter((f: any) => f.fixable)
+  if (fixable.length === 0) {
+    vscode.window.showInformationMessage('Aucun finding auto-fixable dans le rapport.')
+    return
+  }
+  const choice = await vscode.window.showWarningMessage(
+    `Appliquer ${fixable.length} auto-fix ? (backup .bak créé)`,
+    { modal: true },
+    'Apply', 'Dry-run',
+  )
+  if (!choice) return
+  await applyFixesFiltered(fixable, choice === 'Dry-run')
+}
+
+async function applyFixesFiltered(findings: any[], dryRun = false) {
+  const workspace = vscode.workspace.workspaceFolders?.[0]
+  if (!workspace) return
+
+  try {
+    const validator = await import('@mostajs/orm/validator')
+    const cfg = vscode.workspace.getConfiguration('mostajsOrmValidator')
+    const sourceRoot = path.join(workspace.uri.fsPath, cfg.get<string>('schemasDir') ?? './schemas')
+
+    // Construit un mini-rapport ciblé
+    const targetedReport = { ...lastReport, findings }
+    const results = await validator.applyFixes(targetedReport as any, {
+      sourceRoot,
+      dryRun,
+      backup: true,
+    })
+
+    const applied = results.filter(r => r.applied).length
+    const skipped = results.filter(r => !r.applied).length
+    const msg = `${dryRun ? 'Dry-run' : 'Apply'} : ${applied} fix${applied > 1 ? 'es' : ''} ${dryRun ? 'préviewés' : 'appliqués'}, ${skipped} skippés.`
+    outputChannel.appendLine(msg)
+    for (const r of results) {
+      outputChannel.appendLine(`  ${r.applied ? '✓' : '·'} ${r.ruleId} ${r.schema}${r.field ? '.' + r.field : ''}  ${r.reason ?? ''}`)
+      if (r.diff && dryRun) outputChannel.appendLine(r.diff)
+    }
+    vscode.window.showInformationMessage(msg + (dryRun ? '' : ' (.bak créés)'))
+
+    if (!dryRun) {
+      // Relance validation après fix pour rafraîchir les diagnostics
+      setTimeout(() => { void runValidation() }, 200)
+    }
+  } catch (e) {
+    outputChannel.appendLine(`Fix error: ${(e as Error).message}`)
+    vscode.window.showErrorMessage(`Auto-fix échec: ${(e as Error).message}`)
+  }
+}
+
+async function runRollback() {
+  const workspace = vscode.workspace.workspaceFolders?.[0]
+  if (!workspace) return
+  try {
+    const validator = await import('@mostajs/orm/validator')
+    const cfg = vscode.workspace.getConfiguration('mostajsOrmValidator')
+    const schemasDir = path.join(workspace.uri.fsPath, cfg.get<string>('schemasDir') ?? './schemas')
+    const results = validator.rollbackFixes(schemasDir)
+    const ok = results.filter((r) => r.restored).length
+    const fail = results.filter((r) => !r.restored).length
+    outputChannel.appendLine(`Rollback: ${ok} restored, ${fail} failed`)
+    for (const r of results) {
+      outputChannel.appendLine(`  ${r.restored ? '✓' : '✗'} ${r.file}${r.reason ? ' — ' + r.reason : ''}`)
+    }
+    vscode.window.showInformationMessage(`Rollback : ${ok} fichier${ok > 1 ? 's' : ''} restauré${ok > 1 ? 's' : ''}.`)
+    setTimeout(() => { void runValidation() }, 200)
+  } catch (e) {
+    vscode.window.showErrorMessage(`Rollback échec: ${(e as Error).message}`)
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────
+
+function isEnabled(): boolean {
+  return vscode.workspace.getConfiguration('mostajsOrmValidator').get<boolean>('enabled', true)
+}
+
+function hasSchemasDir(): boolean {
+  const workspace = vscode.workspace.workspaceFolders?.[0]
+  if (!workspace) return false
+  const cfg = vscode.workspace.getConfiguration('mostajsOrmValidator')
+  return fs.existsSync(path.join(workspace.uri.fsPath, cfg.get<string>('schemasDir') ?? './schemas'))
+}
+
+function walkSchemas(dir: string, cb: (file: string) => Promise<void> | void) {
+  let entries: string[]
+  try { entries = fs.readdirSync(dir) } catch { return }
+  for (const e of entries) {
+    if (e === 'node_modules' || e === 'dist' || e === '.next' || e === '.git') continue
+    const full = path.join(dir, e)
+    let st
+    try { st = fs.statSync(full) } catch { continue }
+    if (st.isDirectory()) walkSchemas(full, cb)
+    else if ((full.endsWith('.ts') || full.endsWith('.tsx')) && !full.endsWith('.d.ts')) {
+      void cb(full)
+    }
+  }
+}
+
+function isEntitySchema(x: any): boolean {
+  return x && typeof x === 'object'
+    && typeof x.name === 'string'
+    && typeof x.collection === 'string'
+    && x.fields && typeof x.fields === 'object'
+}
+
+function locateFindingFile(f: any, schemasDir: string, workspaceRoot: string): string | null {
+  if (f.location?.file) {
+    const abs = path.isAbsolute(f.location.file)
+      ? f.location.file
+      : path.resolve(workspaceRoot, f.location.file)
+    return fs.existsSync(abs) ? abs : null
+  }
+  if (f.location?.schema) {
+    // Cherche le fichier contenant export const <SchemaName>Schema
+    const re = new RegExp(`export\\s+const\\s+${escapeRegex(f.location.schema)}Schema\\s*[:=]`)
+    let found: string | null = null
+    walkSchemas(schemasDir, (file) => {
+      if (found) return
+      try {
+        if (re.test(fs.readFileSync(file, 'utf-8'))) found = file
+      } catch { /* skip */ }
+    })
+    return found
+  }
+  return null
+}
+
+function computeRange(file: string, finding: any): vscode.Range {
+  if (finding.location?.line) {
+    const line = (finding.location.line - 1) | 0
+    return new vscode.Range(line, 0, line, 999)
+  }
+  // Cherche la déclaration du field dans le fichier pour placer le squiggle
+  if (finding.location?.schema && finding.location?.field) {
+    try {
+      const content = fs.readFileSync(file, 'utf-8')
+      const re = new RegExp(`\\b${escapeRegex(finding.location.field)}\\s*:`, 'm')
+      const m = content.match(re)
+      if (m && m.index !== undefined) {
+        const before = content.slice(0, m.index)
+        const line = (before.match(/\n/g) ?? []).length
+        const col = m.index - before.lastIndexOf('\n') - 1
+        return new vscode.Range(line, col, line, col + finding.location.field.length)
+      }
+    } catch { /* fall through */ }
+  }
+  return new vscode.Range(0, 0, 0, 0)
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function severityToVSCode(sev: string): vscode.DiagnosticSeverity {
+  switch (sev) {
+    case 'error': return vscode.DiagnosticSeverity.Error
+    case 'warning': return vscode.DiagnosticSeverity.Warning
+    case 'info': return vscode.DiagnosticSeverity.Information
+    case 'hint': return vscode.DiagnosticSeverity.Hint
+    default: return vscode.DiagnosticSeverity.Information
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "lib": ["ES2022"],
+    "outDir": "out",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "out", ".vscode-test"]
+}